politty 0.3.0 → 0.3.2

package/dist/extractor-B7bOwpvP.cjs

@@ -0,0 +1,970 @@
+const require_schema_extractor = require('./schema-extractor-BU705qpC.cjs');
+const require_docs_index = require('./docs/index.cjs');
+let zod = require("zod");
+
+//#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 dynamic script that calls the CLI's __complete command at runtime.
+*/
+function generateBashCompletion(_command, options) {
+	const programName = options.programName;
+	return {
+		script: `# Bash completion for ${programName}
+# 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"
+
+    # Handle inline option-value completion for long options (e.g. --format=js)
+    if [[ "$cur" == --*=* ]]; then
+        completion_prefix="\${cur%%=*}="
+        completion_cur="\${cur#*=}"
+    fi
+
+    # 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)
+    fi
+
+    local candidates=()
+    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)
+    fi
+
+    # Handle directives
+    # 16 = FileCompletion, 32 = DirectoryCompletion
+    if (( directive & 16 )); then
+        COMPREPLY=($(compgen -f -- "$completion_cur"))
+
+        if [[ -n "$file_extensions" ]]; then
+            local -a filtered=()
+            local -a extension_list=()
+            local file_candidate ext
+
+            IFS=',' read -r -a extension_list <<< "$file_extensions"
+
+            for file_candidate in "\${COMPREPLY[@]}"; do
+                if [[ -d "$file_candidate" ]]; then
+                    filtered+=("$file_candidate")
+                    continue
+                fi
+
+                for ext in "\${extension_list[@]}"; do
+                    if [[ "$file_candidate" == *."$ext" ]]; then
+                        filtered+=("$file_candidate")
+                        break
+                    fi
+                done
+            done
+
+            COMPREPLY=("\${filtered[@]}")
+        fi
+    elif (( directive & 32 )); then
+        COMPREPLY=($(compgen -d -- "$completion_cur"))
+    elif [[ \${#candidates[@]} -gt 0 ]]; then
+        COMPREPLY=($(compgen -W "\${candidates[*]}" -- "$completion_cur"))
+    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[@]}")
+    fi
+
+    return 0
+}
+
+# Register the completion function
+complete -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
+/**
+* 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
+		};
+	}
+}
+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"
+	});
+}
+/**
+* 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 = [];
+	let directive = CompletionDirective.FilterPrefix;
+	if (!context.targetOption) return {
+		candidates,
+		directive
+	};
+	const vc = context.targetOption.valueCompletion;
+	if (!vc) return {
+		candidates,
+		directive
+	};
+	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;
+	}
+	return {
+		candidates,
+		directive
+	};
+}
+/**
+* Generate positional argument candidates
+*/
+function generatePositionalCandidates(context) {
+	const candidates = [];
+	let directive = CompletionDirective.FilterPrefix;
+	const positionalIndex = context.positionalIndex ?? 0;
+	const positional = context.positionals[positionalIndex];
+	if (!positional) return {
+		candidates,
+		directive
+	};
+	const vc = positional.valueCompletion;
+	if (!vc) return {
+		candidates,
+		directive
+	};
+	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;
+	}
+	return {
+		candidates,
+		directive
+	};
+}
+/**
+* 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
+*/
+/**
+* Resolve value completion from field metadata
+*/
+function resolveValueCompletion$1(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
+	};
+}
+/**
+* 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$1(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,
+		valueCompletion: resolveValueCompletion$1(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 completionType = determineDefaultCompletionType(currentWord, subcommands, positionals, 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);
+		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) {
+	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";
+	return "subcommand";
+}
+
+//#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 -- build --fo
+*   mycli __complete -- plugin add
+*
+* Output format:
+*   value\tdescription
+*   ...
+*   :directive_code
+*/
+/**
+* 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
+}) });
+/**
+* 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 result = generateCandidates(parseCompletionContext(args.args, rootCommand));
+			console.log(formatOutput(result));
+		}
+	});
+}
+/**
+* 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 dynamic script that calls the CLI's __complete command at runtime.
+*/
+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
+
+    for line in (${programName} __complete -- $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 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
+        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
+            end
+        end
+    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"
+    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
+)'
+`,
+		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 dynamic script that calls the CLI's __complete command at runtime.
+*/
+function generateZshCompletion(_command, options) {
+	const programName = options.programName;
+	return {
+		script: `#compdef ${programName}
+
+# Zsh completion for ${programName}
+# Generated by politty
+
+_${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)}")
+
+    # Parse output
+    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 [[ -n "$line" ]]; then
+            local name="\${line%%$'\\t'*}"
+            local desc="\${line#*$'\\t'}"
+            if [[ "$name" == "$desc" ]]; then
+                candidates+=("$name")
+            else
+                candidates+=("$name:$desc")
+            fi
+        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
+        done
+    fi
+
+    # Handle directives
+    # 16 = FileCompletion, 32 = DirectoryCompletion
+    if (( directive & 16 )); then
+        _files
+    elif (( directive & 32 )); then
+        _files -/
+    elif (( \${#candidates[@]} > 0 )); then
+        _describe 'completions' candidates
+    fi
+}
+
+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
+*/
+/**
+* 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) {
+	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, 'formatOutput', {
+  enumerable: true,
+  get: function () {
+    return formatOutput;
+  }
+});
+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;
+  }
+});
+//# sourceMappingURL=extractor-B7bOwpvP.cjs.map