feat: add support for chat input command arguments

src/arguments/CoreBoolean.ts

@@ -1,4 +1,6 @@
 import type { PieceContext } from '@sapphire/pieces';
+import { Result } from '@sapphire/result';
+import { Identifiers } from '../lib/errors/Identifiers';
 import { resolveBoolean } from '../lib/resolvers/boolean';
 import { Argument } from '../lib/structures/Argument';
 import type { BooleanArgumentContext } from '../lib/types/ArgumentContexts';
@@ -8,7 +10,7 @@ export class CoreArgument extends Argument<boolean> {
 		super(context, { name: 'boolean' });
 	}
 
-	public run(parameter: string, context: BooleanArgumentContext): Argument.Result<boolean> {
+	public override messageRun(parameter: string, context: BooleanArgumentContext): Argument.Result<boolean> {
 		const resolved = resolveBoolean(parameter, { truths: context.truths, falses: context.falses });
 		return resolved.mapErrInto((identifier) =>
 			this.error({
@@ -19,4 +21,24 @@ export class CoreArgument extends Argument<boolean> {
 			})
 		);
 	}
+
+	public override chatInputRun(
+		name: string,
+		context: Pick<BooleanArgumentContext, 'truths' | 'falses'> & Argument.ChatInputContext
+	): Argument.Result<boolean> {
+		const resolved = context.useStringResolver
+			? resolveBoolean(context.interaction.options.getString(name) ?? '', { truths: context.truths, falses: context.falses })
+			: (Result.from(context.interaction.options.getBoolean(name) ?? Result.err(Identifiers.ArgumentBooleanError)) as Result<
+					boolean,
+					Identifiers.ArgumentBooleanError
+			  >);
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter: name,
+				identifier,
+				message: 'The argument did not resolve to a boolean.',
+				context
+			})
+		);
+	}
 }

src/arguments/CoreChannel.ts

@@ -8,7 +8,7 @@ export class CoreArgument extends Argument<ChannelTypes> {
 		super(context, { name: 'channel' });
 	}
 
-	public run(parameter: string, context: Argument.Context): Argument.Result<ChannelTypes> {
+	public override messageRun(parameter: string, context: Argument.MessageContext): Argument.Result<ChannelTypes> {
 		const resolved = resolveChannel(parameter, context.message);
 		return resolved.mapErrInto((identifier) =>
 			this.error({
@@ -19,4 +19,18 @@ export class CoreArgument extends Argument<ChannelTypes> {
 			})
 		);
 	}
+
+	public override chatInputRun(name: string, context: Argument.ChatInputContext): Argument.Result<ChannelTypes> {
+		const resolved = context.useStringResolver
+			? resolveChannel(context.interaction.options.getString(name) ?? '', context.interaction)
+			: resolveChannel(context.interaction.options.getChannel(name)?.id ?? '', context.interaction);
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter: name,
+				identifier,
+				message: 'The argument did not resolve to a channel.',
+				context
+			})
+		);
+	}
 }

src/arguments/CoreDMChannel.ts

@@ -8,7 +8,7 @@ export class CoreArgument extends Argument<DMChannel> {
 		super(context, { name: 'dmChannel' });
 	}
 
-	public run(parameter: string, context: Argument.Context): Argument.Result<DMChannel> {
+	public override messageRun(parameter: string, context: Argument.MessageContext): Argument.Result<DMChannel> {
 		const resolved = resolveDMChannel(parameter, context.message);
 		return resolved.mapErrInto((identifier) =>
 			this.error({
@@ -19,4 +19,16 @@ export class CoreArgument extends Argument<DMChannel> {
 			})
 		);
 	}
+
+	public override chatInputRun(name: string, context: Argument.ChatInputContext): Argument.Result<DMChannel> {
+		const resolved = resolveDMChannel(context.interaction.options.getString(name) ?? '', context.interaction);
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter: name,
+				identifier,
+				message: 'The argument did not resolve to a DM channel.',
+				context
+			})
+		);
+	}
 }

src/arguments/CoreDate.ts

@@ -3,18 +3,20 @@ import { Identifiers } from '../lib/errors/Identifiers';
 import { resolveDate } from '../lib/resolvers/date';
 import { Argument } from '../lib/structures/Argument';
 
