bob-core 2.1.0 → 3.0.0-alpha.0

package/dist/cjs/package-I_hjzzxG.cjs

@@ -0,0 +1 @@
+var e={name:`bob-core`,version:`3.0.0-alpha.0`,description:`BOB Core`,type:`module`,main:`./dist/cjs/src/index.js`,module:`./dist/esm/src/index.js`,types:`./dist/esm/src/index.d.ts`,files:[`dist`],exports:{".":{import:{types:`./dist/esm/src/index.d.ts`,default:`./dist/esm/src/index.js`},require:{types:`./dist/cjs/src/index.d.ts`,default:`./dist/cjs/src/index.js`}}},scripts:{start:`node -r @swc-node/register debug/main.ts`,build:`rm -rf ./dist && vite build`,typecheck:`tsc --noEmit`,prepack:`npm run build`,test:`vitest run`,lint:`eslint .`,"lint:fix":`eslint . --fix`},author:`Léo Hubert`,license:`ISC`,devDependencies:{"@eslint/js":`^9.39.4`,"@faker-js/faker":`^10.3.0`,"@swc-node/register":`^1.11.1`,"@trivago/prettier-plugin-sort-imports":`^5.2.2`,"@types/minimist":`^1.2.5`,"@types/node":`^20.14.5`,"@types/prompts":`^2.4.9`,"@types/string-similarity":`^4.0.2`,"@vitest/coverage-v8":`^4.1.0`,eslint:`^9.39.4`,"eslint-config-prettier":`^10.1.8`,"eslint-plugin-prettier":`^5.5.5`,prettier:`^3.6.2`,tsx:`^4.21.0`,typescript:`^5.9.3`,"typescript-eslint":`^8.57.0`,vite:`^8.0.0`,"vite-plugin-dts":`^4.5.4`,vitest:`^4.1.0`},dependencies:{chalk:`^4.1.2`,minimist:`^1.2.8`,prompts:`^2.4.2`}};exports.default=e;

package/dist/cjs/src/Cli.d.ts

