bob-core 1.4.0 → 2.0.0-beta.2

package/dist/esm/package-COKp1myj.js

@@ -0,0 +1,31 @@
+const s = "bob-core", t = "2.0.0-beta.2", e = "BOB Core", i = "module", l = !1, n = ["dist/**"], r = { ".": { import: "./dist/esm/index.js", require: "./dist/cjs/index.js" } }, o = { "*": { "*": ["./dist/cjs/*.d.ts"] } }, c = { start: "node -r @swc-node/register debug/main.ts", build: "rimraf ./dist && vite build", typecheck: "tsc --noEmit", prepare: "npm run build", test: "vitest run" }, d = "Léo Hubert", p = "ISC", a = { "@faker-js/faker": "^10.0.0", "@swc-node/register": "^1.11.1", "@types/minimist": "^1.2.5", "@types/node": "^20.14.5", "@types/prompts": "^2.4.9", "@types/string-similarity": "^4.0.2", "@vitest/coverage-v8": "^3.2.4", rimraf: "^6.0.1", tsx: "^4.20.6", typescript: "^5.7.3", vite: "^7.1.6", "vite-plugin-dts": "^4.5.4", vitest: "^3.2.4" }, m = { chalk: "^4.1.2", minimist: "^1.2.8", prompts: "^2.4.2", "string-similarity": "^4.0.4" }, u = {
+  name: s,
+  version: t,
+  description: e,
+  type: i,
+  sideEffects: !1,
+  files: n,
+  exports: r,
+  typesVersions: o,
+  scripts: c,
+  author: d,
+  license: p,
+  devDependencies: a,
+  dependencies: m
+};
+export {
+  d as author,
+  u as default,
+  m as dependencies,
+  e as description,
+  a as devDependencies,
+  r as exports,
+  n as files,
+  p as license,
+  s as name,
+  c as scripts,
+  l as sideEffects,
+  i as type,
+  o as typesVersions,
+  t as version
+};

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

@@ -1,26 +1,33 @@
 import { CommandRegistry } from './CommandRegistry.js';
-import { Command } from './Command.js';
-import { default as HelpCommand } from './commands/HelpCommand.js';
+import { default as HelpCommand, HelpCommandOptions } from './commands/HelpCommand.js';
 import { ExceptionHandler } from './ExceptionHandler.js';