+type Context = Argument.MessageContext | Argument.ChatInputContext;
+
 export class CoreArgument extends Argument<Date> {
 	private readonly messages = {
-		[Identifiers.ArgumentDateTooEarly]: ({ minimum }: Argument.Context) => `The given date must be after ${new Date(minimum!).toISOString()}.`,
-		[Identifiers.ArgumentDateTooFar]: ({ maximum }: Argument.Context) => `The given date must be before ${new Date(maximum!).toISOString()}.`,
+		[Identifiers.ArgumentDateTooEarly]: ({ minimum }: Context) => `The given date must be after ${new Date(minimum!).toISOString()}.`,
+		[Identifiers.ArgumentDateTooFar]: ({ maximum }: Context) => `The given date must be before ${new Date(maximum!).toISOString()}.`,
 		[Identifiers.ArgumentDateError]: () => 'The argument did not resolve to a date.'
 	} as const;
 
 	public constructor(context: PieceContext) {
 		super(context, { name: 'date' });
 	}
 
-	public run(parameter: string, context: Argument.Context): Argument.Result<Date> {
+	public override messageRun(parameter: string, context: Argument.MessageContext): Argument.Result<Date> {
 		const resolved = resolveDate(parameter, { minimum: context.minimum, maximum: context.maximum });
 		return resolved.mapErrInto((identifier) =>
 			this.error({
@@ -25,4 +27,16 @@ export class CoreArgument extends Argument<Date> {
 			})
 		);
 	}
+
+	public override chatInputRun(name: string, context: Argument.ChatInputContext): Argument.Result<Date> {
+		const resolved = resolveDate(context.interaction.options.getString(name) ?? '', { minimum: context.minimum, maximum: context.maximum });
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter: name,
+				identifier,
+				message: this.messages[identifier](context),
+				context
+			})
+		);
+	}
 }

src/arguments/CoreEmoji.ts

@@ -7,7 +7,7 @@ export class CoreArgument extends Argument<EmojiObject> {
 		super(context, { name: 'emoji' });
 	}
 
-	public run(parameter: string, context: Argument.Context): Argument.Result<EmojiObject> {
+	public override messageRun(parameter: string, context: Argument.MessageContext): Argument.Result<EmojiObject> {
 		const resolved = resolveEmoji(parameter);
 		return resolved.mapErrInto((identifier) =>
 			this.error({
@@ -18,4 +18,16 @@ export class CoreArgument extends Argument<EmojiObject> {
 			})
 		);
 	}
+
+	public override chatInputRun(name: string, context: Argument.ChatInputContext): Argument.Result<EmojiObject> {
+		const resolved = resolveEmoji(context.interaction.options.getString(name) ?? '');
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter: name,
+				identifier,
+				message: 'The argument did not resolve to an emoji.',
+				context
+			})
+		);
+	}
 }

src/arguments/CoreEnum.ts

@@ -8,7 +8,7 @@ export class CoreArgument extends Argument<string> {
 		super(context, { name: 'enum' });
 	}
 
-	public run(parameter: string, context: EnumArgumentContext): Argument.Result<string> {
+	public override messageRun(parameter: string, context: EnumArgumentContext): Argument.Result<string> {
 		const resolved = resolveEnum(parameter, { enum: context.enum, caseInsensitive: context.caseInsensitive });
 		return resolved.mapErrInto((identifier) =>
 			this.error({
@@ -19,4 +19,22 @@ export class CoreArgument extends Argument<string> {
 			})
 		);
 	}
+
+	public override chatInputRun(
+		name: string,
+		context: Pick<EnumArgumentContext, 'enum' | 'caseInsensitive'> & Argument.ChatInputContext
+	): Argument.Result<string> {
+		const resolved = resolveEnum(context.interaction.options.getString(name) ?? '', {
+			enum: context.enum,
+			caseInsensitive: context.caseInsensitive
+		});
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter: name,
+				identifier,
+				message: `The argument must have one of the following values: ${context.enum?.join(', ')}`,
+				context
+			})
+		);
+	}
 }

src/arguments/CoreFloat.ts

@@ -3,18 +3,20 @@ import { Identifiers } from '../lib/errors/Identifiers';
 import { resolveFloat } from '../lib/resolvers/float';
 import { Argument } from '../lib/structures/Argument';
 
+type Context = Argument.MessageContext | Argument.ChatInputContext;
+
 export class CoreArgument extends Argument<number> {
 	private readonly messages = {
-		[Identifiers.ArgumentFloatTooSmall]: ({ minimum }: Argument.Context) => `The given number must be greater than ${minimum}.`,
-		[Identifiers.ArgumentFloatTooLarge]: ({ maximum }: Argument.Context) => `The given number must be less than ${maximum}.`,
+		[Identifiers.ArgumentFloatTooSmall]: ({ minimum }: Context) => `The given number must be greater than ${minimum}.`,
+		[Identifiers.ArgumentFloatTooLarge]: ({ maximum }: Context) => `The given number must be less than ${maximum}.`,
 		[Identifiers.ArgumentFloatError]: () => 'The argument did not resolve to a valid decimal.'
 	} as const;
 
 	public constructor(context: PieceContext) {
 		super(context, { name: 'float' });
 	}
 
-	public run(parameter: string, context: Argument.Context): Argument.Result<number> {
+	public override messageRun(parameter: string, context: Argument.MessageContext): Argument.Result<number> {
 		const resolved = resolveFloat(parameter, { minimum: context.minimum, maximum: context.maximum });
 		return resolved.mapErrInto((identifier) =>
 			this.error({
@@ -25,4 +27,18 @@ export class CoreArgument extends Argument<number> {
 			})
 		);
 	}
+
+	public override chatInputRun(name: string, context: Argument.ChatInputContext): Argument.Result<number> {
+		const resolved = context.useStringResolver
+			? resolveFloat(context.interaction.options.getString(name) ?? 'NaN', { minimum: context.minimum, maximum: context.maximum })
+			: resolveFloat(context.interaction.options.getNumber(name)?.toString() ?? 'NaN', { minimum: context.minimum, maximum: context.maximum });
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter: name,
+				identifier,
+				message: this.messages[identifier](context),
+				context
+			})
+		);
+	}
 }

