@guanghechen/commander 4.7.2 → 4.7.3

package/lib/esm/node.mjs

@@ -305,6 +305,30 @@ function parsePrimitiveNumber(rawValue) {
     }
     return value;
 }
+function normalizeSubcommandNameForDistance(name) {
+    return camelToKebabCase$1(name).toLowerCase();
+}
+function levenshteinDistance(left, right) {
+    if (left === right) {
+        return 0;
+    }
+    if (left.length === 0) {
+        return right.length;
+    }
+    if (right.length === 0) {
+        return left.length;
+    }
+    let prev = Array.from({ length: right.length + 1 }, (_, i) => i);
+    for (let i = 0; i < left.length; i += 1) {
+        const current = [i + 1];
+        for (let j = 0; j < right.length; j += 1) {
+            const substitutionCost = left[i] === right[j] ? 0 : 1;
+            current[j + 1] = Math.min(current[j] + 1, prev[j + 1] + 1, prev[j] + substitutionCost);
+        }
+        prev = current;
+    }
+    return prev[right.length];
+}
 function tokenizeLongOption(arg, commandPath) {
     const eqIdx = arg.indexOf('=');
     const namePart = eqIdx !== -1 ? arg.slice(0, eqIdx) : arg;
@@ -707,7 +731,10 @@ class Command {
             const kebabLong = camelToKebabCase$1(opt.long);
             let sig = opt.short ? `-${opt.short}, ` : '    ';
             sig += `--${kebabLong}`;
-            if (opt.args !== 'none') {
+            if (opt.args === 'optional') {
+                sig += ' [value]';
+            }
+            else if (opt.args !== 'none') {
                 sig += ' <value>';
             }
             let desc = opt.desc;
@@ -1326,6 +1353,14 @@ class Command {
                             consumed.push(tokens[i]);
                         }
                     }
+                    else if (opt.args === 'optional') {
+                        if (!token.resolved.includes('=') &&
+                            i + 1 < tokens.length &&
+                            tokens[i + 1].type === 'none') {
+                            i += 1;
+                            consumed.push(tokens[i]);
+                        }
+                    }
                     else if (opt.args === 'variadic') {
                         if (!token.resolved.includes('=')) {
                             while (i + 1 < tokens.length && tokens[i + 1].type === 'none') {
@@ -1351,6 +1386,12 @@ class Command {
                             consumed.push(tokens[i]);
                         }
                     }
+                    else if (opt.args === 'optional') {
+                        if (i + 1 < tokens.length && tokens[i + 1].type === 'none') {
+                            i += 1;
+                            consumed.push(tokens[i]);
+                        }
+                    }
                     else if (opt.args === 'variadic') {
                         while (i + 1 < tokens.length && tokens[i + 1].type === 'none') {
                             i += 1;
@@ -1392,6 +1433,7 @@ class Command {
                 leafLocalOpts[opt.long] = leafParsedOpts[opt.long];
             }
         }
+        leafCommand.#assertUnknownSubcommand(ctx.sources.user.argv);
         const rawArgStrings = [...argTokens.map(t => t.original), ...restArgs];
         const { args, rawArgs } = leafCommand.#parseArguments(rawArgStrings);
         const parseCtx = {
@@ -1474,6 +1516,23 @@ class Command {
                 i += 1;
                 continue;
             }
+            if (opt.args === 'optional') {
+                const eqIdx = token.resolved.indexOf('=');
+                if (eqIdx !== -1) {
+                    opts[opt.long] = this.#convertValue(opt, token.resolved.slice(eqIdx + 1));
+                    i += 1;
+                    continue;
+                }
+                if (i + 1 < tokens.length && tokens[i + 1].type === 'none') {
+                    opts[opt.long] = this.#convertValue(opt, tokens[i + 1].original);
+                    i += 1;
+                }
+                else {
+                    opts[opt.long] = undefined;
+                }
+                i += 1;
+                continue;
+            }
             if (opt.args === 'variadic') {
                 const values = Array.isArray(opts[opt.long]) ? opts[opt.long] : [];
                 const eqIdx = token.resolved.indexOf('=');
@@ -1493,7 +1552,7 @@ class Command {
             i += 1;
         }
         for (const opt of allOptions) {
-            if (opt.required && opts[opt.long] === undefined) {
+            if (opt.required && !Object.prototype.hasOwnProperty.call(opts, opt.long)) {
                 throw new CommanderError('MissingRequired', `missing required option "--${camelToKebabCase$1(opt.long)}"`, this.#getCommandPath());
             }
         }
@@ -1530,6 +1589,9 @@ class Command {
     #parseArguments(rawArgs) {
         const argumentDefs = this.#arguments;
         const args = {};
+        if (argumentDefs.length === 0 && rawArgs.length > 0) {
+            throw new CommanderError('UnexpectedArgument', `unexpected argument "${rawArgs[0]}"`, this.#getCommandPath());
+        }
         const missing = [];
         let remaining = rawArgs.length;
         for (const def of argumentDefs) {
@@ -1570,25 +1632,23 @@ class Command {
             }
             if (def.kind === 'some') {
                 const rest = rawArgs.slice(index);
-                if (rest.length === 0) {
-                    throw new CommanderError('MissingRequiredArgument', `missing required argument(s): ${def.name}`, this.#getCommandPath());
-                }
                 args[def.name] = rest.map(raw => this.#convertArgument(def, raw));
                 index = rawArgs.length;
                 break;
             }
-            const raw = rawArgs[index];
-            if (raw === undefined) {
-                if (def.kind === 'optional') {
+            if (def.kind === 'optional') {
+                const raw = rawArgs[index];
+                if (raw === undefined) {
                     args[def.name] = def.default ?? undefined;
                     continue;
                 }
-                throw new CommanderError('MissingRequiredArgument', `missing required argument(s): ${def.name}`, this.#getCommandPath());
-            }
-            else {
                 args[def.name] = this.#convertArgument(def, raw);
                 index += 1;
+                continue;
             }
+            const raw = rawArgs[index];
+            args[def.name] = this.#convertArgument(def, raw);
+            index += 1;
         }
         const hasRestArgument = argumentDefs.some(a => a.kind === 'variadic' || a.kind === 'some');
         if (!hasRestArgument && index < rawArgs.length) {
@@ -1622,6 +1682,50 @@ class Command {
         }
         return value;
     }
+    #assertUnknownSubcommand(userTailArgv) {
+        if (this.#subcommandsList.length === 0) {
+            return;
+        }
+        const token = userTailArgv[0];
+        if (token === undefined || token.startsWith('-') || token === 'help') {
+            return;
+        }
+        if (this.#findSubcommandEntry(token) !== undefined) {
+            return;
+        }
+        const hints = [];
+        if (this.#arguments.length === 0) {
+            hints.push(`Hint: command "${this.#getCommandPath()}" does not accept positional arguments.`);
+        }
+        const candidate = this.#resolveDidYouMeanSubcommandName(token);
+        if (candidate !== undefined) {
+            hints.push(`Hint: did you mean "${candidate}"?`);
+        }
+        const details = hints.length > 0 ? `\n${hints.join('\n')}` : '';
+        throw new CommanderError('UnknownSubcommand', `unknown subcommand "${token}" for command "${this.#getCommandPath()}"${details}`, this.#getCommandPath());
+    }
+    #resolveDidYouMeanSubcommandName(token) {
+        const source = normalizeSubcommandNameForDistance(token);
+        let minDistance = Number.POSITIVE_INFINITY;
+        let bestName;
+        let isUniqueBest = false;
+        for (const entry of this.#subcommandsList) {
+            const target = normalizeSubcommandNameForDistance(entry.name);
+            const distance = levenshteinDistance(source, target);
+            if (distance < minDistance) {
+                minDistance = distance;
+                bestName = entry.name;
+                isUniqueBest = true;
+            }
+            else if (distance === minDistance) {
+                isUniqueBest = false;
+            }
+        }
+        if (minDistance <= 2 && isUniqueBest) {
+            return bestName;
+        }
+        return undefined;
+    }
     #hasUserOption(long) {
         return this.#options.some(option => option.long === long);
     }
@@ -1665,11 +1769,9 @@ class Command {
         return optionPolicyMap;
     }
     #mustGetOptionPolicy(optionPolicyMap, cmd) {
-        const policy = optionPolicyMap.get(cmd);
-        if (policy !== undefined) {
-            return policy;
-        }
-        throw new CommanderError('ConfigurationError', `missing option policy for command "${cmd.#getCommandPath()}"`, this.#getCommandPath());
+        const policy = optionPolicyMap.get(cmd) ?? cmd.#resolveOptionPolicy();
+        optionPolicyMap.set(cmd, policy);
+        return policy;
     }
     #validateMergedShortOptions(chain, optionPolicyMap) {
         const mergedByLong = new Map();
@@ -1698,7 +1800,10 @@ class Command {
             throw new CommanderError('ConfigurationError', `boolean option "--${opt.long}" must have args: 'none'`, this.#getCommandPath());
         }
         if ((opt.type === 'string' || opt.type === 'number') && opt.args === 'none') {
-            throw new CommanderError('ConfigurationError', `${opt.type} option "--${opt.long}" must have args: 'required' or 'variadic'`, this.#getCommandPath());
+            throw new CommanderError('ConfigurationError', `${opt.type} option "--${opt.long}" must have args: 'required', 'optional', or 'variadic'`, this.#getCommandPath());
+        }
+        if (opt.type === 'number' && opt.args === 'optional') {
+            throw new CommanderError('ConfigurationError', `number option "--${opt.long}" does not support args: 'optional'`, this.#getCommandPath());
         }
         if (opt.long.startsWith('no')) {
             throw new CommanderError('ConfigurationError', `option long name cannot start with "no": "${opt.long}"`, this.#getCommandPath());
@@ -1715,6 +1820,9 @@ class Command {
         if (opt.type === 'boolean' && opt.required) {
             throw new CommanderError('ConfigurationError', `boolean option "--${opt.long}" cannot be required`, this.#getCommandPath());
         }
+        if (opt.required && opt.args !== 'required') {
+            throw new CommanderError('ConfigurationError', `required option "--${opt.long}" must use args: 'required'`, this.#getCommandPath());
+        }
     }
     #checkOptionUniqueness(opt) {
         if (this.#options.some(o => o.long === opt.long)) {
@@ -2023,6 +2131,35 @@ class Coerce {
 function camelToKebabCase(str) {
     return str.replace(/[A-Z]/g, m => '-' + m.toLowerCase());
 }
+const COMPLETION_SHELL_STATE = Symbol('completion-shell-state');
+function getCommandPath(ctx) {
+    const names = ctx.chain
+        .map(command => command.name)
+        .filter((name) => Boolean(name));
+    if (names.length > 0) {
+        return names.join(' ');
+    }
+    return ctx.cmd.name ?? 'command';
+}
+function getCompletionShellState(ctx) {
+    const host = ctx;
+    host[COMPLETION_SHELL_STATE] ??= {};
+    return host[COMPLETION_SHELL_STATE];
+}
+function registerCompletionShell(ctx, shell) {
+    const state = getCompletionShellState(ctx);
+    if (state.shell !== undefined && state.shell !== shell) {
+        throw new CommanderError('OptionConflict', 'options "--bash", "--fish", and "--pwsh" are mutually exclusive', getCommandPath(ctx));
+    }
+    state.shell = shell;
+}
+function mustGetCompletionShell(ctx) {
+    const state = getCompletionShellState(ctx);
+    if (state.shell === undefined) {
+        throw new CommanderError('MissingRequired', 'missing required option: one of "--bash", "--fish", or "--pwsh"', getCommandPath(ctx));
+    }
+    return state.shell;
+}
 class CompletionCommand extends Command {
     constructor(root, config = {}) {
         const programName = config.programName ?? root.name ?? 'program';
@@ -2036,45 +2173,45 @@ class CompletionCommand extends Command {
             type: 'boolean',
             args: 'none',
             desc: 'Generate Bash completion script',
+            apply: (value, ctx) => {
+                if (value === true) {
+                    registerCompletionShell(ctx, 'bash');
+                }
+            },
         })
             .option({
             long: 'fish',
             type: 'boolean',
             args: 'none',
             desc: 'Generate Fish completion script',
+            apply: (value, ctx) => {
+                if (value === true) {
+                    registerCompletionShell(ctx, 'fish');
+                }
+            },
         })
             .option({
             long: 'pwsh',
             type: 'boolean',
             args: 'none',
             desc: 'Generate PowerShell completion script',
+            apply: (value, ctx) => {
+                if (value === true) {
+                    registerCompletionShell(ctx, 'pwsh');
+                }
+                mustGetCompletionShell(ctx);
+            },
         })
             .option({
             long: 'write',
             short: 'w',
             type: 'string',
-            args: 'required',
-            desc: 'Write to file (use shell default path if empty)',
-            default: undefined,
+            args: 'optional',
+            desc: 'Write to file (use shell default path when value is omitted or empty)',
         })
-            .action(({ opts }) => {
+            .action(({ opts, ctx }) => {
             const meta = root.getCompletionMeta();
-            const selectedShells = [
-                opts['bash'] && 'bash',
-                opts['fish'] && 'fish',
-                opts['pwsh'] && 'pwsh',
-            ].filter(Boolean);
-            if (selectedShells.length === 0) {
-                console.error('Please specify a shell: --bash, --fish, or --pwsh');
-                process.exit(1);
-                return;
-            }
-            if (selectedShells.length > 1) {
-                console.error('Please specify only one shell option');
-                process.exit(1);
-                return;
-            }
-            const shell = selectedShells[0];
+            const shell = mustGetCompletionShell(ctx);
             let script;
             switch (shell) {
                 case 'bash':
@@ -2087,8 +2224,9 @@ class CompletionCommand extends Command {
                     script = new PwshCompletion(meta, programName).generate();
                     break;
             }
-            const writeOpt = opts['write'];
-            if (writeOpt !== undefined) {
+            const hasWrite = Object.prototype.hasOwnProperty.call(opts, 'write');
+            if (hasWrite) {
+                const writeOpt = opts['write'];
                 const filePath = typeof writeOpt === 'string' && writeOpt !== '' ? writeOpt : paths[shell];
                 const expandedPath = expandHome(filePath);
                 const dir = path.dirname(expandedPath);

package/lib/types/browser.d.ts

@@ -29,13 +29,14 @@ interface ICommandToken {
 /** Option value type */
 type ICommandOptionType = 'boolean' | 'number' | 'string';
 /** Option argument mode */
-type ICommandOptionArgs = 'none' | 'required' | 'variadic';
+type ICommandOptionArgs = 'none' | 'required' | 'optional' | 'variadic';
 /**
  * Option configuration.
  *
  * `type` and `args` must be specified together. Valid combinations:
  * - boolean + none → boolean
  * - string + required → string
+ * - string + optional → string | undefined
  * - number + required → number
  * - string + variadic → string[]
  * - number + variadic → number[]

package/lib/types/index.d.ts

@@ -92,54 +92,16 @@ interface ICommandArgumentConfig<T = unknown> {
     /** Custom value transformation (takes precedence over type conversion) */
     coerce?: (rawValue: string) => T;
 }
-interface ICommandBuiltinOptionConfig {
-    /** Enable built-in --version option (root only, requires configured version) */
-    version?: boolean;
-    /** Enable built-in --color/--no-color option for help rendering (defaults respect NO_COLOR) */
-    color?: boolean;
-    /** Enable built-in --log-level option */
-    logLevel?: boolean;
-    /** Enable built-in --silent option */
-    silent?: boolean;
-    /** Enable built-in --log-date/--no-log-date option */
-    logDate?: boolean;
-    /** Enable built-in --log-colorful/--no-log-colorful option */
-    logColorful?: boolean;
-}
-interface ICommandBuiltinConfig {
-    /** Built-in options configuration */
-    option?: boolean | ICommandBuiltinOptionConfig;
-}
-/** Command example configuration */
-interface ICommandExample {
-    /** Example title */
-    title: string;
-    /** Usage fragment relative to command path */
-    usage: string;
-    /** Example description */
-    desc: string;
-}
-/** Command preset defaults */
-interface ICommandPresetConfig {
-    /** Preset root directory (absolute path) */
-    root?: string;
-    /** Default preset options file */
-    opt?: string;
-    /** Default preset envs file */
-    env?: string;
-}
 /** Command configuration */
 interface ICommandConfig {
     /** Command name (only for root command) */
     name?: string;
     /** Command description */
     desc: string;
-    /** Version (for built-in --version on this command) */
+    /** Version (for root --version) */
     version?: string;
-    /** Built-in features configuration */
-    builtin?: boolean | ICommandBuiltinConfig;
-    /** Command-level preset defaults */
-    preset?: ICommandPresetConfig;
+    /** Enable built-in "help" subcommand */
+    help?: boolean;
     /** Default reporter for this command */
     reporter?: IReporter;
 }
@@ -148,28 +110,21 @@ interface ICommand {
     readonly name: string | undefined;
     readonly description: string;
     readonly version: string | undefined;
-    readonly builtin: ICommandConfig['builtin'] | undefined;
-    readonly preset: ICommandPresetConfig | undefined;
     readonly parent: ICommand | undefined;
     readonly options: ICommandOptionConfig[];
     readonly arguments: ICommandArgumentConfig[];
-    readonly examples: ICommandExample[];
     readonly subcommands: Map<string, ICommand>;
 }
 /** Execution context */
 interface ICommandContext {
     /** Current command node */
     cmd: ICommand;
-    /** Command chain from root to leaf */
-    chain: ICommand[];
-    /** Effective environment variables */
+    /** Environment variables */
     envs: Record<string, string | undefined>;
-    /** Built-in control hit status */
-    controls: ICommandControls;
-    /** Input source snapshots */
-    sources: ICommandInputSources;
     /** Reporter instance */
     reporter: IReporter;
+    /** Original argv */
+    argv: string[];
 }
 /** Action callback parameters */
 interface ICommandActionParams {
@@ -198,29 +153,11 @@ type ICommandParsedOpts = Record<string, unknown>;
 /** Parsed arguments record */
 type ICommandParsedArgs = Record<string, unknown>;
 /** Route stage result */
-interface ICommandRouteResult<TCommand = ICommand> {
+interface ICommandRouteResult {
     /** Command chain from root to leaf */
-    chain: TCommand[];
+    chain: ICommand[];
     /** Remaining argv after routing */
     remaining: string[];
-    /** Routed command tokens from user argv (name/alias) */
-    cmds: string[];
-}
-/** Control-scan stage result */
-interface ICommandControlScanResult {
-    /** Built-in control hit status */
-    controls: ICommandControls;
-    /** Remaining argv after stripping control tokens */
-    remaining: string[];
-    /** Optional target token from `help <child>` syntax */
-    helpTarget?: string;
-}
-/** Preset stage result */
-interface ICommandPresetResult {
-    /** Effective tail argv after preset merge */
-    tailArgv: string[];
-    /** Effective envs after preset merge */
-    envs: Record<string, string | undefined>;
 }
 /** Tokenize stage result */
 interface ICommandTokenizeResult {
@@ -254,71 +191,8 @@ interface ICommandParseResult {
     /** Raw argument strings */
     rawArgs: string[];
 }
-/** Input source snapshots for debugging/tracing */
-interface ICommandInputSources {
-    preset: {
-        argv: string[];
-        envs: Record<string, string>;
-    };
-    user: {
-        /** Routed command tokens (name/alias as entered by user) */
-        cmds: string[];
-        /** Clean user tail argv after removing command chain/control/preset directives */
-        argv: string[];
-        /** Raw env snapshot from run/parse params */
-        envs: Record<string, string | undefined>;
-    };
-}
-/** Built-in run controls */
-interface ICommandControls {
-    help: boolean;
-    version: boolean;
-}
-/** Built-in option resolution result (internal) */
-interface ICommandBuiltinOptionResolved {
-    version: boolean;
-    color: boolean;
-    logLevel: boolean;
-    silent: boolean;
-    logDate: boolean;
-    logColorful: boolean;
-}
-/** Built-in config resolution result (internal) */
-interface ICommandBuiltinResolved {
-    option: ICommandBuiltinOptionResolved;
-}
-/** Subcommand registry entry (internal) */
-interface ISubcommandEntry<TCommand = ICommand> {
-    name: string;
-    aliases: string[];
-    command: TCommand;
-}
-/** Help option line (internal) */
-interface IHelpOptionLine {
-    sig: string;
-    desc: string;
-}
-/** Help command line (internal) */
-interface IHelpCommandLine {
-    name: string;
-    desc: string;
-}
-/** Help example line (internal) */
-interface IHelpExampleLine {
-    title: string;
-    usage: string;
-    desc: string;
-}
-/** Structured help data for rendering (internal) */
-interface IHelpData {
-    desc: string;
-    usage: string;
-    options: IHelpOptionLine[];
-    commands: IHelpCommandLine[];
-    examples: IHelpExampleLine[];
-}
 /** Error kinds for command parsing */
-type ICommanderErrorKind = 'InvalidOptionFormat' | 'InvalidNegativeOption' | 'NegativeOptionWithValue' | 'NegativeOptionType' | 'UnknownOption' | 'UnknownSubcommand' | 'UnexpectedArgument' | 'MissingValue' | 'InvalidType' | 'UnsupportedShortSyntax' | 'OptionConflict' | 'MissingRequired' | 'InvalidChoice' | 'InvalidBooleanValue' | 'MissingRequiredArgument' | 'TooManyArguments' | 'ConfigurationError';
+type ICommanderErrorKind = 'InvalidOptionFormat' | 'InvalidNegativeOption' | 'NegativeOptionWithValue' | 'NegativeOptionType' | 'UnknownOption' | 'UnexpectedArgument' | 'MissingValue' | 'InvalidType' | 'UnsupportedShortSyntax' | 'OptionConflict' | 'MissingRequired' | 'InvalidChoice' | 'InvalidBooleanValue' | 'MissingRequiredArgument' | 'TooManyArguments' | 'ConfigurationError';
 /** Commander error with structured information */
 declare class CommanderError extends Error {
     readonly kind: ICommanderErrorKind;
@@ -369,13 +243,13 @@ interface ICompletionCommandConfig {
     /** Program name for completion scripts (defaults to root.name) */
     programName?: string;
     /** Default completion file paths for each shell */
-    paths?: Partial<ICompletionPaths>;
+    paths: ICompletionPaths;
 }
 
 /**
  * Command class - CLI command builder with fluent API
  *
- * Execution flow: route → control-scan → run-control(run) → preset → tokenize → resolve → parse → run
+ * Execution flow: route → tokenize → resolve → parse → run
  *
  * @module @guanghechen/commander
  */
@@ -386,48 +260,20 @@ declare class Command implements ICommand {
     get name(): string | undefined;
     get description(): string;
     get version(): string | undefined;
-    get builtin(): ICommandConfig['builtin'] | undefined;
-    get preset(): ICommandPresetConfig | undefined;
     get parent(): Command | undefined;
     get options(): ICommandOptionConfig[];
     get arguments(): ICommandArgumentConfig[];
-    get examples(): ICommandExample[];
     get subcommands(): Map<string, ICommand>;
     option<T>(opt: ICommandOptionConfig<T>): this;
     argument<T>(arg: ICommandArgumentConfig<T>): this;
     action(fn: ICommandAction): this;
-    example(title: string, usage: string, desc: string): this;
     subcommand(name: string, cmd: Command): this;
     run(params: ICommandRunParams): Promise<void>;
-    parse(params: ICommandRunParams): Promise<ICommandParseResult>;
+    parse(params: ICommandRunParams): ICommandParseResult;
     formatHelp(): string;
     getCompletionMeta(): ICompletionMeta;
 }
 
-/**
- * Pre-defined coerce factory methods for @guanghechen/commander.
- *
- * @module @guanghechen/commander/coerce
- */
-declare class Coerce {
-    private constructor();
-    private static create;
-    static choice<TValue extends string>(name: string, values: ReadonlyArray<TValue>, errorMessage?: string): (rawValue: string) => TValue;
-    static domain(name: string, errorMessage?: string): (rawValue: string) => string;
-    static host(name: string, errorMessage?: string): (rawValue: string) => string;
-    static integer(name: string, errorMessage?: string): (rawValue: string) => number;
-    static ip(name: string, errorMessage?: string): (rawValue: string) => string;
-    static number(name: string, errorMessage?: string): (rawValue: string) => number;
-    static port(name: string, errorMessage?: string): (rawValue: string) => number;
-    static positiveInteger(name: string, errorMessage?: string): (rawValue: string) => number;
-    static positiveNumber(name: string, errorMessage?: string): (rawValue: string) => number;
-}
-
-declare function isIpv4(rawValue: string): boolean;
-declare function isIpv6(rawValue: string): boolean;
-declare function isIp(rawValue: string): boolean;
-declare function isDomain(rawValue: string): boolean;
-
 /**
  * Shell completion generators
  *
@@ -455,7 +301,7 @@ declare function isDomain(rawValue: string): boolean;
  * ```
  */
 declare class CompletionCommand extends Command {
-    constructor(root: Command, config?: ICompletionCommandConfig);
+    constructor(root: Command, config: ICompletionCommandConfig);
 }
 declare class BashCompletion {
     #private;
@@ -509,28 +355,6 @@ declare class PwshCompletion {
  * ```
  */
 declare const logLevelOption: ICommandOptionConfig<string>;
-/**
- * Pre-defined --log-date option for controlling timestamp output.
- *
- * | Property  | Value     |
- * | --------- | --------- |
- * | long      | 'logDate' |
- * | type      | 'boolean' |
- * | args      | 'none'    |
- * | default   | true      |
- */
-declare const logDateOption: ICommandOptionConfig<boolean>;
-/**
- * Pre-defined --log-colorful option for controlling colorful output.
- *
- * | Property  | Value         |
- * | --------- | ------------- |
- * | long      | 'logColorful' |
- * | type      | 'boolean'     |
- * | args      | 'none'        |
- * | default   | true          |
- */
-declare const logColorfulOption: ICommandOptionConfig<boolean>;
 /**
  * Pre-defined --silent option for suppressing non-error output.
  *
@@ -556,5 +380,5 @@ declare const logColorfulOption: ICommandOptionConfig<boolean>;
  */
 declare const silentOption: ICommandOptionConfig<boolean>;
 
-export { BashCompletion, Coerce, Command, CommanderError, CompletionCommand, FishCompletion, PwshCompletion, isDomain, isIp, isIpv4, isIpv6, logColorfulOption, logDateOption, logLevelOption, silentOption };
-export type { ICommand, ICommandAction, ICommandActionParams, ICommandArgumentConfig, ICommandArgumentKind, ICommandArgumentType, ICommandBuiltinConfig, ICommandBuiltinOptionConfig, ICommandBuiltinOptionResolved, ICommandBuiltinResolved, ICommandConfig, ICommandContext, ICommandControlScanResult, ICommandControls, ICommandExample, ICommandInputSources, ICommandOptionArgs, ICommandOptionConfig, ICommandOptionType, ICommandParseResult, ICommandParsedArgs, ICommandParsedOpts, ICommandPresetConfig, ICommandPresetResult, ICommandResolveResult, ICommandRouteResult, ICommandRunParams, ICommandShiftResult, ICommandToken, ICommandTokenType, ICommandTokenizeResult, ICommanderErrorKind, ICompletionCommandConfig, ICompletionMeta, ICompletionOptionMeta, ICompletionPaths, ICompletionShellType, IHelpCommandLine, IHelpData, IHelpExampleLine, IHelpOptionLine, ISubcommandEntry };
+export { BashCompletion, Command, CommanderError, CompletionCommand, FishCompletion, PwshCompletion, logLevelOption, silentOption };
+export type { ICommand, ICommandAction, ICommandActionParams, ICommandArgumentConfig, ICommandArgumentKind, ICommandArgumentType, ICommandConfig, ICommandContext, ICommandOptionArgs, ICommandOptionConfig, ICommandOptionType, ICommandParseResult, ICommandParsedArgs, ICommandParsedOpts, ICommandResolveResult, ICommandRouteResult, ICommandRunParams, ICommandShiftResult, ICommandToken, ICommandTokenType, ICommandTokenizeResult, ICommanderErrorKind, ICompletionCommandConfig, ICompletionMeta, ICompletionOptionMeta, ICompletionPaths, ICompletionShellType };