@guanghechen/commander 4.7.2 → 4.7.4

package/lib/cjs/node.cjs

@@ -307,6 +307,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;
@@ -709,7 +733,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;
@@ -850,7 +877,15 @@ class Command {
         return `  ${outputLabel}  ${desc}`;
     }
     getCompletionMeta() {
-        const allOptions = this.#resolveOptionPolicy().mergedOptions;
+        const optionMap = new Map();
+        for (const option of this.#resolveOptionPolicy().mergedOptions) {
+            optionMap.set(option.long, option);
+        }
+        optionMap.set('help', BUILTIN_HELP_OPTION);
+        if (this.#supportsBuiltinVersion()) {
+            optionMap.set('version', BUILTIN_VERSION_OPTION);
+        }
+        const allOptions = Array.from(optionMap.values());
         const options = [];
         const argumentsMeta = [];
         for (const opt of allOptions) {
@@ -858,7 +893,8 @@ class Command {
                 long: opt.long,
                 short: opt.short,
                 desc: opt.desc,
-                takesValue: opt.args !== 'none',
+                type: opt.type,
+                args: opt.args,
                 choices: opt.choices?.map(choice => String(choice)),
             });
         }
@@ -1328,6 +1364,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') {
@@ -1353,6 +1397,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;
@@ -1394,6 +1444,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 = {
@@ -1476,6 +1527,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('=');
@@ -1495,7 +1563,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());
             }
         }
@@ -1532,6 +1600,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) {
@@ -1572,25 +1643,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) {
@@ -1624,6 +1693,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);
     }
@@ -1667,11 +1780,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();
@@ -1700,7 +1811,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());
@@ -1717,6 +1831,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)) {
@@ -2025,6 +2142,41 @@ class Coerce {
 function camelToKebabCase(str) {
     return str.replace(/[A-Z]/g, m => '-' + m.toLowerCase());
 }
+function canGenerateNegativeCompletion(opt) {
+    return (opt.type === 'boolean' && opt.args === 'none' && opt.long !== 'help' && opt.long !== 'version');
+}
+function optionTakesValue(opt) {
+    return opt.args !== 'none';
+}
+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';
@@ -2038,45 +2190,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':
@@ -2089,8 +2241,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);
@@ -2157,7 +2310,7 @@ class BashCompletion {
             if (opt.short)
                 optParts.push(this.#escapeWord(`-${opt.short}`));
             optParts.push(this.#escapeWord(`--${kebabLong}`));
-            if (!opt.takesValue) {
+            if (canGenerateNegativeCompletion(opt)) {
                 optParts.push(this.#escapeWord(`--no-${kebabLong}`));
             }
         }
@@ -2189,7 +2342,7 @@ class BashCompletion {
         return words.map(choice => this.#escapeWord(choice)).join(' ');
     }
     #appendChoiceLogicForCommand(lines, indent, cmd, depth) {
-        const valueOptions = cmd.options.filter(opt => opt.takesValue);
+        const valueOptions = cmd.options.filter(optionTakesValue);
         const valueOptionsWithChoices = valueOptions.filter(opt => opt.choices && opt.choices.length > 0);
         const valueLongPatterns = valueOptions.map(opt => `--${camelToKebabCase(opt.long)}`);
         const valueShortPatterns = valueOptions
@@ -2316,7 +2469,7 @@ class FishCompletion {
                 line += ` -xa '${opt.choices.map(choice => this.#escapeChoice(choice)).join(' ')}'`;
             }
             lines.push(line);
-            if (!opt.takesValue) {
+            if (canGenerateNegativeCompletion(opt)) {
                 let noLine = `complete -c ${this.#programName}`;
                 if (condition)
                     noLine += ` -n '${condition}'`;
@@ -2326,11 +2479,11 @@ class FishCompletion {
             }
         }
         const valueOptionLongs = cmd.options
-            .filter(opt => opt.takesValue)
+            .filter(optionTakesValue)
             .map(opt => camelToKebabCase(opt.long))
             .join(',');
         const valueOptionShorts = cmd.options
-            .filter(opt => opt.takesValue && opt.short)
+            .filter(opt => optionTakesValue(opt) && opt.short)
             .map(opt => opt.short)
             .join(',');
         const argCount = cmd.arguments.length;
@@ -2529,7 +2682,7 @@ class PwshCompletion {
             '    if ($token.StartsWith("--")) {',
             '      if ($token.Contains("=")) { continue }',
             '      foreach ($opt in $cmd.options) {',
-            '        if ($token -eq "--$($opt.long)" -and $opt.takesValue) {',
+            '        if ($token -eq "--$($opt.long)" -and $opt.args -ne "none") {',
             '          $expectValue = $true',
             '          break',
             '        }',
@@ -2539,7 +2692,7 @@ class PwshCompletion {
             '    if ($token.StartsWith("-") -and $token -ne "-") {',
             '      if ($token.Length -eq 2) {',
             '        foreach ($opt in $cmd.options) {',
-            '          if ($opt.short -and $token -eq "-$($opt.short)" -and $opt.takesValue) {',
+            '          if ($opt.short -and $token -eq "-$($opt.short)" -and $opt.args -ne "none") {',
             '            $expectValue = $true',
             '            break',
             '          }',
@@ -2591,7 +2744,7 @@ class PwshCompletion {
             '          $opt.description',
             '        )',
             '      }',
-            '      if ($opt.isBoolean -and "--no-$($opt.long)" -like "$current*") {',
+            '      if ($opt.canNegate -and "--no-$($opt.long)" -like "$current*") {',
             '        $completions += [System.Management.Automation.CompletionResult]::new(',
             '          "--no-$($opt.long)",',
             '          "no-$($opt.long)",',
@@ -2641,8 +2794,9 @@ class PwshCompletion {
                 lines.push(`${indent}    short = '${opt.short}'`);
             lines.push(`${indent}    long = '${kebabLong}'`);
             lines.push(`${indent}    description = '${this.#escape(opt.desc)}'`);
-            lines.push(`${indent}    isBoolean = $${!opt.takesValue}`);
-            lines.push(`${indent}    takesValue = $${opt.takesValue}`);
+            lines.push(`${indent}    type = '${opt.type}'`);
+            lines.push(`${indent}    args = '${opt.args}'`);
+            lines.push(`${indent}    canNegate = $${canGenerateNegativeCompletion(opt)}`);
             if (opt.choices) {
                 lines.push(`${indent}    choices = @('${opt.choices
                     .map(choice => this.#escape(choice))