politty 0.3.3 → 0.4.1

package/dist/{extractor-CqfDnGKd.cjs → extractor-cjruDqQ2.cjs}

@@ -1,6 +1,7 @@
 const require_subcommand_router = require('./subcommand-router-4d1Xbp8B.cjs');
-const require_schema_extractor = require('./schema-extractor-Cv7ipqLS.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) {
@@ -22,7 +23,12 @@ function defineCommand(config) {
 /**
 * Generate bash completion script for a command
 *
-* Generates a dynamic script that calls the CLI's __complete command at runtime.
+* 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;
@@ -31,99 +37,126 @@ function generateBashCompletion(_command, options) {
 # Generated by politty
 
 _${programName}_completions() {
-    local cur="\${COMP_WORDS[COMP_CWORD]}"
-    local args=("\${COMP_WORDS[@]:1:COMP_CWORD}")
-    local completion_prefix=""
-    local completion_cur="$cur"
+    COMPREPLY=()
+    local IFS=$'\\n'
 
-    # Handle inline option-value completion for long options (e.g. --format=js)
-    if [[ "$cur" == --*=* ]]; then
-        completion_prefix="\${cur%%=*}="
-        completion_cur="\${cur#*=}"
-    fi
+    # 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
 
-    # Call the CLI to get completions
-    local output
-    if ! output=$(${programName} __complete -- "\${args[@]}" 2>/dev/null); then
-        # Backward compatibility for CLIs exposing only completion
-        output=$(${programName} completion __complete -- "\${args[@]}" 2>/dev/null)
+    local count=\${#lines[@]}
+    if (( count == 0 )); then
+        return 0
     fi
 
-    local candidates=()
+    local last="\${lines[count-1]}"
     local directive=0
-    local command_completion=""
-    local file_extensions=""
-
-    # Parse output: value\\tdescription lines, ending with :directive
-    while IFS=$'\\t' read -r name desc; do
-        if [[ "$name" == :* ]]; then
-            directive="\${name:1}"
-        elif [[ "$name" == __command:* ]]; then
-            command_completion="\${name#__command:}"
-        elif [[ "$name" == __extensions:* ]]; then
-            file_extensions="\${name#__extensions:}"
-        elif [[ -n "$name" ]]; then
-            candidates+=("$name")
-        fi
-    done <<< "$output"
-
-    # Execute shellCommand completion if requested by __complete
-    if [[ -n "$command_completion" ]]; then
-        while IFS= read -r command_candidate; do
-            if [[ -n "$command_candidate" ]]; then
-                candidates+=("$command_candidate")
-            fi
-        done < <(eval "$command_completion" 2>/dev/null)
+    if [[ "$last" == :* ]]; then
+        directive="\${last:1}"
+        unset 'lines[count-1]'
+        (( count-- ))
     fi
 
-    # Handle directives
-    # 16 = FileCompletion, 32 = DirectoryCompletion
-    if (( directive & 16 )); then
-        COMPREPLY=($(compgen -f -- "$completion_cur"))
+    # 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
 
-        if [[ -n "$file_extensions" ]]; then
-            local -a filtered=()
-            local -a extension_list=()
-            local file_candidate ext
+    local cur=""
+    (( \${#_words[@]} > 0 )) && cur="\${_words[\${#_words[@]}-1]}"
 
-            IFS=',' read -r -a extension_list <<< "$file_extensions"
+    # Strip --opt= prefix for native file/directory completion
+    local inline_prefix=""
+    if [[ "$cur" == --*=* ]]; then
+        inline_prefix="\${cur%%=*}="
+        cur="\${cur#*=}"
+    fi
 
-            for file_candidate in "\${COMPREPLY[@]}"; do
-                if [[ -d "$file_candidate" ]]; then
-                    filtered+=("$file_candidate")
-                    continue
-                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
 
-                for ext in "\${extension_list[@]}"; do
-                    if [[ "$file_candidate" == *."$ext" ]]; then
-                        filtered+=("$file_candidate")
+    # 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
-            done
+            fi
+        done
+        compopt -o filenames
+        compopt +o default 2>/dev/null
+        return 0
+    fi
 
-            COMPREPLY=("\${filtered[@]}")
+    # 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
-    elif (( directive & 32 )); then
-        COMPREPLY=($(compgen -d -- "$completion_cur"))
-    elif [[ \${#candidates[@]} -gt 0 ]]; then
-        COMPREPLY=($(compgen -W "\${candidates[*]}" -- "$completion_cur"))
+        COMPREPLY+=("\${dirs[@]}")
+        compopt -o filenames
     fi
 
-    if [[ -n "$completion_prefix" && \${#COMPREPLY[@]} -gt 0 ]]; then
-        local -a prefixed=()
-        local candidate
-        for candidate in "\${COMPREPLY[@]}"; do
-            prefixed+=("$completion_prefix$candidate")
-        done
-        COMPREPLY=("\${prefixed[@]}")
+    # 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 -F _${programName}_completions ${programName}
+complete -o default -F _${programName}_completions ${programName}
 `,
 		shell: "bash",
 		installInstructions: `# To enable completions, add the following to your ~/.bashrc:
@@ -142,6 +175,9 @@ source ~/.bashrc`
 //#endregion
 //#region src/completion/dynamic/candidate-generator.ts
 /**
+* Generate completion candidates based on context
+*/
+/**
 * Completion directive flags (bitwise)
 */
 const CompletionDirective = {
@@ -171,14 +207,61 @@ function generateCandidates(context) {
 		};
 	}
 }
-function addFileExtensionMetadata(candidates, extensions) {
-	if (!extensions || extensions.length === 0) return;
-	const normalized = Array.from(new Set(extensions.map((ext) => ext.trim().replace(/^\./, "")).filter((ext) => ext.length > 0)));
-	if (normalized.length === 0) return;
-	candidates.push({
-		value: `__extensions:${normalized.join(",")}`,
-		type: "value"
-	});
+/**
+* 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
@@ -237,43 +320,20 @@ function generateOptionNameCandidates(context) {
 */
 function generateOptionValueCandidates(context) {
 	const candidates = [];
-	let directive = CompletionDirective.FilterPrefix;
 	if (!context.targetOption) return {
 		candidates,
-		directive
+		directive: CompletionDirective.FilterPrefix
 	};
 	const vc = context.targetOption.valueCompletion;
 	if (!vc) return {
 		candidates,
-		directive
+		directive: CompletionDirective.FilterPrefix
 	};
-	switch (vc.type) {
-		case "choices":
-			if (vc.choices) for (const choice of vc.choices) candidates.push({
-				value: choice,
-				type: "value"
-			});
-			break;
-		case "file":
-			directive |= CompletionDirective.FileCompletion;
-			addFileExtensionMetadata(candidates, vc.extensions);
-			break;
-		case "directory":
-			directive |= CompletionDirective.DirectoryCompletion;
-			break;
-		case "command":
-			if (vc.shellCommand) candidates.push({
-				value: `__command:${vc.shellCommand}`,
-				type: "value"
-			});
-			break;
-		case "none":
-			directive |= CompletionDirective.NoFileCompletion;
-			break;
-	}
+	const { directive, fileExtensions } = resolveValueCandidates(vc, candidates, context.currentWord);
 	return {
 		candidates,
-		directive
+		directive,
+		fileExtensions
 	};
 }
 /**
@@ -281,71 +341,36 @@ function generateOptionValueCandidates(context) {
 */
 function generatePositionalCandidates(context) {
 	const candidates = [];
-	let directive = CompletionDirective.FilterPrefix;
 	const positionalIndex = context.positionalIndex ?? 0;
-	const positional = context.positionals[positionalIndex];
+	const positional = context.positionals[positionalIndex] ?? (context.positionals.at(-1)?.variadic ? context.positionals.at(-1) : void 0);
 	if (!positional) return {
 		candidates,
-		directive
+		directive: CompletionDirective.FilterPrefix
 	};
 	const vc = positional.valueCompletion;
 	if (!vc) return {
 		candidates,
-		directive
+		directive: CompletionDirective.FilterPrefix
 	};
-	switch (vc.type) {
-		case "choices":
-			if (vc.choices) for (const choice of vc.choices) candidates.push({
-				value: choice,
-				description: positional.description,
-				type: "value"
-			});
-			break;
-		case "file":
-			directive |= CompletionDirective.FileCompletion;
-			addFileExtensionMetadata(candidates, vc.extensions);
-			break;
-		case "directory":
-			directive |= CompletionDirective.DirectoryCompletion;
-			break;
-		case "command":
-			if (vc.shellCommand) candidates.push({
-				value: `__command:${vc.shellCommand}`,
-				type: "value"
-			});
-			break;
-		case "none":
-			directive |= CompletionDirective.NoFileCompletion;
-			break;
-	}
+	const { directive, fileExtensions } = resolveValueCandidates(vc, candidates, context.currentWord, positional.description);
 	return {
 		candidates,
-		directive
+		directive,
+		fileExtensions
 	};
 }
-/**
-* Format candidates as shell completion output
-*
-* Format: value\tdescription (tab-separated)
-* Last line: :directive_code
-*/
-function formatOutput(result) {
-	const lines = [];
-	for (const candidate of result.candidates) if (candidate.description) lines.push(`${candidate.value}\t${candidate.description}`);
-	else lines.push(candidate.value);
-	lines.push(`:${result.directive}`);
-	return lines.join("\n");
-}
 
 //#endregion
-//#region src/completion/dynamic/context-parser.ts
-/**
-* Parse completion context from partial command line
-*/
+//#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$1(field) {
+function resolveValueCompletion(field) {
 	const meta = field.completion;
 	if (meta?.custom) {
 		if (meta.custom.choices && meta.custom.choices.length > 0) return {
@@ -370,6 +395,12 @@ function resolveValueCompletion$1(field) {
 		choices: field.enumValues
 	};
 }
+
+//#endregion
+//#region src/completion/dynamic/context-parser.ts
+/**
+* Parse completion context from partial command line
+*/
 /**
 * Extract options from a command
 */
@@ -383,7 +414,7 @@ function extractOptions$1(command) {
 		takesValue: field.type !== "boolean",
 		valueType: field.type,
 		required: field.required,
-		valueCompletion: resolveValueCompletion$1(field)
+		valueCompletion: resolveValueCompletion(field)
 	}));
 }
 /**
@@ -397,7 +428,8 @@ function extractPositionalsForContext(command) {
 		position: index,
 		description: field.description,
 		required: field.required,
-		valueCompletion: resolveValueCompletion$1(field)
+		variadic: field.type === "array",
+		valueCompletion: resolveValueCompletion(field)
 	}));
 }
 /**
@@ -506,7 +538,11 @@ function parseCompletionContext(argv, rootCommand) {
 		if (opt && opt.takesValue) {
 			completionType = "option-value";
 			targetOption = opt;
-		} else completionType = determineDefaultCompletionType(currentWord, subcommands, positionals, positionalCount);
+		} 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);
@@ -516,7 +552,7 @@ function parseCompletionContext(argv, rootCommand) {
 		} else completionType = "option-name";
 	} else if (!afterDoubleDash && currentWord.startsWith("-")) completionType = "option-name";
 	else {
-		completionType = determineDefaultCompletionType(currentWord, subcommands, positionals, positionalCount);
+		completionType = determineDefaultCompletionType(currentWord, subcommands, positionals, positionalCount, afterDoubleDash);
 		if (completionType === "positional") positionalIndex = positionalCount;
 	}
 	return {
@@ -537,15 +573,99 @@ function parseCompletionContext(argv, rootCommand) {
 /**
 * Determine default completion type when not completing an option
 */
-function determineDefaultCompletionType(currentWord, subcommands, positionals, positionalCount) {
+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) 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
 /**
@@ -554,24 +674,35 @@ function determineDefaultCompletionType(currentWord, subcommands, positionals, p
 * This creates a hidden `__complete` command that outputs completion candidates
 * for shell scripts to consume. Usage:
 *
-*   mycli __complete -- build --fo
-*   mycli __complete -- plugin add
+*   mycli __complete --shell bash -- build --fo
+*   mycli __complete --shell zsh -- plugin add
 *
-* Output format:
-*   value\tdescription
-*   ...
-*   :directive_code
+* 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
-*
-* Arguments after -- are collected as the completion arguments
 */
-const completeArgsSchema = zod.z.object({ args: require_schema_extractor.arg(zod.z.array(zod.z.string()).default([]), {
-	positional: true,
-	description: "Arguments to complete",
-	variadic: true
-}) });
+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
 *
@@ -584,8 +715,15 @@ function createDynamicCompleteCommand(rootCommand, _programName) {
 		name: "__complete",
 		args: completeArgsSchema,
 		run(args) {
-			const result = generateCandidates(parseCompletionContext(args.args, rootCommand));
-			console.log(formatOutput(result));
+			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);
 		}
 	});
 }
