politty 0.4.0 → 0.4.2

package/dist/zsh-CASZWn0o.cjs

@@ -0,0 +1,1586 @@
+const require_subcommand_router = require('./subcommand-router-ZjNjFaUL.cjs');
+const require_lazy = require('./lazy-BEDnSR0m.cjs');
+let zod = require("zod");
+let node_child_process = require("node:child_process");
+
+//#region src/core/command.ts
+function defineCommand(config) {
+	return {
+		name: config.name,
+		description: config.description,
+		args: config.args,
+		subCommands: config.subCommands,
+		setup: config.setup,
+		run: config.run,
+		cleanup: config.cleanup,
+		notes: config.notes,
+		examples: config.examples
+	};
+}
+
+//#endregion
+//#region src/completion/value-completion-resolver.ts
+/**
+* Resolve value completion from field metadata
+*
+* Priority:
+* 1. Explicit custom completion (choices or shellCommand)
+* 2. Explicit completion type (file, directory, none)
+* 3. Auto-detected enum values from schema
+*/
+function resolveValueCompletion(field) {
+	const meta = field.completion;
+	if (meta?.custom) {
+		if (meta.custom.choices && meta.custom.choices.length > 0) return {
+			type: "choices",
+			choices: meta.custom.choices
+		};
+		if (meta.custom.shellCommand) return {
+			type: "command",
+			shellCommand: meta.custom.shellCommand
+		};
+	}
+	if (meta?.type) {
+		if (meta.type === "file") {
+			if (meta.matcher) return {
+				type: "file",
+				matcher: meta.matcher
+			};
+			if (meta.extensions) return {
+				type: "file",
+				extensions: meta.extensions
+			};
+			return { type: "file" };
+		}
+		if (meta.type === "directory") return { type: "directory" };
+		if (meta.type === "none") return { type: "none" };
+	}
+	if (field.enumValues && field.enumValues.length > 0) return {
+		type: "choices",
+		choices: field.enumValues
+	};
+}
+
+//#endregion
+//#region src/completion/extractor.ts
+/**
+* Extract completion data from commands
+*/
+/**
+* Sanitize a name for use as a shell function/variable identifier.
+* Replaces any character that is not alphanumeric or underscore with underscore.
+*/
+function sanitize(name) {
+	return name.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+/**
+* Filter subcommands to only visible (non-internal) ones.
+* Internal subcommands start with "__" and are hidden from completion/help.
+*/
+function getVisibleSubs(subs) {
+	return subs.filter((s) => !s.name.startsWith("__"));
+}
+/**
+* Convert a resolved field to a completable option
+*/
+function fieldToOption(field) {
+	return {
+		name: field.name,
+		cliName: field.cliName,
+		alias: field.alias,
+		description: field.description,
+		takesValue: field.type !== "boolean",
+		valueType: field.type,
+		required: field.required,
+		valueCompletion: resolveValueCompletion(field)
+	};
+}
+/**
+* Extract options from a command's args schema
+*/
+function extractOptions$1(command) {
+	if (!command.args) return [];
+	return require_lazy.extractFields(command.args).fields.filter((field) => !field.positional).map(fieldToOption);
+}
+/**
+* Extract positional arguments from a command
+*/
+function extractPositionals(command) {
+	if (!command.args) return [];
+	return require_lazy.extractFields(command.args).fields.filter((field) => field.positional);
+}
+/**
+* Extract completable positional arguments from a command
+*/
+function extractCompletablePositionals(command) {
+	if (!command.args) return [];
+	return require_lazy.extractFields(command.args).fields.filter((field) => field.positional).map((field, index) => ({
+		name: field.name,
+		cliName: field.cliName,
+		position: index,
+		description: field.description,
+		required: field.required,
+		variadic: field.type === "array",
+		valueCompletion: resolveValueCompletion(field)
+	}));
+}
+/**
+* Extract a completable subcommand from a command
+*/
+function extractSubcommand(name, command) {
+	const subcommands = [];
+	if (command.subCommands) for (const [subName, subCommand] of Object.entries(command.subCommands)) {
+		const resolved = require_lazy.resolveSubCommandMeta(subCommand);
+		if (resolved) subcommands.push(extractSubcommand(subName, resolved));
+		else subcommands.push({
+			name: subName,
+			description: "(lazy loaded)",
+			subcommands: [],
+			options: [],
+			positionals: []
+		});
+	}
+	return {
+		name,
+		description: command.description,
+		subcommands,
+		options: extractOptions$1(command),
+		positionals: extractCompletablePositionals(command)
+	};
+}
+/**
+* Collect opt-takes-value case entries for a subcommand tree.
+* Used by bash and zsh generators (identical case syntax: `subcmd:--opt) return 0 ;;`).
+*/
+function optTakesValueEntries(sub, subcmdName) {
+	const lines = [];
+	for (const opt of sub.options) if (opt.takesValue) {
+		const patterns = [`${subcmdName}:--${opt.cliName}`];
+		if (opt.alias) patterns.push(`${subcmdName}:-${opt.alias}`);
+		lines.push(`        ${patterns.join("|")}) return 0 ;;`);
+	}
+	for (const child of getVisibleSubs(sub.subcommands)) lines.push(...optTakesValueEntries(child, child.name));
+	return lines;
+}
+/**
+* Extract completion data from a command tree
+*/
+function extractCompletionData(command, programName) {
+	const rootSubcommand = extractSubcommand(programName, command);
+	return {
+		command: rootSubcommand,
+		programName,
+		globalOptions: rootSubcommand.options
+	};
+}
+
+//#endregion
+//#region src/completion/bash.ts
+/** Escape a string for use inside bash double-quotes */
+function escapeBashDQ(s) {
+	return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\$/g, "\\$").replace(/`/g, "\\`");
+}
+/**
+* Generate bash value completion code for a ValueCompletion spec.
+* Returns an array of bash lines.
+*/
+function bashValueLines(vc, inline) {
+	if (!vc) return [];
+	switch (vc.type) {
+		case "choices": {
+			const items = vc.choices.map((c) => `"${escapeBashDQ(c)}"`).join(" ");
+			if (inline) return [
+				`local -a _choices=(${items})`,
+				`COMPREPLY=()`,
+				`local _c; for _c in "\${_choices[@]}"; do [[ "$_c" == "$_cur"* ]] && COMPREPLY+=("\${_inline_prefix}\${_c}"); done`,
+				`compopt -o nospace`,
+				`compopt +o default 2>/dev/null`
+			];
+			return [
+				`local -a _choices=(${items})`,
+				`COMPREPLY=()`,
+				`local _c; for _c in "\${_choices[@]}"; do [[ "$_c" == "$_cur"* ]] && COMPREPLY+=("$_c"); done`,
+				`compopt +o default 2>/dev/null`
+			];
+		}
+		case "file":
+			if (vc.matcher?.length) return bashFileFilter(vc.matcher.map((p) => `[[ "\${_f##*/}" == ${p} ]]`).join(" || "), inline);
+			if (vc.extensions?.length) return bashFileFilter(vc.extensions.map((ext) => `[[ "$_f" == *".${ext}" ]]`).join(" || "), inline);
+			if (inline) return [
+				`local -a _entries=($(compgen -f -- "$_cur"))`,
+				`COMPREPLY=("\${_entries[@]/#/$_inline_prefix}")`,
+				`compopt -o filenames`
+			];
+			return [`COMPREPLY=($(compgen -f -- "$_cur"))`, `compopt -o filenames`];
+		case "directory":
+			if (inline) return [
+				`local -a _dirs=($(compgen -d -- "$_cur"))`,
+				`COMPREPLY=("\${_dirs[@]/#/$_inline_prefix}")`,
+				`compopt -o filenames`
+			];
+			return [`COMPREPLY=($(compgen -d -- "$_cur"))`, `compopt -o filenames`];
+		case "command": {
+			const cmd = vc.shellCommand;
+			if (inline) return [`COMPREPLY=($(compgen -P "$_inline_prefix" -W "$(${cmd})" -- "$_cur"))`];
+			return [`COMPREPLY=($(compgen -W "$(${cmd})" -- "$_cur"))`];
+		}
+		case "none": return [`compopt +o default 2>/dev/null`];
+	}
+}
+function bashFileFilter(checks, inline) {
+	const prefix = inline ? `"\${_inline_prefix}$_f"` : `"$_f"`;
+	return [
+		`local -a _all_entries=($(compgen -f -- "$_cur"))`,
+		`for _f in "\${_all_entries[@]}"; do`,
+		`    if [[ -d "$_f" ]]; then`,
+		`        COMPREPLY+=(${prefix})`,
+		`    elif ${checks}; then`,
+		`        COMPREPLY+=(${prefix})`,
+		`    fi`,
+		`done`,
+		`compopt -o filenames`,
+		`compopt +o default 2>/dev/null`
+	];
+}
+/** Collect value-taking option patterns for case matching */
+function optionValueCases$2(options, inline) {
+	const lines = [];
+	for (const opt of options) {
+		if (!opt.takesValue || !opt.valueCompletion) continue;
+		const valLines = bashValueLines(opt.valueCompletion, inline);
+		if (valLines.length === 0) continue;
+		const patterns = [`--${opt.cliName}`];
+		if (opt.alias) patterns.push(`-${opt.alias}`);
+		const patternStr = patterns.join("|");
+		lines.push(`            ${patternStr})`);
+		for (const vl of valLines) lines.push(`                ${vl}`);
+		lines.push(`                return ;;`);
+	}
+	return lines;
+}
+/** Generate positional completion block */
+function positionalBlock$2(positionals) {
+	if (positionals.length === 0) return [];
+	const lines = [];
+	lines.push(`    case "$_pos_count" in`);
+	for (const pos of positionals) {
+		if (pos.variadic) lines.push(`        ${pos.position}|*)`);
+		else lines.push(`        ${pos.position})`);
+		for (const vl of bashValueLines(pos.valueCompletion, false)) lines.push(`            ${vl}`);
+		lines.push(`            ;;`);
+	}
+	lines.push(`    esac`);
+	return lines;
+}
+/** Generate prev/inline value completion blocks for options */
+function valueCompletionBlocks(options) {
+	if (!options.some((o) => o.takesValue && o.valueCompletion)) return [];
+	const lines = [];
+	const prevCases = optionValueCases$2(options, false);
+	if (prevCases.length > 0) {
+		lines.push(`    if [[ -z "$_inline_prefix" ]]; then`);
+		lines.push(`        case "$_prev" in`);
+		lines.push(...prevCases);
+		lines.push(`        esac`);
+		lines.push(`    fi`);
+	}
+	const inlineCases = optionValueCases$2(options, true);
+	if (inlineCases.length > 0) {
+		lines.push(`    if [[ -n "$_inline_prefix" ]]; then`);
+		lines.push(`        case "\${_inline_prefix%=}" in`);
+		lines.push(...inlineCases);
+		lines.push(`        esac`);
+		lines.push(`    fi`);
+	}
+	return lines;
+}
+/** Generate available-options list lines */
+function availableOptionLines$2(options, fn) {
+	const lines = [];
+	for (const opt of options) if (opt.valueType === "array") lines.push(`        _avail+=(--${opt.cliName})`);
+	else {
+		const patterns = [`"--${opt.cliName}"`];
+		if (opt.alias) patterns.push(`"-${opt.alias}"`);
+		lines.push(`        __${fn}_not_used ${patterns.join(" ")} && _avail+=(--${opt.cliName})`);
+	}
+	lines.push(`        __${fn}_not_used "--help" && _avail+=(--help)`);
+	return lines;
+}
+/**
+* Generate a per-subcommand completion function.
+* Recursively generates functions for nested subcommands.
+*/
+function generateSubHandler$2(sub, fn, path) {
+	const fullPath = [...path, sub.name];
+	const funcName = `__${fn}_complete_${fullPath.map(sanitize).join("_")}`;
+	const visibleSubs = getVisibleSubs(sub.subcommands);
+	const lines = [];
+	for (const child of visibleSubs) lines.push(...generateSubHandler$2(child, fn, fullPath));
+	lines.push(`${funcName}() {`);
+	lines.push(...valueCompletionBlocks(sub.options));
+	lines.push(`    if [[ -z "$_inline_prefix" ]] && __${fn}_opt_takes_value "${sub.name}" "$_prev"; then return; fi`);
+	lines.push(`    if [[ -n "$_inline_prefix" ]] && __${fn}_opt_takes_value "${sub.name}" "\${_inline_prefix%=}"; then return; fi`);
+	if (sub.positionals.length > 0) {
+		lines.push(`    if (( _after_dd )); then`);
+		lines.push(...positionalBlock$2(sub.positionals).map((l) => `    ${l}`));
+		lines.push(`        return`);
+		lines.push(`    fi`);
+	} else lines.push(`    if (( _after_dd )); then return; fi`);
+	lines.push(`    if [[ "$_cur" == -* ]]; then`);
+	lines.push(`        local -a _avail=()`);
+	lines.push(...availableOptionLines$2(sub.options, fn));
+	lines.push(`        COMPREPLY=($(compgen -W "\${_avail[*]}" -- "$_cur"))`);
+	lines.push(`        compopt +o default 2>/dev/null`);
+	lines.push(`        return`);
+	lines.push(`    fi`);
+	if (visibleSubs.length > 0) {
+		const subNames = visibleSubs.map((s) => s.name).join(" ");
+		lines.push(`    COMPREPLY=($(compgen -W "${subNames}" -- "$_cur"))`);
+		lines.push(`    compopt +o default 2>/dev/null`);
+	} else if (sub.positionals.length > 0) lines.push(...positionalBlock$2(sub.positionals));
+	lines.push(`}`);
+	lines.push(``);
+	return lines;
+}
+function generateBashCompletion(command, options) {
+	const { programName } = options;
+	const data = extractCompletionData(command, programName);
+	const fn = sanitize(programName);
+	const root = data.command;
+	const visibleSubs = getVisibleSubs(root.subcommands);
+	const lines = [];
+	lines.push(`# Bash completion for ${programName}`);
+	lines.push(`# Generated by politty`);
+	lines.push(``);
+	lines.push(`__${fn}_not_used() {`);
+	lines.push(`    for _u in "\${_used_opts[@]}"; do`);
+	lines.push(`        for _chk in "$@"; do`);
+	lines.push(`            [[ "$_u" == "$_chk" ]] && return 1`);
+	lines.push(`        done`);
+	lines.push(`    done`);
+	lines.push(`    return 0`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_opt_takes_value() {`);
+	lines.push(`    case "$1:$2" in`);
+	lines.push(...optTakesValueEntries(root, ""));
+	lines.push(`    esac`);
+	lines.push(`    return 1`);
+	lines.push(`}`);
+	lines.push(``);
+	for (const sub of visibleSubs) lines.push(...generateSubHandler$2(sub, fn, []));
+	lines.push(`__${fn}_complete_root() {`);
+	lines.push(...valueCompletionBlocks(root.options));
+	lines.push(`    if [[ -z "$_inline_prefix" ]] && __${fn}_opt_takes_value "" "$_prev"; then return; fi`);
+	lines.push(`    if [[ -n "$_inline_prefix" ]] && __${fn}_opt_takes_value "" "\${_inline_prefix%=}"; then return; fi`);
+	if (root.positionals.length > 0) {
+		lines.push(`    if (( _after_dd )); then`);
+		lines.push(...positionalBlock$2(root.positionals).map((l) => `    ${l}`));
+		lines.push(`        return`);
+		lines.push(`    fi`);
+	} else lines.push(`    if (( _after_dd )); then return; fi`);
+	lines.push(`    if [[ "$_cur" == -* ]]; then`);
+	lines.push(`        local -a _avail=()`);
+	lines.push(...availableOptionLines$2(root.options, fn));
+	lines.push(`        COMPREPLY=($(compgen -W "\${_avail[*]}" -- "$_cur"))`);
+	lines.push(`        compopt +o default 2>/dev/null`);
+	if (visibleSubs.length > 0) {
+		lines.push(`    else`);
+		const subNames = visibleSubs.map((s) => s.name).join(" ");
+		lines.push(`        COMPREPLY=($(compgen -W "${subNames}" -- "$_cur"))`);
+		lines.push(`        compopt +o default 2>/dev/null`);
+	} else if (root.positionals.length > 0) {
+		lines.push(`    else`);
+		lines.push(...positionalBlock$2(root.positionals).map((l) => `    ${l}`));
+	}
+	lines.push(`    fi`);
+	lines.push(`}`);
+	lines.push(``);
+	const subRouting = visibleSubs.map((s) => `        ${s.name}) __${fn}_complete_${sanitize(s.name)} ;;`).join("\n");
+	lines.push(`_${fn}_completions() {`);
+	lines.push(`    COMPREPLY=()`);
+	lines.push(``);
+	lines.push(`    # Rejoin words split by '=' in COMP_WORDBREAKS`);
+	lines.push(`    local -a _words=()`);
+	lines.push(`    local _i=1`);
+	lines.push(`    while (( _i <= COMP_CWORD )); do`);
+	lines.push(`        if [[ "\${COMP_WORDS[_i]}" == "=" && \${#_words[@]} -gt 0 ]]; then`);
+	lines.push(`            _words[\${#_words[@]}-1]+="=\${COMP_WORDS[_i+1]:-}"`);
+	lines.push(`            (( _i += 2 ))`);
+	lines.push(`        else`);
+	lines.push(`            _words+=("\${COMP_WORDS[_i]}")`);
+	lines.push(`            (( _i++ ))`);
+	lines.push(`        fi`);
+	lines.push(`    done`);
+	lines.push(``);
+	lines.push(`    local _cur=""`);
+	lines.push(`    (( \${#_words[@]} > 0 )) && _cur="\${_words[\${#_words[@]}-1]}"`);
+	lines.push(``);
+	lines.push(`    local _inline_prefix=""`);
+	lines.push(`    if [[ "$_cur" == --*=* ]]; then`);
+	lines.push(`        _inline_prefix="\${_cur%%=*}="`);
+	lines.push(`        _cur="\${_cur#*=}"`);
+	lines.push(`    fi`);
+	lines.push(``);
+	lines.push(`    local _prev=""`);
+	lines.push(`    (( \${#_words[@]} > 1 )) && _prev="\${_words[\${#_words[@]}-2]}"`);
+	lines.push(``);
+	lines.push(`    local _subcmd="" _after_dd=0 _pos_count=0 _skip_next=0`);
+	lines.push(`    local -a _used_opts=()`);
+	lines.push(``);
+	lines.push(`    local _j=0`);
+	lines.push(`    while (( _j < \${#_words[@]} - 1 )); do`);
+	lines.push(`        local _w="\${_words[_j]}"`);
+	lines.push(`        if (( _skip_next )); then _skip_next=0; (( _j++ )); continue; fi`);
+	lines.push(`        if [[ "$_w" == "--" ]]; then _after_dd=1; (( _j++ )); continue; fi`);
+	lines.push(`        if (( _after_dd )); then (( _pos_count++ )); (( _j++ )); continue; fi`);
+	lines.push(`        if [[ "$_w" == --*=* ]]; then _used_opts+=("\${_w%%=*}"); (( _j++ )); continue; fi`);
+	lines.push(`        if [[ "$_w" == -* ]]; then`);
+	lines.push(`            _used_opts+=("$_w")`);
+	lines.push(`            __${fn}_opt_takes_value "$_subcmd" "$_w" && _skip_next=1`);
+	lines.push(`            (( _j++ )); continue`);
+	lines.push(`        fi`);
+	if (visibleSubs.length > 0) lines.push(`        if [[ -z "$_subcmd" ]]; then _subcmd="$_w"; _used_opts=(); else (( _pos_count++ )); fi`);
+	else lines.push(`        (( _pos_count++ ))`);
+	lines.push(`        (( _j++ ))`);
+	lines.push(`    done`);
+	lines.push(``);
+	lines.push(`    case "$_subcmd" in`);
+	lines.push(subRouting);
+	lines.push(`        *) __${fn}_complete_root ;;`);
+	lines.push(`    esac`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`complete -o default -F _${fn}_completions ${programName}`);
+	lines.push(``);
+	return {
+		script: lines.join("\n"),
+		shell: "bash",
+		installInstructions: `# To enable completions, add the following to your ~/.bashrc:
+
+# Option 1: Source directly
+eval "$(${programName} completion bash)"
+
+# Option 2: Save to a file
+${programName} completion bash > ~/.local/share/bash-completion/completions/${programName}
+
+# Then reload your shell or run:
+source ~/.bashrc`
+	};
+}
+
+//#endregion
+//#region src/completion/dynamic/candidate-generator.ts
+/**
+* Generate completion candidates based on context
+*/
+/**
+* Completion directive flags (bitwise)
+*/
+const CompletionDirective = {
+	Default: 0,
+	NoSpace: 1,
+	NoFileCompletion: 2,
+	FilterPrefix: 4,
+	KeepOrder: 8,
+	FileCompletion: 16,
+	DirectoryCompletion: 32,
+	Error: 64
+};
+/**
+* Generate completion candidates based on context
+*/
+function generateCandidates(context) {
+	const candidates = [];
+	let directive = CompletionDirective.Default;
+	switch (context.completionType) {
+		case "subcommand": return generateSubcommandCandidates(context);
+		case "option-name": return generateOptionNameCandidates(context);
+		case "option-value": return generateOptionValueCandidates(context);
+		case "positional": return generatePositionalCandidates(context);
+		default: return {
+			candidates,
+			directive
+		};
+	}
+}
+/**
+* Execute a shell command and return results as candidates
+*/
+function executeShellCommand(command) {
+	try {
+		return (0, node_child_process.execSync)(command, {
+			encoding: "utf-8",
+			timeout: 5e3
+		}).split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => ({
+			value: line,
+			type: "value"
+		}));
+	} catch {
+		return [];
+	}
+}
+/**
+* Resolve value completion, executing shell commands and file lookups in JS
+*/
+function resolveValueCandidates(vc, candidates, _currentWord, description) {
+	let directive = CompletionDirective.FilterPrefix;
+	let fileExtensions;
+	let fileMatchers;
+	switch (vc.type) {
+		case "choices":
+			if (vc.choices) for (const choice of vc.choices) candidates.push({
+				value: choice,
+				description,
+				type: "value"
+			});
+			directive |= CompletionDirective.NoFileCompletion;
+			break;
+		case "file":
+			if (vc.matcher && vc.matcher.length > 0) {
+				fileMatchers = vc.matcher.filter((m) => m.trim().length > 0);
+				if (fileMatchers.length === 0) {
+					fileMatchers = void 0;
+					directive |= CompletionDirective.FileCompletion;
+				}
+			} else if (vc.extensions && vc.extensions.length > 0) {
+				fileExtensions = Array.from(new Set(vc.extensions.map((ext) => ext.trim().replace(/^\./, "")).filter((ext) => ext.length > 0)));
+				if (fileExtensions.length === 0) {
+					fileExtensions = void 0;
+					directive |= CompletionDirective.FileCompletion;
+				}
+			} else directive |= CompletionDirective.FileCompletion;
+			break;
+		case "directory":
+			directive |= CompletionDirective.DirectoryCompletion;
+			break;
+		case "command":
+			if (vc.shellCommand) candidates.push(...executeShellCommand(vc.shellCommand));
+			directive |= CompletionDirective.NoFileCompletion;
+			break;
+		case "none":
+			directive |= CompletionDirective.NoFileCompletion;
+			break;
+	}
+	return {
+		directive,
+		fileExtensions,
+		fileMatchers
+	};
+}
+/**
+* Generate subcommand candidates
+*/
+function generateSubcommandCandidates(context) {
+	const candidates = [];
+	let directive = CompletionDirective.FilterPrefix;
+	for (const name of context.subcommands) {
+		const sub = context.currentCommand.subCommands?.[name];
+		const description = sub ? require_lazy.resolveSubCommandMeta(sub)?.description : void 0;
+		candidates.push({
+			value: name,
+			description,
+			type: "subcommand"
+		});
+	}
+	if (candidates.length === 0 || context.currentWord.startsWith("-")) {
+		const optionResult = generateOptionNameCandidates(context);
+		candidates.push(...optionResult.candidates);
+	}
+	return {
+		candidates,
+		directive
+	};
+}
+/**
+* Generate option name candidates
+*/
+function generateOptionNameCandidates(context) {
+	const candidates = [];
+	const directive = CompletionDirective.FilterPrefix;
+	const availableOptions = context.options.filter((opt) => {
+		if (opt.valueType === "array") return true;
+		return !context.usedOptions.has(opt.cliName) && !context.usedOptions.has(opt.alias || "");
+	});
+	for (const opt of availableOptions) candidates.push({
+		value: `--${opt.cliName}`,
+		description: opt.description,
+		type: "option"
+	});
+	if (!context.usedOptions.has("help")) candidates.push({
+		value: "--help",
+		description: "Show help information",
+		type: "option"
+	});
+	return {
+		candidates,
+		directive
+	};
+}
+/**
+* Generate option value candidates
+*/
+function generateOptionValueCandidates(context) {
+	const candidates = [];
+	if (!context.targetOption) return {
+		candidates,
+		directive: CompletionDirective.FilterPrefix
+	};
+	const vc = context.targetOption.valueCompletion;
+	if (!vc) return {
+		candidates,
+		directive: CompletionDirective.FilterPrefix
+	};
+	return {
+		candidates,
+		...resolveValueCandidates(vc, candidates, context.currentWord)
+	};
+}
+/**
+* Generate positional argument candidates
+*/
+function generatePositionalCandidates(context) {
+	const candidates = [];
+	const positionalIndex = context.positionalIndex ?? 0;
+	const positional = context.positionals[positionalIndex] ?? (context.positionals.at(-1)?.variadic ? context.positionals.at(-1) : void 0);
+	if (!positional) return {
+		candidates,
+		directive: CompletionDirective.FilterPrefix
+	};
+	const vc = positional.valueCompletion;
+	if (!vc) return {
+		candidates,
+		directive: CompletionDirective.FilterPrefix
+	};
+	return {
+		candidates,
+		...resolveValueCandidates(vc, candidates, context.currentWord, positional.description)
+	};
+}
+
+//#endregion
+//#region src/completion/dynamic/context-parser.ts
+/**
+* Parse completion context from partial command line
+*/
+/**
+* Extract options from a command
+*/
+function extractOptions(command) {
+	if (!command.args) return [];
+	return require_lazy.extractFields(command.args).fields.filter((field) => !field.positional).map((field) => ({
+		name: field.name,
+		cliName: field.cliName,
+		alias: field.alias,
+		description: field.description,
+		takesValue: field.type !== "boolean",
+		valueType: field.type,
+		required: field.required,
+		valueCompletion: resolveValueCompletion(field)
+	}));
+}
+/**
+* Extract positionals from a command
+*/
+function extractPositionalsForContext(command) {
+	if (!command.args) return [];
+	return require_lazy.extractFields(command.args).fields.filter((field) => field.positional).map((field, index) => ({
+		name: field.name,
+		cliName: field.cliName,
+		position: index,
+		description: field.description,
+		required: field.required,
+		variadic: field.type === "array",
+		valueCompletion: resolveValueCompletion(field)
+	}));
+}
+/**
+* Get subcommand names from a command
+*/
+function getSubcommandNames(command) {
+	if (!command.subCommands) return [];
+	return Object.keys(command.subCommands).filter((name) => !name.startsWith("__"));
+}
+/**
+* Resolve subcommand by name
+*/
+function resolveSubcommand(command, name) {
+	if (!command.subCommands) return null;
+	const sub = command.subCommands[name];
+	if (!sub) return null;
+	return require_lazy.resolveSubCommandMeta(sub);
+}
+/**
+* Check if a word is an option (starts with - or --)
+*/
+function isOption(word) {
+	return word.startsWith("-");
+}
+/**
+* Parse option name from word (e.g., "--foo=bar" -> "foo", "-v" -> "v")
+*/
+function parseOptionName(word) {
+	if (word.startsWith("--")) {
+		const withoutPrefix = word.slice(2);
+		const eqIndex = withoutPrefix.indexOf("=");
+		return eqIndex >= 0 ? withoutPrefix.slice(0, eqIndex) : withoutPrefix;
+	}
+	if (word.startsWith("-")) return word.slice(1, 2);
+	return word;
+}
+/**
+* Check if option has inline value (e.g., "--foo=bar")
+*/
+function hasInlineValue(word) {
+	return word.includes("=");
+}
+/**
+* Find option by name or alias
+*/
+function findOption(options, nameOrAlias) {
+	return options.find((opt) => opt.cliName === nameOrAlias || opt.alias === nameOrAlias);
+}
+/**
+* Parse completion context from command line arguments
+*
+* @param argv - Arguments after the program name (e.g., ["build", "--fo"])
+* @param rootCommand - The root command
+* @returns Completion context
+*/
+function parseCompletionContext(argv, rootCommand) {
+	let currentCommand = rootCommand;
+	const subcommandPath = [];
+	const usedOptions = /* @__PURE__ */ new Set();
+	let positionalCount = 0;
+	let i = 0;
+	let options = extractOptions(currentCommand);
+	let afterDoubleDash = false;
+	while (i < argv.length - 1) {
+		const word = argv[i];
+		if (!afterDoubleDash && word === "--") {
+			afterDoubleDash = true;
+			i++;
+			continue;
+		}
+		if (!afterDoubleDash && isOption(word)) {
+			const optName = parseOptionName(word);
+			const opt = findOption(options, optName);
+			if (opt) {
+				usedOptions.add(opt.cliName);
+				if (opt.alias) usedOptions.add(opt.alias);
+				if (opt.takesValue && !hasInlineValue(word)) i++;
+			}
+			i++;
+			continue;
+		}
+		const subcommand = afterDoubleDash ? null : resolveSubcommand(currentCommand, word);
+		if (subcommand) {
+			subcommandPath.push(word);
+			currentCommand = subcommand;
+			options = extractOptions(currentCommand);
+			usedOptions.clear();
+			positionalCount = 0;
+			i++;
+			continue;
+		}
+		positionalCount++;
+		i++;
+	}
+	const currentWord = argv[argv.length - 1] ?? "";
+	const previousWord = argv[argv.length - 2] ?? "";
+	const positionals = extractPositionalsForContext(currentCommand);
+	const subcommands = getSubcommandNames(currentCommand);
+	let completionType;
+	let targetOption;
+	let positionalIndex;
+	if (!afterDoubleDash && previousWord && isOption(previousWord) && !hasInlineValue(previousWord)) {
+		const optName = parseOptionName(previousWord);
+		const opt = findOption(options, optName);
+		if (opt && opt.takesValue) {
+			completionType = "option-value";
+			targetOption = opt;
+		} else if (currentWord.startsWith("-")) completionType = "option-name";
+		else {
+			completionType = determineDefaultCompletionType(currentWord, subcommands, positionals, positionalCount);
+			if (completionType === "positional") positionalIndex = positionalCount;
+		}
+	} else if (!afterDoubleDash && currentWord.startsWith("--") && hasInlineValue(currentWord)) {
+		const optName = parseOptionName(currentWord);
+		const opt = findOption(options, optName);
+		if (opt && opt.takesValue) {
+			completionType = "option-value";
+			targetOption = opt;
+		} else completionType = "option-name";
+	} else if (!afterDoubleDash && currentWord.startsWith("-")) completionType = "option-name";
+	else {
+		completionType = determineDefaultCompletionType(currentWord, subcommands, positionals, positionalCount, afterDoubleDash);
+		if (completionType === "positional") positionalIndex = positionalCount;
+	}
+	return {
+		subcommandPath,
+		currentCommand,
+		currentWord,
+		previousWord,
+		completionType,
+		targetOption,
+		positionalIndex,
+		options,
+		subcommands,
+		positionals,
+		usedOptions,
+		providedPositionalCount: positionalCount
+	};
+}
+/**
+* Determine default completion type when not completing an option
+*/
+function determineDefaultCompletionType(currentWord, subcommands, positionals, positionalCount, afterDoubleDash) {
+	if (afterDoubleDash) return "positional";
+	if (subcommands.length > 0) {
+		if (subcommands.filter((s) => s.startsWith(currentWord)).length > 0 || currentWord === "") return "subcommand";
+	}
+	if (positionalCount < positionals.length) return "positional";
+	if (positionals.length > 0 && positionals[positionals.length - 1].variadic) return "positional";
+	return "subcommand";
+}
+
+//#endregion
+//#region src/completion/dynamic/shell-formatter.ts
+/**
+* Format completion candidates for the specified shell
+*
+* @returns Shell-ready output string (lines separated by newline, last line is :directive)
+*/
+function formatForShell(result, options) {
+	switch (options.shell) {
+		case "bash": return formatForBash(result, options);
+		case "zsh": return formatForZsh(result, options);
+		case "fish": return formatForFish(result, options);
+	}
+}
+/**
+* Check if the FilterPrefix directive is set
+*/
+function shouldFilterPrefix(directive) {
+	return (directive & CompletionDirective.FilterPrefix) !== 0;
+}
+/**
+* Filter candidates by prefix
+*/
+function filterByPrefix(candidates, prefix) {
+	if (!prefix) return candidates;
+	return candidates.filter((c) => c.value.startsWith(prefix));
+}
+/**
+* Append extension metadata and directive to output lines
+*/
+function appendMetadata(lines, result) {
+	if (result.fileExtensions && result.fileExtensions.length > 0) lines.push(`@ext:${result.fileExtensions.join(",")}`);
+	if (result.fileMatchers && result.fileMatchers.length > 0) lines.push(`@matcher:${result.fileMatchers.join(",")}`);
+	lines.push(`:${result.directive}`);
+}
+/**
+* Format for bash
+*
+* - Pre-filters candidates by currentWord prefix (replaces compgen -W)
+* - Handles --opt=value inline values by prepending prefix
+* - Outputs plain values only (no descriptions - bash COMPREPLY doesn't support them)
+* - Last line: :directive
+*/
+function formatForBash(result, options) {
+	let { candidates } = result;
+	if (shouldFilterPrefix(result.directive)) candidates = filterByPrefix(candidates, options.currentWord);
+	const lines = candidates.map((c) => {
+		if (options.inlinePrefix) return `${options.inlinePrefix}${c.value}`;
+		return c.value;
+	});
+	appendMetadata(lines, result);
+	return lines.join("\n");
+}
+/**
+* Format for zsh
+*
+* - Outputs value:description pairs for _describe
+* - Colons in values/descriptions are escaped with backslash
+* - Last line: :directive
+*/
+function formatForZsh(result, _options) {
+	const lines = result.candidates.map((c) => {
+		const escapedValue = c.value.replace(/:/g, "\\:");
+		if (c.description) return `${escapedValue}:${c.description.replace(/:/g, "\\:")}`;
+		return escapedValue;
+	});
+	appendMetadata(lines, result);
+	return lines.join("\n");
+}
+/**
+* Format for fish
+*
+* - Outputs value\tdescription pairs
+* - Last line: :directive
+*/
+function formatForFish(result, _options) {
+	const lines = result.candidates.map((c) => {
+		if (c.description) return `${c.value}\t${c.description}`;
+		return c.value;
+	});
+	appendMetadata(lines, result);
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/completion/dynamic/complete-command.ts
+/**
+* Dynamic completion command implementation
+*
+* This creates a hidden `__complete` command that outputs completion candidates
+* for shell scripts to consume. Usage:
+*
+*   mycli __complete --shell bash -- build --fo
+*   mycli __complete --shell zsh -- plugin add
+*
+* Output format depends on the target shell:
+*   bash: plain values (pre-filtered by prefix), last line :directive
+*   zsh:  value:description pairs, last line :directive
+*   fish: value\tdescription pairs, last line :directive
+*/
+/**
+* Detect inline option-value prefix (e.g., "--format=" from "--format=json")
+*/
+function detectInlinePrefix(currentWord) {
+	if (currentWord.startsWith("--") && currentWord.includes("=")) return currentWord.slice(0, currentWord.indexOf("=") + 1);
+}
+/**
+* Schema for the __complete command
+*/
+const completeArgsSchema = zod.z.object({
+	shell: require_lazy.arg(zod.z.enum([
+		"bash",
+		"zsh",
+		"fish"
+	]), { description: "Target shell for output formatting" }),
+	args: require_lazy.arg(zod.z.array(zod.z.string()).default([]), {
+		positional: true,
+		description: "Arguments to complete",
+		variadic: true
+	})
+});
+/**
+* Create the dynamic completion command
+*
+* @param rootCommand - The root command to generate completions for
+* @param programName - The program name (optional, defaults to rootCommand.name)
+* @returns A command that outputs completion candidates
+*/
+function createDynamicCompleteCommand(rootCommand, _programName) {
+	return defineCommand({
+		name: "__complete",
+		args: completeArgsSchema,
+		run(args) {
+			const context = parseCompletionContext(args.args, rootCommand);
+			const result = generateCandidates(context);
+			const inlinePrefix = detectInlinePrefix(context.currentWord);
+			const output = formatForShell(result, {
+				shell: args.shell,
+				currentWord: inlinePrefix ? context.currentWord.slice(inlinePrefix.length) : context.currentWord,
+				inlinePrefix
+			});
+			console.log(output);
+		}
+	});
+}
+/**
+* Check if a command tree contains the __complete command
+*/
+function hasCompleteCommand(command) {
+	return Boolean(command.subCommands?.["__complete"]);
+}
+
+//#endregion
+//#region src/completion/fish.ts
+/** Escape shell-special characters for fish double-quoted strings */
+function escapeDesc$1(s) {
+	return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\$/g, "\\$");
+}
+/**
+* Generate fish value completion lines for a ValueCompletion spec.
+* Each line outputs candidates via echo (tab-separated value\tdescription).
+*/
+function fishValueLines(vc) {
+	if (!vc) return [];
+	switch (vc.type) {
+		case "choices": return vc.choices.map((c) => `echo "${escapeDesc$1(c)}"`);
+		case "file":
+			if (vc.matcher?.length) return fishMatcherLines(vc.matcher);
+			if (vc.extensions?.length) return fishExtensionLines(vc.extensions);
+			return [`__fish_complete_path "$_cur"`];
+		case "directory": return [`__fish_complete_directories "$_cur"`];
+		case "command": return [
+			`for _v in (${vc.shellCommand})`,
+			`    echo "$_v"`,
+			`end`
+		];
+		case "none": return [];
+	}
+}
+/** Generate fish matcher-filtered file completion */
+function fishMatcherLines(patterns) {
+	return [
+		`__fish_complete_directories "$_cur"`,
+		`set -l _dir ""`,
+		`if string match -q '*/*' "$_cur"`,
+		`    set _dir (string replace -r '[^/]*$' '' "$_cur")`,
+		`end`,
+		...patterns.flatMap((p) => [
+			`for _f in "$_dir"${p}`,
+			`    test -f "$_f"; and string match -q "$_cur*" "$_f"; and echo "$_f"`,
+			`end`
+		])
+	];
+}
+/** Generate fish extension-filtered file completion */
+function fishExtensionLines(extensions) {
+	const lines = [];
+	lines.push(`__fish_complete_directories "$_cur"`);
+	for (const ext of extensions) {
+		lines.push(`for _f in "$_cur"*.${ext}`);
+		lines.push(`    test -f "$_f"; and echo "$_f"`);
+		lines.push(`end`);
+	}
+	return lines;
+}
+/** Generate option-value switch cases for fish */
+function optionValueCases$1(options) {
+	const lines = [];
+	for (const opt of options) {
+		if (!opt.takesValue || !opt.valueCompletion) continue;
+		const valLines = fishValueLines(opt.valueCompletion);
+		if (valLines.length === 0) continue;
+		const conditions = [`test "$_prev" = "--${opt.cliName}"`];
+		if (opt.alias) conditions.push(`test "$_prev" = "-${opt.alias}"`);
+		const cond = conditions.join("; or ");
+		lines.push(`    if ${cond}`);
+		for (const vl of valLines) lines.push(`        ${vl}`);
+		lines.push(`        return`);
+		lines.push(`    end`);
+	}
+	return lines;
+}
+/** Generate positional completion block for fish */
+function positionalBlock$1(positionals) {
+	if (positionals.length === 0) return [];
+	const lines = [];
+	for (const pos of positionals) {
+		const valLines = fishValueLines(pos.valueCompletion);
+		if (valLines.length === 0) continue;
+		if (pos.variadic) lines.push(`    if test $_pos_count -ge ${pos.position}`);
+		else lines.push(`    if test $_pos_count -eq ${pos.position}`);
+		for (const vl of valLines) lines.push(`        ${vl}`);
+		lines.push(`        return`);
+		lines.push(`    end`);
+	}
+	return lines;
+}
+/** Generate available-option echo lines for fish */
+function availableOptionLines$1(options, fn) {
+	const lines = [];
+	for (const opt of options) {
+		const desc = escapeDesc$1(opt.description ?? "");
+		if (opt.valueType === "array") lines.push(`        echo "--${opt.cliName}\t${desc}"`);
+		else {
+			const checks = [`"--${opt.cliName}"`];
+			if (opt.alias) checks.push(`"-${opt.alias}"`);
+			lines.push(`        __${fn}_not_used ${checks.join(" ")}; and echo "--${opt.cliName}\t${desc}"`);
+		}
+	}
+	lines.push(`        __${fn}_not_used "--help"; and echo "--help\tShow help"`);
+	return lines;
+}
+/** Generate value-option completion block if any value-taking options exist */
+function valueCompletionBlock$1(options) {
+	if (!options.some((o) => o.takesValue && o.valueCompletion)) return [];
+	return optionValueCases$1(options);
+}
+/**
+* Generate a per-subcommand completion function for fish.
+* Recursively generates functions for nested subcommands.
+*/
+function generateSubHandler$1(sub, fn, path) {
+	const fullPath = [...path, sub.name];
+	const funcName = `__${fn}_complete_${fullPath.map(sanitize).join("_")}`;
+	const visibleSubs = getVisibleSubs(sub.subcommands);
+	const lines = [];
+	for (const child of visibleSubs) lines.push(...generateSubHandler$1(child, fn, fullPath));
+	lines.push(`function ${funcName} --no-scope-shadowing`);
+	lines.push(...valueCompletionBlock$1(sub.options));
+	lines.push(`    if __${fn}_opt_takes_value "${sub.name}" "$_prev"; return; end`);
+	if (sub.positionals.length > 0) {
+		lines.push(`    if test $_after_dd -eq 1`);
+		lines.push(...positionalBlock$1(sub.positionals).map((l) => `    ${l}`));
+		lines.push(`        return`);
+		lines.push(`    end`);
+	} else lines.push(`    if test $_after_dd -eq 1; return; end`);
+	lines.push(`    if string match -q -- '-*' "$_cur"`);
+	lines.push(...availableOptionLines$1(sub.options, fn));
+	lines.push(`        return`);
+	lines.push(`    end`);
+	if (visibleSubs.length > 0) for (const s of visibleSubs) {
+		const desc = escapeDesc$1(s.description ?? "");
+		lines.push(`    echo "${s.name}\t${desc}"`);
+	}
+	else if (sub.positionals.length > 0) lines.push(...positionalBlock$1(sub.positionals));
+	lines.push(`end`);
+	lines.push(``);
+	return lines;
+}
+/** Generate opt-takes-value entries for fish switch cases */
+function optTakesValueCases(sub, subcmdName) {
+	const lines = [];
+	for (const opt of sub.options) if (opt.takesValue) {
+		const patterns = [`"${subcmdName}:--${opt.cliName}"`];
+		if (opt.alias) patterns.push(`"${subcmdName}:-${opt.alias}"`);
+		lines.push(`        case ${patterns.join(" ")}`);
+		lines.push(`            return 0`);
+	}
+	for (const child of getVisibleSubs(sub.subcommands)) lines.push(...optTakesValueCases(child, child.name));
+	return lines;
+}
+function generateFishCompletion(command, options) {
+	const { programName } = options;
+	const data = extractCompletionData(command, programName);
+	const fn = sanitize(programName);
+	const root = data.command;
+	const visibleSubs = getVisibleSubs(root.subcommands);
+	const lines = [];
+	lines.push(`# Fish completion for ${programName}`);
+	lines.push(`# Generated by politty`);
+	lines.push(``);
+	lines.push(`function __${fn}_not_used --no-scope-shadowing`);
+	lines.push(`    for _chk in $argv`);
+	lines.push(`        if contains -- "$_chk" $_used_opts`);
+	lines.push(`            return 1`);
+	lines.push(`        end`);
+	lines.push(`    end`);
+	lines.push(`    return 0`);
+	lines.push(`end`);
+	lines.push(``);
+	lines.push(`function __${fn}_opt_takes_value`);
+	lines.push(`    switch "$argv[1]:$argv[2]"`);
+	lines.push(...optTakesValueCases(root, ""));
+	lines.push(`    end`);
+	lines.push(`    return 1`);
+	lines.push(`end`);
+	lines.push(``);
+	for (const sub of visibleSubs) lines.push(...generateSubHandler$1(sub, fn, []));
+	lines.push(`function __${fn}_complete_root --no-scope-shadowing`);
+	lines.push(...valueCompletionBlock$1(root.options));
+	lines.push(`    if __${fn}_opt_takes_value "" "$_prev"; return; end`);
+	if (root.positionals.length > 0) {
+		lines.push(`    if test $_after_dd -eq 1`);
+		lines.push(...positionalBlock$1(root.positionals).map((l) => `    ${l}`));
+		lines.push(`        return`);
+		lines.push(`    end`);
+	} else lines.push(`    if test $_after_dd -eq 1; return; end`);
+	lines.push(`    if string match -q -- '-*' "$_cur"`);
+	lines.push(...availableOptionLines$1(root.options, fn));
+	if (visibleSubs.length > 0) {
+		lines.push(`    else`);
+		for (const s of visibleSubs) {
+			const desc = escapeDesc$1(s.description ?? "");
+			lines.push(`        echo "${s.name}\t${desc}"`);
+		}
+	} else if (root.positionals.length > 0) {
+		lines.push(`    else`);
+		lines.push(...positionalBlock$1(root.positionals));
+	}
+	lines.push(`    end`);
+	lines.push(`end`);
+	lines.push(``);
+	lines.push(`function __fish_${fn}_complete`);
+	lines.push(`    set -l _args (commandline -opc)`);
+	lines.push(`    set -e _args[1]`);
+	lines.push(``);
+	lines.push(`    set -l _ct (commandline -ct)`);
+	lines.push(`    if test (count $_ct) -eq 0`);
+	lines.push(`        set -a _args ""`);
+	lines.push(`    else`);
+	lines.push(`        set -a _args $_ct`);
+	lines.push(`    end`);
+	lines.push(``);
+	lines.push(`    set -l _cur ""`);
+	lines.push(`    if test (count $_args) -gt 0`);
+	lines.push(`        set _cur "$_args[-1]"`);
+	lines.push(`    end`);
+	lines.push(``);
+	lines.push(`    set -l _prev ""`);
+	lines.push(`    if test (count $_args) -gt 1`);
+	lines.push(`        set _prev "$_args[-2]"`);
+	lines.push(`    end`);
+	lines.push(``);
+	lines.push(`    set -l _subcmd "" ; set -l _after_dd 0 ; set -l _pos_count 0 ; set -l _skip_next 0`);
+	lines.push(`    set -l _used_opts`);
+	lines.push(``);
+	lines.push(`    set -l _j 1`);
+	lines.push(`    set -l _limit (math (count $_args) - 1)`);
+	lines.push(`    while test $_j -le $_limit`);
+	lines.push(`        set -l _w "$_args[$_j]"`);
+	lines.push(`        if test $_skip_next -eq 1; set _skip_next 0; set _j (math $_j + 1); continue; end`);
+	lines.push(`        if test "$_w" = "--"; set _after_dd 1; set _j (math $_j + 1); continue; end`);
+	lines.push(`        if test $_after_dd -eq 1; set _pos_count (math $_pos_count + 1); set _j (math $_j + 1); continue; end`);
+	lines.push(`        if string match -q -- '--*=*' "$_w"; set -a _used_opts (string replace -r '=.*' '' -- "$_w"); set _j (math $_j + 1); continue; end`);
+	lines.push(`        if string match -q -- '-*' "$_w"`);
+	lines.push(`            set -a _used_opts "$_w"`);
+	lines.push(`            __${fn}_opt_takes_value "$_subcmd" "$_w"; and set _skip_next 1`);
+	lines.push(`            set _j (math $_j + 1); continue`);
+	lines.push(`        end`);
+	if (visibleSubs.length > 0) lines.push(`        if test -z "$_subcmd"; set _subcmd "$_w"; set _used_opts; else; set _pos_count (math $_pos_count + 1); end`);
+	else lines.push(`        set _pos_count (math $_pos_count + 1)`);
+	lines.push(`        set _j (math $_j + 1)`);
+	lines.push(`    end`);
+	lines.push(``);
+	lines.push(`    switch "$_subcmd"`);
+	for (const s of visibleSubs) lines.push(`        case "${s.name}"; __${fn}_complete_${sanitize(s.name)}`);
+	lines.push(`        case '*'; __${fn}_complete_root`);
+	lines.push(`    end`);
+	lines.push(`end`);
+	lines.push(``);
+	lines.push(`# Clear existing completions`);
+	lines.push(`complete -e -c ${programName}`);
+	lines.push(``);
+	lines.push(`# Register completion`);
+	lines.push(`complete -c ${programName} -f -a '(__fish_${fn}_complete)'`);
+	lines.push(``);
+	return {
+		script: lines.join("\n"),
+		shell: "fish",
+		installInstructions: `# To enable completions, run one of the following:
+
+# Option 1: Source directly
+${programName} completion fish | source
+
+# Option 2: Save to the fish completions directory
+${programName} completion fish > ~/.config/fish/completions/${programName}.fish
+
+# The completion will be available immediately in new shell sessions.
+# To use in the current session, run:
+source ~/.config/fish/completions/${programName}.fish`
+	};
+}
+
+//#endregion
+//#region src/completion/zsh.ts
+function escapeDesc(s) {
+	return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\$/g, "\\$").replace(/`/g, "\\`").replace(/:/g, "\\:");
+}
+/**
+* Generate zsh value completion lines for a ValueCompletion spec.
+* Uses `_vals` array (must be declared in the calling function scope).
+*/
+function zshValueLines(vc, fn) {
+	if (!vc) return [];
+	switch (vc.type) {
+		case "choices": return [`_vals=(${vc.choices.map((c) => `"${escapeDesc(c)}"`).join(" ")})`, `__${fn}_cdescribe 'completions' _vals`];
+		case "file":
+			if (vc.matcher?.length) return vc.matcher.map((p) => `_files -g "${p}"`);
+			if (vc.extensions?.length) return vc.extensions.map((ext) => `_files -g "*.${ext}"`);
+			return [`_files`];
+		case "directory": return [`_files -/`];
+		case "command": return [`_vals=("\${(@f)$(${vc.shellCommand})}")`, `__${fn}_cdescribe 'completions' _vals`];
+		case "none": return [];
+	}
+}
+/** Generate option-value case branches */
+function optionValueCases(options, fn) {
+	const lines = [];
+	for (const opt of options) {
+		if (!opt.takesValue || !opt.valueCompletion) continue;
+		const valLines = zshValueLines(opt.valueCompletion, fn);
+		if (valLines.length === 0) continue;
+		const patterns = [`--${opt.cliName}`];
+		if (opt.alias) patterns.push(`-${opt.alias}`);
+		lines.push(`            ${patterns.join("|")})`);
+		for (const vl of valLines) lines.push(`                ${vl}`);
+		lines.push(`                return 0 ;;`);
+	}
+	return lines;
+}
+/** Generate positional completion block */
+function positionalBlock(positionals, fn) {
+	if (positionals.length === 0) return [];
+	const lines = [];
+	lines.push(`    case "$_pos_count" in`);
+	for (const pos of positionals) {
+		if (pos.variadic) lines.push(`        ${pos.position}|*)`);
+		else lines.push(`        ${pos.position})`);
+		const valLines = zshValueLines(pos.valueCompletion, fn);
+		for (const vl of valLines) lines.push(`            ${vl}`);
+		lines.push(`            ;;`);
+	}
+	lines.push(`    esac`);
+	return lines;
+}
+/** Generate prev-word value completion case block */
+function valueCompletionBlock(options, fn) {
+	if (!options.some((o) => o.takesValue && o.valueCompletion)) return [];
+	const prevCases = optionValueCases(options, fn);
+	if (prevCases.length === 0) return [];
+	return [
+		`    case "\${words[CURRENT-1]}" in`,
+		...prevCases,
+		`    esac`
+	];
+}
+/** Generate available-options list lines */
+function availableOptionLines(options, fn) {
+	const lines = [];
+	for (const opt of options) {
+		const desc = opt.description ? `:${escapeDesc(opt.description)}` : "";
+		if (opt.valueType === "array") lines.push(`        _opts+=("--${opt.cliName}${desc}")`);
+		else {
+			const patterns = [`"--${opt.cliName}"`];
+			if (opt.alias) patterns.push(`"-${opt.alias}"`);
+			lines.push(`        __${fn}_not_used ${patterns.join(" ")} && _opts+=("--${opt.cliName}${desc}")`);
+		}
+	}
+	lines.push(`        __${fn}_not_used "--help" && _opts+=("--help:Show help")`);
+	return lines;
+}
+/**
+* Generate a per-subcommand completion function.
+* Recursively generates functions for nested subcommands.
+*/
+function generateSubHandler(sub, fn, path) {
+	const fullPath = [...path, sub.name];
+	const funcName = `__${fn}_complete_${fullPath.map(sanitize).join("_")}`;
+	const visibleSubs = getVisibleSubs(sub.subcommands);
+	const lines = [];
+	for (const child of visibleSubs) lines.push(...generateSubHandler(child, fn, fullPath));
+	lines.push(`${funcName}() {`);
+	lines.push(`    local -a _vals=()`);
+	lines.push(...valueCompletionBlock(sub.options, fn));
+	lines.push(`    if __${fn}_opt_takes_value "${sub.name}" "\${words[CURRENT-1]}"; then return 0; fi`);
+	if (sub.positionals.length > 0) {
+		lines.push(`    if (( _after_dd )); then`);
+		lines.push(...positionalBlock(sub.positionals, fn).map((l) => `    ${l}`));
+		lines.push(`        return 0`);
+		lines.push(`    fi`);
+	} else lines.push(`    if (( _after_dd )); then return 0; fi`);
+	lines.push(`    if [[ "\${words[CURRENT]}" == -* ]]; then`);
+	lines.push(`        local -a _opts=()`);
+	lines.push(...availableOptionLines(sub.options, fn));
+	lines.push(`        __${fn}_cdescribe 'options' _opts`);
+	lines.push(`        return 0`);
+	lines.push(`    fi`);
+	if (visibleSubs.length > 0) {
+		const subItems = visibleSubs.map((s) => {
+			const desc = s.description ? `:${escapeDesc(s.description)}` : "";
+			return `"${s.name}${desc}"`;
+		}).join(" ");
+		lines.push(`    local -a _subs=(${subItems})`);
+		lines.push(`    __${fn}_cdescribe 'subcommands' _subs`);
+	} else if (sub.positionals.length > 0) lines.push(...positionalBlock(sub.positionals, fn));
+	lines.push(`}`);
+	lines.push(``);
+	return lines;
+}
+function generateZshCompletion(command, options) {
+	const { programName } = options;
+	const data = extractCompletionData(command, programName);
+	const fn = sanitize(programName);
+	const root = data.command;
+	const visibleSubs = getVisibleSubs(root.subcommands);
+	const lines = [];
+	lines.push(`#compdef ${programName}`);
+	lines.push(``);
+	lines.push(`# Zsh completion for ${programName}`);
+	lines.push(`# Generated by politty`);
+	lines.push(``);
+	lines.push(`__${fn}_not_used() {`);
+	lines.push(`    local _u _chk`);
+	lines.push(`    for _u in "\${_used_opts[@]}"; do`);
+	lines.push(`        for _chk in "$@"; do`);
+	lines.push(`            [[ "$_u" == "$_chk" ]] && return 1`);
+	lines.push(`        done`);
+	lines.push(`    done`);
+	lines.push(`    return 0`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_cdescribe() {`);
+	lines.push(`    _describe "$@" 2>/dev/null && return 0`);
+	lines.push(`    shift`);
+	lines.push(`    local -a _cd_vals=("\${(@)\${(P)1}%%:*}")`);
+	lines.push(`    compadd -a _cd_vals 2>/dev/null`);
+	lines.push(`    return 0`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_opt_takes_value() {`);
+	lines.push(`    case "$1:$2" in`);
+	lines.push(...optTakesValueEntries(root, ""));
+	lines.push(`    esac`);
+	lines.push(`    return 1`);
+	lines.push(`}`);
+	lines.push(``);
+	for (const sub of visibleSubs) lines.push(...generateSubHandler(sub, fn, []));
+	lines.push(`__${fn}_complete_root() {`);
+	lines.push(`    local -a _vals=()`);
+	lines.push(...valueCompletionBlock(root.options, fn));
+	lines.push(`    if __${fn}_opt_takes_value "" "\${words[CURRENT-1]}"; then return 0; fi`);
+	if (root.positionals.length > 0) {
+		lines.push(`    if (( _after_dd )); then`);
+		lines.push(...positionalBlock(root.positionals, fn).map((l) => `    ${l}`));
+		lines.push(`        return 0`);
+		lines.push(`    fi`);
+	} else lines.push(`    if (( _after_dd )); then return 0; fi`);
+	lines.push(`    if [[ "\${words[CURRENT]}" == -* ]]; then`);
+	lines.push(`        local -a _opts=()`);
+	lines.push(...availableOptionLines(root.options, fn));
+	lines.push(`        __${fn}_cdescribe 'options' _opts`);
+	if (visibleSubs.length > 0) {
+		lines.push(`    else`);
+		const subItems = visibleSubs.map((s) => {
+			const desc = s.description ? `:${escapeDesc(s.description)}` : "";
+			return `"${s.name}${desc}"`;
+		}).join(" ");
+		lines.push(`        local -a _subs=(${subItems})`);
+		lines.push(`        __${fn}_cdescribe 'subcommands' _subs`);
+	} else if (root.positionals.length > 0) {
+		lines.push(`    else`);
+		lines.push(...positionalBlock(root.positionals, fn).map((l) => `    ${l}`));
+	}
+	lines.push(`    fi`);
+	lines.push(`}`);
+	lines.push(``);
+	const subRouting = visibleSubs.map((s) => `        ${s.name}) __${fn}_complete_${sanitize(s.name)} ;;`).join("\n");
+	lines.push(`_${fn}() {`);
+	lines.push(`    (( CURRENT )) || CURRENT=\${#words}`);
+	lines.push(``);
+	lines.push(`    local _subcmd="" _after_dd=0 _pos_count=0 _skip_next=0`);
+	lines.push(`    local -a _used_opts=()`);
+	lines.push(``);
+	lines.push(`    local _j=2`);
+	lines.push(`    while (( _j < CURRENT )); do`);
+	lines.push(`        local _w="\${words[_j]}"`);
+	lines.push(`        if (( _skip_next )); then _skip_next=0; (( _j++ )); continue; fi`);
+	lines.push(`        if [[ "$_w" == "--" ]]; then _after_dd=1; (( _j++ )); continue; fi`);
+	lines.push(`        if (( _after_dd )); then (( _pos_count++ )); (( _j++ )); continue; fi`);
+	lines.push(`        if [[ "$_w" == --*=* ]]; then _used_opts+=("\${_w%%=*}"); (( _j++ )); continue; fi`);
+	lines.push(`        if [[ "$_w" == -* ]]; then`);
+	lines.push(`            _used_opts+=("$_w")`);
+	lines.push(`            __${fn}_opt_takes_value "$_subcmd" "$_w" && _skip_next=1`);
+	lines.push(`            (( _j++ )); continue`);
+	lines.push(`        fi`);
+	if (visibleSubs.length > 0) lines.push(`        if [[ -z "$_subcmd" ]]; then _subcmd="$_w"; _used_opts=(); else (( _pos_count++ )); fi`);
+	else lines.push(`        (( _pos_count++ ))`);
+	lines.push(`        (( _j++ ))`);
+	lines.push(`    done`);
+	lines.push(``);
+	lines.push(`    case "$_subcmd" in`);
+	lines.push(subRouting);
+	lines.push(`        *) __${fn}_complete_root ;;`);
+	lines.push(`    esac`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`zstyle ':completion:*:*:${programName}:*' file-patterns '%p:globbed-files *(-/):directories'`);
+	lines.push(``);
+	lines.push(`compdef _${fn} ${programName}`);
+	lines.push(``);
+	return {
+		script: lines.join("\n"),
+		shell: "zsh",
+		installInstructions: `# To enable completions, add the following to your ~/.zshrc:
+
+# Option 1: Source directly (add before compinit)
+eval "$(${programName} completion zsh)"
+
+# Option 2: Save to a file in your fpath
+${programName} completion zsh > ~/.zsh/completions/_${programName}
+
+# Make sure your fpath includes the completions directory:
+# fpath=(~/.zsh/completions $fpath)
+# autoload -Uz compinit && compinit
+
+# Then reload your shell or run:
+source ~/.zshrc`
+	};
+}
+
+//#endregion
+Object.defineProperty(exports, 'CompletionDirective', {
+  enumerable: true,
+  get: function () {
+    return CompletionDirective;
+  }
+});
+Object.defineProperty(exports, 'createDynamicCompleteCommand', {
+  enumerable: true,
+  get: function () {
+    return createDynamicCompleteCommand;
+  }
+});
+Object.defineProperty(exports, 'defineCommand', {
+  enumerable: true,
+  get: function () {
+    return defineCommand;
+  }
+});
+Object.defineProperty(exports, 'extractCompletionData', {
+  enumerable: true,
+  get: function () {
+    return extractCompletionData;
+  }
+});
+Object.defineProperty(exports, 'extractPositionals', {
+  enumerable: true,
+  get: function () {
+    return extractPositionals;
+  }
+});
+Object.defineProperty(exports, 'formatForShell', {
+  enumerable: true,
+  get: function () {
+    return formatForShell;
+  }
+});
+Object.defineProperty(exports, 'generateBashCompletion', {
+  enumerable: true,
+  get: function () {
+    return generateBashCompletion;
+  }
+});
+Object.defineProperty(exports, 'generateCandidates', {
+  enumerable: true,
+  get: function () {
+    return generateCandidates;
+  }
+});
+Object.defineProperty(exports, 'generateFishCompletion', {
+  enumerable: true,
+  get: function () {
+    return generateFishCompletion;
+  }
+});
+Object.defineProperty(exports, 'generateZshCompletion', {
+  enumerable: true,
+  get: function () {
+    return generateZshCompletion;
+  }
+});
+Object.defineProperty(exports, 'hasCompleteCommand', {
+  enumerable: true,
+  get: function () {
+    return hasCompleteCommand;
+  }
+});
+Object.defineProperty(exports, 'parseCompletionContext', {
+  enumerable: true,
+  get: function () {
+    return parseCompletionContext;
+  }
+});
+Object.defineProperty(exports, 'resolveValueCompletion', {
+  enumerable: true,
+  get: function () {
+    return resolveValueCompletion;
+  }
+});
+//# sourceMappingURL=zsh-CASZWn0o.cjs.map