politty 0.4.0 → 0.4.2

package/dist/zsh-hjvdI8uZ.js

@@ -0,0 +1,1508 @@
+import { c as arg, i as extractFields, r as resolveSubCommandMeta } from "./lazy-BrEg8SgI.js";
+import { z } from "zod";
+import { execSync } from "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 extractFields(command.args).fields.filter((field) => !field.positional).map(fieldToOption);
+}
+/**
+* Extract positional arguments from a command
+*/
+function extractPositionals(command) {
+	if (!command.args) return [];
+	return extractFields(command.args).fields.filter((field) => field.positional);
+}
+/**
+* Extract completable positional arguments from a command
+*/
+function extractCompletablePositionals(command) {
+	if (!command.args) return [];
+	return 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 = 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 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 ? 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 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 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 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 = z.object({
+	shell: arg(z.enum([
+		"bash",
+		"zsh",
+		"fish"
+	]), { description: "Target shell for output formatting" }),
+	args: arg(z.array(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
+export { formatForShell as a, generateCandidates as c, extractPositionals as d, resolveValueCompletion as f, hasCompleteCommand as i, generateBashCompletion as l, generateFishCompletion as n, parseCompletionContext as o, defineCommand as p, createDynamicCompleteCommand as r, CompletionDirective as s, generateZshCompletion as t, extractCompletionData as u };
+//# sourceMappingURL=zsh-hjvdI8uZ.js.map