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

package/dist/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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';

package/dist/cjs/src/index.js

@@ -0,0 +1,17 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const y=require("prompts"),a=require("chalk"),M=require("minimist");class R{logger;constructor(t){this.logger=t.logger}log(...t){this.logger.log(...t)}info(...t){this.logger.info(...t)}warn(...t){this.logger.warn(...t)}error(...t){this.logger.error(...t)}debug(...t){this.logger.debug(...t)}async askForConfirmation(t="Do you want to continue?",e){return(await y({type:"confirm",name:"value",message:t,initial:e??!1})).value}async askForInput(t,e,i){return(await y({type:"text",name:"value",message:t,initial:e,...i}))?.value??null}async askForDate(t,e,i){return(await y({type:"date",name:"value",message:t,initial:e,...i}))?.value??null}async askForList(t,e,i){return(await y({type:"list",name:"value",message:t,initial:e,...i}))?.value??null}async askForToggle(t,e,i){return(await y({type:"toggle",name:"value",message:t,initial:e,...i}))?.value??null}async askForSelect(t,e,i){if(e.length===0)throw new Error("No options provided");const n=[];for(const o of e)typeof o=="string"?n.push({title:o,value:o}):n.push(o);return(await y({type:"select",name:"value",message:t,choices:n,...i}))?.value??null}newLoader(t="",e=["⠙","⠘","⠰","⠴","⠤","⠦","⠆","⠃","⠋","⠉"],i=100){let n=t,r=null,o=0;const u=setInterval(function(){r&&(process.stdout.write(new TextEncoder().encode("\r"+" ".repeat(r.length+5)+"\r")),r=null),process.stdout.write(new TextEncoder().encode("\r"+e[o++]+" "+n)),o=o%e.length},i),m=()=>{clearInterval(u),process.stdout.write(new TextEncoder().encode("\r"+" ".repeat(n.length+5)+"\r"))};return{[Symbol.dispose]:m,[Symbol.asyncDispose]:m,updateText:h=>{r=n,n=h},stop:m}}}class f extends Error{}function F(s){if(s==="string"||s==="number")return null;if(s==="boolean")return!1;if(Array.isArray(s)&&s.length===1){if(s[0]==="string")return[];if(s[0]==="number")return[]}throw new Error("Invalid option type: "+s)}function k(s){return typeof s=="string"||Array.isArray(s)?F(s):s.default!==void 0?s.default:F(s.type)}function g(s){return typeof s=="string"||Array.isArray(s)?{alias:[],default:k(s),description:"",required:!1,secret:!1,type:s,variadic:!1}:{alias:s.alias?Array.isArray(s.alias)?s.alias:[s.alias]:[],default:s.default??k(s.type),description:s.description??"",required:s.required??!1,secret:s.secret??!1,type:s.type,variadic:s.variadic??!1}}class b extends f{constructor(t,e={}){super(`Invalid option ${t} in not recognized`),this.option=t,this.optionsSchema=e}pretty(t){const e=Object.entries(this.optionsSchema);if(e.length>0){t.log(`
+${a.yellow("Available options")}:`);for(const[i,n]of e){const r=g(n),o=r.alias?typeof r.alias=="string"?[r.alias]:r.alias:[],u=Array.isArray(r.type)?`[${r.type[0]}]`:r.type,m=`--${i}${o.length>0?o.map(l=>`, -${l}`).join(""):""}`,h=" ".repeat(30-m.length);t.log(`  ${a.green(m)} ${h} ${r.description||"\b"} ${a.white(`(${u})`)}`)}t.log("")}t.log(`${a.white.bgRed(" ERROR ")} Option ${a.bold.yellow(this.option)} is not recognized.`)}}class A extends f{constructor(t){super(`Argument "${t}" is required.`),this.argument=t}pretty(t){t.log(`${a.white.bgRed(" ERROR ")} Argument ${a.bold.yellow(this.argument)} is required.`)}}class N extends f{constructor(t){super(`Argument "${t}" is required.`),this.option=t}pretty(t){t.log(`${a.white.bgRed(" ERROR ")} Option ${a.bold.yellow(this.option)} is required.`)}}class j extends f{constructor(t){let e=`Argument "${t.param}" value is invalid.`;t.reason?e+=` Reason: ${t.reason}`:e+=` Value: "${t.value}"`,super(e),this.param=t}pretty(t){t.log(`  ${a.white.bgRed(" ERROR ")} Argument ${a.bold.yellow(this.param.param)} value is invalid. `),(this.param.value||this.param.reason)&&t.log(""),this.param.value&&t.log(`  ${a.blue("Value")}: ${this.param.value}`),this.param.reason&&t.log(`  ${a.yellow("Reason")}: ${this.param.reason}`)}}class C extends f{constructor(t){let e=`Option "${t.option}" value is invalid.`;t.reason?e+=` Reason: ${t.reason}`:e+=` Value: "${t.value}"`,super(e),this.param=t}pretty(t){t.log(`  ${a.white.bgRed(" ERROR ")} Option ${a.bold.yellow(this.param.option)} value is invalid. `),(this.param.value||this.param.reason)&&t.log(""),this.param.value&&t.log(`  ${a.blue("Value")}: ${this.param.value}`),this.param.reason&&t.log(`  ${a.yellow("Reason")}: ${this.param.reason}`)}}class P extends f{constructor(t){super(`Command "${t}" not found.`),this.command=t}pretty(t){t.log(`${a.bgRed(" ERROR ")} Command ${a.yellow(this.command)} not found.`)}}function w(s,t,e,i){if(s==null)return i??null;if(t==="string")return String(s);if(t==="number"){const n=Number(s);if(isNaN(n))throw new C({option:e,reason:`Expected a number, got "${s}"`});return n}if(t==="boolean")return typeof s=="boolean"?s:s==="true"||s==="1"?!0:s==="false"||s==="0"?!1:!!s;if(Array.isArray(t)){const n=t[0],r=Array.isArray(s)?s:[s];if(n==="string")return r.map(o=>String(o));if(n==="number")return r.map(o=>{const u=Number(o);if(isNaN(u))throw new C({option:e,reason:`Expected array of numbers, got "${o}" in array`});return u})}return s}class x{options;parsedOptions=null;arguments;parsedArguments=null;io;shouldPromptForMissingOptions=!0;constructor(t){this.options=t.options,this.arguments=t.arguments,this.io=t.io}init(t){const{_:e,...i}=M(t);return this.validateUnknownOptions(i),this.parsedOptions=this.handleOptions(i),this.parsedArguments=this.handleArguments(e),{options:this.parsedOptions,arguments:this.parsedArguments}}async validate(){for(const t in this.options)if(g(this.options[t]).required&&(this.parsedOptions?.[t]===void 0||this.parsedOptions?.[t]===null))throw new N(t);for(const t in this.arguments){const e=g(this.arguments[t]),i=this.parsedArguments?.[t];if(e.required&&i==null){if(this.shouldPromptForMissingOptions){const n=await this.promptForArgument(t,e);if(n&&this.parsedArguments){this.parsedArguments[t]=w(n,e.type,t);continue}}throw new A(t)}if(e.required&&e.variadic&&Array.isArray(i)&&i.length===0){if(this.shouldPromptForMissingOptions){const n=await this.promptForArgument(t,e);if(n&&this.parsedArguments){this.parsedArguments[t]=w(n,e.type,t);continue}}throw new A(t)}}}option(t,e){if(!this.parsedOptions)throw new Error("Options have not been parsed yet. Call init() first.");return this.isEmptyValue(this.parsedOptions[t])&&e!==void 0?e:this.parsedOptions[t]}setOption(t,e){if(!this.parsedOptions)throw new Error("Options have not been parsed yet. Call init() first.");if(!(t in this.options))throw new b(t,this.options);this.parsedOptions[t]=e}argument(t,e){if(!this.parsedArguments)throw new Error("Arguments have not been parsed yet. Call init() first.");return this.isEmptyValue(this.parsedArguments[t])&&e!==void 0?e:this.parsedArguments[t]}setArgument(t,e){if(!this.parsedArguments)throw new Error("Arguments have not been parsed yet. Call init() first.");if(!(t in this.arguments))throw new b(t,this.arguments);this.parsedArguments[t]=e}isEmptyValue(t){return t==null||Array.isArray(t)&&t.length===0}validateUnknownOptions(t){const e=new Set;for(const i in this.options){e.add(i);const n=g(this.options[i]);for(const r of n.alias)e.add(r)}for(const i in t)if(!e.has(i))throw new b(i,this.options)}handleOptions(t){const e={};for(const i in this.options){const n=g(this.options[i]);e[i]=this.resolveOptionValue(i,n,t)}return e}handleArguments(t){const e={},i=[...t];for(const n in this.arguments){const r=g(this.arguments[n]);if(r.variadic){e[n]=this.handleVariadicArgument(n,r,i);continue}e[n]=this.resolveArgumentValue(n,r,i.shift())}return e}handleVariadicArgument(t,e,i){return i.length?w(i,e.type,t,e.default):e.default}resolveArgumentValue(t,e,i){return i===void 0?e.default:w(i,e.type,t,e.default)}resolveOptionValue(t,e,i){let n;const r=[t,...e.alias];for(const o of r)if(o in i){n=i[o];break}if(n===void 0){if(e.required)throw new C({option:t,reason:"Required option is missing"});return e.default}return w(n,e.type,t,e.default)}optionDefinitions(){const t={};for(const e in this.options)t[e]=g(this.options[e]);return t}argumentDefinitions(){const t={};for(const e in this.arguments)t[e]=g(this.arguments[e]);return t}availableOptions(){return Object.keys(this.options)}availableArguments(){return Object.keys(this.arguments)}disablePrompting(){return this.shouldPromptForMissingOptions=!1,this}async promptForArgument(t,e){if(!Array.isArray(e.type)&&!["string","number","secret"].includes(e.type))return null;let i=`${a.yellow.bold(t)} is required`;return e.description&&(i+=`: ${a.gray(`(${e.description})`)}`),i+=` ${a.green(`(${e.type}${e.variadic==!0?"[]":""})`)}
+`,Array.isArray(e.type)?(i+=`Please provide one or more values, separated by commas:
+`,await this.io.askForList(i,void 0,{separator:",",validate:n=>{if(!n.length)return"Please enter at least one value";if(e.type[0]==="number"){for(const r of n.split(","))if(isNaN(Number(r)))return"Please enter only valid numbers"}return!0}})):await this.io.askForInput(i,void 0,{type:e.type==="number"?"number":e.secret?"password":"text",validate:n=>{if(n==null||typeof n=="string"&&!n.length)return"This value is required";if(e.type==="number"){const r=Number(n);if(isNaN(r))return"Please enter a valid number"}else if(e.type==="string"&&(typeof n!="string"||!n.length))return"Please enter a valid text";return!0}})}}function O(s){return new Array(s+5).join(" ")}class L{type="boolean";option="help";alias=["h"];default=!1;description=`Display help for the given command. When no command is given display help for the ${a.green("list")} command`;async handler(){const t=this.parser.argumentDefinitions(),e=this.parser.optionDefinitions(),i=Object.entries(t),n=Object.entries(e),r=n.map(([l,d])=>{const c=Array.isArray(d.alias)?d.alias:d.alias?[d.alias]:[];return{name:l,...d,optionWithAlias:`--${l}${c.map(p=>`, -${p}`).join("")}`}}),o=i.filter(([,l])=>l.required);this.io.log(a.yellow("Description:")),this.io.log(`  ${this.description}
+`),this.io.log(a.yellow("Usage:")),this.io.log(`  ${this.command} ${o.length>0?o.map(([l])=>`<${l}>`).join(" "):"\b"} [options]`);const u=Math.max(...r.map(l=>l.optionWithAlias.length),0),m=Math.max(...i.map(([l])=>l.length),0),h=m>u?m:u;if(i.length>0){this.io.log(`
+${a.yellow("Arguments")}:`);for(const[l,d]of i){const c=O(h-l.length);let p=`  ${a.green(l)} ${c} ${d.description??"\b"}`;if(d.default!==void 0&&!d.required){const D=(Array.isArray(d.type)?`[${d.type[0]}]`:d.type)==="array"||Array.isArray(d.type)?JSON.stringify(d.default):d.default;p+=` ${a.yellow(`[default: ${D}]`)}`}d.variadic&&(p+=` ${a.white("(variadic)")}`),this.io.log(p)}}if(n.length>0){this.io.log(`
+${a.yellow("Options")}:`);for(const l of r){const d=O(h-l.optionWithAlias.length);let c=`${a.green(l.optionWithAlias)} ${d} ${l.description??"\b"}`;if(l.type){const p=Array.isArray(l.type)?`[${l.type[0]}]`:l.type;c+=` ${a.white(`(${p})`)}`}if(l.default!==void 0&&!l.required){const S=(Array.isArray(l.type)?`[${l.type[0]}]`:l.type)==="array"||Array.isArray(l.type)?JSON.stringify(l.default):l.default;c+=` ${a.yellow(`[default: ${S}]`)}`}this.io.log(c)}}if(this.commandsExamples.length>0){this.io.log(`
+${a.yellow("Examples")}:`);let l=process.argv[0].split("/").pop();l==="node"&&(l+=" "+process.argv[1].split("/").pop());for(const[d,c]of this.commandsExamples.entries())d>0&&this.io.log(""),this.io.log(`  ${c.description}
+`),this.io.log(`    ${a.green(`${l} ${c.command}`)}`)}return-1}}class v{_command;description;group;commandsExamples=[];get command(){return this._command}ctx;io;parser;disablePromptingFlag=!1;_preHandler;_handler;tmp;defaultOptions(){return[new L]}newCommandParser(t){return new x({io:t.io,options:t.options,arguments:t.arguments})}newCommandIO(t){return new R(t)}constructor(t,e){this._command=t,this.description=e?.description??"",this.group=e?.group,this.tmp={options:e?.options??{},arguments:e?.arguments??{}};const i=this.defaultOptions();if(i.length>0)for(const n of i)this.tmp.options[n.option]=n}disablePrompting(){return this.disablePromptingFlag=!0,this}preHandler(t){return this._preHandler=t,this}handler(t){return this._handler=t,this}options(t){return this.tmp={options:{...this.tmp?.options??{},...t},arguments:this.tmp?.arguments??{}},this}arguments(t){return this.tmp={options:this.tmp?.options??{},arguments:{...this.tmp?.arguments??{},...t}},this}async run(t){if(!this._handler&&!this.handle)throw new Error(`No handler defined for command ${this.command||"(unknown)"}`);let e;if(this.ctx=t.ctx,this.io=this.newCommandIO({logger:t.logger}),t&&"args"in t){const n=this.tmp?.options??{};for(const r of this.defaultOptions())r.option in n||(n[r.option]=r);this.parser=this.newCommandParser({io:this.io,options:n,arguments:this.tmp?.arguments??{}}),e=this.parser.init(t.args);for(const r of this.defaultOptions())if(e.options[r.option]===!0){const o=await r.handler.call(this);if(o&&o!==0)return o}this.disablePromptingFlag&&this.parser.disablePrompting(),await this.parser.validate()}else e={options:t.options,arguments:t.arguments};if(!this._preHandler&&this.preHandle&&(this._preHandler=this.preHandle.bind(this)),this._preHandler){const n=await this._preHandler(t.ctx,e);if(n&&n!==0)return n}if(!this._handler&&this.handle)this._handler=this.handle.bind(this);else if(!this._handler)throw new Error(`No handler defined for command ${this.command||"(unknown)"}`);return await this._handler(t.ctx,e)??0}}class $ extends x{command;constructor(t){const e=$.parseSignature(t.signature,t.helperDefinitions,t.defaultOptions);super({io:t.io,options:e.options,arguments:e.arguments}),this.command=e.command}static parseSignature(t,e,i){const[n,...r]=t.split(/\{(.*?)\}/g).map(m=>m.trim()).filter(Boolean),o={},u={};for(const m of r){const{name:h,isOption:l,definition:d}=$.parseParamSignature(m,e);l?o[h]=d:u[h]=d}for(const m of i)o[m.option]={type:m.type,required:m.required,alias:m.alias,variadic:m.variadic??!1,description:m.description,default:m.default??null};return{command:n,options:o,arguments:u}}static parseParamSignature(t,e){let i=t,n=!1;const r={required:!0,type:"string",description:void 0,default:null,variadic:!1};if(i.includes(":")){const[o,u]=i.split(":");i=o.trim(),r.description=u.trim()}if(i.includes("=")){const[o,u]=i.split("=");i=o.trim(),r.default=u.trim(),r.required=!1,typeof r.default=="string"&&!r.default.length?r.default=null:r.default==="true"?(r.default=!0,r.type="boolean"):r.default==="false"&&(r.default=!1,r.type="boolean")}else i.startsWith("--")&&(r.required=!1,r.default=!1,r.type="boolean");if(i.includes("|")){const[o,...u]=i.split("|");i=o.trim(),r.alias=u.map(m=>m.trim())}return i.startsWith("--")&&(n=!0,i=i.slice(2)),r.default==="*"&&(r.default=[],r.type=["string"]),i.endsWith("?")&&(r.required=!1,i=i.slice(0,-1)),i.endsWith("*")&&(r.type=["string"],r.variadic=!0,r.default=[],i=i.slice(0,-1)),r.description=r.description??e[i]??e[`--${i}`],{name:i,isOption:n,definition:r}}}class W extends v{helperDefinitions={};get command(){return this.parser?this.parser.command:this.signature.split(" ")[0]}newCommandParser(t){return new $({io:t.io,signature:this.signature,helperDefinitions:this.helperDefinitions,defaultOptions:this.defaultOptions()})}constructor(){super("")}option(t,e=null){return this.parser.option(t,e)}argument(t,e=null){return this.parser.argument(t,e)}async askForConfirmation(...t){return this.io.askForConfirmation(...t)}async askForInput(...t){return this.io.askForInput(...t)}async askForSelect(...t){return this.io.askForSelect(...t)}newLoader(...t){return this.io.newLoader(...t)}}const q={};class E{level;constructor(t={}){this.level=t.level??"info"}shouldLog(t){const e=["debug","info","warn","error"],i=e.indexOf(this.level);return e.indexOf(t)>=i}setLevel(t){this.level=t}getLevel(){return this.level}log(...t){console.log(...t)}info(...t){this.shouldLog("info")&&console.log(...t)}warn(...t){this.shouldLog("warn")&&console.warn(...t)}error(...t){this.shouldLog("error")&&console.error(...t)}debug(...t){this.shouldLog("debug")&&console.log(...t)}}class I{getBigrams(t){const e=[],i=t.toLowerCase();for(let n=0;n<i.length-1;n++)e.push(i.slice(n,n+2));return e}calculateSimilarity(t,e){if(t===e)return 1;if(t.length<2||e.length<2)return 0;const i=this.getBigrams(t),n=this.getBigrams(e),r=new Set(n);let o=0;for(const u of i)r.has(u)&&(o++,r.delete(u));return 2*o/(i.length+n.length)}findBestMatch(t,e){const i=e.map(o=>({target:o,rating:this.calculateSimilarity(t,o)}));let n=0,r=i[0]?.rating??0;for(let o=1;o<i.length;o++)i[o].rating>r&&(r=i[o].rating,n=o);return{ratings:i,bestMatch:i[n],bestMatchIndex:n}}}class V{commands={};io;logger;stringSimilarity;newCommandIO(t){return new R(t)}constructor(t){this.logger=t?.logger??new E,this.io=this.newCommandIO({logger:this.logger}),this.stringSimilarity=t?.stringSimilarity??new I}getAvailableCommands(){return Object.keys(this.commands)}getCommands(){return Object.values(this.commands)}importFile=async t=>(await import(t)).default;commandResolver=async t=>{let e=await this.importFile(t);if(!e)throw new Error(`The command at path ${t} does not have a default export.`);return e&&typeof e=="object"&&"default"in e&&(e=e.default),typeof e=="function"?new e:e instanceof v?e:null};withCommandResolver(t){return this.commandResolver=t,this}withFileImporter(t){return this.importFile=t,this}registerCommand(t,e=!1){const i=t.command;if(!i)throw new Error("Command signature is invalid, it must have a command name.");if(!e&&this.commands[i])throw new Error(`Command ${i} already registered.`);this.commands[i]=t}async loadCommandsPath(t){for await(const e of this.listCommandsFiles(t))try{const i=await this.commandResolver(e);i instanceof v&&this.registerCommand(i)}catch(i){throw new Error(`Command ${e} failed to load. ${i}`,{cause:i})}}async runCommand(t,e,...i){const n=typeof e=="string"?this.commands[e]:e,r=typeof e=="string"?e:n.command;if(!n){const o=await this.suggestCommand(r);return o?await this.runCommand(t,o,...i):1}return await n.run({ctx:t,logger:this.logger,args:i})??0}async suggestCommand(t){const e=this.getAvailableCommands(),{bestMatch:i,bestMatchIndex:n,ratings:r}=this.stringSimilarity.findBestMatch(t,e),o=r.filter(u=>u.rating>.3).map(u=>u.target);if(i.rating>0&&o.length<=1||i.rating>.7&&o.length>1){const u=e[n];return await this.askRunSimilarCommand(t,u)?u:null}if(o.length){this.io.error(`${a.bgRed(" ERROR ")} Command ${a.yellow(t)} not found.
+`);const u=await this.io.askForSelect(a.green("Did you mean to run one of these commands instead?"),o);if(u)return u}throw new P(t)}async askRunSimilarCommand(t,e){return this.io.error(`${a.bgRed(" ERROR ")} Command ${a.yellow(t)} not found.
+`),this.io.askForConfirmation(`${a.green(`Do you want to run ${a.yellow(e)} instead?`)} `)}async*listCommandsFiles(t){const e=(void 0)(t,{withFileTypes:!0});for(const i of e){const n=q.resolve(t,i.name);if(i.isDirectory())yield*this.listCommandsFiles(q.resolve(t,i.name));else{if(!n.endsWith(".ts")&&!n.endsWith(".js")&&!n.endsWith(".mjs")&&!n.endsWith(".cjs"))continue;yield n}}}}class H{logger;constructor(t){this.logger=t}handle(t){if(t instanceof f)return t.pretty(this.logger),-1;throw t}}class B extends v{constructor(t){super("help",{description:a.bold("Show help information about the CLI and its commands")}),this.opts=t}async handle(){const t=this.opts.commandRegistry.getCommands(),e=this.opts.cliName??"Bob CLI",i=this.opts.cliVersion??"0.0.0",n=(await Promise.resolve().then(()=>require("../package-Bxb7QZU4.cjs")))?.default?.version??"0.0.0";this.io.log(`${e} ${a.green(i)} (core: ${a.yellow(n)})
+
+${a.yellow("Usage")}:
+  command [options] [arguments]
+
+${a.yellow("Available commands")}:
+`);const r=Math.max(...t.map(m=>m.command.length))??0,o={};for(const m of t){const h=m.group??m.command.split(":")[0];o[h]||(o[h]=[]),o[h].push(m)}const u=Object.entries(o).sort(([m],[h])=>m.toLowerCase().localeCompare(h.toLowerCase())).sort(([,m],[,h])=>m.length-h.length);for(const[m,h]of u){const l=h.length>1;l&&this.io.log(a.yellow(`${m}:`));const d=h.sort((c,p)=>c.command.toLowerCase().localeCompare(p.command.toLowerCase()));for(const c of d){let p=O(r-c.command.length);l&&(p=p.slice(2)),this.io.log(`${l?"  ":""}${a.green(c.command)} ${p} ${c.description}`)}}}}class T{ctx;logger;commandRegistry;exceptionHandler;helpCommand;newCommandRegistry(t){return new V(t)}newHelpCommand(t){return new B(t)}newExceptionHandler(t){return new H(t.logger)}constructor(t={}){this.ctx=t.ctx,this.logger=t.logger??new E,this.commandRegistry=this.newCommandRegistry({logger:this.logger}),this.exceptionHandler=this.newExceptionHandler({logger:this.logger}),this.helpCommand=this.newHelpCommand({cliName:t.name,cliVersion:t.version,commandRegistry:this.commandRegistry})}withCommandResolver(t){return this.commandRegistry.withCommandResolver(t),this}withFileImporter(t){return this.commandRegistry.withFileImporter(t),this}async withCommands(...t){for(const e of t)typeof e=="string"?await this.commandRegistry.loadCommandsPath(e):typeof e=="function"?this.registerCommand(new e):this.registerCommand(e)}async runCommand(t,...e){return t?await this.commandRegistry.runCommand(this.ctx??{},t,...e).catch(this.exceptionHandler.handle.bind(this.exceptionHandler)):await this.runHelpCommand()}async runHelpCommand(){return await this.runCommand(this.helpCommand)}registerCommand(t){this.commandRegistry.registerCommand(t)}}exports.BadCommandOption=C;exports.BadCommandParameter=j;exports.BobError=f;exports.Cli=T;exports.Command=v;exports.CommandIO=R;exports.CommandNotFoundError=P;exports.CommandParser=x;exports.CommandRegistry=V;exports.CommandSignatureParser=$;exports.CommandWithSignature=W;exports.ExceptionHandler=H;exports.HelpOption=L;exports.InvalidOption=b;exports.Logger=E;exports.MissingRequiredArgumentValue=A;exports.MissingRequiredOptionValue=N;exports.StringSimilarity=I;

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

@@ -1,5 +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>;
+export declare function getOptionDefaultValue<Opts extends Option>(option: Opts): OptionReturnType<Opts> | null;
 export type OptionDetails = Required<OptionDefinition>;
 export declare function getOptionDetails(option: Option): OptionDetails;

package/dist/cjs/src/lib/types.d.ts

@@ -4,6 +4,7 @@ export type OptionDefinition = {
     description?: string;
     alias?: string | Array<string>;
     required?: boolean;
+    secret?: boolean;
     default?: any;
     variadic?: boolean;
 };
@@ -27,3 +28,4 @@ export type ArgumentsSchema = {
 export type ArgumentsObject<Arguments extends ArgumentsSchema> = {
     [Key in keyof Arguments]: OptionReturnType<Arguments[Key]>;
 };
+export type ContextDefinition = any;

package/dist/cjs/src/options/HelpOption.d.ts

@@ -1,5 +1,5 @@
-import { CommandOption } from '../contracts/index.js';
 import { Command } from '../Command.js';
+import { CommandOption } from '../contracts/index.js';
 import { OptionPrimitive } from '../lib/types.js';
 export declare class HelpOption implements CommandOption<Command> {
     type: OptionPrimitive;