-export type CliOptions<C> = {
+import { Command } from './Command.js';
+import { Logger } from './Logger.js';
+export type CliOptions<C = any> = {
     ctx?: C;
     name?: string;
     version?: string;
+    logger?: Logger;
 };
-export declare class Cli<C> {
+export declare class Cli<C = any> {
+    private readonly ctx?;
+    private readonly logger;
     readonly commandRegistry: CommandRegistry;
     private readonly exceptionHandler;
-    private readonly ctx?;
     private readonly helpCommand;
-    get CommandRegistryClass(): typeof CommandRegistry;
-    get HelpCommandClass(): typeof HelpCommand;
-    get ExceptionHandlerClass(): typeof ExceptionHandler;
+    protected newCommandRegistry(opts: {
+        logger: Logger;
+    }): CommandRegistry;
+    protected newHelpCommand(opts: HelpCommandOptions): HelpCommand;
+    protected newExceptionHandler(opts: {
+        logger: Logger;
+    }): ExceptionHandler;
     constructor(opts?: CliOptions<C>);
     setCommandResolver(resolver: (path: string) => Promise<Command<C>>): void;
-    withCommands(...commands: Array<Command<C> | {
+    withCommands(...commands: Array<Command<C, any, any> | {
         new (): Command<C>;
     } | string>): Promise<void>;
-    runCommand(command: string | Command, ...args: any[]): Promise<number>;
+    runCommand(command: string | Command | undefined, ...args: any[]): Promise<number>;
     runHelpCommand(): Promise<number>;
     protected registerCommand(command: Command<C>): void;
 }

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

@@ -1,45 +1,58 @@
+import { OptionsSchema, OptionsObject, ArgumentsSchema, ArgumentsObject } from './lib/types.js';
 import { CommandParser } from './CommandParser.js';
+import { CommandSignatureParser } from './CommandSignatureParser.js';
 import { CommandOption } from './contracts/index.js';
 import { CommandIO } from './CommandIO.js';
+import { Logger } from './Logger.js';
+export type CommandHandlerOptions<Options extends OptionsSchema, Arguments extends ArgumentsSchema> = {
+    options: OptionsObject<Options>;
+    arguments: ArgumentsObject<Arguments>;
+};
+export type CommandHandler<C, Options extends OptionsSchema, Arguments extends ArgumentsSchema> = (ctx: C, opts: CommandHandlerOptions<Options, Arguments>) => Promise<number | void> | number | void;
+type BaseCommandRunOption<C> = {
+    logger: Logger;
+    ctx: C;
+};
+export type CommandRunArgsOption<C> = {
+    args: string[];
+} & BaseCommandRunOption<C>;
+export type CommandRunParsedOption<C, Options extends OptionsSchema, Arguments extends ArgumentsSchema> = {
+    options: OptionsObject<Options>;
+    arguments: ArgumentsObject<Arguments>;
+} & BaseCommandRunOption<C>;
+export type CommandRunOption<C, Options extends OptionsSchema, Arguments extends ArgumentsSchema> = CommandRunArgsOption<C> | CommandRunParsedOption<C, Options, Arguments>;
 export type CommandExample = {
     description: string;
     command: string;
 };
-export declare abstract class Command<C = any> {
-    abstract signature: string;
-    abstract description: string;
-    protected ctx: C;
-    protected helperDefinitions: {
-        [key: string]: string;
-    };
+export declare class Command<C = any, Options extends OptionsSchema = {}, Arguments extends ArgumentsSchema = {}> {
+    readonly _command: string;
+    readonly description: string;
     protected commandsExamples: CommandExample[];
-    protected parser: CommandParser;
+    get command(): string;
+    protected ctx: C;
     protected io: CommandIO;
-    protected abstract handle(): Promise<void | number>;
+    protected logger: Logger;
+    protected _handler?: CommandHandler<C, Options, Arguments>;
+    protected parser: CommandParser<Options, Arguments>;
+    private tmp?;
+    protected defaultOptions(): CommandOption<Command<any, any, any>>[];
+    protected newCommandParser(opts: {
+        io: CommandIO;
+        options: Options;
+        arguments: Arguments;
+    }): CommandParser<Options, Arguments> | CommandSignatureParser;
+    protected newCommandIO(opts: {
+        logger: Logger;
+    }): CommandIO;
+    constructor(command: string, opts?: {
+        description?: string;
+    });
     protected preHandle?(): Promise<void | number>;
-    protected get CommandParserClass(): typeof CommandParser;
-    protected get CommandIOClass(): typeof CommandIO;
-    protected defaultOptions(): CommandOption<Command<C>>[];
-    get command(): string;
-    run(ctx: C, ...args: any[]): Promise<number>;
-    protected setOption(name: string, value: any): void;
-    protected setArgument(name: string, value: any): void;
-    protected option<T = string>(key: string): T | null;
-    protected option<T = string>(key: string, defaultValue: T): NoInfer<T>;
-    protected optionBoolean(key: string, defaultValue?: boolean): boolean;
-    protected optionArray<T = string>(key: string, defaultValue?: Array<T>): Array<NoInfer<T>>;
-    protected optionNumber(key: string): number | null;
-    protected optionNumber(key: string, defaultValue: number): number;
-    protected argument<T = string>(key: string): T | null;
-    protected argument<T = string>(key: string, defaultValue: T): NoInfer<T>;
-    protected argumentArray<T = string>(key: string, defaultValue?: Array<any>): Array<T>;
-    protected argumentBoolean(key: string, defaultValue?: boolean): boolean;
-    protected argumentNumber(key: string, defaultValue?: number | null): number | null;
-    /**
-     * Prompt utils
-     */
-    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>;
+    protected handle?(ctx: C, opts: CommandHandlerOptions<Options, Arguments>): Promise<number | void> | number | void;
+    handler(handler: CommandHandler<C, Options, Arguments>): Command<C, Options, Arguments>;
+    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>;
 }
+export {};

package/dist/esm/src/CommandIO.d.ts

@@ -1,3 +1,4 @@
+import { Logger } from './Logger.js';
 export type SelectOption = {
     title: string;
     value?: any;
@@ -6,6 +7,17 @@ export type SelectOption = {
     description?: string | undefined;
 };
 export declare class CommandIO {
+    private logger;
+    constructor(logger: Logger);
+    /**
+     * Logger methods
+     */
+    log(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    debug(...args: any[]): void;
+    verbose(...args: any[]): void;
     /**
      * Prompt utils
      */

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

@@ -1,48 +1,80 @@
-import { CommandOption } from './contracts/index.js';
+import { OptionsSchema, OptionReturnType, OptionsObject } from './lib/types.js';
+import { OptionDetails } from './lib/optionHelpers.js';
 import { CommandIO } from './CommandIO.js';
-export type ArgSignature = {
-    name: string;
-    type: 'string' | 'boolean' | 'array';
-    optional?: boolean;
-    variadic?: boolean;
-    alias?: string[];
-    help?: string;
-    defaultValue: string | boolean | Array<string> | null;
-    isOption?: boolean;
-};
-export declare class CommandParser {
-    protected readonly io: CommandIO;
-    protected readonly signature: string;
-    protected readonly helperDefinitions: {
-        [key: string]: string;
+/**
+ * Parses command-line arguments into typed options 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;
+    protected io: CommandIO;
+    constructor(opts: {
+        io: CommandIO;
+        options: Options;
+        arguments: Arguments;
+    });
+    /**
+     * Parses raw command-line arguments into structured options 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 unknown option is provided
+     * @throws {BadCommandOption} If a value cannot be converted to the expected type
+     */
+    init(args: string[]): {
+        options: OptionsObject<Options>;
+        arguments: OptionsObject<Arguments>;
     };
-    protected readonly defaultCommandOptions: CommandOption<any>[];
-    command: string;
-    private arguments;
-    private options;
-    private argumentsSignature;
-    private optionSignatures;
-    private optionAliases;
-    constructor(io: CommandIO, signature: string, helperDefinitions: {
-        [key: string]: string;
-    }, defaultCommandOptions: CommandOption<any>[], ...args: any[]);
-    option(name: string): any;
-    setOption(name: string, value: any): void;
-    optionHelp(name: string): string | undefined;
-    argument(name: string): any;
-    setArgument(name: string, value: any): void;
-    argumentHelp(name: string): string | undefined;
-    getArgumentSignatures(): {
-        [argument: string]: ArgSignature;
-    };
-    getOptionSignatures(): {
-        [option: string]: ArgSignature;
-    };
-    private getParamValue;
-    private handleArguments;
-    private handleOptions;
-    private parseSignature;
-    private parseDefaultOptions;
-    private parseParamSignature;
+    /**
+     * Validates the parsed options and arguments
+     * @throws {Error} If validation fails
+     */
     validate(): Promise<void>;
+    /**
+     * Retrieves a parsed option value by name
+     * @param name - The option name
+     * @returns The typed option value
+     * @throws {Error} If init() has not been called yet
+     */
+    option<OptsName extends keyof Options>(name: OptsName): OptionReturnType<Options[OptsName]>;
+    /**
+     * Retrieves a parsed argument value by name
+     * @param name - The argument name
+     * @returns The typed argument value
+     * @throws {Error} If init() has not been called yet
+     */
+    argument<ArgName extends keyof Arguments>(name: ArgName): OptionReturnType<Arguments[ArgName]>;
+    /**
+     * Validates that all provided options are recognized
+     * @throws {InvalidOption} If an unknown option is found
+     */
+    private validateUnknownOptions;
+    /**
+     * Processes named options from minimist output
+     */
+    private handleOptions;
+    /**
+     * Processes positional arguments from minimist output
+     */
+    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
+     */
+    private resolveArgumentValue;
+    /**
+     * Resolves an option value from the parsed option values object
+     * Handles alias resolution, defaults, and type conversion
+     */
+    private resolveOptionValue;
+    optionDefinitions(): Record<string, OptionDetails>;
+    argumentDefinitions(): Record<string, OptionDetails>;
+    availableOptions(): string[];
+    availableArguments(): string[];
 }

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

@@ -1,17 +1,18 @@
-import { Command } from './Command.js';
 import { CommandIO } from './CommandIO.js';
+import { Command } from './Command.js';
+import { Logger } from './Logger.js';
 export type CommandResolver = (path: string) => Promise<Command>;
 export declare class CommandRegistry {
     private readonly commands;
     protected readonly io: CommandIO;
-    get commandSuffix(): string;
+    protected readonly logger: Logger;
     protected get CommandIOClass(): typeof CommandIO;
-    constructor();
+    constructor(logger?: Logger);
     getAvailableCommands(): string[];
-    getCommands(): Command[];
+    getCommands(): Array<Command>;
     private commandResolver;
-    setCommandResolver(resolver: (path: string) => Promise<Command>): void;
-    registerCommand(command: Command, force?: boolean): void;
+    setCommandResolver(resolver: CommandResolver): void;
+    registerCommand(command: Command<any, any, any>, force?: boolean): void;
     loadCommandsPath(commandsPath: string): Promise<void>;
     runCommand(ctx: any, command: string | Command, ...args: any[]): Promise<number>;
     private suggestCommand;

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

@@ -0,0 +1,85 @@
+import { CommandOption } from './contracts/index.js';
+import { CommandIO } from './CommandIO.js';
+import { OptionsObject, OptionsSchema } from './lib/types.js';
+import { CommandParser } from './CommandParser.js';
+/**
+ * Extends CommandParser to parse command signatures like "command {arg} {--option}"
+ * Handles interactive prompting for missing required arguments via CommandIO
+ */
+export declare class CommandSignatureParser<Opts extends OptionsSchema = any, Args extends OptionsSchema = any> extends CommandParser<Opts, Args> {
+    readonly command: string;
+    private readonly argumentsSchema;
+    private readonly optionsSchema;
+    constructor(opts: {
+        io: CommandIO;
+        signature: string;
+        helperDefinitions: {
+            [key: string]: string;
+        };
+        defaultOptions: CommandOption<any>[];
+    });
+    /**
+     * Parses command signature string into command name and parameter schemas
+     * Example: "migrate {name} {--force}" -> { command: "migrate", arguments: {name: ...}, options: {force: ...} }
+     */
+    private static parseSignature;
+    /**
+     * Retrieves an option value by name, with signature validation
+     */
+    option(name: any): any;
+    /**
+     * Sets an option value programmatically
+     */
+    setOption(name: string, value: any): void;
+    /**
+     * Retrieves the description/help text for an option
+     */
+    optionHelp(name: string): string | undefined;
+    /**
+     * Retrieves the description/help text for an argument
+     */
+    argumentHelp(name: string): string | undefined;
+    /**
+     * Retrieves an argument value by name, with signature validation
+     */
+    argument(name: any): any;
+    /**
+     * Sets an argument value programmatically
+     */
+    setArgument(name: string, value: any): void;
+    /**
+     * Returns all argument definitions from the signature
+     */
+    getArgumentSignatures(): OptionsSchema;
+    /**
+     * Returns all option definitions from the signature
+     */
+    getOptionSignatures(): OptionsSchema;
+    /**
+     * Parses a single parameter signature like "{name}" or "{--force}" or "{files*}"
+     * Extracts name, type, default value, aliases, description, etc.
+     *
+     * Signature syntax:
+     * - {arg}          -> required string argument
+     * - {arg?}         -> optional argument
+     * - {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
+     */
+    private static parseParamSignature;
+    /**
+     * Validates that all required arguments are present
+     * If missing, prompts the user via CommandIO to provide them
+     * @throws {MissingRequiredArgumentValue} If a required argument cannot be obtained
+     */
+    validate(): Promise<void>;
+    /**
+     * Prompts the user to provide a missing argument value via CommandIO
+     */
+    private promptForArgument;
+    optionValues(): OptionsObject<Opts>;
+    argumentValues(): OptionsObject<Args>;
+}

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

@@ -0,0 +1,37 @@
+import { Command, CommandHandlerOptions } from './Command.js';
+import { CommandIO } from './CommandIO.js';
+import { CommandSignatureParser } from './CommandSignatureParser.js';
+import { OptionsSchema } from './lib/types.js';
+export declare abstract class CommandWithSignature<C = any, Opts extends OptionsSchema = {}, Args extends OptionsSchema = {}> extends Command<C, Opts, Args> {
+    abstract signature: string;
+    abstract description: string;
+    protected helperDefinitions: {
+        [key: string]: string;
+    };
+    get command(): string;
+    parser: CommandSignatureParser<Opts, Args>;
+    protected newCommandParser(opts: {
+        io: CommandIO;
+        options: Opts;
+        arguments: Args;
+    }): CommandSignatureParser;
+    constructor();
+    protected abstract handle(ctx: C, opts: CommandHandlerOptions<Opts, Args>): Promise<number | void>;
+    protected setOption(name: string, value: any): void;
+    protected setArgument(name: string, value: any): void;
+    protected option<T = string>(key: string): T | null;
+    protected option<T = string>(key: string, defaultValue: T): NoInfer<T>;
+    protected optionBoolean(key: string, defaultValue?: boolean): boolean;
+    protected optionArray<T = string>(key: string, defaultValue?: Array<T>): Array<NoInfer<T>>;
+    protected optionNumber(key: string): number | null;
+    protected optionNumber(key: string, defaultValue: number): number;
+    protected argument<T = string>(key: string): T | null;
+    protected argument<T = string>(key: string, defaultValue: T): NoInfer<T>;
+    protected argumentArray<T = string>(key: string, defaultValue?: Array<any>): Array<T>;
+    protected argumentBoolean(key: string, defaultValue?: boolean): boolean;
+    protected argumentNumber(key: string, defaultValue?: number | null): number | null;
+    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/esm/src/ExceptionHandler.d.ts

@@ -1,4 +1,7 @@
 import { BobError } from './errors/index.js';
+import { Logger } from './Logger.js';
 export declare class ExceptionHandler {
+    private readonly logger;
+    constructor(logger: Logger);
     handle(err: Error | BobError): number;
 }

package/dist/esm/src/Logger.d.ts

@@ -0,0 +1,17 @@
+export type LogLevel = 'debug' | 'verbose' | 'info' | 'warn' | 'error' | 'silent';
+export type LoggerOptions = {
+    level?: LogLevel;
+};
+export declare class Logger {
+    private level;
+    constructor(opts?: LoggerOptions);
+    private shouldLog;
+    setLevel(level: LogLevel): void;
+    getLevel(): LogLevel;
+    log(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    debug(...args: any[]): void;
+    verbose(...args: any[]): void;
+}

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

@@ -1,5 +1,5 @@
-import { Command } from '../Command.js';
 import { CommandRegistry } from '../CommandRegistry.js';
+import { Command } from '../Command.js';
 export type HelpCommandOptions = {
     commandRegistry: CommandRegistry;
     cliName?: string;
@@ -7,8 +7,6 @@ export type HelpCommandOptions = {
 };
 export default class HelpCommand extends Command {
     private opts;
-    signature: string;
-    description: string;
     constructor(opts: HelpCommandOptions);
-    protected handle(): Promise<void>;
+    handle(): Promise<void>;
 }

package/dist/esm/src/contracts/CommandOption.d.ts

@@ -1,7 +1,6 @@
-export interface CommandOption<C> {
+import { OptionDefinition } from '../lib/types.js';
+import { Command } from '../Command.js';
+export interface CommandOption<C extends Command> extends OptionDefinition {
     option: string;
-    alias?: string[];
-    defaultValue: string | boolean | Array<string> | null;
-    description?: string;
     handler(this: C): Promise<number | void>;
 }

package/dist/esm/src/contracts/LoggerContract.d.ts

@@ -0,0 +1,14 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'verbose';
+/**
+ * Logger interface defining standard logging methods and level management
+ */
+export interface LoggerContract {
+    log(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    debug(message: string, ...args: any[]): void;
+    verbose(message: string, ...args: any[]): void;
+    setLevel(level: LogLevel): void;
+    getLevel(): LogLevel;
+}

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

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

package/dist/esm/src/errors/BadCommandOption.d.ts

@@ -7,5 +7,5 @@ export type OptionProps = {
 export declare class BadCommandOption extends BobError {
     readonly param: OptionProps;
     constructor(param: OptionProps);
-    pretty(): void;
+    pretty(io: any): void;
 }

package/dist/esm/src/errors/BadCommandParameter.d.ts

@@ -7,5 +7,5 @@ export type ParameterProps = {
 export declare class BadCommandParameter extends BobError {
     readonly param: ParameterProps;
     constructor(param: ParameterProps);
-    pretty(): void;
+    pretty(io: any): void;
 }

package/dist/esm/src/errors/BobError.d.ts

@@ -1,3 +1,4 @@
+import { Logger } from '../Logger.js';
 export declare abstract class BobError extends Error {
-    abstract pretty(): void;
+    abstract pretty(logger: Logger): void;
 }

package/dist/esm/src/errors/CommandNotFoundError.d.ts

@@ -2,5 +2,5 @@ import { BobError } from './BobError.js';
 export declare class CommandNotFoundError extends BobError {
     readonly command: string;
     constructor(command: string);
-    pretty(): void;
+    pretty(io: any): void;
 }

package/dist/esm/src/errors/InvalidOption.d.ts

@@ -1,8 +1,8 @@
 import { BobError } from './BobError.js';
-import { ArgSignature } from '../CommandParser.js';
+import { OptionsSchema } from '../lib/types.js';
 export declare class InvalidOption extends BobError {
     private option;
-    private optionsSignature;
-    constructor(option: string, optionsSignature: ArgSignature[]);
-    pretty(): void;
+    private optionsSchema;
+    constructor(option: string, optionsSchema?: OptionsSchema);
+    pretty(io: any): void;
 }

package/dist/esm/src/errors/MissingRequiredArgumentValue.d.ts

@@ -1,7 +1,6 @@
 import { BobError } from './BobError.js';
-import { ArgSignature } from '../CommandParser.js';
 export declare class MissingRequiredArgumentValue extends BobError {
-    readonly paramSignature: ArgSignature;
-    constructor(paramSignature: ArgSignature);
-    pretty(): void;
+    readonly argument: string;
+    constructor(argument: string);
+    pretty(io: any): void;
 }

package/dist/esm/src/errors/MissingRequiredOptionValue.d.ts

@@ -0,0 +1,6 @@
+import { BobError } from './BobError.js';
+export declare class MissingRequiredOptionValue extends BobError {
+    readonly option: string;
+    constructor(option: string);
+    pretty(io: any): void;
+}

package/dist/esm/src/errors/MissingSignatureArgument.d.ts

@@ -1,8 +1,8 @@
 import { BobError } from './BobError.js';
-import { ArgSignature } from '../CommandParser.js';
+import { OptionsSchema } from '../lib/types.js';
 export declare class MissingSignatureArgument extends BobError {
     private argument;
-    private argumentSignatures;
-    constructor(argument: string, argumentSignatures: ArgSignature[]);
-    pretty(): void;
+    private argumentsSchema;
+    constructor(argument: string, argumentsSchema: OptionsSchema);
+    pretty(io: any): void;
 }

package/dist/esm/src/errors/MissingSignatureOption.d.ts

@@ -1,8 +1,8 @@
 import { BobError } from './BobError.js';
-import { ArgSignature } from '../CommandParser.js';
+import { OptionsSchema } from '../lib/types.js';
 export declare class MissingSignatureOption extends BobError {
     private option;
-    private optionsSignature;
-    constructor(option: string, optionsSignature: ArgSignature[]);
-    pretty(): void;
+    private optionsSchema;
+    constructor(option: string, optionsSchema: OptionsSchema);
+    pretty(io: any): void;
 }

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

@@ -1,3 +1,9 @@
 export * from './BobError.js';
 export * from './BadCommandParameter.js';
 export * from './BadCommandOption.js';
+export * from './InvalidOption.js';
+export * from './CommandNotFoundError.js';
+export * from './MissingSignatureArgument.js';
+export * from './MissingSignatureOption.js';
+export * from './MissingRequiredArgumentValue.js';
+export * from './MissingRequiredOptionValue.js';