@@ -601,81 +739,75 @@ function hasCompleteCommand(command) {
 /**
 * Generate fish completion script for a command
 *
-* Generates a dynamic script that calls the CLI's __complete command at runtime.
+* 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
-# This script calls the CLI to generate completions dynamically
 
 function __fish_${programName}_complete
-    # Get current command line arguments
     set -l args (commandline -opc)
-    # Remove the program name
     set -e args[1]
-
-    # Call the CLI to get completions
     set -l directive 0
-    set -l command_completion
-    set -l file_extensions
+    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 -- $args 2>/dev/null)
+    for line in (${programName} __complete --shell fish -- $args 2>/dev/null)
         if string match -q ':*' -- $line
-            # Parse directive
             set directive (string sub -s 2 -- $line)
-        else if string match -q '__command:*' -- $line
-            # Parse shell command completion request
-            set command_completion (string sub -s 11 -- $line)
-        else if string match -q '__extensions:*' -- $line
-            # Parse optional file extension metadata
-            set file_extensions (string sub -s 14 -- $line)
+        else if string match -q '@ext:*' -- $line
+            set extensions (string sub -s 6 -- $line)
         else if test -n "$line"
-            # Parse completion: value\\tdescription
-            set -l parts (string split \\t -- $line)
-            if test (count $parts) -ge 2
-                echo $parts[1]\\t$parts[2]
-            else
-                echo $parts[1]
-            end
+            echo $line
         end
     end
 
-    # Execute shellCommand completion if requested by __complete
-    if test -n "$command_completion"
-        for command_candidate in (eval "$command_completion" 2>/dev/null)
-            if test -n "$command_candidate"
-                echo $command_candidate
+    # 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
 
-    # Handle directives by returning special values
-    # The main completion function will check for these
-    if test (math "$directive & 16") -ne 0
-        echo "__directive:file"
-    else if test (math "$directive & 32") -ne 0
-        echo "__directive:directory"
+    # 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}
 
-# Main completion
-complete -c ${programName} -f -a '(
-    set -l completions (__fish_${programName}_complete)
-    for c in $completions
-        if string match -q "__directive:file" -- $c
-            __fish_complete_path
-        else if string match -q "__directive:directory" -- $c
-            __fish_complete_directories
-        else
-            echo $c
-        end
-    end
-)'
+# Register completion
+complete -c ${programName} -f -a '(__fish_${programName}_complete)'
 `,
 		shell: "fish",
 		installInstructions: `# To enable completions, run one of the following:
@@ -697,7 +829,12 @@ source ~/.config/fish/completions/${programName}.fish`
 /**
 * Generate zsh completion script for a command
 *
-* Generates a dynamic script that calls the CLI's __complete command at runtime.
+* 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;
@@ -709,57 +846,55 @@ function generateZshCompletion(_command, options) {
 
 _${programName}() {
     local -a candidates
-    local output line directive=0
-    local command_completion=""
-    local file_extensions=""
+    local line directive=0
+    local -a args=("\${words[@]:1}")
+    local -a output=("\${(@f)$(${programName} __complete --shell zsh -- "\${args[@]}" 2>/dev/null)}")
 
-    # Get the current words being completed
-    local -a args
-    args=("\${words[@]:1}")
-
-    # Call the CLI to get completions
-    output=("\${(@f)$(${programName} __complete -- "\${args[@]}" 2>/dev/null)}")
-
-    # Parse output
+    local extensions=""
     for line in "\${output[@]}"; do
         if [[ "$line" == :* ]]; then
             directive="\${line:1}"
-        elif [[ "$line" == __command:* ]]; then
-            command_completion="\${line#__command:}"
-        elif [[ "$line" == __extensions:* ]]; then
-            file_extensions="\${line#__extensions:}"
+        elif [[ "$line" == @ext:* ]]; then
+            extensions="\${line:5}"
         elif [[ -n "$line" ]]; then
-            local name="\${line%%$'\\t'*}"
-            local desc="\${line#*$'\\t'}"
-            if [[ "$name" == "$desc" ]]; then
-                candidates+=("$name")
-            else
-                candidates+=("$name:$desc")
-            fi
+            candidates+=("$line")
         fi
     done
 
-    # Execute shellCommand completion if requested by __complete
-    if [[ -n "$command_completion" ]]; then
-        local command_candidate
-        for command_candidate in "\${(@f)$(eval "$command_completion" 2>/dev/null)}"; do
-            if [[ -n "$command_candidate" ]]; then
-                candidates+=("$command_candidate")
-            fi
+    # 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
 
-    # Handle directives
-    # 16 = FileCompletion, 32 = DirectoryCompletion
-    if (( directive & 16 )); then
-        _files
-    elif (( directive & 32 )); then
-        _files -/
-    elif (( \${#candidates[@]} > 0 )); then
+    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",
@@ -786,39 +921,6 @@ source ~/.zshrc`
 * Extract completion data from commands
 */
 /**
-* 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
-	};
-}
-/**
 * Convert a resolved field to a completable option
 */
 function fieldToOption(field) {
@@ -925,10 +1027,10 @@ Object.defineProperty(exports, 'extractPositionals', {
     return extractPositionals;
   }
 });
-Object.defineProperty(exports, 'formatOutput', {
+Object.defineProperty(exports, 'formatForShell', {
   enumerable: true,
   get: function () {
-    return formatOutput;
+    return formatForShell;
   }
 });
 Object.defineProperty(exports, 'generateBashCompletion', {
@@ -967,4 +1069,10 @@ Object.defineProperty(exports, 'parseCompletionContext', {
     return parseCompletionContext;
   }
 });
-//# sourceMappingURL=extractor-CqfDnGKd.cjs.map
+Object.defineProperty(exports, 'resolveValueCompletion', {
+  enumerable: true,
+  get: function () {
+    return resolveValueCompletion;
+  }
+});
+//# sourceMappingURL=extractor-cjruDqQ2.cjs.map