@@ -3,7 +3,7 @@ import { CommandRegistry, CommandRegistryOptions, CommandResolver, FileImporter
 import { ExceptionHandler } from './ExceptionHandler.js';
 import { Logger } from './Logger.js';
 import { default as HelpCommand, HelpCommandOptions } from './commands/HelpCommand.js';
-import { ContextDefinition, OptionsSchema } from './lib/types.js';
+import { ContextDefinition } from './lib/types.js';
 export type CliOptions<C extends ContextDefinition = ContextDefinition> = {
     ctx?: C;
     name?: string;
@@ -24,10 +24,8 @@ export declare class Cli<C extends ContextDefinition = ContextDefinition> {
     constructor(opts?: CliOptions<C>);
     withCommandResolver(resolver: CommandResolver): this;
     withFileImporter(importer: FileImporter): this;
-    withCommands(...commands: Array<Command<C, OptionsSchema, OptionsSchema> | {
-        new (): Command<C>;
-    } | string>): Promise<void>;
-    runCommand(command: string | Command | undefined, ...args: string[]): Promise<number>;
+    withCommands(...commands: Array<typeof Command<C> | Command<C> | string>): Promise<void>;
+    runCommand(command: string | typeof Command | Command | undefined, ...args: string[]): Promise<number>;
     runHelpCommand(): Promise<number>;
-    protected registerCommand(command: Command<C, OptionsSchema, OptionsSchema>): void;
+    protected registerCommand(command: typeof Command<C>): void;
 }

package/dist/cjs/src/Command.d.ts

@@ -1,68 +1,45 @@
 import { CommandIO, CommandIOOptions } from './CommandIO.js';
 import { CommandParser } from './CommandParser.js';
 import { Logger } from './Logger.js';
-import { CommandOption } from './contracts/index.js';
-import { ArgumentsObject, ArgumentsSchema, ContextDefinition, OptionsObject, OptionsSchema } from './lib/types.js';
-export type CommandHandlerOptions<Options extends OptionsSchema, Arguments extends ArgumentsSchema> = {
-    options: OptionsObject<Options>;
-    arguments: ArgumentsObject<Arguments>;
+import { ArgumentsSchema, ContextDefinition, FlagsSchema, Parsed } from './lib/types.js';
+export type CommandRunExample = {
+    description: string;
+    command: string;
 };
-export type CommandHandler<C extends ContextDefinition, Options extends OptionsSchema, Arguments extends ArgumentsSchema> = (ctx: C, opts: CommandHandlerOptions<Options, Arguments>) => Promise<number | void> | number | void;
-export type CommandRunOption<C, Options extends OptionsSchema, Arguments extends ArgumentsSchema> = {
+export type CommandRunOption<C = ContextDefinition> = {
     logger: Logger;
     ctx: C;
 } & ({
     args: string[];
 } | {
-    options: OptionsObject<Options>;
-    arguments: ArgumentsObject<Arguments>;
+    args: Record<string, any>;
+    flags: Record<string, any>;
 });
-export type CommandExample = {
-    description: string;
-    command: string;
-};
-export declare class Command<C extends ContextDefinition = ContextDefinition, Options extends OptionsSchema = OptionsSchema, Arguments extends ArgumentsSchema = ArgumentsSchema> {
+export declare abstract class Command<C extends ContextDefinition = ContextDefinition> {
     $type: "BobCommand";
-    readonly _command: string;
-    readonly description: string;
-    readonly group?: string;
-    protected commandsExamples: CommandExample[];
-    get command(): string;
+    static command: string;
+    static description: string;
+    static group?: string;
+    static args: ArgumentsSchema;
+    static flags: FlagsSchema;
+    static examples: CommandRunExample[];
+    static hidden: boolean;
+    static disableDefaultOptions: boolean;
+    static disablePrompting: boolean;
+    static allowUnknownFlags: boolean;
+    static strictMode: boolean;
     protected ctx: C;
     protected io: CommandIO;
-    protected parser: CommandParser<Options, Arguments>;
-    protected disablePromptingFlag: boolean;
-    protected allowUnknownOptionsFlag: boolean;
-    protected hiddenFlag: boolean;
-    protected disableDefaultOptionsFlag: boolean;
-    protected strictModeFlag: boolean;
+    protected parser: CommandParser<FlagsSchema, FlagsSchema>;
     protected preHandle?(): Promise<void | number>;
-    protected _preHandler?: CommandHandler<C, Options, Arguments>;
-    protected handle?(ctx: C, opts: CommandHandlerOptions<Options, Arguments>): Promise<number | void> | number | void;
-    protected _handler?: CommandHandler<C, Options, Arguments>;
-    private tmp?;
-    protected defaultOptions(): CommandOption<Command>[];
+    protected abstract handle(ctx: C, parsed: Parsed<any>): Promise<number | void> | number | void;
+    static baseFlags: FlagsSchema;
     protected newCommandParser(opts: {
+        flags: FlagsSchema;
+        args: ArgumentsSchema;
+        ctx: ContextDefinition;
         io: CommandIO;
-        options: Options;
-        arguments: Arguments;
-    }): CommandParser<Options, Arguments>;
+    }): CommandParser<FlagsSchema, FlagsSchema>;
     protected newCommandIO(opts: CommandIOOptions): CommandIO;
-    constructor(command: string, opts?: {
-        description?: string;
-        group?: string;
-        options?: Options;
-        arguments?: Arguments;
-    });
-    disablePrompting(): this;
-    allowUnknownOptions(): this;
-    hidden(): this;
-    get isHidden(): boolean;
-    disableDefaultOptions(): this;
-    strictMode(): this;
-    preHandler(handler: CommandHandler<C, Options, Arguments>): this;
-    handler(handler: CommandHandler<C, Options, Arguments>): this;
-    options<Opts extends OptionsSchema>(opts: Opts): Command<C, Options & Opts, Arguments>;
-    arguments<Args extends ArgumentsSchema>(args: Args): Command<C, Options, Arguments & Args>;
-    run(opts: CommandRunOption<C, Options, Arguments>): Promise<number | void>;
+    run(runOpts: CommandRunOption<C>): Promise<number | void>;
 }

package/dist/cjs/src/CommandParser.d.ts

@@ -1,49 +1,55 @@
 import { CommandIO } from './CommandIO.js';
-import { OptionDetails } from './lib/optionHelpers.js';
-import { OptionDefinition, OptionReturnType, OptionsObject, OptionsSchema } from './lib/types.js';
+import { ArgumentsSchema, ContextDefinition, FlagDefinition, FlagReturnType, FlagsObject, FlagsSchema } from './lib/types.js';
 /**
- * Parses command-line arguments into typed options and arguments
+ * Parses command-line arguments into typed flags and arguments
  * Handles validation, type conversion, and default values
  */
-export declare class CommandParser<Options extends OptionsSchema, Arguments extends OptionsSchema> {
-    protected options: Options;
-    protected parsedOptions: OptionsObject<Options> | null;
-    protected arguments: Arguments;
-    protected parsedArguments: OptionsObject<Arguments> | null;
+export declare class CommandParser<Flags extends FlagsSchema, Arguments extends ArgumentsSchema> {
+    protected opts: {
+        flags: Flags;
+        args: Arguments;
+        ctx?: ContextDefinition;
+        io: CommandIO;
+    };
+    protected flags: FlagsSchema;
+    protected parsedFlags: FlagsObject<Flags> | null;
+    protected args: ArgumentsSchema;
+    protected parsedArguments: FlagsObject<Arguments> | null;
     protected io: CommandIO;
-    protected shouldPromptForMissingOptions: boolean;
-    protected shouldValidateUnknownOptions: boolean;
+    protected shouldPromptForMissingFlags: boolean;
+    protected shouldValidateUnknownFlags: boolean;
     protected shouldRejectExtraArguments: boolean;
     constructor(opts: {
+        flags: Flags;
+        args: Arguments;
+        ctx?: ContextDefinition;
         io: CommandIO;
-        options: Options;
-        arguments: Arguments;
     });
     /**
-     * Parses raw command-line arguments into structured options and arguments
+     * Parses raw command-line arguments into structured flags and arguments
      * @param args - Raw command line arguments (typically from process.argv.slice(2))
-     * @returns Object containing parsed options and arguments
-     * @throws {InvalidOption} If an naan option is provided
-     * @throws {BadCommandOption} If a value cannot be converted to the expected type
+     * @returns Object containing parsed flags and arguments
+     * @throws {InvalidFlag} If an unknown flag is provided
+     * @throws {BadCommandFlag} If a value cannot be converted to the expected type
      */
-    init(args: string[]): {
-        options: OptionsObject<Options>;
-        arguments: OptionsObject<Arguments>;
-    };
+    init(args: string[]): Promise<{
+        flags: FlagsObject<Flags>;
+        args: FlagsObject<Arguments>;
+    }>;
     /**
-     * Validates the parsed options and arguments
+     * Validates the parsed flags and arguments
      * @throws {Error} If validation fails
      */
     validate(): Promise<void>;
     /**
-     * Retrieves a parsed option value by name
-     * @param name - The option name
-     * @param defaultValue - Optional default value if option is not set
-     * @returns The typed option value
+     * Retrieves a parsed flag value by name
+     * @param name - The flag name
+     * @param defaultValue - Optional default value if flag is not set
+     * @returns The typed flag value
      * @throws {Error} If init() has not been called yet
      */
-    option<OptsName extends keyof Options>(name: OptsName, defaultValue?: OptionReturnType<Options[OptsName]>): OptionReturnType<Options[OptsName]>;
-    setOption<OptsName extends keyof Options>(name: OptsName, value: OptionReturnType<Options[OptsName]>): void;
+    flag<FlagName extends keyof Flags>(name: FlagName, defaultValue?: FlagReturnType<Flags[FlagName]>): FlagReturnType<Flags[FlagName]>;
+    setFlag<FlagName extends keyof Flags>(name: FlagName, value: FlagReturnType<Flags[FlagName]>): Promise<void>;
     /**
      * Retrieves a parsed argument value by name
      * @param name - The argument name
@@ -51,8 +57,8 @@ export declare class CommandParser<Options extends OptionsSchema, Arguments exte
      * @returns The typed argument value
      * @throws {Error} If init() has not been called yet
      */
-    argument<ArgName extends keyof Arguments>(name: ArgName, defaultValue?: OptionReturnType<Arguments[ArgName]>): OptionReturnType<Arguments[ArgName]>;
-    setArgument<ArgName extends keyof Arguments>(name: ArgName, value: OptionReturnType<Arguments[ArgName]>): void;
+    argument<ArgName extends keyof Arguments>(name: ArgName, defaultValue?: FlagReturnType<Arguments[ArgName]>): FlagReturnType<Arguments[ArgName]>;
+    setArgument<ArgName extends keyof Arguments>(name: ArgName, value: FlagReturnType<Arguments[ArgName]>): Promise<void>;
     /**
      * Checks if a value should be considered "empty" for default value purposes
      * @param value - The value to check
@@ -60,12 +66,12 @@ export declare class CommandParser<Options extends OptionsSchema, Arguments exte
      */
     private isEmptyValue;
     /**
-     * Validates that all provided options are recognized
-     * @throws {InvalidOption} If an unknown option is found
+     * Validates that all provided flags are recognized
+     * @throws {InvalidFlag} If an unknown flag is found
      */
-    private validateUnknownOptions;
+    private validateUnknownFlags;
     /**
-     * Processes named options from minimist output
+     * Processes named flags from minimist output
      */
     private handleOptions;
     /**
@@ -73,36 +79,28 @@ export declare class CommandParser<Options extends OptionsSchema, Arguments exte
      */
     private handleArguments;
     /**
-     * Handles variadic arguments that consume all remaining positional values
-     */
-    private handleVariadicArgument;
-    /**
-     * Resolves a single positional argument value with defaults and type conversion
-     * Note: Does not validate required arguments - validation happens in subclass validate() methods
+     * Resolves a flag value from the parsed flag values object
+     * Handles alias resolution, defaults, and type conversion
      */
-    private resolveArgumentValue;
+    private resolveFlagValue;
     /**
-     * Resolves an option value from the parsed option values object
-     * Handles alias resolution, defaults, and type conversion
+     * Parses a raw value using the flag's parse function
      */
-    private resolveOptionValue;
-    optionDefinitions(): Record<string, OptionDetails>;
-    argumentDefinitions(): Record<string, OptionDetails>;
-    availableOptions(): string[];
-    availableArguments(): string[];
+    private parseValue;
+    private safeParse;
     /**
      * Disables prompting for missing argument values
      * Useful for non-interactive environments
      */
     disablePrompting(): this;
-    allowUnknownOptions(): this;
+    allowUnknownFlags(): this;
     strictMode(): this;
     /**
      * Prompts the user to provide a missing argument value via CommandIO
      * Used by validate() when shouldPromptForMissingArgs is enabled
      * @param argumentName - The name of the missing argument
-     * @param argDef - The argument's definition for type and description
+     * @param definition - The argument's definition for type and description
      * @returns The user-provided value, or null if none given
      */
-    protected promptForArgument(argumentName: string, argDef: OptionDefinition): Promise<string | number | string[] | null>;
+    protected promptForArgument(argumentName: string, definition: FlagDefinition): Promise<string | number | string[] | null>;
 }

package/dist/cjs/src/CommandRegistry.d.ts

@@ -2,8 +2,8 @@ import { Command } from './Command.js';
 import { CommandIO, CommandIOOptions } from './CommandIO.js';
 import { Logger } from './Logger.js';
 import { StringSimilarity } from './StringSimilarity.js';
-import { ArgumentsSchema, ContextDefinition, OptionsSchema } from './lib/types.js';
-export type CommandResolver = (path: string) => Promise<Command | null>;
+import { ContextDefinition } from './lib/types.js';
+export type CommandResolver = (path: string) => Promise<typeof Command | null>;
 export type FileImporter = (filePath: string) => Promise<unknown>;
 export type CommandRegistryOptions = {
     logger?: Logger;
@@ -17,14 +17,14 @@ export declare class CommandRegistry {
     protected newCommandIO(opts: CommandIOOptions): CommandIO;
     constructor(opts?: CommandRegistryOptions);
     getAvailableCommands(): string[];
-    getCommands(): Array<Command>;
+    getCommands(): Array<typeof Command>;
     private importFile;
     private commandResolver;
     withCommandResolver(resolver: CommandResolver): this;
     withFileImporter(importer: FileImporter): this;
-    registerCommand<C extends ContextDefinition = ContextDefinition, Opts extends OptionsSchema = OptionsSchema, Args extends ArgumentsSchema = ArgumentsSchema>(command: Command<C, Opts, Args>, force?: boolean): void;
+    registerCommand(command: typeof Command<any>, force?: boolean): void;
     loadCommandsPath(commandsPath: string): Promise<void>;
-    runCommand(ctx: ContextDefinition, command: string | Command, ...args: string[]): Promise<number>;
+    runCommand(ctx: ContextDefinition, command: string | typeof Command | Command, ...args: string[]): Promise<number>;
     private suggestCommand;
     private askRunSimilarCommand;
     private listCommandsFiles;

package/dist/cjs/src/CommandSignatureParser.d.ts

@@ -1,30 +1,24 @@
-import { Command } from './Command.js';
-import { CommandIO } from './CommandIO.js';
-import { CommandParser } from './CommandParser.js';
-import { CommandOption } from './contracts/index.js';
-import { OptionsSchema } from './lib/types.js';
+import { ArgumentsSchema, FlagsSchema } from './lib/types.js';
 /**
- * Extends CommandParser to parse command signatures like "command {arg} {--option}"
- * Handles interactive prompting for missing required arguments via CommandIO
+ * @deprecated This class is deprecated and will be removed in future versions. Use CommandParser with explicit schema definitions instead.
+ * Parses command signature strings like "command {arg} {--option}" into
+ * FlagsSchema and ArgumentsSchema using Flags/Args factories.
  */
-export declare class CommandSignatureParser<Opts extends OptionsSchema = OptionsSchema, Args extends OptionsSchema = OptionsSchema> extends CommandParser<Opts, Args> {
-    readonly command: string;
-    constructor(opts: {
-        io: CommandIO;
-        signature: string;
-        helperDefinitions: {
-            [key: string]: string;
-        };
-        defaultOptions: CommandOption<Command>[];
-    });
+export declare class CommandSignatureParser {
     /**
-     * Parses command signature string into command name and parameter schemas
-     * Example: "migrate {name} {--force}" -> { command: "migrate", arguments: {name: ...}, options: {force: ...} }
+     * Parses a command signature string into command name, flags, and args schemas.
+     *
+     * @example
+     * CommandSignatureParser.parse('migrate {name} {--force}')
+     * // => { command: 'migrate', flags: { force: Flags.boolean() }, args: { name: Args.string({ required: true }) } }
      */
-    private static parseSignature;
+    static parse(signature: string, helperDefinitions?: Record<string, string>): {
+        command: string;
+        flags: FlagsSchema;
+        args: ArgumentsSchema;
+    };
     /**
-     * Parses a single parameter signature like "{name}" or "{--force}" or "{files*}"
-     * Extracts name, type, default value, aliases, description, etc.
+     * Parses a single parameter signature into a FlagDefinition.
      *
      * Signature syntax:
      * - {arg}          -> required string argument
@@ -32,9 +26,12 @@ export declare class CommandSignatureParser<Opts extends OptionsSchema = Options
      * - {arg=default}  -> argument with default value
      * - {arg*}         -> variadic argument (array)
      * - {arg:desc}     -> argument with description
-     * - {--opt}        -> boolean option
-     * - {--opt=}       -> string option
-     * - {--opt|o}      -> option with alias
+     * - {--opt}        -> boolean flag
+     * - {--opt=}       -> string flag
+     * - {--opt=default} -> string flag with default
+     * - {--opt=*}      -> array flag
+     * - {--opt|o}      -> flag with alias
+     * - {--opt=true}   -> boolean flag with default true
      */
     private static parseParamSignature;
 }

package/dist/cjs/src/CommandWithSignature.d.ts

@@ -1,28 +1,24 @@
-import { Command, CommandHandlerOptions } from './Command.js';
-import { CommandIO } from './CommandIO.js';
-import { CommandSignatureParser } from './CommandSignatureParser.js';
-import { ContextDefinition, OptionsSchema } from './lib/types.js';
-export declare abstract class CommandWithSignature<C extends ContextDefinition = ContextDefinition, Opts extends OptionsSchema = OptionsSchema, Args extends OptionsSchema = OptionsSchema> extends Command<C, Opts, Args> {
-    abstract signature: string;
-    abstract description: string;
-    protected helperDefinitions: {
-        [key: string]: string;
-    };
-    protected parser: CommandSignatureParser<Opts, Args>;
-    get command(): string;
-    protected newCommandParser(opts: {
-        io: CommandIO;
-        options: Opts;
-        arguments: Args;
-    }): CommandSignatureParser<Opts, Args>;
-    constructor();
-    protected abstract handle(ctx: C, opts: CommandHandlerOptions<Opts, Args>): Promise<number | void>;
-    protected option<T = string>(key: string): T | null;
-    protected option<T = string>(key: string, defaultValue: T): NoInfer<T>;
+import { Command, CommandRunOption } from './Command.js';
+import { ContextDefinition } from './lib/types.js';
+/**
+ * @deprecated Use `Command` with explicit `flags` and `args` instead. This class will be removed in a future major release.
+ *
+ * CommandWithSignature allows defining a command using a concise signature string, which is parsed to generate flags and arguments.
+ * The signature is parsed lazily on first run to avoid unnecessary overhead if the command is never executed.
+ */
+export declare abstract class CommandWithSignature<C extends ContextDefinition = ContextDefinition> extends Command<C> {
+    static signature: string;
+    static helperDefinitions: Record<string, string>;
+    static get command(): string;
+    run(runOpts: CommandRunOption<C>): Promise<number | void>;
+    /**
+     * Convenience accessor for a parsed flag value.
+     */
+    protected flag<T = string>(key: string): T | null;
+    protected flag<T = string>(key: string, defaultValue: T): NoInfer<T>;
+    /**
+     * Convenience accessor for a parsed argument value.
+     */
     protected argument<T = string>(key: string): T | null;
     protected argument<T = string>(key: string, defaultValue: T): NoInfer<T>;
-    askForConfirmation(...opts: Parameters<typeof this.io.askForConfirmation>): ReturnType<typeof this.io.askForConfirmation>;
-    askForInput(...opts: Parameters<typeof this.io.askForInput>): ReturnType<typeof this.io.askForInput>;
-    askForSelect(...opts: Parameters<typeof this.io.askForSelect>): ReturnType<typeof this.io.askForSelect>;
-    newLoader(...opts: Parameters<typeof this.io.newLoader>): ReturnType<typeof this.io.newLoader>;
 }

package/dist/cjs/src/Flags.d.ts

@@ -0,0 +1,25 @@
+import { BooleanFlagDef, CustomFlagDef, DirectoryFlagDef, EnumFlagDef, FileFlagDef, FlagInput, NumberFlagDef, StringFlagDef, UrlFlagDef } from './lib/types.js';
+export declare const Flags: {
+    string<const T extends FlagInput<StringFlagDef>>(opts?: T): StringFlagDef & T;
+    number<const T extends FlagInput<NumberFlagDef>>(opts?: T): NumberFlagDef & T;
+    boolean<const T extends FlagInput<BooleanFlagDef>>(opts?: T): BooleanFlagDef & T;
+    enum<const T extends readonly string[], const U extends FlagInput<EnumFlagDef<T>, "options">>(opts: {
+        options: T;
+    } & U): EnumFlagDef<T> & U;
+    file<const T extends FlagInput<FileFlagDef>>(opts?: T): FileFlagDef & T;
+    directory<const T extends FlagInput<DirectoryFlagDef>>(opts?: T): DirectoryFlagDef & T;
+    url<const T extends FlagInput<UrlFlagDef>>(opts?: T): UrlFlagDef & T;
+    custom<T>(defaults?: FlagInput<CustomFlagDef<T>>): <const U extends FlagInput<CustomFlagDef<T>>>(overrides?: U) => CustomFlagDef<T> & U;
+};
+export declare const Args: {
+    string<const T extends FlagInput<StringFlagDef>>(opts?: T): StringFlagDef & T;
+    number<const T extends FlagInput<NumberFlagDef>>(opts?: T): NumberFlagDef & T;
+    boolean<const T extends FlagInput<BooleanFlagDef>>(opts?: T): BooleanFlagDef & T;
+    enum<const T extends readonly string[], const U extends FlagInput<EnumFlagDef<T>, "options">>(opts: {
+        options: T;
+    } & U): EnumFlagDef<T> & U;
+    file<const T extends FlagInput<FileFlagDef>>(opts?: T): FileFlagDef & T;
+    directory<const T extends FlagInput<DirectoryFlagDef>>(opts?: T): DirectoryFlagDef & T;
+    url<const T extends FlagInput<UrlFlagDef>>(opts?: T): UrlFlagDef & T;
+    custom<T>(defaults?: FlagInput<CustomFlagDef<T>>): <const U extends FlagInput<CustomFlagDef<T>>>(overrides?: U) => CustomFlagDef<T> & U;
+};

package/dist/cjs/src/commands/HelpCommand.d.ts

@@ -7,6 +7,8 @@ export type HelpCommandOptions = {
 };
 export default class HelpCommand extends Command {
     private opts;
+    static command: string;
+    static description: string;
     constructor(opts: HelpCommandOptions);
     handle(): Promise<void>;
 }

package/dist/cjs/src/contracts/index.d.ts

@@ -1,2 +1 @@
-export * from './CommandOption.js';
 export * from './LoggerContract.js';

package/dist/cjs/src/errors/BadCommandArgument.d.ts

@@ -0,0 +1,14 @@
+import { Logger } from '../Logger.js';
+import { BobError } from './BobError.js';
+import { FlagDefinition } from '../lib/types.js';
+export type ArgumentProps = {
+    arg: string;
+    value?: any;
+    reason?: string;
+};
+export declare class BadCommandArgument extends BobError {
+    readonly detail: ArgumentProps;
+    readonly argDefinition?: FlagDefinition | undefined;
+    constructor(detail: ArgumentProps, argDefinition?: FlagDefinition | undefined);
+    pretty(logger: Logger): void;
+}

package/dist/cjs/src/errors/BadCommandFlag.d.ts

@@ -0,0 +1,14 @@
+import { Logger } from '../Logger.js';
+import { BobError } from './BobError.js';
+import { FlagDefinition } from '../lib/types.js';
+export type FlagProps = {
+    flag: string;
+    value?: any;
+    reason?: string;
+};
+export declare class BadCommandFlag extends BobError {
+    readonly param: FlagProps;
+    readonly flagDefinition?: FlagDefinition | undefined;
+    constructor(param: FlagProps, flagDefinition?: FlagDefinition | undefined);
+    pretty(logger: Logger): void;
+}

package/dist/cjs/src/errors/InvalidFlag.d.ts

@@ -0,0 +1,9 @@
+import { Logger } from '../Logger.js';
+import { BobError } from './BobError.js';
+import { FlagsSchema } from '../lib/types.js';
+export declare class InvalidFlag extends BobError {
+    private flag;
+    private flagsSchema;
+    constructor(flag: string, flagsSchema?: FlagsSchema);
+    pretty(logger: Logger): void;
+}

package/dist/cjs/src/errors/MissingRequiredFlagValue.d.ts

@@ -0,0 +1,7 @@
+import { Logger } from '../Logger.js';
+import { BobError } from './BobError.js';
+export declare class MissingRequiredFlagValue extends BobError {
+    readonly flag: string;
+    constructor(flag: string);
+    pretty(logger: Logger): void;
+}

package/dist/cjs/src/errors/index.d.ts

@@ -1,8 +1,8 @@
 export * from './BobError.js';
-export * from './BadCommandParameter.js';
-export * from './BadCommandOption.js';
-export * from './InvalidOption.js';
+export * from './BadCommandArgument.js';
+export * from './BadCommandFlag.js';
+export * from './InvalidFlag.js';
 export * from './CommandNotFoundError.js';
 export * from './MissingRequiredArgumentValue.js';
-export * from './MissingRequiredOptionValue.js';
+export * from './MissingRequiredFlagValue.js';
 export * from './TooManyArguments.js';

package/dist/cjs/src/index.d.ts

@@ -1,14 +1,15 @@
 export * from './Command.js';
-export * from './CommandWithSignature.js';
 export * from './CommandIO.js';
 export * from './CommandParser.js';
-export * from './CommandSignatureParser.js';
 export * from './CommandRegistry.js';
+export * from './CommandSignatureParser.js';
+export * from './CommandWithSignature.js';
 export * from './Cli.js';
 export * from './Logger.js';
 export * from './ExceptionHandler.js';
 export * from './StringSimilarity.js';
 export * from './lib/types.js';
+export * from './Flags.js';
 export * from './errors/index.js';
 export * from './options/index.js';
 export * from './contracts/index.js';