bob-core 2.0.0-beta.9 → 2.0.0

package/dist/esm/package-DbMvpGfM.js

@@ -0,0 +1,33 @@
+const t = "bob-core", s = "2.0.0", 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,23 +1,22 @@
-import { CommandRegistry, CommandResolver, FileImporter } 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;
@@ -25,10 +24,10 @@ export declare class Cli<C = any> {
     constructor(opts?: CliOptions<C>);
     withCommandResolver(resolver: CommandResolver): this;
     withFileImporter(importer: FileImporter): this;
-    withCommands(...commands: Array<Command<C, any, any> | {
+    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,30 +1,27 @@
-import { OptionsSchema, OptionsObject, ArgumentsSchema, ArgumentsObject } from './lib/types.js';
+import { CommandIO, CommandIOOptions } from './CommandIO.js';
 import { CommandParser } from './CommandParser.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;
@@ -32,7 +29,6 @@ export declare class Command<C = any, Options extends OptionsSchema = {}, Argume
     get command(): string;
     protected ctx: C;
     protected io: CommandIO;
-    protected logger: Logger;
     protected parser: CommandParser<Options, Arguments>;
     protected disablePromptingFlag: boolean;
     protected preHandle?(): Promise<void | number>;
@@ -40,15 +36,13 @@ export declare class Command<C = any, Options extends OptionsSchema = {}, Argume
     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>;
-    protected newCommandIO(opts: {
-        logger: Logger;
-    }): CommandIO;
+    protected newCommandIO(opts: CommandIOOptions): CommandIO;
     constructor(command: string, opts?: {
         description?: string;
         group?: string;
@@ -62,4 +56,3 @@ export declare class Command<C = any, Options extends OptionsSchema = {}, Argume
     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
      */
@@ -32,7 +35,7 @@ export declare class CommandIO {
         mask?: string;
     }): Promise<Date | null>;
     askForList(message: string, defaultValue?: string | number, opts?: {
-        validate?: (value: string[]) => boolean | string;
+        validate?: (value: string) => boolean | string;
         format?: (value: string) => string;
         separator?: string;
     }): Promise<string[] | null>;

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

@@ -1,6 +1,6 @@
-import { OptionsSchema, OptionReturnType, OptionsObject, OptionDefinition } 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
@@ -21,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[]): {
@@ -36,19 +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

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

@@ -1,23 +1,30 @@
-import { CommandIO } from './CommandIO.js';
 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>;
-export type FileImporter = (filePath: string) => Promise<any>;
+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;
     withCommandResolver(resolver: CommandResolver): this;
     withFileImporter(importer: FileImporter): this;
-    registerCommand(command: Command<any, any, any>, force?: boolean): void;
+    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,12 +1,13 @@
-import { CommandOption } from './contracts/index.js';
+import { Command } from './Command.js';
 import { CommandIO } from './CommandIO.js';
-import { 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;
     constructor(opts: {
         io: CommandIO;
@@ -14,7 +15,7 @@ export declare class CommandSignatureParser<Opts extends OptionsSchema = any, Ar
         helperDefinitions: {
             [key: string]: string;
         };
-        defaultOptions: CommandOption<any>[];
+        defaultOptions: CommandOption<Command>[];
     });
     /**
      * Parses command signature string into command name and parameter schemas

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

@@ -1,15 +1,15 @@
 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;

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,4 +1,4 @@
-import { LoggerContract, LogLevel } from './contracts/index.js';
+import { LogLevel, LoggerContract } from './contracts/index.js';
 export type LoggerOptions = {
     level?: LogLevel;
 };

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/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/index.d.ts

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