bob-core 1.4.0 → 2.0.0-beta.10

package/dist/esm/package-O5nP1XlU.js

@@ -0,0 +1,31 @@
+const t = "bob-core", e = "2.0.0-beta.10", s = "BOB Core", i = "module", m = !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", prepack: "npm run build", test: "vitest run", lint: "eslint .", "lint:fix": "eslint . --fix" }, p = "Léo Hubert", d = "ISC", l = { "@eslint/js": "^9.37.0", "@faker-js/faker": "^10.0.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": "^3.2.4", eslint: "^9.37.0", "eslint-config-prettier": "^10.1.8", "eslint-plugin-prettier": "^5.5.4", prettier: "^3.6.2", rimraf: "^6.0.1", tsx: "^4.20.6", typescript: "^5.7.3", "typescript-eslint": "^8.46.0", vite: "^7.1.6", "vite-plugin-dts": "^4.5.4", vitest: "^3.2.4" }, a = { chalk: "^5.6.2", minimist: "^1.2.8", prompts: "^2.4.2", "string-similarity": "^4.0.4" }, f = {
+  name: t,
+  version: e,
+  description: s,
+  type: i,
+  sideEffects: !1,
+  files: n,
+  exports: r,
+  typesVersions: o,
+  scripts: c,
+  author: p,
+  license: d,
+  devDependencies: l,
+  dependencies: a
+};
+export {
+  p as author,
+  f as default,
+  a as dependencies,
+  s as description,
+  l as devDependencies,
+  r as exports,
+  n as files,
+  d as license,
+  t as name,
+  c as scripts,
+  m as sideEffects,
+  i as type,
+  o as typesVersions,
+  e as version
+};

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

@@ -1,26 +1,35 @@
-import { CommandRegistry } from './CommandRegistry.js';
 import { Command } from './Command.js';
-import { default as HelpCommand } from './commands/HelpCommand.js';
+import { CommandRegistry, CommandResolver, FileImporter } from './CommandRegistry.js';
 import { ExceptionHandler } from './ExceptionHandler.js';