src/arguments/CoreGuild.ts

@@ -8,7 +8,7 @@ export class CoreArgument extends Argument<Guild> {
 		super(context, { name: 'guild' });
 	}
 
-	public async run(parameter: string, context: Argument.Context): Argument.AsyncResult<Guild> {
+	public override async messageRun(parameter: string, context: Argument.MessageContext): Argument.AsyncResult<Guild> {
 		const resolved = await resolveGuild(parameter);
 		return resolved.mapErrInto((identifier) =>
 			this.error({
@@ -19,4 +19,16 @@ export class CoreArgument extends Argument<Guild> {
 			})
 		);
 	}
+
+	public override async chatInputRun(name: string, context: Argument.ChatInputContext): Argument.AsyncResult<Guild> {
+		const resolved = await resolveGuild(context.interaction.options.getString(name) ?? '');
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter: name,
+				identifier,
+				message: 'The given argument did not resolve to a Discord guild.',
+				context
+			})
+		);
+	}
 }

src/arguments/CoreGuildCategoryChannel.ts

@@ -9,16 +9,9 @@ export class CoreArgument extends Argument<CategoryChannel> {
 		super(context, { name: 'guildCategoryChannel' });
 	}
 
-	public run(parameter: string, context: Argument.Context): Argument.Result<CategoryChannel> {
+	public override messageRun(parameter: string, context: Argument.MessageContext): Argument.Result<CategoryChannel> {
 		const { guild } = context.message;
-		if (!guild) {
-			return this.error({
-				parameter,
-				identifier: Identifiers.ArgumentGuildChannelMissingGuildError,
-				message: 'This command can only be used in a server.',
-				context
-			});
-		}
+		if (!guild) return this.guildError(parameter, context);
 
 		const resolved = resolveGuildCategoryChannel(parameter, guild);
 		return resolved.mapErrInto((identifier) =>
@@ -30,4 +23,30 @@ export class CoreArgument extends Argument<CategoryChannel> {
 			})
 		);
 	}
+
+	public override chatInputRun(name: string, context: Argument.ChatInputContext): Argument.Result<CategoryChannel> {
+		const { guild } = context.interaction;
+		if (!guild) return this.guildError(name, context);
+
+		const resolved = context.useStringResolver
+			? resolveGuildCategoryChannel(context.interaction.options.getString(name) ?? '', guild)
+			: resolveGuildCategoryChannel(context.interaction.options.getChannel(name)?.id ?? '', guild);
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter: name,
+				identifier,
+				message: 'The argument did not resolve to a valid server category channel.',
+				context: { ...context, guild }
+			})
+		);
+	}
+
+	private guildError(parameter: string, context: Argument.MessageContext | Argument.ChatInputContext) {
+		return this.error({
+			parameter,
+			identifier: Identifiers.ArgumentGuildChannelMissingGuildError,
+			message: 'This command can only be used in a server.',
+			context
+		});
+	}
 }

src/arguments/CoreGuildChannel.ts

@@ -9,16 +9,9 @@ export class CoreArgument extends Argument<GuildBasedChannelTypes> {
 		super(context, { name: 'guildChannel' });
 	}
 
-	public run(parameter: string, context: Argument.Context): Argument.Result<GuildBasedChannelTypes> {
+	public override messageRun(parameter: string, context: Argument.MessageContext): Argument.Result<GuildBasedChannelTypes> {
 		const { guild } = context.message;
-		if (!guild) {
-			return this.error({
-				parameter,
-				identifier: Identifiers.ArgumentGuildChannelMissingGuildError,
-				message: 'This command can only be used in a server.',
-				context
-			});
-		}
+		if (!guild) return this.guildError(parameter, context);
 
 		const resolved = resolveGuildChannel(parameter, guild);
 		return resolved.mapErrInto((identifier) =>
@@ -30,4 +23,30 @@ export class CoreArgument extends Argument<GuildBasedChannelTypes> {
 			})
 		);
 	}
+
+	public override chatInputRun(name: string, context: Argument.ChatInputContext): Argument.Result<GuildBasedChannelTypes> {
+		const { guild } = context.interaction;
+		if (!guild) return this.guildError(name, context);
+
+		const resolved = context.useStringResolver
+			? resolveGuildChannel(context.interaction.options.getString(name) ?? '', guild)
+			: resolveGuildChannel(context.interaction.options.getChannel(name)?.id ?? '', guild);
+		return resolved.mapErrInto((identifier) =>
+			this.error({
+				parameter: name,
+				identifier,
+				message: 'The argument did not resolve to a valid server channel.',
+				context: { ...context, guild }
+			})
+		);
+	}
+
+	private guildError(parameter: string, context: Argument.MessageContext | Argument.ChatInputContext) {
+		return this.error({
+			parameter,
+			identifier: Identifiers.ArgumentGuildChannelMissingGuildError,
+			message: 'This command can only be used in a server.',
+			context
+		});
+	}
 }