politty 0.4.0 → 0.4.1

package/dist/{extractor-JfoYSoMk.js → extractor-DO-FDKkW.js}

@@ -1,5 +1,6 @@
-import { a as arg, t as extractFields } from "./schema-extractor-CP3ar0Wi.js";
+import { a as arg, t as extractFields } from "./schema-extractor-DAkmmrOy.js";
 import { z } from "zod";
+import { execSync } from "node:child_process";
 
 //#region src/core/command.ts
 function defineCommand(config) {
@@ -21,7 +22,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;
@@ -30,99 +36,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'
+
+    # 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
 
-    # Handle inline option-value completion for long options (e.g. --format=js)
-    if [[ "$cur" == --*=* ]]; then
-        completion_prefix="\${cur%%=*}="
-        completion_cur="\${cur#*=}"
-    fi
+    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:
@@ -141,6 +174,9 @@ source ~/.bashrc`
 //#endregion
 //#region src/completion/dynamic/candidate-generator.ts
 /**
+* Generate completion candidates based on context
+*/
+/**
 * Completion directive flags (bitwise)
 */
 const CompletionDirective = {
@@ -170,14 +206,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 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
@@ -236,43 +319,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
 	};
 }
 /**
@@ -280,71 +340,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 {
@@ -369,6 +394,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
 */
@@ -382,7 +413,7 @@ function extractOptions$1(command) {
 		takesValue: field.type !== "boolean",
 		valueType: field.type,
 		required: field.required,
-		valueCompletion: resolveValueCompletion$1(field)
+		valueCompletion: resolveValueCompletion(field)
 	}));
 }
 /**
@@ -396,7 +427,8 @@ function extractPositionalsForContext(command) {
 		position: index,
 		description: field.description,
 		required: field.required,
-		valueCompletion: resolveValueCompletion$1(field)
+		variadic: field.type === "array",
+		valueCompletion: resolveValueCompletion(field)
 	}));
 }
 /**
@@ -505,7 +537,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);
@@ -515,7 +551,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 {
@@ -536,15 +572,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
 /**
@@ -553,24 +673,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 = z.object({ args: arg(z.array(z.string()).default([]), {
-	positional: true,
-	description: "Arguments to complete",
-	variadic: true
-}) });
+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
 *
@@ -583,8 +714,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);
 		}
 	});
 }
@@ -600,81 +738,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:
@@ -696,7 +828,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;
@@ -708,57 +845,55 @@ function generateZshCompletion(_command, options) {
 
 _${programName}() {
     local -a candidates
-    local output line directive=0
-    local command_completion=""
-    local file_extensions=""
-
-    # 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)}")
+    local line directive=0
+    local -a args=("\${words[@]:1}")
+    local -a output=("\${(@f)$(${programName} __complete --shell zsh -- "\${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",
@@ -785,39 +920,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) {
@@ -894,5 +996,5 @@ function extractCompletionData(command, programName) {
 }
 
 //#endregion
-export { createDynamicCompleteCommand as a, CompletionDirective as c, generateBashCompletion as d, defineCommand as f, generateFishCompletion as i, formatOutput as l, extractPositionals as n, hasCompleteCommand as o, generateZshCompletion as r, parseCompletionContext as s, extractCompletionData as t, generateCandidates as u };
-//# sourceMappingURL=extractor-JfoYSoMk.js.map
+export { createDynamicCompleteCommand as a, parseCompletionContext as c, generateCandidates as d, generateBashCompletion as f, generateFishCompletion as i, resolveValueCompletion as l, extractPositionals as n, hasCompleteCommand as o, defineCommand as p, generateZshCompletion as r, formatForShell as s, extractCompletionData as t, CompletionDirective as u };
+//# sourceMappingURL=extractor-DO-FDKkW.js.map