-export type CliOptions<C> = {
+import { Logger } from './Logger.js';
+import { default as HelpCommand, HelpCommandOptions } from './commands/HelpCommand.js';
+import { ContextDefinition, OptionsSchema } from './lib/types.js';
+export type CliOptions<C extends ContextDefinition = ContextDefinition> = {
     ctx?: C;
     name?: string;
     version?: string;
+    logger?: Logger;
 };
-export declare class Cli<C> {
+export declare class Cli<C extends ContextDefinition = ContextDefinition> {
+    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> | {
+    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, ...args: any[]): Promise<number>;
+    runCommand(command: string | Command | undefined, ...args: string[]): Promise<number>;
     runHelpCommand(): Promise<number>;
-    protected registerCommand(command: Command<C>): void;
+    protected registerCommand(command: Command<C, OptionsSchema, OptionsSchema>): void;
 }

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

@@ -1,45 +1,61 @@
+import { CommandIO } from './CommandIO.js';
 import { CommandParser } from './CommandParser.js';
+import { Logger } from './Logger.js';
 import { CommandOption } from './contracts/index.js';
-import { CommandIO } from './CommandIO.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>;
+};
+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> = {
+    logger: Logger;
+    ctx: C;
+} & ({
+    args: string[];
+} | {
+    options: OptionsObject<Options>;
+    arguments: ArgumentsObject<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 extends ContextDefinition = ContextDefinition, Options extends OptionsSchema = OptionsSchema, Arguments extends ArgumentsSchema = ArgumentsSchema> {
+    readonly _command: string;
+    readonly description: string;
+    readonly group?: string;
     protected commandsExamples: CommandExample[];
-    protected parser: CommandParser;
+    get command(): string;
+    protected ctx: C | undefined;
     protected io: CommandIO;
-    protected abstract handle(): Promise<void | number>;
+    protected logger: Logger;
+    protected parser: CommandParser<Options, Arguments>;
+    protected disablePromptingFlag: boolean;
     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 _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 newCommandParser(opts: {
+        io: CommandIO;
+        options: Options;
+        arguments: Arguments;
+    }): CommandParser<Options, Arguments>;
+    protected newCommandIO(opts: {
+        logger: Logger;
+    }): CommandIO;
+    constructor(command: string, opts?: {
+        description?: string;
+        group?: string;
+        options?: Options;
+        arguments?: Arguments;
+    });
+    disablePrompting(): 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>;
 }

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

@@ -1,11 +1,22 @@
+import { Logger } from './Logger.js';
 export type SelectOption = {
     title: string;
-    value?: any;
+    value?: unknown;
     disabled?: boolean | undefined;
     selected?: boolean | undefined;
     description?: string | undefined;
 };
 export declare class CommandIO {
+    private logger;
+    constructor(logger: Logger);
+    /**
+     * Logger methods
+     */
+    log(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
     /**
      * Prompt utils
      */
@@ -16,6 +27,15 @@ export declare class CommandIO {
         min?: number;
         max?: number;
     }): Promise<string | null>;
+    askForDate(message: string, defaultValue?: Date, opts?: {
+        validate?: (value: Date) => boolean | string;
+        mask?: string;
+    }): Promise<Date | null>;
+    askForList(message: string, defaultValue?: string | number, opts?: {
+        validate?: (value: string) => boolean | string;
+        format?: (value: string) => string;
+        separator?: string;
+    }): Promise<string[] | null>;
     askForToggle(message: string, defaultValue?: boolean, opts?: {
         active?: string;
         inactive?: string;

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

@@ -1,48 +1,96 @@
-import { CommandOption } from './contracts/index.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;
+import { OptionDetails } from './lib/optionHelpers.js';
+import { OptionDefinition, OptionReturnType, OptionsObject, OptionsSchema } from './lib/types.js';
+/**
+ * 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;
+    protected shouldPromptForMissingOptions: boolean;
+    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]>;
+    setOption<OptsName extends keyof Options>(name: OptsName, value: OptionReturnType<Options[OptsName]>): void;
+    /**
+     * 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]>;
+    setArgument<ArgName extends keyof Arguments>(name: ArgName, value: OptionReturnType<Arguments[ArgName]>): void;
+    /**
+     * 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[];
+    /**
+     * Disables prompting for missing argument values
+     * Useful for non-interactive environments
+     */
+    disablePrompting(): 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
+     * @returns The user-provided value, or null if none given
+     */
+    protected promptForArgument(argumentName: string, argDef: OptionDefinition): Promise<string | number | string[] | null>;
 }

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

@@ -1,19 +1,24 @@
 import { Command } from './Command.js';
 import { CommandIO } from './CommandIO.js';
-export type CommandResolver = (path: string) => Promise<Command>;
+import { Logger } from './Logger.js';
+import { ArgumentsSchema, ContextDefinition, OptionsSchema } from './lib/types.js';
+export type CommandResolver = (path: string) => Promise<Command | null>;
+export type FileImporter = (filePath: string) => Promise<unknown>;
 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 importFile;
     private commandResolver;
-    setCommandResolver(resolver: (path: string) => Promise<Command>): void;
-    registerCommand(command: Command, force?: boolean): void;
+    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;
     loadCommandsPath(commandsPath: string): Promise<void>;
-    runCommand(ctx: any, command: string | Command, ...args: any[]): Promise<number>;
+    runCommand(ctx: ContextDefinition, command: string | Command, ...args: string[]): Promise<number>;
     private suggestCommand;
     private askRunSimilarCommand;
     private listCommandsFiles;

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

@@ -0,0 +1,40 @@
+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';
+/**
+ * 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 = 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>[];
+    });
+    /**
+     * Parses command signature string into command name and parameter schemas
+     * Example: "migrate {name} {--force}" -> { command: "migrate", arguments: {name: ...}, options: {force: ...} }
+     */
+    private static parseSignature;
+    /**
+     * 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;
+}

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

@@ -0,0 +1,28 @@
+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;
+    };
+    get command(): string;
+    parser: CommandSignatureParser<Opts, Args>;
+    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>;
+    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/esm/src/ExceptionHandler.d.ts

@@ -1,4 +1,7 @@
+import { Logger } from './Logger.js';
 import { BobError } from './errors/index.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,16 @@
+import { LogLevel, LoggerContract } from './contracts/index.js';
+export type LoggerOptions = {
+    level?: LogLevel;
+};
+export declare class Logger implements LoggerContract {
+    private level;
+    constructor(opts?: LoggerOptions);
+    private shouldLog;
+    setLevel(level: LogLevel): void;
+    getLevel(): LogLevel;
+    log(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+}

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

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

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

@@ -0,0 +1,13 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Logger interface defining standard logging methods and level management
+ */
+export interface LoggerContract {
+    log(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    debug(message: string, ...args: unknown[]): 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

@@ -1,3 +1,4 @@
+import { Logger } from '../Logger.js';
 import { BobError } from './BobError.js';
 export type OptionProps = {
     option: string;
@@ -7,5 +8,5 @@ export type OptionProps = {
 export declare class BadCommandOption extends BobError {
     readonly param: OptionProps;
     constructor(param: OptionProps);
-    pretty(): void;
+    pretty(io: Logger): void;
 }

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

@@ -1,3 +1,4 @@
+import { Logger } from '../Logger.js';
 import { BobError } from './BobError.js';
 export type ParameterProps = {
     param: string;
@@ -7,5 +8,5 @@ export type ParameterProps = {
 export declare class BadCommandParameter extends BobError {
     readonly param: ParameterProps;
     constructor(param: ParameterProps);
-    pretty(): void;
+    pretty(io: Logger): 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

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

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

@@ -1,8 +1,9 @@
+import { Logger } from '../Logger.js';
 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: Logger): void;
 }

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

@@ -1,7 +1,7 @@
+import { Logger } from '../Logger.js';
 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: Logger): void;
 }

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

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

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

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

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

@@ -1,6 +1,13 @@
 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 './Cli.js';
+export * from './Logger.js';
+export * from './ExceptionHandler.js';
+export * from './lib/types.js';
 export * from './errors/index.js';
-export * from './contracts/index.js';
 export * from './options/index.js';
+export * from './contracts/index.js';

package/dist/esm/src/lib/optionHelpers.d.ts

@@ -0,0 +1,5 @@
+import { Option, OptionDefinition, OptionReturnType } from './types.js';
+export declare function getOptionPrimitiveDefaultValue<Opts extends Option>(type: Opts): OptionReturnType<Opts>;
+export declare function getOptionDefaultValue<Opts extends Option>(option: Opts): OptionReturnType<Opts> | null;
+export type OptionDetails = Required<OptionDefinition>;
+export declare function getOptionDetails(option: Option): OptionDetails;