politty 0.3.0 → 0.3.2

package/dist/extractor-JfoYSoMk.js

@@ -0,0 +1,898 @@
+import { a as arg, t as extractFields } from "./schema-extractor-CP3ar0Wi.js";
+import { z } from "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 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 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 = z.object({ args: arg(z.array(z.string()).default([]), {
+	positional: true,
+	description: "Arguments to complete",
+	variadic: true
+}) });
+/**
+* Create the dynamic completion command
+*
+* @param rootCommand - The root command to generate completions for
+* @param programName - The program name (optional, defaults to rootCommand.name)
+* @returns A command that outputs completion candidates
+*/
+function createDynamicCompleteCommand(rootCommand, _programName) {
+	return defineCommand({
+		name: "__complete",
+		args: completeArgsSchema,
+		run(args) {
+			const 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 extractFields(command.args).fields.filter((field) => !field.positional).map(fieldToOption);
+}
+/**
+* Extract positional arguments from a command
+*/
+function extractPositionals(command) {
+	if (!command.args) return [];
+	return extractFields(command.args).fields.filter((field) => field.positional);
+}
+/**
+* Extract completable positional arguments from a command
+*/
+function extractCompletablePositionals(command) {
+	if (!command.args) return [];
+	return extractFields(command.args).fields.filter((field) => field.positional).map((field, index) => ({
+		name: field.name,
+		cliName: field.cliName,
+		position: index,
+		description: field.description,
+		required: field.required,
+		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
+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