bob-core 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/esm/package-DZqOZEXL.js

@@ -0,0 +1,33 @@
+const t = "bob-core", s = "2.0.0-beta.21", e = "BOB Core", i = "module", n = "./dist/cjs/src/index.js", r = "./dist/esm/src/index.js", c = "./dist/esm/src/index.d.ts", o = ["dist"], d = { ".": { 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" } } }, p = { 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" }, l = "Léo Hubert", m = "ISC", a = { "@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.9.3", "typescript-eslint": "^8.46.0", vite: "^7.2.7", "vite-plugin-dts": "^4.5.4", vitest: "^3.2.4" }, u = { chalk: "^4.1.2", minimist: "^1.2.8", prompts: "^2.4.2" }, x = {
+  name: t,
+  version: s,
+  description: e,
+  type: i,
+  main: n,
+  module: r,
+  types: c,
+  files: o,
+  exports: d,
+  scripts: p,
+  author: l,
+  license: m,
+  devDependencies: a,
+  dependencies: u
+};
+export {
+  l as author,
+  x as default,
+  u as dependencies,
+  e as description,
+  a as devDependencies,
+  d as exports,
+  o as files,
+  m as license,
+  n as main,
+  r as module,
+  t as name,
+  p as scripts,
+  i as type,
+  c as types,
+  s as version
+};

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

@@ -1,33 +1,33 @@
-import { CommandRegistry } from './CommandRegistry.js';
-import { default as HelpCommand, HelpCommandOptions } from './commands/HelpCommand.js';
-import { ExceptionHandler } from './ExceptionHandler.js';
 import { Command } from './Command.js';
+import { CommandRegistry, CommandRegistryOptions, CommandResolver, FileImporter } from './CommandRegistry.js';
+import { ExceptionHandler } from './ExceptionHandler.js';
 import { Logger } from './Logger.js';
-export type CliOptions<C = any> = {
+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 = any> {
+export declare class Cli<C extends ContextDefinition = ContextDefinition> {
     private readonly ctx?;
     private readonly logger;
     readonly commandRegistry: CommandRegistry;
     private readonly exceptionHandler;
     private readonly helpCommand;
-    protected newCommandRegistry(opts: {
-        logger: Logger;
-    }): CommandRegistry;
+    protected newCommandRegistry(opts: CommandRegistryOptions): 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, any, any> | {
+    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: 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,58 +1,58 @@
-import { OptionsSchema, OptionsObject, ArgumentsSchema, ArgumentsObject } from './lib/types.js';
+import { CommandIO, CommandIOOptions } from './CommandIO.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';
+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>;
 };
-export type CommandHandler<C, Options extends OptionsSchema, Arguments extends ArgumentsSchema> = (ctx: C, opts: CommandHandlerOptions<Options, Arguments>) => Promise<number | void> | number | void;
-type BaseCommandRunOption<C> = {
+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;
-};
-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 class Command<C = any, Options extends OptionsSchema = {}, Arguments extends ArgumentsSchema = {}> {
+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[];
     get command(): string;
     protected ctx: C;
     protected io: CommandIO;
-    protected logger: Logger;
-    protected _handler?: CommandHandler<C, Options, Arguments>;
     protected parser: CommandParser<Options, Arguments>;
+    protected disablePromptingFlag: boolean;
+    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<any, any, any>>[];
+    protected defaultOptions(): CommandOption<Command>[];
     protected newCommandParser(opts: {
         io: CommandIO;
         options: Options;
         arguments: Arguments;
-    }): CommandParser<Options, Arguments> | CommandSignatureParser;
-    protected newCommandIO(opts: {
-        logger: Logger;
-    }): CommandIO;
+    }): CommandParser<Options, Arguments>;
+    protected newCommandIO(opts: CommandIOOptions): CommandIO;
     constructor(command: string, opts?: {
         description?: string;
+        group?: string;
+        options?: Options;
+        arguments?: Arguments;
     });
-    protected preHandle?(): Promise<void | number>;
-    protected handle?(ctx: C, opts: CommandHandlerOptions<Options, Arguments>): Promise<number | void> | number | void;
-    handler(handler: CommandHandler<C, Options, Arguments>): Command<C, Options, 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>;
 }
-export {};

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

@@ -6,9 +6,12 @@ export type SelectOption = {
     selected?: boolean | undefined;
     description?: string | undefined;
 };
+export type CommandIOOptions = {
+    logger: Logger;
+};
 export declare class CommandIO {
     private logger;
-    constructor(logger: Logger);
+    constructor(opts: CommandIOOptions);
     /**
      * Logger methods
      */
@@ -17,7 +20,6 @@ export declare class CommandIO {
     warn(...args: any[]): void;
     error(...args: any[]): void;
     debug(...args: any[]): void;
-    verbose(...args: any[]): void;
     /**
      * Prompt utils
      */
@@ -28,6 +30,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,6 +1,6 @@
-import { OptionsSchema, OptionReturnType, OptionsObject } from './lib/types.js';
-import { OptionDetails } from './lib/optionHelpers.js';
 import { CommandIO } from './CommandIO.js';
+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
@@ -11,6 +11,7 @@ export declare class CommandParser<Options extends OptionsSchema, Arguments exte
     protected arguments: Arguments;
     protected parsedArguments: OptionsObject<Arguments> | null;
     protected io: CommandIO;
+    protected shouldPromptForMissingOptions: boolean;
     constructor(opts: {
         io: CommandIO;
         options: Options;
@@ -20,7 +21,7 @@ export declare class CommandParser<Options extends OptionsSchema, Arguments exte
      * 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 {InvalidOption} If an naan option is provided
      * @throws {BadCommandOption} If a value cannot be converted to the expected type
      */
     init(args: string[]): {
@@ -35,17 +36,27 @@ export declare class CommandParser<Options extends OptionsSchema, Arguments exte
     /**
      * 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
      * @throws {Error} If init() has not been called yet
      */
-    option<OptsName extends keyof Options>(name: OptsName): OptionReturnType<Options[OptsName]>;
+    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;
     /**
      * Retrieves a parsed argument value by name
      * @param name - The argument name
+     * @param defaultValue - Optional default value if argument is not set
      * @returns The typed argument value
      * @throws {Error} If init() has not been called yet
      */
-    argument<ArgName extends keyof Arguments>(name: ArgName): OptionReturnType<Arguments[ArgName]>;
+    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;
+    /**
+     * Checks if a value should be considered "empty" for default value purposes
+     * @param value - The value to check
+     * @returns true if the value is null, undefined, or an empty array
+     */
+    private isEmptyValue;
     /**
      * Validates that all provided options are recognized
      * @throws {InvalidOption} If an unknown option is found
@@ -77,4 +88,17 @@ export declare class CommandParser<Options extends OptionsSchema, Arguments exte
     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,20 +1,30 @@
-import { CommandIO } from './CommandIO.js';
 import { Command } from './Command.js';
+import { CommandIO, CommandIOOptions } from './CommandIO.js';
 import { Logger } from './Logger.js';
-export type CommandResolver = (path: string) => Promise<Command>;
+import { StringSimilarity } from './StringSimilarity.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 type CommandRegistryOptions = {
+    logger?: Logger;
+    stringSimilarity?: StringSimilarity;
+};
 export declare class CommandRegistry {
     private readonly commands;
     protected readonly io: CommandIO;
     protected readonly logger: Logger;
-    protected get CommandIOClass(): typeof CommandIO;
-    constructor(logger?: Logger);
+    private readonly stringSimilarity;
+    protected newCommandIO(opts: CommandIOOptions): CommandIO;
+    constructor(opts?: CommandRegistryOptions);
     getAvailableCommands(): string[];
     getCommands(): Array<Command>;
+    private importFile;
     private commandResolver;
-    setCommandResolver(resolver: CommandResolver): void;
-    registerCommand(command: Command<any, any, any>, 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

@@ -1,60 +1,27 @@
-import { CommandOption } from './contracts/index.js';
+import { Command } from './Command.js';
 import { CommandIO } from './CommandIO.js';
-import { OptionsObject, OptionsSchema } from './lib/types.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 = any, Args extends OptionsSchema = any> extends CommandParser<Opts, Args> {
+export declare class CommandSignatureParser<Opts extends OptionsSchema = OptionsSchema, Args extends OptionsSchema = OptionsSchema> 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>[];
+        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;
-    /**
-     * 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.
@@ -70,16 +37,4 @@ export declare class CommandSignatureParser<Opts extends OptionsSchema = any, Ar
      * - {--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

@@ -1,35 +1,26 @@
 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> {
+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;
-    parser: CommandSignatureParser<Opts, Args>;
     protected newCommandParser(opts: {
         io: CommandIO;
         options: Opts;
         arguments: Args;
-    }): CommandSignatureParser;
+    }): CommandSignatureParser<Opts, Args>;
     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>;

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

@@ -1,5 +1,5 @@
-import { BobError } from './errors/index.js';
 import { Logger } from './Logger.js';
+import { BobError } from './errors/index.js';
 export declare class ExceptionHandler {
     private readonly logger;
     constructor(logger: Logger);

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

@@ -1,8 +1,8 @@
-export type LogLevel = 'debug' | 'verbose' | 'info' | 'warn' | 'error' | 'silent';
+import { LogLevel, LoggerContract } from './contracts/index.js';
 export type LoggerOptions = {
     level?: LogLevel;
 };
-export declare class Logger {
+export declare class Logger implements LoggerContract {
     private level;
     constructor(opts?: LoggerOptions);
     private shouldLog;
@@ -13,5 +13,4 @@ export declare class Logger {
     warn(...args: any[]): void;
     error(...args: any[]): void;
     debug(...args: any[]): void;
-    verbose(...args: any[]): void;
 }

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

@@ -0,0 +1,26 @@
+export interface SimilarityResult {
+    rating: number;
+    target: string;
+}
+export interface BestMatchResult {
+    bestMatch: SimilarityResult;
+    bestMatchIndex: number;
+    ratings: SimilarityResult[];
+}
+/**
+ * String similarity calculator using Dice's Coefficient algorithm
+ */
+export declare class StringSimilarity {
+    /**
+     * Generate bigrams (character pairs) from a string
+     */
+    private getBigrams;
+    /**
+     * Calculate Dice's Coefficient similarity between two strings (0-1 scale)
+     */
+    calculateSimilarity(str1: string, str2: string): number;
+    /**
+     * Find best matching string and ratings for all candidates
+     */
+    findBestMatch(target: string, candidates: string[]): BestMatchResult;
+}

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

@@ -1,5 +1,5 @@
-import { CommandRegistry } from '../CommandRegistry.js';
 import { Command } from '../Command.js';
+import { CommandRegistry } from '../CommandRegistry.js';
 export type HelpCommandOptions = {
     commandRegistry: CommandRegistry;
     cliName?: string;

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

@@ -1,6 +1,6 @@
-import { OptionDefinition } from '../lib/types.js';
 import { Command } from '../Command.js';
-export interface CommandOption<C extends Command> extends OptionDefinition {
+import { OptionDefinition } from '../lib/types.js';
+export interface CommandOption<Cmd extends Command> extends OptionDefinition {
     option: string;
-    handler(this: C): Promise<number | void>;
+    handler(this: Cmd): Promise<number | void>;
 }

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

@@ -1,4 +1,4 @@
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'verbose';
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 /**
  * Logger interface defining standard logging methods and level management
  */
@@ -8,7 +8,6 @@ export interface LoggerContract {
     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/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(io: any): void;
+    pretty(logger: 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(io: any): void;
+    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(io: any): void;
+    pretty(logger: 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 { OptionsSchema } from '../lib/types.js';
 export declare class InvalidOption extends BobError {
     private option;
     private optionsSchema;
     constructor(option: string, optionsSchema?: OptionsSchema);
-    pretty(io: any): void;
+    pretty(logger: Logger): void;
 }

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

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

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

@@ -1,6 +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: any): void;
+    pretty(logger: Logger): void;
 }

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

@@ -3,7 +3,5 @@ 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';

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

@@ -7,6 +7,8 @@ export * from './CommandRegistry.js';
 export * from './Cli.js';
 export * from './Logger.js';
 export * from './ExceptionHandler.js';
+export * from './StringSimilarity.js';
 export * from './lib/types.js';
 export * from './errors/index.js';
 export * from './options/index.js';
+export * from './contracts/index.js';