What you receive

The object run receives

Reading costs nothing

import { command } from 'chapterjs';

export default command({
  name: 'whois',
  description: 'Tells you about someone',
  options: {
    who: { type: 'user', description: 'Who to look at', required: true },
  },
  async run({ interaction, options, guild }) {
    const user = options.who;
    const member = await guild.fetchMember(user);
    const roles = member.roles.map(role => role.name).join(', ') || 'none';
    await interaction.reply(
      `${member.displayName} joined ${guild.name} on ${member.joinedAt?.toDateString() ?? 'an unknown date'}. ` +
        `Roles: ${roles}. Highest: ${member.highestRole.name}.`
    );
  },
});

• Properties read what the bot already knows. guild.name, member.roles, member.highestRole: no request to Discord, the answer is immediate. The bot remembers its servers, their channels and roles, because Discord told it when it connected and tells it every change.
• fetch…() methods ask Discord. guild.fetchMember(user) gets a member the bot may not know yet, and await is needed. The bot answers from memory when it can and asks Discord otherwise.

Actions: asking Discord to do something

import { command, DiscordApiError } from 'chapterjs';

export default command({
  name: 'warn',
  description: 'Warns a member with a short timeout',
  permissions: ['ModerateMembers'],
  options: {
    who: { type: 'user', description: 'Who to warn', required: true },
    reason: {
      type: 'string',
      description: 'Why',
      required: true,
      maxLength: 200,
    },
  },
  async run({ interaction, options, guild, member }) {
    const target = await guild.fetchMember(options.who);
    if (!member.isHigherThan(target)) {
      await interaction.reply({
        content: 'You can only warn members below you.',
        ephemeral: true,
      });
      return;
    }
    await target.timeout(10 * 60 * 1000, options.reason);
    let told = 'and they were told in private';
    try {
      await target.send(`You were warned in ${guild.name}: ${options.reason}`);
    } catch (error) {
      // 50007: this person does not accept private messages.
      if (!(error instanceof DiscordApiError && error.code === 50007))
        throw error;
      told = 'but their private messages are closed';
    }
    await interaction.reply(
      `${target.displayName} was warned for 10 minutes, ${told}.`
    );
  },
});

• permissions: ['ModerateMembers'] says who may use the command. Discord hides it from the others, and the framework checks again when it is used: someone without the permission reads “You need the Moderate Members permission to use this command.” and run never starts. Permissions are written by name, and the editor completes them.
• member.isHigherThan(target) compares roles: Discord refuses to moderate someone whose highest role is above yours, so checking first gives a better answer than letting Discord refuse.
• timeout(duration, reason) takes milliseconds, and a reason that goes to the audit log of the server. Actions that appear in the audit log all take a reason.
• try / catch around send(). Some people close their private messages; Discord then refuses with the code 50007. The error is a DiscordApiError, and its code is the thing to test: the text may change, the code never does. Anything else is rethrown, so that a real problem is reported.

The structures you will meet

import type { Guild } from 'chapterjs';

async function announce(guild: Guild, text: string) {
  const general = [...guild.channels.values()].find(
    channel => channel.name === 'general'
  );
  if (general?.isTextBased()) await general.send(text);
}

Mentions in a text

Recap

• user is the account, member the person in this server, guild the server, channel the channel; in a server, none of them is ever missing.
• A property reads what the bot knows, at once; a fetch…() asks Discord.
• Actions are awaited and can fail; DiscordApiError.code says why.
• permissions on a command decides who may use it, before run.