@guanghechen/commander 4.7.5 → 4.7.7

package/lib/esm/index.mjs

@@ -1,1208 +0,0 @@
-import { Reporter, LOG_LEVELS, resolveLogLevel } from '@guanghechen/reporter';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-
-class CommanderError extends Error {
-    kind;
-    commandPath;
-    constructor(kind, message, commandPath) {
-        super(message);
-        this.name = 'CommanderError';
-        this.kind = kind;
-        this.commandPath = commandPath;
-    }
-    format() {
-        return `Error: ${this.message}\nRun "${this.commandPath} --help" for usage.`;
-    }
-}
-
-const LONG_OPTION_REGEX = /^--[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
-const NEGATIVE_OPTION_REGEX = /^--no-[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
-function kebabToCamelCase(str) {
-    return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-}
-function camelToKebabCase$1(str) {
-    return str.replace(/[A-Z]/g, m => '-' + m.toLowerCase());
-}
-function tokenizeLongOption(arg, commandPath) {
-    const eqIdx = arg.indexOf('=');
-    const namePart = eqIdx !== -1 ? arg.slice(0, eqIdx) : arg;
-    const valuePart = eqIdx !== -1 ? arg.slice(eqIdx) : '';
-    if (namePart.includes('_')) {
-        throw new CommanderError('InvalidOptionFormat', `invalid option "${arg}": use '-' instead of '_'`, commandPath);
-    }
-    const lowerName = namePart.toLowerCase();
-    if (lowerName === '--no' || lowerName === '--no-') {
-        throw new CommanderError('InvalidNegativeOption', `invalid negative option syntax "${arg}"`, commandPath);
-    }
-    if (lowerName.startsWith('--no-')) {
-        if (valuePart !== '') {
-            throw new CommanderError('NegativeOptionWithValue', `"${namePart}" does not accept a value`, commandPath);
-        }
-        if (!NEGATIVE_OPTION_REGEX.test(lowerName)) {
-            throw new CommanderError('InvalidOptionFormat', `invalid option format "${arg}"`, commandPath);
-        }
-        const camelName = kebabToCamelCase(lowerName.slice(5));
-        return {
-            original: arg,
-            resolved: `--${camelName}=false`,
-            name: camelName,
-            type: 'long',
-        };
-    }
-    if (!LONG_OPTION_REGEX.test(lowerName)) {
-        throw new CommanderError('InvalidOptionFormat', `invalid option format "${arg}"`, commandPath);
-    }
-    const camelName = kebabToCamelCase(lowerName.slice(2));
-    return {
-        original: arg,
-        resolved: `--${camelName}${valuePart}`,
-        name: camelName,
-        type: 'long',
-    };
-}
-function tokenizeShortOptions(arg, commandPath) {
-    if (arg.includes('=')) {
-        throw new CommanderError('UnsupportedShortSyntax', `"${arg}" is not supported. Use "-${arg[1]} ${arg.slice(3)}" instead`, commandPath);
-    }
-    const flags = arg.slice(1);
-    return flags.split('').map(flag => ({
-        original: `-${flag}`,
-        resolved: `-${flag}`,
-        name: flag,
-        type: 'short',
-    }));
-}
-function tokenize(argv, commandPath) {
-    const optionTokens = [];
-    const restArgs = [];
-    let passThrough = false;
-    for (const arg of argv) {
-        if (arg === '--') {
-            passThrough = true;
-            continue;
-        }
-        if (passThrough) {
-            restArgs.push(arg);
-            continue;
-        }
-        if (arg.startsWith('--')) {
-            optionTokens.push(tokenizeLongOption(arg, commandPath));
-            continue;
-        }
-        if (arg.startsWith('-') && arg.length > 1) {
-            optionTokens.push(...tokenizeShortOptions(arg, commandPath));
-            continue;
-        }
-        optionTokens.push({
-            original: arg,
-            resolved: arg,
-            name: '',
-            type: 'none',
-        });
-    }
-    return { optionTokens, restArgs };
-}
-const BUILTIN_HELP_OPTION = {
-    long: 'help',
-    short: 'h',
-    type: 'boolean',
-    args: 'none',
-    desc: 'Show help information',
-};
-const BUILTIN_VERSION_OPTION = {
-    long: 'version',
-    short: 'V',
-    type: 'boolean',
-    args: 'none',
-    desc: 'Show version number',
-};
-class Command {
-    #name;
-    #desc;
-    #version;
-    #helpSubcommandEnabled;
-    #reporter;
-    #parent;
-    #options = [];
-    #arguments = [];
-    #subcommandsList = [];
-    #subcommandsMap = new Map();
-    #action = undefined;
-    constructor(config) {
-        this.#name = config.name ?? '';
-        this.#desc = config.desc;
-        this.#version = config.version;
-        this.#helpSubcommandEnabled = config.help ?? false;
-        this.#reporter = config.reporter;
-    }
-    get name() {
-        return this.#name || undefined;
-    }
-    get description() {
-        return this.#desc;
-    }
-    get version() {
-        return this.#version;
-    }
-    get parent() {
-        return this.#parent;
-    }
-    get options() {
-        return [...this.#options];
-    }
-    get arguments() {
-        return [...this.#arguments];
-    }
-    get subcommands() {
-        return new Map(this.#subcommandsMap);
-    }
-    option(opt) {
-        this.#validateOptionConfig(opt);
-        this.#checkOptionUniqueness(opt);
-        this.#options.push(opt);
-        return this;
-    }
-    argument(arg) {
-        this.#validateArgumentConfig(arg);
-        this.#arguments.push(arg);
-        return this;
-    }
-    action(fn) {
-        this.#action = fn;
-        return this;
-    }
-    subcommand(name, cmd) {
-        if (this.#helpSubcommandEnabled && name === 'help') {
-            throw new CommanderError('ConfigurationError', '"help" is a reserved subcommand name when help subcommand is enabled', this.#getCommandPath());
-        }
-        if (cmd.#parent && cmd.#parent !== this) {
-            throw new CommanderError('ConfigurationError', `command "${cmd.#name}" already has a parent`, this.#getCommandPath());
-        }
-        const existing = this.#subcommandsList.find(e => e.command === cmd);
-        if (existing) {
-            existing.aliases.push(name);
-            this.#subcommandsMap.set(name, cmd);
-        }
-        else {
-            cmd.#name = name;
-            cmd.#parent = this;
-            this.#subcommandsList.push({ name, aliases: [], command: cmd });
-            this.#subcommandsMap.set(name, cmd);
-        }
-        return this;
-    }
-    async run(params) {
-        const { argv, envs, reporter } = params;
-        try {
-            const processedArgv = this.#processHelpSubcommand(argv);
-            const routeResult = this.#route(processedArgv);
-            const { chain, remaining } = routeResult;
-            const leafCommand = chain[chain.length - 1];
-            const rootCommand = chain[0];
-            const tokenizeResult = tokenize(remaining, leafCommand.#getCommandPath());
-            const { optionTokens, restArgs } = tokenizeResult;
-            const hasUserHelp = leafCommand.#options.some(o => o.long === 'help');
-            const hasUserVersion = leafCommand.#options.some(o => o.long === 'version');
-            if (!hasUserHelp && this.#hasFlag(optionTokens, 'help', 'h')) {
-                console.log(leafCommand.formatHelp());
-                return;
-            }
-            if (!hasUserVersion && leafCommand === rootCommand && leafCommand.#version) {
-                if (this.#hasFlag(optionTokens, 'version', 'V')) {
-                    console.log(leafCommand.#version);
-                    return;
-                }
-            }
-            const resolveResult = this.#resolve(chain, optionTokens);
-            const ctx = {
-                cmd: leafCommand,
-                envs,
-                reporter: reporter ?? this.#reporter ?? new Reporter(),
-                argv,
-            };
-            const parseResult = this.#parse(chain, resolveResult, ctx, restArgs);
-            const actionParams = {
-                ctx: parseResult.ctx,
-                opts: parseResult.opts,
-                args: parseResult.args,
-                rawArgs: parseResult.rawArgs,
-            };
-            if (leafCommand.#action) {
-                await leafCommand.#runAction(actionParams);
-            }
-            else if (leafCommand.#subcommandsList.length > 0) {
-                console.log(leafCommand.formatHelp());
-            }
-            else {
-                throw new CommanderError('ConfigurationError', `no action defined for command "${leafCommand.#getCommandPath()}"`, leafCommand.#getCommandPath());
-            }
-        }
-        catch (err) {
-            if (err instanceof CommanderError) {
-                console.error(err.format());
-                process.exit(2);
-                return;
-            }
-            throw err;
-        }
-    }
-    parse(params) {
-        const { argv, envs, reporter } = params;
-        const processedArgv = this.#processHelpSubcommand(argv);
-        const routeResult = this.#route(processedArgv);
-        const { chain, remaining } = routeResult;
-        const leafCommand = chain[chain.length - 1];
-        const tokenizeResult = tokenize(remaining, leafCommand.#getCommandPath());
-        const { optionTokens, restArgs } = tokenizeResult;
-        const resolveResult = this.#resolve(chain, optionTokens);
-        const ctx = {
-            cmd: leafCommand,
-            envs,
-            reporter: reporter ?? this.#reporter ?? new Reporter(),
-            argv,
-        };
-        return this.#parse(chain, resolveResult, ctx, restArgs);
-    }
-    formatHelp() {
-        const lines = [];
-        const allOptions = this.#getMergedOptions();
-        lines.push(this.#desc);
-        lines.push('');
-        const commandPath = this.#getCommandPath();
-        let usage = `Usage: ${commandPath}`;
-        if (allOptions.length > 0)
-            usage += ' [options]';
-        if (this.#subcommandsList.length > 0)
-            usage += ' [command]';
-        for (const arg of this.#arguments) {
-            if (arg.kind === 'required') {
-                usage += ` <${arg.name}>`;
-            }
-            else if (arg.kind === 'optional') {
-                usage += ` [${arg.name}]`;
-            }
-            else {
-                usage += ` [${arg.name}...]`;
-            }
-        }
-        lines.push(usage);
-        lines.push('');
-        if (allOptions.length > 0) {
-            lines.push('Options:');
-            const optLines = [];
-            for (const opt of allOptions) {
-                const kebabLong = camelToKebabCase$1(opt.long);
-                let sig = opt.short ? `-${opt.short}, ` : '    ';
-                sig += `--${kebabLong}`;
-                if (opt.args !== 'none') {
-                    sig += ' <value>';
-                }
-                let desc = opt.desc;
-                if (opt.default !== undefined && opt.type !== 'boolean') {
-                    desc += ` (default: ${JSON.stringify(opt.default)})`;
-                }
-                if (opt.choices) {
-                    desc += ` [choices: ${opt.choices.join(', ')}]`;
-                }
-                optLines.push({ sig, desc });
-                if (opt.type === 'boolean' && opt.args === 'none') {
-                    optLines.push({
-                        sig: `    --no-${kebabLong}`,
-                        desc: `Negate --${kebabLong}`,
-                    });
-                }
-            }
-            const maxSigLen = Math.max(...optLines.map(l => l.sig.length));
-            for (const { sig, desc } of optLines) {
-                const padding = ' '.repeat(maxSigLen - sig.length + 2);
-                lines.push(`  ${sig}${padding}${desc}`);
-            }
-            lines.push('');
-        }
-        const showHelpSubcommand = this.#helpSubcommandEnabled && this.#subcommandsList.length > 0;
-        if (this.#subcommandsList.length > 0) {
-            lines.push('Commands:');
-            const cmdLines = [];
-            if (showHelpSubcommand) {
-                cmdLines.push({ name: 'help', desc: 'Show help for a command' });
-            }
-            for (const entry of this.#subcommandsList) {
-                let name = entry.name;
-                if (entry.aliases.length > 0) {
-                    name += `, ${entry.aliases.join(', ')}`;
-                }
-                cmdLines.push({ name, desc: entry.command.#desc });
-            }
-            const maxNameLen = Math.max(...cmdLines.map(l => l.name.length));
-            for (const { name, desc } of cmdLines) {
-                const padding = ' '.repeat(maxNameLen - name.length + 2);
-                lines.push(`  ${name}${padding}${desc}`);
-            }
-            lines.push('');
-        }
-        return lines.join('\n');
-    }
-    getCompletionMeta() {
-        const allOptions = this.#getMergedOptions();
-        const options = [];
-        for (const opt of allOptions) {
-            options.push({
-                long: opt.long,
-                short: opt.short,
-                desc: opt.desc,
-                takesValue: opt.args !== 'none',
-                choices: opt.choices,
-            });
-        }
-        return {
-            name: this.#name,
-            desc: this.#desc,
-            aliases: [],
-            options,
-            subcommands: this.#subcommandsList.map(entry => {
-                const subMeta = entry.command.getCompletionMeta();
-                return {
-                    ...subMeta,
-                    name: entry.name,
-                    aliases: entry.aliases,
-                };
-            }),
-        };
-    }
-    #processHelpSubcommand(argv) {
-        if (!this.#helpSubcommandEnabled)
-            return argv;
-        if (argv.length < 1 || argv[0] !== 'help')
-            return argv;
-        if (argv.length === 1 || this.#subcommandsList.length === 0) {
-            return ['--help'];
-        }
-        const subName = argv[1];
-        const entry = this.#subcommandsList.find(e => e.name === subName || e.aliases.includes(subName));
-        if (entry) {
-            return [subName, '--help', ...argv.slice(2)];
-        }
-        return argv;
-    }
-    #route(argv) {
-        const chain = [this];
-        let current = this;
-        let idx = 0;
-        while (idx < argv.length) {
-            const token = argv[idx];
-            if (token.startsWith('-'))
-                break;
-            const entry = current.#subcommandsList.find(e => e.name === token || e.aliases.includes(token));
-            if (!entry)
-                break;
-            current = entry.command;
-            chain.push(current);
-            idx += 1;
-        }
-        return { chain, remaining: argv.slice(idx) };
-    }
-    #resolve(chain, tokens) {
-        const consumedTokens = new Map();
-        let remaining = [...tokens];
-        const shadowed = new Set();
-        for (let i = chain.length - 1; i >= 0; i--) {
-            const cmd = chain[i];
-            const includeVersion = i === 0;
-            const result = cmd.#shift(remaining, shadowed, includeVersion);
-            consumedTokens.set(cmd, result.consumed);
-            remaining = result.remaining;
-            for (const opt of cmd.#options) {
-                shadowed.add(opt.long);
-            }
-        }
-        const argTokens = [];
-        for (const token of remaining) {
-            if (token.type !== 'none') {
-                const leafCommand = chain[chain.length - 1];
-                throw new CommanderError('UnknownOption', `unknown option "${token.original}" for command "${leafCommand.#getCommandPath()}"`, leafCommand.#getCommandPath());
-            }
-            argTokens.push(token);
-        }
-        return { consumedTokens, argTokens };
-    }
-    #shift(tokens, shadowed, includeVersion) {
-        const allOptions = this.#getMergedOptions(includeVersion);
-        const effectiveOptions = allOptions.filter(o => !shadowed.has(o.long));
-        const optionByLong = new Map();
-        const optionByShort = new Map();
-        for (const opt of effectiveOptions) {
-            optionByLong.set(opt.long, opt);
-            if (opt.short) {
-                optionByShort.set(opt.short, opt);
-            }
-        }
-        const consumed = [];
-        const remaining = [];
-        let i = 0;
-        while (i < tokens.length) {
-            const token = tokens[i];
-            if (token.type === 'long') {
-                const opt = optionByLong.get(token.name);
-                if (opt) {
-                    consumed.push(token);
-                    if (opt.args === 'required') {
-                        if (!token.resolved.includes('=') && i + 1 < tokens.length) {
-                            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') {
-                                i += 1;
-                                consumed.push(tokens[i]);
-                            }
-                        }
-                    }
-                    i += 1;
-                    continue;
-                }
-                remaining.push(token);
-                i += 1;
-                continue;
-            }
-            if (token.type === 'short') {
-                const opt = optionByShort.get(token.name);
-                if (opt) {
-                    consumed.push(token);
-                    if (opt.args === 'required') {
-                        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;
-                            consumed.push(tokens[i]);
-                        }
-                    }
-                    i += 1;
-                    continue;
-                }
-                remaining.push(token);
-                i += 1;
-                continue;
-            }
-            remaining.push(token);
-            i += 1;
-        }
-        return { consumed, remaining };
-    }
-    #parse(chain, resolveResult, ctx, restArgs) {
-        const { consumedTokens, argTokens } = resolveResult;
-        const leafCommand = chain[chain.length - 1];
-        this.#validateMergedShortOptions(chain);
-        const optsMap = new Map();
-        for (let i = 0; i < chain.length; i++) {
-            const cmd = chain[i];
-            const includeVersion = i === 0;
-            const tokens = consumedTokens.get(cmd) ?? [];
-            const opts = cmd.#parseOptions(tokens, includeVersion);
-            optsMap.set(cmd, opts);
-            for (const opt of cmd.#getMergedOptions(includeVersion)) {
-                if (opt.apply && opts[opt.long] !== undefined) {
-                    opt.apply(opts[opt.long], ctx);
-                }
-            }
-        }
-        const mergedOpts = {};
-        for (const cmd of chain) {
-            Object.assign(mergedOpts, optsMap.get(cmd) ?? {});
-        }
-        const rawArgStrings = [...argTokens.map(t => t.original), ...restArgs];
-        const { args, rawArgs } = leafCommand.#parseArguments(rawArgStrings);
-        return { ctx, opts: mergedOpts, args, rawArgs };
-    }
-    #parseOptions(tokens, includeVersion) {
-        const allOptions = this.#getMergedOptions(includeVersion);
-        const opts = {};
-        for (const opt of allOptions) {
-            if (opt.default !== undefined) {
-                opts[opt.long] = opt.default;
-            }
-            else if (opt.type === 'boolean' && opt.args === 'none') {
-                opts[opt.long] = false;
-            }
-            else if (opt.args === 'variadic') {
-                opts[opt.long] = [];
-            }
-        }
-        const optionByLong = new Map();
-        const optionByShort = new Map();
-        for (const opt of allOptions) {
-            optionByLong.set(opt.long, opt);
-            if (opt.short) {
-                optionByShort.set(opt.short, opt);
-            }
-        }
-        let i = 0;
-        while (i < tokens.length) {
-            const token = tokens[i];
-            const opt = token.type === 'long' ? optionByLong.get(token.name) : optionByShort.get(token.name);
-            if (!opt) {
-                i += 1;
-                continue;
-            }
-            const isNegativeToken = token.original.toLowerCase().startsWith('--no-');
-            if (isNegativeToken && !(opt.type === 'boolean' && opt.args === 'none')) {
-                throw new CommanderError('NegativeOptionType', `"--no-${camelToKebabCase$1(opt.long)}" can only be used with boolean options`, this.#getCommandPath());
-            }
-            if (opt.type === 'boolean' && opt.args === 'none') {
-                const eqIdx = token.resolved.indexOf('=');
-                if (eqIdx !== -1) {
-                    const value = token.resolved.slice(eqIdx + 1);
-                    if (value === 'true') {
-                        opts[opt.long] = true;
-                    }
-                    else if (value === 'false') {
-                        opts[opt.long] = false;
-                    }
-                    else {
-                        throw new CommanderError('InvalidBooleanValue', `invalid value "${value}" for boolean option "--${camelToKebabCase$1(opt.long)}". Use "true" or "false"`, this.#getCommandPath());
-                    }
-                }
-                else {
-                    opts[opt.long] = true;
-                }
-                i += 1;
-                continue;
-            }
-            if (opt.args === 'required') {
-                const eqIdx = token.resolved.indexOf('=');
-                let rawValue;
-                if (eqIdx !== -1) {
-                    rawValue = token.resolved.slice(eqIdx + 1);
-                }
-                else if (i + 1 < tokens.length && tokens[i + 1].type === 'none') {
-                    rawValue = tokens[i + 1].original;
-                    i += 1;
-                }
-                else {
-                    throw new CommanderError('MissingValue', `option "--${camelToKebabCase$1(opt.long)}" requires a value`, this.#getCommandPath());
-                }
-                opts[opt.long] = this.#convertValue(opt, rawValue);
-                i += 1;
-                continue;
-            }
-            if (opt.args === 'variadic') {
-                const values = Array.isArray(opts[opt.long]) ? opts[opt.long] : [];
-                const eqIdx = token.resolved.indexOf('=');
-                if (eqIdx !== -1) {
-                    values.push(this.#convertValue(opt, token.resolved.slice(eqIdx + 1)));
-                }
-                else {
-                    while (i + 1 < tokens.length && tokens[i + 1].type === 'none') {
-                        i += 1;
-                        values.push(this.#convertValue(opt, tokens[i].original));
-                    }
-                }
-                opts[opt.long] = values;
-                i += 1;
-                continue;
-            }
-            i += 1;
-        }
-        for (const opt of allOptions) {
-            if (opt.required && opts[opt.long] === undefined) {
-                throw new CommanderError('MissingRequired', `missing required option "--${camelToKebabCase$1(opt.long)}"`, this.#getCommandPath());
-            }
-        }
-        for (const opt of allOptions) {
-            if (opt.choices && opts[opt.long] !== undefined) {
-                const value = opts[opt.long];
-                const values = Array.isArray(value) ? value : [value];
-                const choices = opt.choices;
-                for (const v of values) {
-                    if (!choices.includes(v)) {
-                        throw new CommanderError('InvalidChoice', `invalid value "${v}" for option "--${camelToKebabCase$1(opt.long)}". Allowed: ${opt.choices.join(', ')}`, this.#getCommandPath());
-                    }
-                }
-            }
-        }
-        return opts;
-    }
-    #convertValue(opt, rawValue) {
-        if (opt.coerce) {
-            return opt.coerce(rawValue);
-        }
-        if (opt.type === 'number') {
-            const num = Number(rawValue);
-            if (Number.isNaN(num)) {
-                throw new CommanderError('InvalidType', `invalid number "${rawValue}" for option "--${camelToKebabCase$1(opt.long)}"`, this.#getCommandPath());
-            }
-            return num;
-        }
-        return rawValue;
-    }
-    #parseArguments(rawArgs) {
-        const argumentDefs = this.#arguments;
-        const args = {};
-        const requiredCount = argumentDefs.filter(a => a.kind === 'required').length;
-        if (rawArgs.length < requiredCount) {
-            const missing = argumentDefs
-                .filter(a => a.kind === 'required')
-                .slice(rawArgs.length)
-                .map(a => a.name);
-            throw new CommanderError('MissingRequiredArgument', `missing required argument(s): ${missing.join(', ')}`, this.#getCommandPath());
-        }
-        let index = 0;
-        for (const def of argumentDefs) {
-            if (def.kind === 'variadic') {
-                const rest = rawArgs.slice(index);
-                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') {
-                    args[def.name] = def.default ?? undefined;
-                    continue;
-                }
-            }
-            else {
-                args[def.name] = this.#convertArgument(def, raw);
-                index += 1;
-            }
-        }
-        const hasVariadic = argumentDefs.some(a => a.kind === 'variadic');
-        if (!hasVariadic && index < rawArgs.length) {
-            throw new CommanderError('TooManyArguments', `too many arguments: expected ${argumentDefs.length}, got ${rawArgs.length}`, this.#getCommandPath());
-        }
-        return { args, rawArgs };
-    }
-    #convertArgument(def, raw) {
-        if (def.coerce) {
-            try {
-                return def.coerce(raw);
-            }
-            catch {
-                throw new CommanderError('InvalidType', `invalid value "${raw}" for argument "${def.name}"`, this.#getCommandPath());
-            }
-        }
-        if (def.type === 'number') {
-            const n = Number(raw);
-            if (Number.isNaN(n)) {
-                throw new CommanderError('InvalidType', `invalid number "${raw}" for argument "${def.name}"`, this.#getCommandPath());
-            }
-            return n;
-        }
-        return raw;
-    }
-    #getMergedOptions(includeVersion = !this.#parent) {
-        const optionMap = new Map();
-        const hasUserHelp = this.#options.some(o => o.long === 'help');
-        const hasUserVersion = this.#options.some(o => o.long === 'version');
-        if (!hasUserHelp) {
-            optionMap.set('help', BUILTIN_HELP_OPTION);
-        }
-        if (!hasUserVersion && includeVersion) {
-            optionMap.set('version', BUILTIN_VERSION_OPTION);
-        }
-        for (const opt of this.#options) {
-            optionMap.set(opt.long, opt);
-        }
-        return Array.from(optionMap.values());
-    }
-    #validateMergedShortOptions(chain) {
-        const mergedByLong = new Map();
-        for (let i = 0; i < chain.length; i++) {
-            const cmd = chain[i];
-            const includeVersion = i === 0;
-            for (const opt of cmd.#getMergedOptions(includeVersion)) {
-                mergedByLong.set(opt.long, opt);
-            }
-        }
-        const shortMap = new Map();
-        for (const opt of mergedByLong.values()) {
-            if (!opt.short)
-                continue;
-            const existingLong = shortMap.get(opt.short);
-            if (existingLong && existingLong !== opt.long) {
-                throw new CommanderError('OptionConflict', `short option "-${opt.short}" conflicts with "--${existingLong}"`, this.#getCommandPath());
-            }
-            shortMap.set(opt.short, opt.long);
-        }
-    }
-    #validateOptionConfig(opt) {
-        if (opt.type === 'boolean' && opt.args !== 'none') {
-            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());
-        }
-        if (opt.long.startsWith('no')) {
-            throw new CommanderError('ConfigurationError', `option long name cannot start with "no": "${opt.long}"`, this.#getCommandPath());
-        }
-        if (!/^[a-z][a-zA-Z0-9]*$/.test(opt.long)) {
-            throw new CommanderError('ConfigurationError', `option long name must be camelCase: "${opt.long}"`, this.#getCommandPath());
-        }
-        if (opt.required && opt.default !== undefined) {
-            throw new CommanderError('ConfigurationError', `option "--${opt.long}" cannot be both required and have a default value`, this.#getCommandPath());
-        }
-        if (opt.type === 'boolean' && opt.required) {
-            throw new CommanderError('ConfigurationError', `boolean option "--${opt.long}" cannot be required`, this.#getCommandPath());
-        }
-    }
-    #checkOptionUniqueness(opt) {
-        if (this.#options.some(o => o.long === opt.long)) {
-            throw new CommanderError('OptionConflict', `option "--${opt.long}" is already defined`, this.#getCommandPath());
-        }
-        if (opt.short && this.#options.some(o => o.short === opt.short)) {
-            throw new CommanderError('OptionConflict', `short option "-${opt.short}" is already defined`, this.#getCommandPath());
-        }
-    }
-    #validateArgumentConfig(arg) {
-        if (arg.kind === 'required' && arg.default !== undefined) {
-            throw new CommanderError('ConfigurationError', `required argument "${arg.name}" cannot have a default value`, this.#getCommandPath());
-        }
-        if (arg.kind === 'variadic') {
-            if (this.#arguments.some(a => a.kind === 'variadic')) {
-                throw new CommanderError('ConfigurationError', 'only one variadic argument is allowed', this.#getCommandPath());
-            }
-        }
-        if (this.#arguments.length > 0) {
-            const last = this.#arguments[this.#arguments.length - 1];
-            if (last.kind === 'variadic') {
-                throw new CommanderError('ConfigurationError', 'variadic argument must be the last argument', this.#getCommandPath());
-            }
-        }
-        if (arg.kind === 'required') {
-            const hasOptional = this.#arguments.some(a => a.kind === 'optional' || a.kind === 'variadic');
-            if (hasOptional) {
-                throw new CommanderError('ConfigurationError', `required argument "${arg.name}" cannot come after optional/variadic arguments`, this.#getCommandPath());
-            }
-        }
-    }
-    async #runAction(params) {
-        if (!this.#action)
-            return;
-        try {
-            await this.#action(params);
-        }
-        catch (err) {
-            if (err instanceof Error) {
-                console.error(`Error: ${err.message}`);
-            }
-            else {
-                console.error('Error: action failed');
-            }
-            process.exit(1);
-        }
-    }
-    #hasFlag(tokens, longName, shortName) {
-        for (const token of tokens) {
-            if (token.type === 'long' && token.name === longName) {
-                return true;
-            }
-            if (token.type === 'short' && token.name === shortName) {
-                return true;
-            }
-        }
-        return false;
-    }
-    #getCommandPath() {
-        const parts = [];
-        let current = this;
-        while (current) {
-            if (current.#name) {
-                parts.unshift(current.#name);
-            }
-            current = current.#parent;
-        }
-        return parts.join(' ') || this.#name;
-    }
-}
-
-function camelToKebabCase(str) {
-    return str.replace(/[A-Z]/g, m => '-' + m.toLowerCase());
-}
-class CompletionCommand extends Command {
-    constructor(root, config) {
-        const paths = config.paths;
-        const programName = config.programName ?? root.name ?? 'program';
-        super({ desc: 'Generate shell completion script' });
-        this.option({
-            long: 'bash',
-            type: 'boolean',
-            args: 'none',
-            desc: 'Generate Bash completion script',
-        })
-            .option({
-            long: 'fish',
-            type: 'boolean',
-            args: 'none',
-            desc: 'Generate Fish completion script',
-        })
-            .option({
-            long: 'pwsh',
-            type: 'boolean',
-            args: 'none',
-            desc: 'Generate PowerShell completion script',
-        })
-            .option({
-            long: 'write',
-            short: 'w',
-            type: 'string',
-            args: 'required',
-            desc: 'Write to file (use shell default path if empty)',
-            default: undefined,
-        })
-            .action(({ opts }) => {
-            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];
-            let script;
-            switch (shell) {
-                case 'bash':
-                    script = new BashCompletion(meta, programName).generate();
-                    break;
-                case 'fish':
-                    script = new FishCompletion(meta, programName).generate();
-                    break;
-                case 'pwsh':
-                    script = new PwshCompletion(meta, programName).generate();
-                    break;
-            }
-            const writeOpt = opts['write'];
-            if (writeOpt !== undefined) {
-                const filePath = typeof writeOpt === 'string' && writeOpt !== '' ? writeOpt : paths[shell];
-                const expandedPath = expandHome(filePath);
-                const dir = path.dirname(expandedPath);
-                if (!fs.existsSync(dir)) {
-                    fs.mkdirSync(dir, { recursive: true });
-                }
-                fs.writeFileSync(expandedPath, script, 'utf-8');
-                console.log(`Completion script written to: ${expandedPath}`);
-            }
-            else {
-                console.log(script);
-            }
-        });
-    }
-}
-function expandHome(filepath) {
-    if (filepath.startsWith('~/') || filepath === '~') {
-        const home = process.env['HOME'] || process.env['USERPROFILE'] || '';
-        return filepath.replace(/^~/, home);
-    }
-    return filepath;
-}
-class BashCompletion {
-    #meta;
-    #programName;
-    constructor(meta, programName) {
-        this.#meta = meta;
-        this.#programName = programName;
-    }
-    generate() {
-        const funcName = `_${this.#sanitizeName(this.#programName)}_completions`;
-        const lines = [
-            `# Bash completion for ${this.#programName}`,
-            '# Generated by @guanghechen/commander',
-            '',
-            `${funcName}() {`,
-            '  local cur prev words cword',
-            '  _init_completion || return',
-            '',
-            ...this.#generateCommandCase(this.#meta, 1),
-            '',
-            '  COMPREPLY=($(compgen -W "$opts" -- "$cur"))',
-            '}',
-            '',
-            `complete -F ${funcName} ${this.#programName}`,
-            '',
-        ];
-        return lines.join('\n');
-    }
-    #generateCommandCase(cmd, depth) {
-        const indent = '  '.repeat(depth);
-        const lines = [];
-        const optParts = [];
-        for (const opt of cmd.options) {
-            const kebabLong = camelToKebabCase(opt.long);
-            if (opt.short)
-                optParts.push(`-${opt.short}`);
-            optParts.push(`--${kebabLong}`);
-            if (!opt.takesValue) {
-                optParts.push(`--no-${kebabLong}`);
-            }
-        }
-        const subParts = cmd.subcommands.flatMap(sub => [sub.name, ...sub.aliases]);
-        const allOpts = [...optParts, ...subParts].join(' ');
-        if (cmd.subcommands.length > 0) {
-            lines.push(`${indent}case "\${words[${depth}]}" in`);
-            for (const sub of cmd.subcommands) {
-                const pattern = [sub.name, ...sub.aliases].join('|');
-                lines.push(`${indent}  ${pattern})`);
-                lines.push(...this.#generateCommandCase(sub, depth + 1));
-                lines.push(`${indent}    ;;`);
-            }
-            lines.push(`${indent}  *)`);
-            lines.push(`${indent}    opts="${allOpts}"`);
-            lines.push(`${indent}    ;;`);
-            lines.push(`${indent}esac`);
-        }
-        else {
-            lines.push(`${indent}opts="${allOpts}"`);
-        }
-        return lines;
-    }
-    #sanitizeName(name) {
-        return name.replace(/[^a-zA-Z0-9]/g, '_');
-    }
-}
-class FishCompletion {
-    #meta;
-    #programName;
-    constructor(meta, programName) {
-        this.#meta = meta;
-        this.#programName = programName;
-    }
-    generate() {
-        const lines = [
-            `# Fish completion for ${this.#programName}`,
-            '# Generated by @guanghechen/commander',
-            '',
-            ...this.#generateCommandCompletions(this.#meta, []),
-            '',
-        ];
-        return lines.join('\n');
-    }
-    #generateCommandCompletions(cmd, parentPath) {
-        const lines = [];
-        const isRoot = parentPath.length === 0;
-        const condition = this.#buildCondition(parentPath);
-        for (const opt of cmd.options) {
-            const kebabLong = camelToKebabCase(opt.long);
-            let line = `complete -c ${this.#programName}`;
-            if (condition)
-                line += ` -n '${condition}'`;
-            if (opt.short)
-                line += ` -s ${opt.short}`;
-            line += ` -l ${kebabLong}`;
-            line += ` -d '${this.#escape(opt.desc)}'`;
-            if (opt.choices && opt.choices.length > 0) {
-                line += ` -xa '${opt.choices.join(' ')}'`;
-            }
-            lines.push(line);
-            if (!opt.takesValue) {
-                let noLine = `complete -c ${this.#programName}`;
-                if (condition)
-                    noLine += ` -n '${condition}'`;
-                noLine += ` -l no-${kebabLong}`;
-                noLine += ` -d '${this.#escape(opt.desc)}'`;
-                lines.push(noLine);
-            }
-        }
-        for (const sub of cmd.subcommands) {
-            let line = `complete -c ${this.#programName}`;
-            if (isRoot) {
-                line += ' -n __fish_use_subcommand';
-            }
-            else if (condition) {
-                line += ` -n '${condition}; and not __fish_seen_subcommand_from ${this.#getSubcommandNames(cmd).join(' ')}'`;
-            }
-            line += ` -a ${sub.name}`;
-            line += ` -d '${this.#escape(sub.desc)}'`;
-            lines.push(line);
-            for (const alias of sub.aliases) {
-                let aliasLine = `complete -c ${this.#programName}`;
-                if (isRoot) {
-                    aliasLine += ' -n __fish_use_subcommand';
-                }
-                else if (condition) {
-                    aliasLine += ` -n '${condition}; and not __fish_seen_subcommand_from ${this.#getSubcommandNames(cmd).join(' ')}'`;
-                }
-                aliasLine += ` -a ${alias}`;
-                aliasLine += ` -d 'Alias for ${sub.name}'`;
-                lines.push(aliasLine);
-            }
-            const newPath = [...parentPath, sub.name];
-            lines.push(...this.#generateCommandCompletions(sub, newPath));
-        }
-        return lines;
-    }
-    #buildCondition(path) {
-        if (path.length === 0)
-            return '';
-        return `__fish_seen_subcommand_from ${path[path.length - 1]}`;
-    }
-    #getSubcommandNames(cmd) {
-        return cmd.subcommands.flatMap(sub => [sub.name, ...sub.aliases]);
-    }
-    #escape(s) {
-        return s.replace(/'/g, "\\'");
-    }
-}
-class PwshCompletion {
-    #meta;
-    #programName;
-    constructor(meta, programName) {
-        this.#meta = meta;
-        this.#programName = programName;
-    }
-    generate() {
-        const lines = [
-            `# PowerShell completion for ${this.#programName}`,
-            '# Generated by @guanghechen/commander',
-            '',
-            `Register-ArgumentCompleter -Native -CommandName ${this.#programName} -ScriptBlock {`,
-            '  param($wordToComplete, $commandAst, $cursorPosition)',
-            '',
-            '  $commands = @{',
-            this.#generateCommandHash(this.#meta, '    '),
-            '  }',
-            '',
-            '  $words = $commandAst.CommandElements | ForEach-Object { $_.ToString() }',
-            '  $current = $wordToComplete',
-            '',
-            '  # Find current command context',
-            '  $cmd = $commands',
-            '  foreach ($word in $words[1..($words.Count - 1)]) {',
-            '    if ($word.StartsWith("-")) { continue }',
-            '    if ($cmd.subcommands -and $cmd.subcommands.ContainsKey($word)) {',
-            '      $cmd = $cmd.subcommands[$word]',
-            '    }',
-            '  }',
-            '',
-            '  # Generate completions',
-            '  $completions = @()',
-            '',
-            '  # Options',
-            '  if ($current.StartsWith("-")) {',
-            '    foreach ($opt in $cmd.options) {',
-            '      if ("--$($opt.long)" -like "$current*") {',
-            '        $completions += [System.Management.Automation.CompletionResult]::new(',
-            '          "--$($opt.long)",',
-            '          $opt.long,',
-            '          "ParameterName",',
-            '          $opt.desc',
-            '        )',
-            '      }',
-            '      if ($opt.isBoolean -and "--no-$($opt.long)" -like "$current*") {',
-            '        $completions += [System.Management.Automation.CompletionResult]::new(',
-            '          "--no-$($opt.long)",',
-            '          "no-$($opt.long)",',
-            '          "ParameterName",',
-            '          $opt.desc',
-            '        )',
-            '      }',
-            '      if ($opt.short -and "-$($opt.short)" -like "$current*") {',
-            '        $completions += [System.Management.Automation.CompletionResult]::new(',
-            '          "-$($opt.short)",',
-            '          $opt.short,',
-            '          "ParameterName",',
-            '          $opt.desc',
-            '        )',
-            '      }',
-            '    }',
-            '  }',
-            '',
-            '  # Subcommands',
-            '  if ($cmd.subcommands) {',
-            '    foreach ($sub in $cmd.subcommands.Keys) {',
-            '      if ($sub -like "$current*") {',
-            '        $completions += [System.Management.Automation.CompletionResult]::new(',
-            '          $sub,',
-            '          $sub,',
-            '          "Command",',
-            '          $cmd.subcommands[$sub].desc',
-            '        )',
-            '      }',
-            '    }',
-            '  }',
-            '',
-            '  return $completions',
-            '}',
-            '',
-        ];
-        return lines.join('\n');
-    }
-    #generateCommandHash(cmd, indent) {
-        const lines = [];
-        lines.push(`${indent}description = '${this.#escape(cmd.desc)}'`);
-        lines.push(`${indent}options = @(`);
-        for (const opt of cmd.options) {
-            const kebabLong = camelToKebabCase(opt.long);
-            lines.push(`${indent}  @{`);
-            if (opt.short)
-                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}`);
-            if (opt.choices) {
-                lines.push(`${indent}    choices = @('${opt.choices.join("', '")}')`);
-            }
-            lines.push(`${indent}  }`);
-        }
-        lines.push(`${indent})`);
-        if (cmd.subcommands.length > 0) {
-            lines.push(`${indent}subcommands = @{`);
-            for (const sub of cmd.subcommands) {
-                lines.push(`${indent}  '${sub.name}' = @{`);
-                lines.push(this.#generateCommandHash(sub, `${indent}    `));
-                lines.push(`${indent}  }`);
-                for (const alias of sub.aliases) {
-                    lines.push(`${indent}  '${alias}' = @{`);
-                    lines.push(this.#generateCommandHash(sub, `${indent}    `));
-                    lines.push(`${indent}  }`);
-                }
-            }
-            lines.push(`${indent}}`);
-        }
-        return lines.join('\n');
-    }
-    #escape(s) {
-        return s.replace(/'/g, "''");
-    }
-}
-
-const logLevelOption = {
-    long: 'logLevel',
-    type: 'string',
-    args: 'required',
-    desc: 'Set log level',
-    default: 'info',
-    choices: LOG_LEVELS,
-    coerce: (raw) => {
-        const level = resolveLogLevel(raw);
-        if (level === undefined) {
-            throw new Error(`Invalid log level: ${raw}`);
-        }
-        return level;
-    },
-    apply: (value, ctx) => {
-        ctx.reporter.setLevel(value);
-    },
-};
-const silentOption = {
-    long: 'silent',
-    type: 'boolean',
-    args: 'none',
-    desc: 'Suppress non-error output',
-    default: false,
-};
-
-export { BashCompletion, Command, CommanderError, CompletionCommand, FishCompletion, PwshCompletion, logLevelOption, silentOption };