politty 0.4.1 → 0.4.3

package/dist/extractor-cjruDqQ2.cjs

@@ -1,1078 +0,0 @@
-const require_subcommand_router = require('./subcommand-router-4d1Xbp8B.cjs');
-const require_schema_extractor = require('./schema-extractor-Mk1MHBkQ.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/bash.ts
-/**
-* Generate bash completion script for a command
-*
-* Generates a minimal script that delegates all logic to the CLI's __complete command.
-* The shell script only handles:
-* - Getting current command line tokens
-* - Calling __complete with --shell bash
-* - Setting COMPREPLY from the output
-* - Falling back to native file/directory completion when directed
-*/
-function generateBashCompletion(_command, options) {
-	const programName = options.programName;
-	return {
-		script: `# Bash completion for ${programName}
-# Generated by politty
-
-_${programName}_completions() {
-    COMPREPLY=()
-    local IFS=$'\\n'
-
-    # Rejoin words split by '=' in COMP_WORDBREAKS (e.g. --opt=value)
-    local -a _words=()
-    local _i=1
-    while (( _i <= COMP_CWORD )); do
-        if [[ "\${COMP_WORDS[_i]}" == "=" && \${#_words[@]} -gt 0 ]]; then
-            _words[\${#_words[@]}-1]+="=\${COMP_WORDS[_i+1]:-}"
-            (( _i += 2 ))
-        else
-            _words+=("\${COMP_WORDS[_i]}")
-            (( _i++ ))
-        fi
-    done
-
-    local lines prev_opts="$-"
-    set -f
-    lines=($(${programName} __complete --shell bash -- "\${_words[@]}" 2>/dev/null))
-    [[ "$prev_opts" != *f* ]] && set +f
-
-    local count=\${#lines[@]}
-    if (( count == 0 )); then
-        return 0
-    fi
-
-    local last="\${lines[count-1]}"
-    local directive=0
-    if [[ "$last" == :* ]]; then
-        directive="\${last:1}"
-        unset 'lines[count-1]'
-        (( count-- ))
-    fi
-
-    # Parse @ext: metadata (extension filter for native file completion)
-    local extensions=""
-    if (( count > 0 )); then
-        local maybe_ext="\${lines[count-1]}"
-        if [[ "$maybe_ext" == @ext:* ]]; then
-            extensions="\${maybe_ext:5}"
-            unset 'lines[count-1]'
-        fi
-    fi
-
-    local cur=""
-    (( \${#_words[@]} > 0 )) && cur="\${_words[\${#_words[@]}-1]}"
-
-    # Strip --opt= prefix for native file/directory completion
-    local inline_prefix=""
-    if [[ "$cur" == --*=* ]]; then
-        inline_prefix="\${cur%%=*}="
-        cur="\${cur#*=}"
-    fi
-
-    # 16 = FileCompletion: delegate entirely to native file completion
-    if (( directive & 16 )); then
-        local -a entries=($(compgen -f -- "$cur"))
-        if [[ -n "$inline_prefix" ]]; then
-            local i
-            for (( i=0; i<\${#entries[@]}; i++ )); do
-                entries[$i]="\${inline_prefix}\${entries[$i]}"
-            done
-        fi
-        COMPREPLY=("\${entries[@]}")
-        compopt -o filenames
-        return 0
-    fi
-
-    # Extension-filtered file completion: keep matching files + directories
-    if [[ -n "$extensions" ]]; then
-        local -a all_entries=($(compgen -f -- "$cur"))
-        local IFS=','
-        local -a ext_arr=($extensions)
-        IFS=$'\\n'
-        for f in "\${all_entries[@]}"; do
-            if [[ -d "$f" ]]; then
-                COMPREPLY+=("\${inline_prefix}$f")
-            else
-                for ext in "\${ext_arr[@]}"; do
-                    if [[ "$f" == *".$ext" ]]; then
-                        COMPREPLY+=("\${inline_prefix}$f")
-                        break
-                    fi
-                done
-            fi
-        done
-        compopt -o filenames
-        compopt +o default 2>/dev/null
-        return 0
-    fi
-
-    # Start with JS candidates
-    if (( \${#lines[@]} > 0 )); then
-        COMPREPLY=("\${lines[@]}")
-    fi
-
-    # 32 = DirectoryCompletion: merge native directory matches
-    if (( directive & 32 )); then
-        local -a dirs=($(compgen -d -- "$cur"))
-        if [[ -n "$inline_prefix" ]]; then
-            local i
-            for (( i=0; i<\${#dirs[@]}; i++ )); do
-                dirs[$i]="\${inline_prefix}\${dirs[$i]}"
-            done
-        fi
-        COMPREPLY+=("\${dirs[@]}")
-        compopt -o filenames
-    fi
-
-    # 2 = NoFileCompletion, 32 = DirectoryCompletion:
-    # suppress -o default file fallback when completions are restricted
-    if (( directive & 2 )) || (( directive & 32 )); then
-        compopt +o default 2>/dev/null
-    fi
-
-    return 0
-}
-
-# Register the completion function
-complete -o default -F _${programName}_completions ${programName}
-`,
-		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;
-	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.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
-	};
-}
-/**
-* Generate subcommand candidates
-*/
-function generateSubcommandCandidates(context) {
-	const candidates = [];
-	let directive = CompletionDirective.FilterPrefix;
-	for (const name of context.subcommands) {
-		let description;
-		if (context.currentCommand.subCommands) {
-			const sub = context.currentCommand.subCommands[name];
-			if (sub && typeof sub !== "function") description = sub.description;
-		}
-		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
-	};
-	const { directive, fileExtensions } = resolveValueCandidates(vc, candidates, context.currentWord);
-	return {
-		candidates,
-		directive,
-		fileExtensions
-	};
-}
-/**
-* 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
-	};
-	const { directive, fileExtensions } = resolveValueCandidates(vc, candidates, context.currentWord, positional.description);
-	return {
-		candidates,
-		directive,
-		fileExtensions
-	};
-}
-
-//#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") return meta.extensions ? {
-			type: "file",
-			extensions: meta.extensions
-		} : { 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/dynamic/context-parser.ts
-/**
-* Parse completion context from partial command line
-*/
-/**
-* Extract options from a command
-*/
-function extractOptions$1(command) {
-	if (!command.args) return [];
-	return require_schema_extractor.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_schema_extractor.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;
-	if (typeof sub === "function") return null;
-	return 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$1(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$1(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(",")}`);
-	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_schema_extractor.arg(zod.z.enum([
-		"bash",
-		"zsh",
-		"fish"
-	]), { description: "Target shell for output formatting" }),
-	args: require_schema_extractor.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
-/**
-* Generate fish completion script for a command
-*
-* Generates a minimal script that delegates all logic to the CLI's __complete command.
-* The shell script only handles:
-* - Getting current command line tokens
-* - Calling __complete with --shell fish
-* - Echoing output as completions
-* - Falling back to native file/directory completion when directed
-*/
-function generateFishCompletion(_command, options) {
-	const programName = options.programName;
-	return {
-		script: `# Fish completion for ${programName}
-# Generated by politty
-
-function __fish_${programName}_complete
-    set -l args (commandline -opc)
-    set -e args[1]
-    set -l directive 0
-    set -l extensions ""
-
-    # commandline -opc excludes the current token; always include it
-    set -l ct (commandline -ct)
-    if test (count $ct) -eq 0
-        set -a args ""
-    else
-        set -a args $ct
-    end
-
-    for line in (${programName} __complete --shell fish -- $args 2>/dev/null)
-        if string match -q ':*' -- $line
-            set directive (string sub -s 2 -- $line)
-        else if string match -q '@ext:*' -- $line
-            set extensions (string sub -s 6 -- $line)
-        else if test -n "$line"
-            echo $line
-        end
-    end
-
-    # 16 = FileCompletion: delegate entirely to native file completion
-    if test (math "bitand($directive, 16)") -ne 0
-        __fish_complete_path
-        return
-    end
-
-    # Extension-filtered file completion: keep matching files + directories
-    if test -n "$extensions"
-        set -l cur (commandline -ct)
-        test (count $cur) -eq 0; and set cur ""
-        __fish_complete_directories "$cur"
-        for ext in (string split "," -- $extensions)
-            for f in "$cur"*.$ext
-                if test -f "$f"
-                    echo $f
-                end
-            end
-        end
-        return
-    end
-
-    # 32 = DirectoryCompletion: add native directory matches
-    if test (math "bitand($directive, 32)") -ne 0
-        __fish_complete_directories
-    end
-end
-
-# Clear existing completions
-complete -e -c ${programName}
-
-# Register completion
-complete -c ${programName} -f -a '(__fish_${programName}_complete)'
-`,
-		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
-/**
-* Generate zsh completion script for a command
-*
-* Generates a minimal script that delegates all logic to the CLI's __complete command.
-* The shell script only handles:
-* - Getting current command line tokens
-* - Calling __complete with --shell zsh
-* - Passing output directly to _describe
-* - Falling back to native file/directory completion when directed
-*/
-function generateZshCompletion(_command, options) {
-	const programName = options.programName;
-	return {
-		script: `#compdef ${programName}
-
-# Zsh completion for ${programName}
-# Generated by politty
-
-_${programName}() {
-    local -a candidates
-    local line directive=0
-    local -a args=("\${words[@]:1}")
-    local -a output=("\${(@f)$(${programName} __complete --shell zsh -- "\${args[@]}" 2>/dev/null)}")
-
-    local extensions=""
-    for line in "\${output[@]}"; do
-        if [[ "$line" == :* ]]; then
-            directive="\${line:1}"
-        elif [[ "$line" == @ext:* ]]; then
-            extensions="\${line:5}"
-        elif [[ -n "$line" ]]; then
-            candidates+=("$line")
-        fi
-    done
-
-    # 16 = FileCompletion: delegate entirely to native file completion
-    if (( directive & 16 )); then
-        _files
-        return 0
-    fi
-
-    # Extension-filtered file completion: call _files -g per extension
-    if [[ -n "$extensions" ]]; then
-        local ext
-        for ext in \${(s:,:)extensions}; do
-            _files -g "*.$ext"
-        done
-        return 0
-    fi
-
-    if (( \${#candidates[@]} > 0 )); then
-        _describe 'completions' candidates
-    fi
-
-    # 32 = DirectoryCompletion: add native directory matches
-    if (( directive & 32 )); then
-        _files -/
-    fi
-
-    # 2 = NoFileCompletion, 32 = DirectoryCompletion:
-    # prevent fallback to default completers (e.g. file completion)
-    if (( directive & 2 )) || (( directive & 32 )); then
-        return 0
-    fi
-}
-
-# Prevent _files -g from falling back to showing all files when no pattern matches
-zstyle ':completion:*:*:${programName}:*' file-patterns '%p:globbed-files *(-/):directories'
-
-compdef _${programName} ${programName}
-`,
-		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
-//#region src/completion/extractor.ts
-/**
-* Extract completion data from commands
-*/
-/**
-* 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(command) {
-	if (!command.args) return [];
-	return require_schema_extractor.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_schema_extractor.extractFields(command.args).fields.filter((field) => field.positional);
-}
-/**
-* Extract completable positional arguments from a command
-*/
-function extractCompletablePositionals(command) {
-	if (!command.args) return [];
-	return require_schema_extractor.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,
-		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)) if (typeof subCommand === "function") subcommands.push({
-		name: subName,
-		description: "(lazy loaded)",
-		subcommands: [],
-		options: [],
-		positionals: []
-	});
-	else subcommands.push(extractSubcommand(subName, subCommand));
-	return {
-		name,
-		description: command.description,
-		subcommands,
-		options: extractOptions(command),
-		positionals: extractCompletablePositionals(command)
-	};
-}
-/**
-* Extract completion data from a command tree
-*/
-function extractCompletionData(command, programName) {
-	const rootSubcommand = extractSubcommand(programName, command);
-	return {
-		command: rootSubcommand,
-		programName,
-		globalOptions: rootSubcommand.options
-	};
-}
-
-//#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=extractor-cjruDqQ2.cjs.map