wp-typia 0.24.4 → 0.24.6

package/dist-bunli/cli.js

@@ -1,2523 +0,0 @@
-// @bun
-import {
-  ALL_COMMAND_OPTION_METADATA,
-  COMMAND_OPTION_METADATA_BY_GROUP,
-  COMMAND_ROUTING_METADATA,
-  GLOBAL_OPTION_METADATA,
-  WP_TYPIA_CANONICAL_CREATE_USAGE,
-  WP_TYPIA_COMMAND_OPTION_GROUP_NAMES_BY_TOP_LEVEL_COMMAND,
-  WP_TYPIA_CONFIG_SOURCES,
-  WP_TYPIA_RESERVED_TOP_LEVEL_COMMAND_NAMES,
-  buildCommandOptionParser,
-  collectOptionNamesByType,
-  collectPositionalIndexes,
-  createMissingOptionValueError,
-  createPlugin,
-  extractKnownOptionValuesFromArgv,
-  findFirstPositionalIndex,
-  loadWpTypiaUserConfig,
-  loadWpTypiaUserConfigFromSource,
-  mergeWpTypiaUserConfig,
-  normalizeCliOutputFormatArgv,
-  package_default,
-  validateCliOutputFormatArgv,
-  writeStructuredCliDiagnosticError
-} from "./cli-368d4cgy.js";
-import"./cli-03j0axbt.js";
-import {
-  GLOBAL_FLAGS,
-  Result,
-  TaggedError,
-  createCLI,
-  deepMerge,
-  defineCommand,
-  defineConfig,
-  defineGroup,
-  exports_external
-} from "./cli-hv2yedw2.js";
-import"./cli-ac2ebaf8.js";
-import"./cli-6v0pcxw6.js";
-import"./cli-bajwv85z.js";
-import {
-  CLI_DIAGNOSTIC_CODES,
-  createCliDiagnosticCodeError
-} from "./cli-tq730sqt.js";
-import {
-  __require
-} from "./cli-xnn9xjcy.js";
-
-// src/cli.ts
-import fs from "fs";
-import path2 from "path";
-import { fileURLToPath } from "url";
-
-// ../../node_modules/.bun/@bunli+plugin-ai-detect@0.6.4+44deef6f8e4a2f18/node_modules/@bunli/plugin-ai-detect/src/index.ts
-var AI_AGENTS = [
-  {
-    name: "claude",
-    envVars: ["CLAUDECODE", "CLAUDE_CODE"],
-    detect: (env) => !!env.CLAUDECODE || !!env.CLAUDE_CODE
-  },
-  {
-    name: "cursor",
-    envVars: ["CURSOR_AGENT"],
-    detect: (env) => !!env.CURSOR_AGENT
-  },
-  {
-    name: "codex",
-    envVars: ["CODEX_CI", "CODEX_THREAD_ID", "CODEX_SANDBOX"],
-    detect: (env) => !!env.CODEX_CI || !!env.CODEX_THREAD_ID || !!env.CODEX_SANDBOX
-  },
-  {
-    name: "amp",
-    envVars: ["AMP_CURRENT_THREAD_ID", "AGENT"],
-    detect: (env) => !!env.AMP_CURRENT_THREAD_ID || env.AGENT === "amp"
-  },
-  {
-    name: "gemini",
-    envVars: ["GEMINI_CLI"],
-    detect: (env) => !!env.GEMINI_CLI
-  },
-  {
-    name: "opencode",
-    envVars: ["OPENCODE"],
-    detect: (env) => env.OPENCODE === "1"
-  }
-];
-var aiAgentPlugin = createPlugin((options = {}) => {
-  const agents = [...AI_AGENTS, ...options.customAgents || []];
-  return {
-    name: "@bunli/plugin-ai-detect",
-    version: "1.0.0",
-    store: {
-      isAIAgent: false,
-      aiAgents: [],
-      aiAgentEnvVars: []
-    },
-    beforeCommand(context) {
-      const env = process.env;
-      const detectedAgents = [];
-      const allDetectedEnvVars = [];
-      context.env.isAIAgent = false;
-      context.env.aiAgents = [];
-      for (const agent of agents) {
-        if (agent.detect(env)) {
-          detectedAgents.push(agent.name);
-          const detectedVars = agent.envVars.filter((v) => !!env[v]);
-          allDetectedEnvVars.push(...detectedVars);
-          if (options.verbose) {
-            console.log(`\uD83E\uDD16 AI agent detected: ${agent.name}`);
-            console.log(`   Environment variables: ${detectedVars.join(", ")}`);
-          }
-        }
-      }
-      if (detectedAgents.length > 0) {
-        context.env.isAIAgent = true;
-        context.env.aiAgents = detectedAgents;
-        if (context.store) {
-          context.store.isAIAgent = true;
-          context.store.aiAgents = detectedAgents;
-          context.store.aiAgentEnvVars = allDetectedEnvVars;
-        }
-        if (options.verbose) {
-          if (detectedAgents.length === 1) {
-            console.log(`\uD83E\uDD16 AI agent detected: ${detectedAgents[0]}`);
-          } else {
-            console.log(`\uD83E\uDD16 Multiple AI agents detected: ${detectedAgents.join(", ")}`);
-          }
-        }
-      } else {
-        if (context.store) {
-          context.store.isAIAgent = false;
-          context.store.aiAgents = [];
-          context.store.aiAgentEnvVars = [];
-        }
-      }
-    }
-  };
-});
-
-// ../../node_modules/.bun/@bunli+plugin-completions@0.3.5+44deef6f8e4a2f18/node_modules/@bunli/plugin-completions/dist/index.js
-import { resolve } from "path";
-import { readFile } from "fs/promises";
-import { pathToFileURL } from "url";
-function generate(name, exec) {
-  return `#compdef ${name}
-compdef _${name} ${name}
-
-# zsh completion for ${name} -*- shell-script -*-
-
-__${name}_debug() {
-    local file="$BASH_COMP_DEBUG_FILE"
-    if [[ -n \${file} ]]; then
-        echo "$*" >> "\${file}"
-    fi
-}
-
-_${name}() {
-    local shellCompDirectiveError=${ShellCompDirective.ShellCompDirectiveError}
-    local shellCompDirectiveNoSpace=${ShellCompDirective.ShellCompDirectiveNoSpace}
-    local shellCompDirectiveNoFileComp=${ShellCompDirective.ShellCompDirectiveNoFileComp}
-    local shellCompDirectiveFilterFileExt=${ShellCompDirective.ShellCompDirectiveFilterFileExt}
-    local shellCompDirectiveFilterDirs=${ShellCompDirective.ShellCompDirectiveFilterDirs}
-    local shellCompDirectiveKeepOrder=${ShellCompDirective.ShellCompDirectiveKeepOrder}
-
-    local lastParam lastChar flagPrefix requestComp out directive comp lastComp noSpace keepOrder
-    local -a completions
-
-    __${name}_debug "\\n========= starting completion logic =========="
-    __${name}_debug "CURRENT: \${CURRENT}, words[*]: \${words[*]}"
-
-    # The user could have moved the cursor backwards on the command-line.
-    # We need to trigger completion from the $CURRENT location, so we need
-    # to truncate the command-line ($words) up to the $CURRENT location.
-    # (We cannot use $CURSOR as its value does not work when a command is an alias.)
-    words=( "\${=words[1,CURRENT]}" )
-    __${name}_debug "Truncated words[*]: \${words[*]},"
-
-    lastParam=\${words[-1]}
-    lastChar=\${lastParam[-1]}
-    __${name}_debug "lastParam: \${lastParam}, lastChar: \${lastChar}"
-
-    # For zsh, when completing a flag with an = (e.g., ${name} -n=<TAB>)
-    # completions must be prefixed with the flag
-    setopt local_options BASH_REMATCH
-    if [[ "\${lastParam}" =~ '-.*=' ]]; then
-        # We are dealing with a flag with an =
-        flagPrefix="-P \${BASH_REMATCH}"
-    fi
-
-    # Prepare the command to obtain completions, ensuring arguments are quoted for eval
-    local -a args_to_quote=("\${(@)words[2,-1]}")
-    if [ "\${lastChar}" = "" ]; then
-        # If the last parameter is complete (there is a space following it)
-        # We add an extra empty parameter so we can indicate this to the go completion code.
-        __${name}_debug "Adding extra empty parameter"
-        args_to_quote+=("")
-    fi
-
-    # Use Zsh's (q) flag to quote each argument safely for eval
-    local quoted_args=("\${(@q)args_to_quote}")
-
-    # Join the main command and the quoted arguments into a single string for eval
-    requestComp="${exec} complete -- \${quoted_args[*]}"
-
-    __${name}_debug "About to call: eval \${requestComp}"
-
-    # Use eval to handle any environment variables and such
-    out=$(eval \${requestComp} 2>/dev/null)
-    __${name}_debug "completion output: \${out}"
-
-    # Extract the directive integer following a : from the last line
-    local lastLine
-    while IFS='
-' read -r line; do
-        lastLine=\${line}
-    done < <(printf "%s
-" "\${out[@]}")
-    __${name}_debug "last line: \${lastLine}"
-
-    if [ "\${lastLine[1]}" = : ]; then
-        directive=\${lastLine[2,-1]}
-        # Remove the directive including the : and the newline
-        local suffix
-        (( suffix=\${#lastLine}+2))
-        out=\${out[1,-$suffix]}
-    else
-        # There is no directive specified.  Leave $out as is.
-        __${name}_debug "No directive found.  Setting to default"
-        directive=0
-    fi
-
-    __${name}_debug "directive: \${directive}"
-    __${name}_debug "completions: \${out}"
-    __${name}_debug "flagPrefix: \${flagPrefix}"
-
-    if [ $((directive & shellCompDirectiveError)) -ne 0 ]; then
-        __${name}_debug "Completion received error. Ignoring completions."
-        return
-    fi
-
-    local activeHelpMarker="%"
-    local endIndex=\${#activeHelpMarker}
-    local startIndex=$((\${#activeHelpMarker}+1))
-    local hasActiveHelp=0
-    while IFS='
-' read -r comp; do
-        # Check if this is an activeHelp statement (i.e., prefixed with $activeHelpMarker)
-        if [ "\${comp[1,$endIndex]}" = "$activeHelpMarker" ];then
-            __${name}_debug "ActiveHelp found: $comp"
-            comp="\${comp[$startIndex,-1]}"
-            if [ -n "$comp" ]; then
-                compadd -x "\${comp}"
-                __${name}_debug "ActiveHelp will need delimiter"
-                hasActiveHelp=1
-            fi
-            continue
-        fi
-
-        if [ -n "$comp" ]; then
-            # If requested, completions are returned with a description.
-            # The description is preceded by a TAB character.
-            # For zsh's _describe, we need to use a : instead of a TAB.
-            # We first need to escape any : as part of the completion itself.
-            comp=\${comp//:/\\:}
-
-            local tab="$(printf '\\t')"
-            comp=\${comp//$tab/:}
-
-            __${name}_debug "Adding completion: \${comp}"
-            completions+=\${comp}
-            lastComp=$comp
-        fi
-    done < <(printf "%s
-" "\${out[@]}")
-
-    # Add a delimiter after the activeHelp statements, but only if:
-    # - there are completions following the activeHelp statements, or
-    # - file completion will be performed (so there will be choices after the activeHelp)
-    if [ $hasActiveHelp -eq 1 ]; then
-        if [ \${#completions} -ne 0 ] || [ $((directive & shellCompDirectiveNoFileComp)) -eq 0 ]; then
-            __${name}_debug "Adding activeHelp delimiter"
-            compadd -x "--"
-            hasActiveHelp=0
-        fi
-    fi
-
-    if [ $((directive & shellCompDirectiveNoSpace)) -ne 0 ]; then
-        __${name}_debug "Activating nospace."
-        noSpace="-S ''"
-    fi
-
-    if [ $((directive & shellCompDirectiveKeepOrder)) -ne 0 ]; then
-        __${name}_debug "Activating keep order."
-        keepOrder="-V"
-    fi
-
-    if [ $((directive & shellCompDirectiveFilterFileExt)) -ne 0 ]; then
-        # File extension filtering
-        local filteringCmd
-        filteringCmd='_files'
-        for filter in \${completions[@]}; do
-            if [ \${filter[1]} != '*' ]; then
-                # zsh requires a glob pattern to do file filtering
-                filter="\\*.$filter"
-            fi
-            filteringCmd+=" -g $filter"
-        done
-        filteringCmd+=" \${flagPrefix}"
-
-        __${name}_debug "File filtering command: $filteringCmd"
-        _arguments '*:filename:'"$filteringCmd"
-    elif [ $((directive & shellCompDirectiveFilterDirs)) -ne 0 ]; then
-        # File completion for directories only
-        local subdir
-        subdir="\${completions[1]}"
-        if [ -n "$subdir" ]; then
-            __${name}_debug "Listing directories in $subdir"
-            pushd "\${subdir}" >/dev/null 2>&1
-        else
-            __${name}_debug "Listing directories in ."
-        fi
-
-        local result
-        _arguments '*:dirname:_files -/'" \${flagPrefix}"
-        result=$?
-        if [ -n "$subdir" ]; then
-            popd >/dev/null 2>&1
-        fi
-        return $result
-    else
-        __${name}_debug "Calling _describe"
-        if eval _describe $keepOrder "completions" completions -Q \${flagPrefix} \${noSpace}; then
-            __${name}_debug "_describe found some completions"
-
-            # Return the success of having called _describe
-            return 0
-        else
-            __${name}_debug "_describe did not find completions."
-            __${name}_debug "Checking if we should do file completion."
-            if [ $((directive & shellCompDirectiveNoFileComp)) -ne 0 ]; then
-                __${name}_debug "deactivating file completion"
-
-                # Return 0 to indicate completion is finished and prevent zsh from
-                # trying other completion algorithms (which could cause hanging).
-                # We use NoFileComp directive to explicitly disable file completion.
-                return 0
-            else
-                # Perform file completion
-                __${name}_debug "Activating file completion"
-
-                # We must return the result of this command, so it must be the
-                # last command, or else we must store its result to return it.
-                _arguments '*:filename:_files'" \${flagPrefix}"
-            fi
-        fi
-    fi
-}
-
-# don't run the completion function when being sourced or eval-ed
-if [ "\${funcstack[1]}" = "_${name}" ]; then
-    _${name}
-fi
-`;
-}
-function generate2(name, exec) {
-  const nameForVar = name.replace(/[-:]/g, "_");
-  const ShellCompDirectiveError = ShellCompDirective.ShellCompDirectiveError;
-  const ShellCompDirectiveNoSpace = ShellCompDirective.ShellCompDirectiveNoSpace;
-  const ShellCompDirectiveNoFileComp = ShellCompDirective.ShellCompDirectiveNoFileComp;
-  const ShellCompDirectiveFilterFileExt = ShellCompDirective.ShellCompDirectiveFilterFileExt;
-  const ShellCompDirectiveFilterDirs = ShellCompDirective.ShellCompDirectiveFilterDirs;
-  const ShellCompDirectiveKeepOrder = ShellCompDirective.ShellCompDirectiveKeepOrder;
-  return `# bash completion for ${name}
-
-# Define shell completion directives
-readonly ShellCompDirectiveError=${ShellCompDirectiveError}
-readonly ShellCompDirectiveNoSpace=${ShellCompDirectiveNoSpace}
-readonly ShellCompDirectiveNoFileComp=${ShellCompDirectiveNoFileComp}
-readonly ShellCompDirectiveFilterFileExt=${ShellCompDirectiveFilterFileExt}
-readonly ShellCompDirectiveFilterDirs=${ShellCompDirectiveFilterDirs}
-readonly ShellCompDirectiveKeepOrder=${ShellCompDirectiveKeepOrder}
-
-# Function to debug completion
-__${nameForVar}_debug() {
-    if [[ -n \${BASH_COMP_DEBUG_FILE:-} ]]; then
-        echo "$*" >> "\${BASH_COMP_DEBUG_FILE}"
-    fi
-}
-
-# Function to handle completions
-__${nameForVar}_complete() {
-    local cur prev words cword
-    _get_comp_words_by_ref -n "=:" cur prev words cword
-
-    local requestComp out directive
-
-    # Build the command to get completions
-    requestComp="${exec} complete -- \${words[@]:1}"
-
-    # Add an empty parameter if the last parameter is complete
-    if [[ -z "$cur" ]]; then
-        requestComp="$requestComp ''"
-    fi
-
-    # Get completions from the program
-    out=$(eval "$requestComp" 2>/dev/null)
-
-    # Extract directive if present
-    directive=0
-    if [[ "$out" == *:* ]]; then
-        directive=\${out##*:}
-        out=\${out%:*}
-    fi
-
-    # Process completions based on directive
-    if [[ $((directive & $ShellCompDirectiveError)) -ne 0 ]]; then
-        # Error, no completion
-        return
-    fi
-
-    # Apply directives
-    if [[ $((directive & $ShellCompDirectiveNoSpace)) -ne 0 ]]; then
-        compopt -o nospace
-    fi
-    if [[ $((directive & $ShellCompDirectiveKeepOrder)) -ne 0 ]]; then
-        compopt -o nosort
-    fi
-    if [[ $((directive & $ShellCompDirectiveNoFileComp)) -ne 0 ]]; then
-        compopt +o default
-    fi
-
-    # Handle file extension filtering
-    if [[ $((directive & $ShellCompDirectiveFilterFileExt)) -ne 0 ]]; then
-        local filter=""
-        for ext in $out; do
-            filter="$filter|$ext"
-        done
-        filter="\\.($filter)"
-        compopt -o filenames
-        COMPREPLY=( $(compgen -f -X "!$filter" -- "$cur") )
-        return
-    fi
-
-    # Handle directory filtering
-    if [[ $((directive & $ShellCompDirectiveFilterDirs)) -ne 0 ]]; then
-        compopt -o dirnames
-        COMPREPLY=( $(compgen -d -- "$cur") )
-        return
-    fi
-
-    # Process completions
-    local IFS=$'\\n'
-    local tab=$(printf '\\t')
-
-    # Parse completions with descriptions
-    local completions=()
-    while read -r comp; do
-        if [[ "$comp" == *$tab* ]]; then
-            # Split completion and description
-            local value=\${comp%%$tab*}
-            local desc=\${comp#*$tab}
-            completions+=("$value")
-        else
-            completions+=("$comp")
-        fi
-    done <<< "$out"
-
-    # Return completions
-    COMPREPLY=( $(compgen -W "\${completions[*]}" -- "$cur") )
-}
-
-# Register completion function
-complete -F __${nameForVar}_complete ${name}
-`;
-}
-function generate3(name, exec) {
-  const nameForVar = name.replace(/[-:]/g, "_");
-  const ShellCompDirectiveError = ShellCompDirective.ShellCompDirectiveError;
-  const ShellCompDirectiveNoSpace = ShellCompDirective.ShellCompDirectiveNoSpace;
-  const ShellCompDirectiveNoFileComp = ShellCompDirective.ShellCompDirectiveNoFileComp;
-  const ShellCompDirectiveFilterFileExt = ShellCompDirective.ShellCompDirectiveFilterFileExt;
-  const ShellCompDirectiveFilterDirs = ShellCompDirective.ShellCompDirectiveFilterDirs;
-  const ShellCompDirectiveKeepOrder = ShellCompDirective.ShellCompDirectiveKeepOrder;
-  return `# fish completion for ${name} -*- shell-script -*-
-
-function __${nameForVar}_debug
-    set -l file "$BASH_COMP_DEBUG_FILE"
-    if test -n "$file"
-        echo "$argv" >> $file
-    end
-end
-
-function __${nameForVar}_perform_completion
-    __${nameForVar}_debug "Starting __${nameForVar}_perform_completion"
-
-    # Extract all args except the last one
-    set -l args (commandline -opc)
-    # Extract the last arg and escape it in case it is a space or wildcard
-    set -l lastArg (string escape -- (commandline -ct))
-
-    __${nameForVar}_debug "args: $args"
-    __${nameForVar}_debug "last arg: $lastArg"
-
-    # Build the completion request command
-    set -l requestComp "${exec} complete -- (string join ' ' -- (string escape -- $args[2..-1])) $lastArg"
-
-    __${nameForVar}_debug "Calling $requestComp"
-    set -l results (eval $requestComp 2> /dev/null)
-
-    # Some programs may output extra empty lines after the directive.
-    # Let's ignore them or else it will break completion.
-    # Ref: https://github.com/spf13/cobra/issues/1279
-    for line in $results[-1..1]
-        if test (string trim -- $line) = ""
-            # Found an empty line, remove it
-            set results $results[1..-2]
-        else
-            # Found non-empty line, we have our proper output
-            break
-        end
-    end
-
-    set -l comps $results[1..-2]
-    set -l directiveLine $results[-1]
-
-    # For Fish, when completing a flag with an = (e.g., <program> -n=<TAB>)
-    # completions must be prefixed with the flag
-    set -l flagPrefix (string match -r -- '-.*=' "$lastArg")
-
-    __${nameForVar}_debug "Comps: $comps"
-    __${nameForVar}_debug "DirectiveLine: $directiveLine"
-    __${nameForVar}_debug "flagPrefix: $flagPrefix"
-
-    for comp in $comps
-        printf "%s%s\\n" "$flagPrefix" "$comp"
-    end
-
-    printf "%s\\n" "$directiveLine"
-end
-
-# This function limits calls to __${nameForVar}_perform_completion, by caching the result
-function __${nameForVar}_perform_completion_once
-    __${nameForVar}_debug "Starting __${nameForVar}_perform_completion_once"
-
-    if test -n "$__${nameForVar}_perform_completion_once_result"
-        __${nameForVar}_debug "Seems like a valid result already exists, skipping __${nameForVar}_perform_completion"
-        return 0
-    end
-
-    set --global __${nameForVar}_perform_completion_once_result (__${nameForVar}_perform_completion)
-    if test -z "$__${nameForVar}_perform_completion_once_result"
-        __${nameForVar}_debug "No completions, probably due to a failure"
-        return 1
-    end
-
-    __${nameForVar}_debug "Performed completions and set __${nameForVar}_perform_completion_once_result"
-    return 0
-end
-
-# This function is used to clear the cached result after completions are run
-function __${nameForVar}_clear_perform_completion_once_result
-    __${nameForVar}_debug ""
-    __${nameForVar}_debug "========= clearing previously set __${nameForVar}_perform_completion_once_result variable =========="
-    set --erase __${nameForVar}_perform_completion_once_result
-    __${nameForVar}_debug "Successfully erased the variable __${nameForVar}_perform_completion_once_result"
-end
-
-function __${nameForVar}_requires_order_preservation
-    __${nameForVar}_debug ""
-    __${nameForVar}_debug "========= checking if order preservation is required =========="
-
-    __${nameForVar}_perform_completion_once
-    if test -z "$__${nameForVar}_perform_completion_once_result"
-        __${nameForVar}_debug "Error determining if order preservation is required"
-        return 1
-    end
-
-    set -l directive (string sub --start 2 $__${nameForVar}_perform_completion_once_result[-1])
-    __${nameForVar}_debug "Directive is: $directive"
-
-    set -l shellCompDirectiveKeepOrder ${ShellCompDirectiveKeepOrder}
-    set -l keeporder (math (math --scale 0 $directive / $shellCompDirectiveKeepOrder) % 2)
-    __${nameForVar}_debug "Keeporder is: $keeporder"
-
-    if test $keeporder -ne 0
-        __${nameForVar}_debug "This does require order preservation"
-        return 0
-    end
-
-    __${nameForVar}_debug "This doesn't require order preservation"
-    return 1
-end
-
-# This function does two things:
-# - Obtain the completions and store them in the global __${nameForVar}_comp_results
-# - Return false if file completion should be performed
-function __${nameForVar}_prepare_completions
-    __${nameForVar}_debug ""
-    __${nameForVar}_debug "========= starting completion logic =========="
-
-    # Start fresh
-    set --erase __${nameForVar}_comp_results
-
-    __${nameForVar}_perform_completion_once
-    __${nameForVar}_debug "Completion results: $__${nameForVar}_perform_completion_once_result"
-
-    if test -z "$__${nameForVar}_perform_completion_once_result"
-        __${nameForVar}_debug "No completion, probably due to a failure"
-        # Might as well do file completion, in case it helps
-        return 1
-    end
-
-    set -l directive (string sub --start 2 $__${nameForVar}_perform_completion_once_result[-1])
-    set --global __${nameForVar}_comp_results $__${nameForVar}_perform_completion_once_result[1..-2]
-
-    __${nameForVar}_debug "Completions are: $__${nameForVar}_comp_results"
-    __${nameForVar}_debug "Directive is: $directive"
-
-    set -l shellCompDirectiveError ${ShellCompDirectiveError}
-    set -l shellCompDirectiveNoSpace ${ShellCompDirectiveNoSpace}
-    set -l shellCompDirectiveNoFileComp ${ShellCompDirectiveNoFileComp}
-    set -l shellCompDirectiveFilterFileExt ${ShellCompDirectiveFilterFileExt}
-    set -l shellCompDirectiveFilterDirs ${ShellCompDirectiveFilterDirs}
-
-    if test -z "$directive"
-        set directive 0
-    end
-
-    set -l compErr (math (math --scale 0 $directive / $shellCompDirectiveError) % 2)
-    if test $compErr -eq 1
-        __${nameForVar}_debug "Received error directive: aborting."
-        # Might as well do file completion, in case it helps
-        return 1
-    end
-
-    set -l filefilter (math (math --scale 0 $directive / $shellCompDirectiveFilterFileExt) % 2)
-    set -l dirfilter (math (math --scale 0 $directive / $shellCompDirectiveFilterDirs) % 2)
-    if test $filefilter -eq 1; or test $dirfilter -eq 1
-        __${nameForVar}_debug "File extension filtering or directory filtering not supported"
-        # Do full file completion instead
-        return 1
-    end
-
-    set -l nospace (math (math --scale 0 $directive / $shellCompDirectiveNoSpace) % 2)
-    set -l nofiles (math (math --scale 0 $directive / $shellCompDirectiveNoFileComp) % 2)
-
-    __${nameForVar}_debug "nospace: $nospace, nofiles: $nofiles"
-
-    # If we want to prevent a space, or if file completion is NOT disabled,
-    # we need to count the number of valid completions.
-    # To do so, we will filter on prefix as the completions we have received
-    # may not already be filtered so as to allow fish to match on different
-    # criteria than the prefix.
-    if test $nospace -ne 0; or test $nofiles -eq 0
-        set -l prefix (commandline -t | string escape --style=regex)
-        __${nameForVar}_debug "prefix: $prefix"
-
-        set -l completions (string match -r -- "^$prefix.*" $__${nameForVar}_comp_results)
-        set --global __${nameForVar}_comp_results $completions
-        __${nameForVar}_debug "Filtered completions are: $__${nameForVar}_comp_results"
-
-        # Important not to quote the variable for count to work
-        set -l numComps (count $__${nameForVar}_comp_results)
-        __${nameForVar}_debug "numComps: $numComps"
-
-        if test $numComps -eq 1; and test $nospace -ne 0
-            # We must first split on \\t to get rid of the descriptions to be
-            # able to check what the actual completion will be.
-            # We don't need descriptions anyway since there is only a single
-            # real completion which the shell will expand immediately.
-            set -l split (string split --max 1 "\\t" $__${nameForVar}_comp_results[1])
-
-            # Fish won't add a space if the completion ends with any
-            # of the following characters: @=/:.,
-            set -l lastChar (string sub -s -1 -- $split)
-            if not string match -r -q "[@=/:.,]" -- "$lastChar"
-                # In other cases, to support the "nospace" directive we trick the shell
-                # by outputting an extra, longer completion.
-                __${nameForVar}_debug "Adding second completion to perform nospace directive"
-                set --global __${nameForVar}_comp_results $split[1] $split[1].
-                __${nameForVar}_debug "Completions are now: $__${nameForVar}_comp_results"
-            end
-        end
-
-        if test $numComps -eq 0; and test $nofiles -eq 0
-            # To be consistent with bash and zsh, we only trigger file
-            # completion when there are no other completions
-            __${nameForVar}_debug "Requesting file completion"
-            return 1
-        end
-    end
-
-    return 0
-end
-
-# Since Fish completions are only loaded once the user triggers them, we trigger them ourselves
-# so we can properly delete any completions provided by another script.
-# Only do this if the program can be found, or else fish may print some errors; besides,
-# the existing completions will only be loaded if the program can be found.
-if type -q "${name}"
-    # The space after the program name is essential to trigger completion for the program
-    # and not completion of the program name itself.
-    # Also, we use '> /dev/null 2>&1' since '&>' is not supported in older versions of fish.
-    complete --do-complete "${name} " > /dev/null 2>&1
-end
-
-# Remove any pre-existing completions for the program since we will be handling all of them.
-complete -c ${name} -e
-
-# This will get called after the two calls below and clear the cached result
-complete -c ${name} -n '__${nameForVar}_clear_perform_completion_once_result'
-# The call to __${nameForVar}_prepare_completions will setup __${nameForVar}_comp_results
-# which provides the program's completion choices.
-# If this doesn't require order preservation, we don't use the -k flag
-complete -c ${name} -n 'not __${nameForVar}_requires_order_preservation && __${nameForVar}_prepare_completions' -f -a '$__${nameForVar}_comp_results'
-# Otherwise we use the -k flag
-complete -k -c ${name} -n '__${nameForVar}_requires_order_preservation && __${nameForVar}_prepare_completions' -f -a '$__${nameForVar}_comp_results'
-`;
-}
-function generate4(name, exec) {
-  const nameForVar = name.replace(/[-:]/g, "_");
-  const ShellCompDirectiveError = ShellCompDirective.ShellCompDirectiveError;
-  const ShellCompDirectiveNoSpace = ShellCompDirective.ShellCompDirectiveNoSpace;
-  const ShellCompDirectiveNoFileComp = ShellCompDirective.ShellCompDirectiveNoFileComp;
-  const ShellCompDirectiveFilterFileExt = ShellCompDirective.ShellCompDirectiveFilterFileExt;
-  const ShellCompDirectiveFilterDirs = ShellCompDirective.ShellCompDirectiveFilterDirs;
-  const ShellCompDirectiveKeepOrder = ShellCompDirective.ShellCompDirectiveKeepOrder;
-  return `# powershell completion for ${name} -*- shell-script -*-
-
-  [Console]::OutputEncoding = [System.Text.Encoding]::UTF8
-    function __${name}_debug {
-        if ($env:BASH_COMP_DEBUG_FILE) {
-            "$args" | Out-File -Append -FilePath "$env:BASH_COMP_DEBUG_FILE"
-        }
-    }
-
-    filter __${name}_escapeStringWithSpecialChars {
-        $_ -replace '\\s|#|@|\\$|;|,|''|\\{|\\}|\\(|\\)|"|\\||<|>|&','\`$&'
-    }
-
-[scriptblock]$__${nameForVar}CompleterBlock = {
-    param(
-            $WordToComplete,
-            $CommandAst,
-            $CursorPosition
-        )
-
-    # Get the current command line and convert into a string
-    $Command = $CommandAst.CommandElements
-    $Command = "$Command"
-
-    __${name}_debug ""
-    __${name}_debug "========= starting completion logic =========="
-    __${name}_debug "WordToComplete: $WordToComplete Command: $Command CursorPosition: $CursorPosition"
-
-    # The user could have moved the cursor backwards on the command-line.
-    # We need to trigger completion from the $CursorPosition location, so we need
-    # to truncate the command-line ($Command) up to the $CursorPosition location.
-    # Make sure the $Command is longer then the $CursorPosition before we truncate.
-    # This happens because the $Command does not include the last space.
-    if ($Command.Length -gt $CursorPosition) {
-        $Command = $Command.Substring(0, $CursorPosition)
-    }
-    __${name}_debug "Truncated command: $Command"
-
-    $ShellCompDirectiveError=${ShellCompDirectiveError}
-    $ShellCompDirectiveNoSpace=${ShellCompDirectiveNoSpace}
-    $ShellCompDirectiveNoFileComp=${ShellCompDirectiveNoFileComp}
-    $ShellCompDirectiveFilterFileExt=${ShellCompDirectiveFilterFileExt}
-    $ShellCompDirectiveFilterDirs=${ShellCompDirectiveFilterDirs}
-    $ShellCompDirectiveKeepOrder=${ShellCompDirectiveKeepOrder}
-
-    # Prepare the command to request completions for the program.
-    # Split the command at the first space to separate the program and arguments.
-    $Program, $Arguments = $Command.Split(" ", 2)
-
-    $QuotedArgs = ($Arguments -split ' ' | ForEach-Object { "'" + ($_ -replace "'", "''") + "'" }) -join ' '
-    __${name}_debug "QuotedArgs: $QuotedArgs"
-
-    $RequestComp = "& ${exec} complete '--' $QuotedArgs"
-    __${name}_debug "RequestComp: $RequestComp"
-
-    # we cannot use $WordToComplete because it
-    # has the wrong values if the cursor was moved
-    # so use the last argument
-    if ($WordToComplete -ne "" ) {
-        $WordToComplete = $Arguments.Split(" ")[-1]
-    }
-    __${name}_debug "New WordToComplete: $WordToComplete"
-
-
-    # Check for flag with equal sign
-    $IsEqualFlag = ($WordToComplete -Like "--*=*" )
-    if ( $IsEqualFlag ) {
-        __${name}_debug "Completing equal sign flag"
-        # Remove the flag part
-        $Flag, $WordToComplete = $WordToComplete.Split("=", 2)
-    }
-
-    if ( $WordToComplete -eq "" -And ( -Not $IsEqualFlag )) {
-        # If the last parameter is complete (there is a space following it)
-        # We add an extra empty parameter so we can indicate this to the go method.
-        __${name}_debug "Adding extra empty parameter"
-        # PowerShell 7.2+ changed the way how the arguments are passed to executables,
-        # so for pre-7.2 or when Legacy argument passing is enabled we need to use
-        if ($PSVersionTable.PsVersion -lt [version]'7.2.0' -or
-            ($PSVersionTable.PsVersion -lt [version]'7.3.0' -and -not [ExperimentalFeature]::IsEnabled("PSNativeCommandArgumentPassing")) -or
-            (($PSVersionTable.PsVersion -ge [version]'7.3.0' -or [ExperimentalFeature]::IsEnabled("PSNativeCommandArgumentPassing")) -and
-              $PSNativeCommandArgumentPassing -eq 'Legacy')) {
-             $RequestComp="$RequestComp" + ' \`"\`"'
-        } else {
-             $RequestComp = "$RequestComp" + ' ""'
-        }
-    }
-
-    __${name}_debug "Calling $RequestComp"
-    # First disable ActiveHelp which is not supported for Powershell
-    $env:ActiveHelp = 0
-
-    # call the command store the output in $out and redirect stderr and stdout to null
-    # $Out is an array contains each line per element
-    Invoke-Expression -OutVariable out "$RequestComp" 2>&1 | Out-Null
-
-    # get directive from last line
-    [int]$Directive = $Out[-1].TrimStart(':')
-    if ($Directive -eq "") {
-        # There is no directive specified
-        $Directive = 0
-    }
-    __${name}_debug "The completion directive is: $Directive"
-
-    # remove directive (last element) from out
-    $Out = $Out | Where-Object { $_ -ne $Out[-1] }
-    __${name}_debug "The completions are: $Out"
-
-    if (($Directive -band $ShellCompDirectiveError) -ne 0 ) {
-        # Error code.  No completion.
-        __${name}_debug "Received error from custom completion go code"
-        return
-    }
-
-    $Longest = 0
-    [Array]$Values = $Out | ForEach-Object {
-        # Split the output in name and description
-        $Name, $Description = $_.Split("\`t", 2)
-        __${name}_debug "Name: $Name Description: $Description"
-
-        # Look for the longest completion so that we can format things nicely
-        if ($Longest -lt $Name.Length) {
-            $Longest = $Name.Length
-        }
-
-        # Set the description to a one space string if there is none set.
-        # This is needed because the CompletionResult does not accept an empty string as argument
-        if (-Not $Description) {
-            $Description = " "
-        }
-        @{ Name = "$Name"; Description = "$Description" }
-    }
-
-
-    $Space = " "
-    if (($Directive -band $ShellCompDirectiveNoSpace) -ne 0 ) {
-        # remove the space here
-        __${name}_debug "ShellCompDirectiveNoSpace is called"
-        $Space = ""
-    }
-
-    if ((($Directive -band $ShellCompDirectiveFilterFileExt) -ne 0 ) -or
-       (($Directive -band $ShellCompDirectiveFilterDirs) -ne 0 ))  {
-        __${name}_debug "ShellCompDirectiveFilterFileExt ShellCompDirectiveFilterDirs are not supported"
-
-        # return here to prevent the completion of the extensions
-        return
-    }
-
-    $Values = $Values | Where-Object {
-        # filter the result
-        $_.Name -like "$WordToComplete*"
-
-        # Join the flag back if we have an equal sign flag
-        if ( $IsEqualFlag ) {
-            __${name}_debug "Join the equal sign flag back to the completion value"
-            $_.Name = $Flag + "=" + $_.Name
-        }
-    }
-
-    # we sort the values in ascending order by name if keep order isn't passed
-    if (($Directive -band $ShellCompDirectiveKeepOrder) -eq 0 ) {
-        $Values = $Values | Sort-Object -Property Name
-    }
-
-    if (($Directive -band $ShellCompDirectiveNoFileComp) -ne 0 ) {
-        __${name}_debug "ShellCompDirectiveNoFileComp is called"
-
-        if ($Values.Length -eq 0) {
-            # Just print an empty string here so the
-            # shell does not start to complete paths.
-            # We cannot use CompletionResult here because
-            # it does not accept an empty string as argument.
-            ""
-            return
-        }
-    }
-
-    # Get the current mode
-    $Mode = (Get-PSReadLineKeyHandler | Where-Object { $_.Key -eq "Tab" }).Function
-    __${name}_debug "Mode: $Mode"
-
-    $Values | ForEach-Object {
-
-        # store temporary because switch will overwrite $_
-        $comp = $_
-
-        # PowerShell supports three different completion modes
-        # - TabCompleteNext (default windows style - on each key press the next option is displayed)
-        # - Complete (works like bash)
-        # - MenuComplete (works like zsh)
-        # You set the mode with Set-PSReadLineKeyHandler -Key Tab -Function <mode>
-
-        # CompletionResult Arguments:
-        # 1) CompletionText text to be used as the auto completion result
-        # 2) ListItemText   text to be displayed in the suggestion list
-        # 3) ResultType     type of completion result
-        # 4) ToolTip        text for the tooltip with details about the object
-
-        switch ($Mode) {
-
-            # bash like
-            "Complete" {
-
-                if ($Values.Length -eq 1) {
-                    __${name}_debug "Only one completion left"
-
-                    # insert space after value
-                    [System.Management.Automation.CompletionResult]::new($($comp.Name | __${name}_escapeStringWithSpecialChars) + $Space, "$($comp.Name)", 'ParameterValue', "$($comp.Description)")
-
-                } else {
-                    # Add the proper number of spaces to align the descriptions
-                    while($comp.Name.Length -lt $Longest) {
-                        $comp.Name = $comp.Name + " "
-                    }
-
-                    # Check for empty description and only add parentheses if needed
-                    if ($($comp.Description) -eq " " ) {
-                        $Description = ""
-                    } else {
-                        $Description = "  ($($comp.Description))"
-                    }
-
-                    [System.Management.Automation.CompletionResult]::new("$($comp.Name)$Description", "$($comp.Name)$Description", 'ParameterValue', "$($comp.Description)")
-                }
-             }
-
-            # zsh like
-            "MenuComplete" {
-                # insert space after value
-                # MenuComplete will automatically show the ToolTip of
-                # the highlighted value at the bottom of the suggestions.
-                [System.Management.Automation.CompletionResult]::new($($comp.Name | __${name}_escapeStringWithSpecialChars) + $Space, "$($comp.Name)", 'ParameterValue', "$($comp.Description)")
-            }
-
-            # TabCompleteNext and in case we get something unknown
-            Default {
-                # Like MenuComplete but we don't want to add a space here because
-                # the user need to press space anyway to get the completion.
-                # Description will not be shown because that's not possible with TabCompleteNext
-                [System.Management.Automation.CompletionResult]::new($($comp.Name | __${name}_escapeStringWithSpecialChars), "$($comp.Name)", 'ParameterValue', "$($comp.Description)")
-            }
-        }
-
-    }
-}
-
-Register-ArgumentCompleter -CommandName '${name}' -ScriptBlock $__${nameForVar}CompleterBlock
-`;
-}
-var ShellCompDirective = {
-  ShellCompDirectiveError: 1 << 0,
-  ShellCompDirectiveNoSpace: 1 << 1,
-  ShellCompDirectiveNoFileComp: 1 << 2,
-  ShellCompDirectiveFilterFileExt: 1 << 3,
-  ShellCompDirectiveFilterDirs: 1 << 4,
-  ShellCompDirectiveKeepOrder: 1 << 5,
-  shellCompDirectiveMaxValue: 1 << 6,
-  ShellCompDirectiveDefault: 0
-};
-
-class Argument {
-  name;
-  variadic;
-  command;
-  handler;
-  constructor(command, name, handler, variadic = false) {
-    this.command = command;
-    this.name = name;
-    this.handler = handler;
-    this.variadic = variadic;
-  }
-}
-
-class Option {
-  value;
-  description;
-  command;
-  handler;
-  alias;
-  isBoolean;
-  constructor(command, value, description, handler, alias, isBoolean) {
-    this.command = command;
-    this.value = value;
-    this.description = description;
-    this.handler = handler;
-    this.alias = alias;
-    this.isBoolean = isBoolean;
-  }
-}
-
-class Command {
-  value;
-  description;
-  options = new Map;
-  arguments = new Map;
-  parent;
-  constructor(value, description) {
-    this.value = value;
-    this.description = description;
-  }
-  option(value, description, handlerOrAlias, alias) {
-    let handler;
-    let aliasStr;
-    let isBoolean;
-    if (typeof handlerOrAlias === "function") {
-      handler = handlerOrAlias;
-      aliasStr = alias;
-      isBoolean = false;
-    } else if (typeof handlerOrAlias === "string") {
-      handler = undefined;
-      aliasStr = handlerOrAlias;
-      isBoolean = true;
-    } else {
-      handler = undefined;
-      aliasStr = undefined;
-      isBoolean = true;
-    }
-    const option = new Option(this, value, description, handler, aliasStr, isBoolean);
-    this.options.set(value, option);
-    return this;
-  }
-  argument(name, handler, variadic = false) {
-    const arg = new Argument(this, name, handler, variadic);
-    this.arguments.set(name, arg);
-    return this;
-  }
-}
-var SUPPORTED_SHELLS = new Set(["zsh", "bash", "fish", "powershell"]);
-
-class RootCommand extends Command {
-  commands = new Map;
-  completions = [];
-  directive = ShellCompDirective.ShellCompDirectiveDefault;
-  constructor() {
-    super("", "");
-  }
-  command(value, description) {
-    const c = new Command(value, description);
-    this.commands.set(value, c);
-    return c;
-  }
-  stripOptions(args) {
-    const parts = [];
-    let i = 0;
-    while (i < args.length) {
-      const arg = args[i];
-      if (arg.startsWith("-")) {
-        i++;
-        const hasInlineValue = arg.includes("=");
-        let isBoolean = false;
-        const rootOption = this.findOption(this, arg);
-        if (rootOption) {
-          isBoolean = rootOption.isBoolean ?? false;
-        } else {
-          for (const [, command] of this.commands) {
-            const option = this.findOption(command, arg);
-            if (option) {
-              isBoolean = option.isBoolean ?? false;
-              break;
-            }
-          }
-        }
-        if (!hasInlineValue && !isBoolean && i < args.length && !args[i].startsWith("-")) {
-          i++;
-        }
-      } else {
-        parts.push(arg);
-        i++;
-      }
-    }
-    return parts;
-  }
-  matchCommand(args) {
-    args = this.stripOptions(args);
-    const parts = [];
-    let remaining = [];
-    let matchedCommand = null;
-    for (let i = 0;i < args.length; i++) {
-      const k = args[i];
-      parts.push(k);
-      const potential = this.commands.get(parts.join(" "));
-      if (potential) {
-        matchedCommand = potential;
-      } else {
-        remaining = args.slice(i, args.length);
-        break;
-      }
-    }
-    return [matchedCommand || this, remaining];
-  }
-  shouldCompleteFlags(lastPrevArg, toComplete) {
-    if (toComplete.startsWith("-")) {
-      return true;
-    }
-    if (lastPrevArg?.startsWith("-")) {
-      let option = this.findOption(this, lastPrevArg);
-      if (!option) {
-        for (const [, command] of this.commands) {
-          option = this.findOption(command, lastPrevArg);
-          if (option)
-            break;
-        }
-      }
-      if (option && option.isBoolean) {
-        return false;
-      }
-      return true;
-    }
-    return false;
-  }
-  shouldCompleteCommands(toComplete) {
-    return !toComplete.startsWith("-");
-  }
-  handleFlagCompletion(command, previousArgs, toComplete, lastPrevArg) {
-    let optionName;
-    if (toComplete.includes("=")) {
-      const [flag] = toComplete.split("=");
-      optionName = flag;
-    } else if (lastPrevArg?.startsWith("-")) {
-      const option = this.findOption(command, lastPrevArg);
-      if (option && !option.isBoolean) {
-        optionName = lastPrevArg;
-      }
-    }
-    if (optionName) {
-      const option = this.findOption(command, optionName);
-      if (option?.handler) {
-        const suggestions = [];
-        option.handler.call(option, (value, description) => suggestions.push({ value, description }), command.options);
-        this.completions = suggestions;
-      }
-      return;
-    }
-    if (toComplete.startsWith("-")) {
-      const isShortFlag = toComplete.startsWith("-") && !toComplete.startsWith("--");
-      const cleanToComplete = toComplete.replace(/^-+/, "");
-      for (const [name, option] of command.options) {
-        if (isShortFlag && option.alias && `-${option.alias}`.startsWith(toComplete)) {
-          this.completions.push({
-            value: `-${option.alias}`,
-            description: option.description
-          });
-        } else if (!isShortFlag && name.startsWith(cleanToComplete)) {
-          this.completions.push({
-            value: `--${name}`,
-            description: option.description
-          });
-        }
-      }
-    }
-  }
-  findOption(command, optionName) {
-    const normalized = this.normalizeOptionToken(optionName);
-    let option = command.options.get(optionName);
-    if (option)
-      return option;
-    option = command.options.get(normalized);
-    if (option)
-      return option;
-    for (const [_name, opt] of command.options) {
-      if (opt.alias === normalized) {
-        return opt;
-      }
-    }
-    return;
-  }
-  normalizeOptionToken(optionName) {
-    return optionName.replace(/^-+/, "").split("=")[0] ?? "";
-  }
-  handleCommandCompletion(previousArgs, toComplete) {
-    const commandParts = this.stripOptions(previousArgs);
-    for (const [k, command] of this.commands) {
-      if (k === "")
-        continue;
-      const parts = k.split(" ");
-      const match = parts.slice(0, commandParts.length).every((part, i) => part === commandParts[i]);
-      if (match && parts[commandParts.length]?.startsWith(toComplete)) {
-        this.completions.push({
-          value: parts[commandParts.length],
-          description: command.description
-        });
-      }
-    }
-  }
-  handlePositionalCompletion(command, previousArgs) {
-    const commandParts = command.value.split(" ").length;
-    const currentArgIndex = Math.max(0, previousArgs.length - commandParts);
-    const argumentEntries = Array.from(command.arguments.entries());
-    if (argumentEntries.length > 0) {
-      let targetArgument;
-      if (currentArgIndex < argumentEntries.length) {
-        const [_argName, argument] = argumentEntries[currentArgIndex];
-        targetArgument = argument;
-      } else {
-        const lastArgument = argumentEntries[argumentEntries.length - 1][1];
-        if (lastArgument.variadic) {
-          targetArgument = lastArgument;
-        }
-      }
-      if (targetArgument && targetArgument.handler && typeof targetArgument.handler === "function") {
-        const suggestions = [];
-        targetArgument.handler.call(targetArgument, (value, description) => suggestions.push({ value, description }), command.options);
-        this.completions.push(...suggestions);
-      }
-    }
-  }
-  complete(toComplete) {
-    this.directive = ShellCompDirective.ShellCompDirectiveNoFileComp;
-    const seen = new Set;
-    this.completions.filter((comp) => {
-      if (seen.has(comp.value))
-        return false;
-      seen.add(comp.value);
-      return true;
-    }).filter((comp) => {
-      if (toComplete.includes("=")) {
-        const [, valueToComplete] = toComplete.split("=");
-        return comp.value.startsWith(valueToComplete ?? "");
-      }
-      return comp.value.startsWith(toComplete);
-    }).forEach((comp) => console.log(`${comp.value}	${comp.description ?? ""}`));
-    console.log(`:${this.directive}`);
-  }
-  parse(args) {
-    this.completions = [];
-    const endsWithSpace = args[args.length - 1] === "";
-    if (endsWithSpace) {
-      args.pop();
-    }
-    let toComplete = args[args.length - 1] || "";
-    const previousArgs = args.slice(0, -1);
-    if (endsWithSpace) {
-      if (toComplete !== "") {
-        previousArgs.push(toComplete);
-      }
-      toComplete = "";
-    }
-    const [matchedCommand] = this.matchCommand(previousArgs);
-    const lastPrevArg = previousArgs[previousArgs.length - 1];
-    if (this.shouldCompleteFlags(lastPrevArg, toComplete)) {
-      this.handleFlagCompletion(matchedCommand, previousArgs, toComplete, lastPrevArg);
-    } else {
-      if (lastPrevArg?.startsWith("-") && toComplete === "" && endsWithSpace) {
-        let option = this.findOption(this, lastPrevArg);
-        if (!option) {
-          for (const [, command] of this.commands) {
-            option = this.findOption(command, lastPrevArg);
-            if (option)
-              break;
-          }
-        }
-        if (option && option.isBoolean) {
-          this.complete(toComplete);
-          return;
-        }
-      }
-      if (this.shouldCompleteCommands(toComplete)) {
-        this.handleCommandCompletion(previousArgs, toComplete);
-      }
-      if (matchedCommand && matchedCommand.arguments.size > 0) {
-        this.handlePositionalCompletion(matchedCommand, previousArgs);
-      }
-    }
-    this.complete(toComplete);
-  }
-  setup(name, executable, shell) {
-    if (!SUPPORTED_SHELLS.has(shell)) {
-      throw new Error(`Unsupported shell: ${shell}`);
-    }
-    switch (shell) {
-      case "zsh": {
-        const script = generate(name, executable);
-        console.log(script);
-        break;
-      }
-      case "bash": {
-        const script = generate2(name, executable);
-        console.log(script);
-        break;
-      }
-      case "fish": {
-        const script = generate3(name, executable);
-        console.log(script);
-        break;
-      }
-      case "powershell": {
-        const script = generate4(name, executable);
-        console.log(script);
-        break;
-      }
-    }
-  }
-}
-var t = new RootCommand;
-function dual(arity, body) {
-  if (arity === 2)
-    return (...args) => {
-      if (args.length >= 2)
-        return body(args[0], args[1]);
-      return (self) => body(self, args[0]);
-    };
-  if (arity === 3)
-    return (...args) => {
-      if (args.length >= 3)
-        return body(args[0], args[1], args[2]);
-      return (self) => body(self, args[0], args[1]);
-    };
-  if (arity === 4)
-    return (...args) => {
-      if (args.length >= 4)
-        return body(args[0], args[1], args[2], args[3]);
-      return (self) => body(self, args[0], args[1], args[2]);
-    };
-  return (...args) => {
-    if (args.length >= arity)
-      return body(...args);
-    return (self) => body(self, ...args);
-  };
-}
-var serializeCause = (cause) => {
-  if (cause instanceof Error)
-    return {
-      name: cause.name,
-      message: cause.message,
-      stack: cause.stack
-    };
-  return cause;
-};
-var isAnyTaggedError = (value) => {
-  return value instanceof Error && "_tag" in value && typeof value._tag === "string";
-};
-var TaggedError2 = Object.assign((tag) => () => {
-
-  class Base extends Error {
-    _tag = tag;
-    static is(value) {
-      return value instanceof Base;
-    }
-    constructor(args) {
-      const message = args && "message" in args && typeof args.message === "string" ? args.message : undefined;
-      const cause = args && "cause" in args ? args.cause : undefined;
-      super(message, cause !== undefined ? { cause } : undefined);
-      if (args)
-        Object.assign(this, args);
-      Object.setPrototypeOf(this, new.target.prototype);
-      this.name = tag;
-      if (cause instanceof Error && cause.stack) {
-        const indented = cause.stack.replace(/\n/g, `
-  `);
-        this.stack = `${this.stack}
-Caused by: ${indented}`;
-      }
-    }
-    toJSON() {
-      return {
-        ...this,
-        _tag: this._tag,
-        name: this.name,
-        message: this.message,
-        cause: serializeCause(this.cause),
-        stack: this.stack
-      };
-    }
-  }
-  return Base;
-}, { is: isAnyTaggedError });
-var matchError = dual(2, (err$1, handlers) => {
-  const handler = handlers[err$1._tag];
-  return handler(err$1);
-});
-var matchErrorPartial = dual(3, (err$1, handlers, fallback) => {
-  const handler = handlers[err$1._tag];
-  if (typeof handler === "function")
-    return handler(err$1);
-  return fallback(err$1);
-});
-var UnhandledException = class extends TaggedError2("UnhandledException")() {
-  constructor(args) {
-    const message = args.cause instanceof Error ? `Unhandled exception: ${args.cause.message}` : `Unhandled exception: ${String(args.cause)}`;
-    super({
-      message,
-      cause: args.cause
-    });
-  }
-};
-var Panic = class extends TaggedError2("Panic")() {
-};
-var ResultDeserializationError = class extends TaggedError2("ResultDeserializationError")() {
-  constructor(args) {
-    super({
-      message: `Failed to deserialize value as Result: expected { status: "ok", value } or { status: "error", error }`,
-      value: args.value
-    });
-  }
-};
-var panic = (message, cause) => {
-  throw new Panic({
-    message,
-    cause
-  });
-};
-var tryOrPanic = (fn, message) => {
-  try {
-    return fn();
-  } catch (cause) {
-    throw panic(message, cause);
-  }
-};
-var tryOrPanicAsync = async (fn, message) => {
-  try {
-    return await fn();
-  } catch (cause) {
-    throw panic(message, cause);
-  }
-};
-var Ok = class Ok2 {
-  status = "ok";
-  constructor(value) {
-    this.value = value;
-  }
-  isOk() {
-    return true;
-  }
-  isErr() {
-    return false;
-  }
-  map(fn) {
-    return tryOrPanic(() => new Ok2(fn(this.value)), "map callback threw");
-  }
-  mapError(_fn) {
-    return this;
-  }
-  andThen(fn) {
-    return tryOrPanic(() => fn(this.value), "andThen callback threw");
-  }
-  andThenAsync(fn) {
-    return tryOrPanicAsync(() => fn(this.value), "andThenAsync callback threw");
-  }
-  match(handlers) {
-    return tryOrPanic(() => handlers.ok(this.value), "match ok handler threw");
-  }
-  unwrap(_message) {
-    return this.value;
-  }
-  unwrapOr(_fallback) {
-    return this.value;
-  }
-  tap(fn) {
-    return tryOrPanic(() => {
-      fn(this.value);
-      return this;
-    }, "tap callback threw");
-  }
-  tapAsync(fn) {
-    return tryOrPanicAsync(async () => {
-      await fn(this.value);
-      return this;
-    }, "tapAsync callback threw");
-  }
-  *[Symbol.iterator]() {
-    return this.value;
-  }
-};
-var Err = class Err2 {
-  status = "error";
-  constructor(error) {
-    this.error = error;
-  }
-  isOk() {
-    return false;
-  }
-  isErr() {
-    return true;
-  }
-  map(_fn) {
-    return this;
-  }
-  mapError(fn) {
-    return tryOrPanic(() => new Err2(fn(this.error)), "mapError callback threw");
-  }
-  andThen(_fn) {
-    return this;
-  }
-  andThenAsync(_fn) {
-    return Promise.resolve(this);
-  }
-  match(handlers) {
-    return tryOrPanic(() => handlers.err(this.error), "match err handler threw");
-  }
-  unwrap(message) {
-    return panic(message ?? `Unwrap called on Err: ${String(this.error)}`, this.error);
-  }
-  unwrapOr(fallback) {
-    return fallback;
-  }
-  tap(_fn) {
-    return this;
-  }
-  tapAsync(_fn) {
-    return Promise.resolve(this);
-  }
-  *[Symbol.iterator]() {
-    yield this;
-    return panic("Unreachable: Err yielded in Result.gen but generator continued", this.error);
-  }
-};
-function ok(value) {
-  return new Ok(value);
-}
-var isOk = (result) => {
-  return result.status === "ok";
-};
-var err = (error) => new Err(error);
-var isError = (result) => {
-  return result.status === "error";
-};
-var tryFn = (options, config) => {
-  const execute = () => {
-    if (typeof options === "function")
-      try {
-        return ok(options());
-      } catch (cause) {
-        return err(new UnhandledException({ cause }));
-      }
-    try {
-      return ok(options.try());
-    } catch (originalCause) {
-      try {
-        return err(options.catch(originalCause));
-      } catch (catchHandlerError) {
-        throw panic("Result.try catch handler threw", catchHandlerError);
-      }
-    }
-  };
-  const times = config?.retry?.times ?? 0;
-  let result = execute();
-  for (let retry = 0;retry < times && result.status === "error"; retry++)
-    result = execute();
-  return result;
-};
-var tryPromise = async (options, config) => {
-  const execute = async () => {
-    if (typeof options === "function")
-      try {
-        return ok(await options());
-      } catch (cause) {
-        return err(new UnhandledException({ cause }));
-      }
-    try {
-      return ok(await options.try());
-    } catch (originalCause) {
-      try {
-        return err(await options.catch(originalCause));
-      } catch (catchHandlerError) {
-        throw panic("Result.tryPromise catch handler threw", catchHandlerError);
-      }
-    }
-  };
-  const retry = config?.retry;
-  if (!retry)
-    return execute();
-  const getDelay = (retryAttempt) => {
-    switch (retry.backoff) {
-      case "constant":
-        return retry.delayMs;
-      case "linear":
-        return retry.delayMs * (retryAttempt + 1);
-      case "exponential":
-        return retry.delayMs * 2 ** retryAttempt;
-    }
-  };
-  const sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
-  let result = await execute();
-  const shouldRetryFn = retry.shouldRetry ?? (() => true);
-  for (let attempt = 0;attempt < retry.times; attempt++) {
-    if (result.status !== "error")
-      break;
-    const error = result.error;
-    if (!tryOrPanic(() => shouldRetryFn(error), "shouldRetry predicate threw"))
-      break;
-    await sleep(getDelay(attempt));
-    result = await execute();
-  }
-  return result;
-};
-var map = dual(2, (result, fn) => {
-  return result.map(fn);
-});
-var mapError = dual(2, (result, fn) => {
-  return result.mapError(fn);
-});
-var andThen = dual(2, (result, fn) => {
-  return result.andThen(fn);
-});
-var andThenAsync = dual(2, (result, fn) => {
-  return result.andThenAsync(fn);
-});
-var match = dual(2, (result, handlers) => {
-  return result.match(handlers);
-});
-var tap = dual(2, (result, fn) => {
-  return result.tap(fn);
-});
-var tapAsync = dual(2, (result, fn) => {
-  return result.tapAsync(fn);
-});
-var unwrap = (result, message) => {
-  return result.unwrap(message);
-};
-function assertIsResult(value) {
-  if (value !== null && typeof value === "object" && "status" in value && (value.status === "ok" || value.status === "error"))
-    return;
-  return panic("Result.gen body must return Result.ok() or Result.err(), got: " + (value === null ? "null" : typeof value === "object" ? JSON.stringify(value) : String(value)));
-}
-var unwrapOr = dual(2, (result, fallback) => {
-  return result.unwrapOr(fallback);
-});
-var gen = (body, thisArg) => {
-  const iterator = body.call(thisArg);
-  if (Symbol.asyncIterator in iterator)
-    return (async () => {
-      const asyncIter = iterator;
-      let state$1;
-      try {
-        state$1 = await asyncIter.next();
-      } catch (cause) {
-        throw panic("generator body threw", cause);
-      }
-      assertIsResult(state$1.value);
-      if (!state$1.done)
-        try {
-          await asyncIter.return?.(undefined);
-        } catch (cause) {
-          throw panic("generator cleanup threw", cause);
-        }
-      return state$1.value;
-    })();
-  const syncIter = iterator;
-  let state;
-  try {
-    state = syncIter.next();
-  } catch (cause) {
-    throw panic("generator body threw", cause);
-  }
-  assertIsResult(state.value);
-  if (!state.done)
-    try {
-      syncIter.return?.(undefined);
-    } catch (cause) {
-      throw panic("generator cleanup threw", cause);
-    }
-  return state.value;
-};
-async function* resultAwait(promise) {
-  return yield* await promise;
-}
-function isSerializedResult(obj) {
-  return obj !== null && typeof obj === "object" && "status" in obj && (obj.status === "ok" && ("value" in obj) || obj.status === "error" && ("error" in obj));
-}
-var serialize = (result) => {
-  return result.status === "ok" ? {
-    status: "ok",
-    value: result.value
-  } : {
-    status: "error",
-    error: result.error
-  };
-};
-var deserialize = (value) => {
-  if (isSerializedResult(value))
-    return value.status === "ok" ? new Ok(value.value) : new Err(value.error);
-  return err(new ResultDeserializationError({ value }));
-};
-var hydrate = (value) => {
-  return deserialize(value);
-};
-var partition = (results) => {
-  const oks = [];
-  const errs = [];
-  for (const r of results)
-    if (r.status === "ok")
-      oks.push(r.value);
-    else
-      errs.push(r.error);
-  return [oks, errs];
-};
-var flatten = (result) => {
-  if (result.status === "ok")
-    return result.value;
-  return result;
-};
-var Result2 = {
-  ok,
-  isOk,
-  err,
-  isError,
-  try: tryFn,
-  tryPromise,
-  map,
-  mapError,
-  andThen,
-  andThenAsync,
-  match,
-  tap,
-  tapAsync,
-  unwrap,
-  unwrapOr,
-  gen,
-  await: resultAwait,
-  serialize,
-  deserialize,
-  hydrate,
-  partition,
-  flatten
-};
-
-class PackageJsonReadError extends TaggedError2("PackageJsonReadError")() {
-}
-
-class LoadGeneratedMetadataError extends TaggedError2("LoadGeneratedMetadataError")() {
-}
-function stripScope(name) {
-  const idx = name.lastIndexOf("/");
-  return idx >= 0 ? name.slice(idx + 1) : name;
-}
-async function resolveCliInfo(options = {}) {
-  if (options.commandName && options.executable) {
-    return { commandName: options.commandName, executable: options.executable };
-  }
-  const packageJsonResult = await readProjectPackageJson();
-  const pkg = Result2.isOk(packageJsonResult) ? packageJsonResult.value : null;
-  const pkgName = typeof pkg?.name === "string" ? pkg.name : undefined;
-  const pkgNameStripped = pkgName ? stripScope(pkgName) : undefined;
-  let inferredCommandName;
-  const bin = pkg?.bin;
-  if (typeof bin === "string") {
-    inferredCommandName = pkgNameStripped;
-  } else if (bin && typeof bin === "object") {
-    const keys = Object.keys(bin);
-    if (pkgNameStripped && keys.includes(pkgNameStripped))
-      inferredCommandName = pkgNameStripped;
-    else
-      inferredCommandName = keys[0];
-    if (inferredCommandName)
-      inferredCommandName = stripScope(inferredCommandName);
-  } else {
-    inferredCommandName = pkgNameStripped;
-  }
-  const commandName = options.commandName ?? inferredCommandName ?? "cli";
-  const executable = options.executable ?? commandName;
-  return { commandName, executable };
-}
-async function loadGeneratedMetadata(options = {}) {
-  const generatedPath = options.generatedPath ?? ".bunli/commands.gen.ts";
-  const absolute = resolve(process.cwd(), generatedPath);
-  const url = pathToFileURL(absolute).href;
-  return await Result2.tryPromise({
-    try: async () => {
-      const mod = await import(url);
-      const list = mod.generated?.list?.() ?? [];
-      return { commands: list.map((i) => i.metadata) };
-    },
-    catch: (cause) => new LoadGeneratedMetadataError({
-      generatedPath,
-      message: `Could not load command metadata from ${generatedPath}. Make sure it exists (run "bunli generate").`,
-      cause
-    })
-  });
-}
-async function readProjectPackageJson() {
-  return Result2.tryPromise({
-    try: async () => {
-      const pkgPath = resolve(process.cwd(), "package.json");
-      const pkgContent = await readFile(pkgPath, "utf-8");
-      const parsed = JSON.parse(pkgContent);
-      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        throw new Error("package.json must be a JSON object");
-      }
-      return parsed;
-    },
-    catch: (cause) => new PackageJsonReadError({
-      message: "Could not read project package.json",
-      cause
-    })
-  });
-}
-function canonicalCommandPath(name) {
-  return name.replace(/\s+/g, "/").replace(/\/+/g, "/").replace(/^\/+|\/+$/g, "").trim();
-}
-function resolveNestedCommandName(parentPath, rawName) {
-  const child = canonicalCommandPath(rawName);
-  if (!child)
-    return parentPath ?? "";
-  if (!parentPath)
-    return child;
-  if (!child.includes("/")) {
-    return `${parentPath}/${child}`;
-  }
-  if (child === parentPath || child.startsWith(`${parentPath}/`)) {
-    return child;
-  }
-  return child;
-}
-function flattenCommandTree(commands) {
-  const flattened = [];
-  const walk = (meta, parentPath) => {
-    const resolvedName = resolveNestedCommandName(parentPath, meta.name);
-    if (!resolvedName)
-      return;
-    flattened.push({
-      ...meta,
-      name: resolvedName
-    });
-    for (const nested of meta.commands ?? []) {
-      walk(nested, resolvedName);
-    }
-  };
-  for (const meta of commands) {
-    walk(meta);
-  }
-  return flattened;
-}
-function normalizeCommandPath(name) {
-  return name.replace(/\//g, " ").trim();
-}
-function isBooleanOption(meta) {
-  const t2 = meta.type.toLowerCase();
-  return t2.includes("boolean") || t2.includes("bool");
-}
-function addGlobalFlags(cmd) {
-  for (const [name, flag] of Object.entries(GLOBAL_FLAGS)) {
-    const desc = flag.description ?? "";
-    const short = "short" in flag ? flag.short : undefined;
-    const handler = createGlobalFlagHandler(name);
-    if (handler) {
-      if (short)
-        cmd.option(name, desc, handler, short);
-      else
-        cmd.option(name, desc, handler);
-      continue;
-    }
-    if (short)
-      cmd.option(name, desc, short);
-    else
-      cmd.option(name, desc);
-  }
-}
-function createGlobalFlagHandler(name) {
-  const enumValues = name === "format" ? ["json", "yaml", "md", "toon"] : name === "image-mode" ? ["off", "auto", "on"] : undefined;
-  if (!enumValues)
-    return;
-  return (complete) => {
-    for (const value of enumValues)
-      complete(value, "");
-  };
-}
-function addOption(cmd, name, meta) {
-  const desc = meta.description ?? "";
-  const short = meta.short;
-  if (isBooleanOption(meta)) {
-    if (short)
-      cmd.option(name, desc, short);
-    else
-      cmd.option(name, desc);
-    return;
-  }
-  const enumValues = meta.enumValues;
-  const literalValue = meta.literalValue;
-  const handler = (complete) => {
-    if (enumValues && enumValues.length > 0) {
-      for (const v of enumValues)
-        complete(String(v), "");
-      return;
-    }
-    if (literalValue !== undefined) {
-      complete(String(literalValue), "");
-    }
-  };
-  if (short)
-    cmd.option(name, desc, handler, short);
-  else
-    cmd.option(name, desc, handler);
-}
-function addCommandOptions(cmd, meta) {
-  for (const [name, opt] of Object.entries(meta.options ?? {})) {
-    addOption(cmd, name, opt);
-  }
-}
-function expandAliases(meta, opts) {
-  const primary = normalizeCommandPath(meta.name);
-  if (!opts.includeAliases || !meta.alias)
-    return [primary];
-  const aliases = Array.isArray(meta.alias) ? meta.alias : [meta.alias];
-  const parts = primary.split(" ").filter(Boolean);
-  const parent = parts.slice(0, -1);
-  const expanded = [primary];
-  for (const a of aliases) {
-    const aliasRaw = String(a).trim();
-    if (!aliasRaw)
-      continue;
-    if (aliasRaw.includes("/") || aliasRaw.includes(" ")) {
-      expanded.push(normalizeCommandPath(aliasRaw));
-      continue;
-    }
-    expanded.push([...parent, aliasRaw].join(" ").trim());
-  }
-  return expanded;
-}
-function buildRegistry(commands, options = {}) {
-  const opts = {
-    includeAliases: options.includeAliases ?? true,
-    includeGlobalFlags: options.includeGlobalFlags ?? true
-  };
-  const root = new RootCommand;
-  const flattenedCommands = flattenCommandTree(commands);
-  const metaByPath = new Map;
-  const allPaths = new Set;
-  for (const meta of flattenedCommands) {
-    for (const path of expandAliases(meta, opts)) {
-      metaByPath.set(path, meta);
-      const parts = path.split(" ").filter(Boolean);
-      for (let i = 1;i <= parts.length; i += 1) {
-        allPaths.add(parts.slice(0, i).join(" "));
-      }
-    }
-  }
-  const sortedPaths = Array.from(allPaths).sort((a, b) => {
-    const al = a.split(" ").length;
-    const bl = b.split(" ").length;
-    if (al !== bl)
-      return al - bl;
-    return a.localeCompare(b);
-  });
-  const tabCommands = new Map;
-  for (const path of sortedPaths) {
-    const meta = metaByPath.get(path);
-    const desc = meta?.description ?? "";
-    const cmd = root.command(path, desc);
-    tabCommands.set(path, cmd);
-    if (opts.includeGlobalFlags)
-      addGlobalFlags(cmd);
-    if (meta)
-      addCommandOptions(cmd, meta);
-  }
-  if (opts.includeGlobalFlags)
-    addGlobalFlags(root);
-  return root;
-}
-var SHELLS = ["bash", "zsh", "fish", "powershell"];
-function isShell(value) {
-  return SHELLS.includes(value);
-}
-
-class CompletionProtocolError extends TaggedError2("CompletionProtocolError")() {
-}
-function completionsCommand(pluginOptions) {
-  return defineCommand({
-    name: "completions",
-    alias: ["complete"],
-    description: "Generate shell completion scripts and handle completion protocol callbacks",
-    handler: async ({ runtime, colors }) => {
-      const argv = runtime.args;
-      const invokedCommand = runtime.command.split(/\s+/).at(-1) ?? "completions";
-      const isProtocolCommand = invokedCommand === "complete";
-      if (!isProtocolCommand) {
-        const first = argv[0];
-        if (argv.length === 1 && typeof first === "string" && isShell(first)) {
-          const shell = first;
-          const { commandName, executable } = await resolveCliInfo(pluginOptions);
-          const root = new RootCommand;
-          root.setup(commandName, executable, shell);
-          return;
-        }
-        console.error(colors.red("Missing or invalid shell name for completions script generation."));
-        console.error(colors.dim("Usage: <cli> completions <bash|zsh|fish|powershell>"));
-        console.error(colors.dim("Protocol callback form: <cli> complete -- <args...>"));
-        return;
-      }
-      const metadataResult = await loadGeneratedMetadata(pluginOptions);
-      if (Result2.isError(metadataResult)) {
-        console.log(":1");
-        if (process.env.BUNLI_DEBUG_COMPLETIONS) {
-          console.error(colors.red(metadataResult.error.message));
-        }
-        return;
-      }
-      const parseResult = Result2.try({
-        try: () => {
-          const root = buildRegistry(metadataResult.value.commands, {
-            includeAliases: pluginOptions.includeAliases,
-            includeGlobalFlags: pluginOptions.includeGlobalFlags
-          });
-          root.parse(argv);
-        },
-        catch: (cause) => new CompletionProtocolError({
-          message: "Completion registry failed to parse protocol arguments.",
-          cause
-        })
-      });
-      if (Result2.isError(parseResult)) {
-        console.log(":1");
-        if (process.env.BUNLI_DEBUG_COMPLETIONS) {
-          console.error(colors.red(parseResult.error.message));
-        }
-      }
-    }
-  });
-}
-var completionsPlugin = createPlugin((options = {}) => ({
-  name: "completions",
-  setup(context) {
-    const command = completionsCommand(options);
-    context.registerCommand(command);
-  }
-}));
-
-// ../../node_modules/.bun/@bunli+plugin-config@0.4.4+44deef6f8e4a2f18/node_modules/@bunli/plugin-config/src/index.ts
-import { readFile as readFile2, access } from "fs/promises";
-import { homedir } from "os";
-class ConfigFileNotFoundError extends TaggedError("ConfigFileNotFoundError")() {
-}
-
-class ConfigFileReadError extends TaggedError("ConfigFileReadError")() {
-}
-
-class ConfigFileParseError extends TaggedError("ConfigFileParseError")() {
-}
-var configMergerPlugin = createPlugin((options = {}) => {
-  const sources = options.sources || [
-    "~/.config/{{name}}/config.json",
-    ".{{name}}rc",
-    ".{{name}}rc.json",
-    ".config/{{name}}.json"
-  ];
-  return {
-    name: "@bunli/plugin-config",
-    version: "1.0.0",
-    async setup(context) {
-      const appName = context.config.name || "bunli";
-      const configs = [];
-      for (const source of sources) {
-        const configPath = source.replace(/^~/, homedir()).replace(/\{\{name\}\}/g, appName);
-        const loadedConfig = await readConfigSource(configPath);
-        if (Result.isError(loadedConfig)) {
-          if (ConfigFileNotFoundError.is(loadedConfig.error)) {
-            context.logger.debug(`Config file not found: ${configPath}`);
-            continue;
-          }
-          if (ConfigFileParseError.is(loadedConfig.error)) {
-            context.logger.warn(`Failed to parse config file ${configPath}: ${loadedConfig.error.message}`);
-            continue;
-          }
-          context.logger.warn(`Failed to load config file ${configPath}: ${loadedConfig.error.message}`);
-          continue;
-        }
-        configs.push(loadedConfig.value);
-        context.logger.debug(`Loaded config from ${configPath}`);
-        if (options.stopOnFirst) {
-          break;
-        }
-      }
-      if (configs.length > 0) {
-        let merged;
-        if (options.mergeStrategy === "shallow") {
-          merged = Object.assign({}, ...configs);
-        } else {
-          merged = deepMerge(...configs);
-        }
-        context.updateConfig(merged);
-        context.logger.info(`Merged ${configs.length} config file(s)`);
-      }
-    }
-  };
-});
-async function readConfigSource(path) {
-  const existsResult = await Result.tryPromise({
-    try: async () => {
-      await access(path);
-    },
-    catch: (cause) => new ConfigFileNotFoundError({
-      path,
-      message: `Config file not found: ${path}`,
-      cause
-    })
-  });
-  if (Result.isError(existsResult)) {
-    return existsResult;
-  }
-  const readResult = await Result.tryPromise({
-    try: async () => await readFile2(path, "utf-8"),
-    catch: (cause) => new ConfigFileReadError({
-      path,
-      message: `Unable to read config file: ${path}`,
-      cause
-    })
-  });
-  if (Result.isError(readResult)) {
-    return readResult;
-  }
-  return Result.try({
-    try: () => {
-      const parsed = JSON.parse(readResult.value);
-      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        throw new Error("Config file must contain a JSON object");
-      }
-      return parsed;
-    },
-    catch: (cause) => new ConfigFileParseError({
-      path,
-      message: `Invalid JSON in config file: ${path}`,
-      cause
-    })
-  });
-}
-
-// ../../node_modules/.bun/@bunli+plugin-skills@0.1.0+44deef6f8e4a2f18/node_modules/@bunli/plugin-skills/src/plugin.ts
-var skillsPlugin = createPlugin((options = {}) => ({
-  name: "skills",
-  setup(context) {
-    const skillsGroup = defineGroup({
-      name: "skills",
-      description: "Manage agent skill files",
-      commands: [
-        defineCommand({
-          name: "sync",
-          description: "Generate and install skill files for detected agents",
-          options: {
-            global: {
-              schema: exports_external.boolean().default(true),
-              description: "Install globally (default) or project-local",
-              argumentKind: "flag"
-            },
-            force: {
-              schema: exports_external.boolean().default(false),
-              short: "f",
-              description: "Force regeneration even if up to date",
-              argumentKind: "flag"
-            }
-          },
-          async handler({ flags, colors, output }) {
-            const typedFlags = flags;
-            const { syncSkills } = await import("./sync-k2k8svyc.js");
-            const { detectAgents, builtinAgents } = await import("./agents-91fpdyyt.js");
-            const allAgents = options.agents ? [...builtinAgents, ...options.agents] : builtinAgents;
-            const detected = detectAgents(allAgents);
-            const commands = context.store.get("_skillsCommands");
-            if (!commands || commands.size === 0) {
-              console.log(colors.yellow("No commands registered. Nothing to sync."));
-              return;
-            }
-            const cliName = context.store.get("_skillsCliName") || "cli";
-            const result = await syncSkills(cliName, commands, {
-              global: typedFlags.global,
-              force: typedFlags.force,
-              description: options.description,
-              agents: detected
-            });
-            if (!result.updated && !typedFlags.force) {
-              console.log(colors.dim("Skills are up to date."));
-              output({ updated: false, agents: detected.map((a) => a.name) });
-              return;
-            }
-            console.log(colors.green(`Synced skills to ${result.paths.length} location(s)`));
-            for (const install of result.agents) {
-              console.log(colors.dim(`  ${install.agent}: ${install.mode} \u2192 ${install.path}`));
-            }
-            output({
-              updated: true,
-              paths: result.paths,
-              agents: result.agents.map((a) => ({
-                agent: a.agent,
-                path: a.path,
-                mode: a.mode
-              }))
-            });
-          }
-        }),
-        defineCommand({
-          name: "list",
-          description: "List detected agents on this system",
-          async handler({ colors, output }) {
-            const { detectAgents, builtinAgents } = await import("./agents-91fpdyyt.js");
-            const allAgents = options.agents ? [...builtinAgents, ...options.agents] : builtinAgents;
-            const detected = detectAgents(allAgents);
-            if (detected.length === 0) {
-              console.log(colors.dim("No agents detected."));
-              output({ agents: [] });
-              return;
-            }
-            console.log(`Detected ${detected.length} agent(s):
-`);
-            for (const agent of detected) {
-              const tag = agent.universal ? colors.dim(" (universal)") : "";
-              console.log(`  ${colors.bold(agent.name)}${tag}`);
-              console.log(colors.dim(`    ${agent.projectSkillsDir}`));
-            }
-            output({
-              agents: detected.map((a) => ({
-                name: a.name,
-                universal: a.universal,
-                projectSkillsDir: a.projectSkillsDir,
-                globalSkillsDir: a.globalSkillsDir
-              }))
-            });
-          }
-        })
-      ]
-    });
-    context.registerCommand(skillsGroup);
-  }
-}));
-// bunli.config.ts
-var bunliConfig = defineConfig({
-  name: package_default.name,
-  version: package_default.version,
-  description: package_default.description,
-  commands: {
-    entry: "./src/cli.ts",
-    directory: "./src/commands",
-    generateReport: true
-  },
-  build: {
-    entry: "./src/cli.ts",
-    outdir: "./dist-bunli",
-    sourcemap: true
-  },
-  test: {
-    pattern: ["tests/*.test.ts"],
-    coverage: false,
-    watch: false
-  },
-  tui: {
-    renderer: {
-      bufferMode: "alternate"
-    }
-  }
-});
-
-// src/command-contract.ts
-import path from "path";
-var SHARED_OPTION_PARSER = buildCommandOptionParser(ALL_COMMAND_OPTION_METADATA);
-var STRING_OPTION_NAMES_BY_GROUP = Object.fromEntries(Object.entries(COMMAND_OPTION_METADATA_BY_GROUP).map(([groupName, metadata]) => [
-  groupName,
-  new Set(collectOptionNamesByType(metadata, "string"))
-]));
-var STRING_OPTION_NAMES_BY_COMMAND = Object.fromEntries(WP_TYPIA_RESERVED_TOP_LEVEL_COMMAND_NAMES.map((commandName) => [
-  commandName,
-  new Set(WP_TYPIA_COMMAND_OPTION_GROUP_NAMES_BY_TOP_LEVEL_COMMAND[commandName].flatMap((groupName) => Array.from(STRING_OPTION_NAMES_BY_GROUP[groupName])))
-]));
-var GLOBAL_STRING_OPTION_NAMES = new Set(collectOptionNamesByType(GLOBAL_OPTION_METADATA, "string"));
-var SHORT_OPTION_NAMES_WITH_VALUES = new Set([...SHARED_OPTION_PARSER.shortFlagMap.entries()].filter(([, option]) => option.type === "string").map(([short]) => short));
-function isReservedTopLevelCommandName(value) {
-  return WP_TYPIA_RESERVED_TOP_LEVEL_COMMAND_NAMES.includes(value);
-}
-function assertStringOptionValues(argv) {
-  const firstPositionalIndex = findFirstPositionalIndex(argv, COMMAND_ROUTING_METADATA);
-  if (firstPositionalIndex === -1) {
-    return;
-  }
-  const commandName = argv[firstPositionalIndex];
-  const stringOptionNames = new Set(GLOBAL_STRING_OPTION_NAMES);
-  for (const optionName of STRING_OPTION_NAMES_BY_COMMAND[commandName] ?? []) {
-    stringOptionNames.add(optionName);
-  }
-  for (let index = firstPositionalIndex + 1;index < argv.length; index += 1) {
-    const arg = argv[index];
-    if (arg === "--") {
-      break;
-    }
-    if (arg.length === 2 && arg.startsWith("-")) {
-      if (SHORT_OPTION_NAMES_WITH_VALUES.has(arg.slice(1))) {
-        const next2 = argv[index + 1];
-        if (!next2 || next2.startsWith("-")) {
-          throw createMissingOptionValueError(arg);
-        }
-        index += 1;
-      }
-      continue;
-    }
-    if (!arg.startsWith("--")) {
-      continue;
-    }
-    const [rawName, inlineValue] = arg.slice(2).split("=", 2);
-    if (!stringOptionNames.has(rawName)) {
-      continue;
-    }
-    if (arg.includes("=")) {
-      if (!inlineValue) {
-        throw createMissingOptionValueError(`--${rawName}`);
-      }
-      continue;
-    }
-    const next = argv[index + 1];
-    if (!next || next.startsWith("-")) {
-      throw createMissingOptionValueError(`--${rawName}`);
-    }
-    index += 1;
-  }
-}
-function isWindowsDrivePath(value) {
-  return /^[A-Za-z]:([\\/]|$)/.test(value);
-}
-function looksLikeStructuredProjectInput(value) {
-  if (value.includes("#")) {
-    return true;
-  }
-  if (!isWindowsDrivePath(value) && /^[A-Za-z][A-Za-z0-9+.-]*:/u.test(value)) {
-    return true;
-  }
-  return value.startsWith("@") && value.includes("/");
-}
-function assertPositionalAliasProjectDir(projectDir) {
-  const normalizedProjectDir = path.normalize(projectDir).replace(/[\\/]+$/u, "") || path.normalize(projectDir);
-  if (normalizedProjectDir === "." || normalizedProjectDir === "..") {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `The positional alias does not scaffold into \`${projectDir}\`. Use \`${WP_TYPIA_CANONICAL_CREATE_USAGE}\` with an explicit child directory instead.`);
-  }
-  if (looksLikeStructuredProjectInput(projectDir)) {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `The positional alias only accepts unambiguous local project directories. Use \`${WP_TYPIA_CANONICAL_CREATE_USAGE}\` for \`${projectDir}\`.`);
-  }
-}
-function normalizeWpTypiaArgv(argv) {
-  const positionalIndexes = collectPositionalIndexes(argv, COMMAND_ROUTING_METADATA);
-  const firstPositionalIndex = positionalIndexes[0] ?? -1;
-  if (firstPositionalIndex === -1) {
-    return argv;
-  }
-  const firstPositional = argv[firstPositionalIndex];
-  if (!firstPositional) {
-    return argv;
-  }
-  if (firstPositional === "migrations") {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, "`wp-typia migrations` was removed in favor of `wp-typia migrate`. Use `wp-typia migrate <subcommand>` instead.");
-  }
-  if (isReservedTopLevelCommandName(firstPositional)) {
-    assertStringOptionValues(argv);
-    return argv;
-  }
-  if (positionalIndexes.length > 1) {
-    const extraPositionals = positionalIndexes.slice(1).map((index) => argv[index]).filter((value) => typeof value === "string" && value.length > 0);
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `The positional alias only accepts a single project directory. Use \`${WP_TYPIA_CANONICAL_CREATE_USAGE}\` for scaffold invocations with additional positional arguments, or check the command spelling if you meant another top-level command. Extra positional arguments: ${extraPositionals.map((value) => `\`${value}\``).join(", ")}.`);
-  }
-  assertPositionalAliasProjectDir(firstPositional);
-  const normalizedArgv = [
-    ...argv.slice(0, firstPositionalIndex),
-    "create",
-    ...argv.slice(firstPositionalIndex)
-  ];
-  assertStringOptionValues(normalizedArgv);
-  return normalizedArgv;
-}
-
-// src/config-override.ts
-var GLOBAL_OPTION_PARSER = buildCommandOptionParser(GLOBAL_OPTION_METADATA);
-function extractWpTypiaConfigOverride(argv) {
-  const { argv: nextArgv, flags } = extractKnownOptionValuesFromArgv(argv, {
-    optionNames: ["config"],
-    parser: GLOBAL_OPTION_PARSER
-  });
-  return {
-    argv: nextArgv,
-    configOverridePath: typeof flags.config === "string" ? flags.config : undefined
-  };
-}
-
-// src/plugins/wp-typia-skills.ts
-function createWpTypiaSkillsMetadataPlugin(commands) {
-  return {
-    name: "wp-typia-skills-metadata",
-    setup(context) {
-      context.store.set("_skillsCommands", new Map(commands.map((command) => [command.name, command])));
-      context.store.set("_skillsCliName", "wp-typia");
-    }
-  };
-}
-
-// src/plugins/wp-typia-user-config.ts
-var wpTypiaUserConfigPlugin = createPlugin((options = {}) => {
-  let resolvedConfig = {};
-  return {
-    name: "wp-typia-user-config",
-    async setup(context) {
-      resolvedConfig = await loadWpTypiaUserConfig(context.paths.cwd);
-      if (options.overrideSource) {
-        const overrideConfig = await loadWpTypiaUserConfigFromSource(context.paths.cwd, options.overrideSource);
-        resolvedConfig = mergeWpTypiaUserConfig(resolvedConfig, overrideConfig);
-      }
-    },
-    beforeCommand(context) {
-      context.store.wpTypiaUserConfig = resolvedConfig;
-    }
-  };
-});
-
-// src/cli.ts
-function applyStandaloneSupportLayoutEnv() {
-  if (process.env.WP_TYPIA_PROJECT_TOOLS_PACKAGE_ROOT) {
-    return;
-  }
-  const executableDir = path2.dirname(process.execPath);
-  const candidateRoots = [
-    path2.join(executableDir, ".wp-typia", "share", "wp-typia-project-tools"),
-    path2.resolve(executableDir, "..", ".wp-typia", "share", "wp-typia-project-tools")
-  ];
-  for (const candidateRoot of candidateRoots) {
-    if (fs.existsSync(path2.join(candidateRoot, "package.json"))) {
-      process.env.WP_TYPIA_PROJECT_TOOLS_PACKAGE_ROOT = candidateRoot;
-      return;
-    }
-  }
-}
-function resolveGeneratedMetadataPath(moduleUrl) {
-  const candidates = [
-    new URL("./.bunli/commands.gen.js", moduleUrl),
-    new URL("../lib/.bunli/commands.gen.js", moduleUrl),
-    new URL("../.bunli/commands.gen.ts", moduleUrl)
-  ];
-  for (const candidate of candidates) {
-    const candidatePath = fileURLToPath(candidate);
-    if (fs.existsSync(candidatePath)) {
-      return candidatePath;
-    }
-  }
-  return fileURLToPath(new URL("../.bunli/commands.gen.ts", moduleUrl));
-}
-async function formatCliError(error) {
-  try {
-    const { formatCliDiagnosticError } = await import("./cli-diagnostics-10drxh34.js");
-    return formatCliDiagnosticError(error);
-  } catch {
-    return error instanceof Error ? error.message : String(error);
-  }
-}
-async function createWpTypiaCli(options = {}) {
-  applyStandaloneSupportLayoutEnv();
-  const { wpTypiaCommands } = await import("./command-list-y3g7e9rb.js");
-  const cli = await createCLI({
-    ...bunliConfig,
-    description: package_default.description,
-    name: package_default.name,
-    plugins: [
-      configMergerPlugin({
-        mergeStrategy: "deep",
-        sources: [...WP_TYPIA_CONFIG_SOURCES]
-      }),
-      wpTypiaUserConfigPlugin({
-        overrideSource: options.configOverridePath
-      }),
-      aiAgentPlugin({}),
-      createWpTypiaSkillsMetadataPlugin(wpTypiaCommands),
-      skillsPlugin({
-        description: package_default.description
-      }),
-      completionsPlugin({
-        commandName: "wp-typia",
-        executable: "wp-typia",
-        generatedPath: resolveGeneratedMetadataPath(import.meta.url)
-      })
-    ],
-    version: package_default.version
-  });
-  for (const command of wpTypiaCommands) {
-    cli.command(command);
-  }
-  return cli;
-}
-async function main(argv = process.argv.slice(2)) {
-  const normalizedArgv = normalizeWpTypiaArgv(argv);
-  const { argv: cliArgv, configOverridePath } = extractWpTypiaConfigOverride(normalizedArgv);
-  validateCliOutputFormatArgv(cliArgv);
-  const cli = await createWpTypiaCli({ configOverridePath });
-  await cli.run(normalizeCliOutputFormatArgv(cliArgv));
-}
-async function runCliEntrypoint(argv = process.argv.slice(2)) {
-  try {
-    await main(argv);
-  } catch (error) {
-    if (writeStructuredCliDiagnosticError(argv, error)) {
-      return;
-    }
-    console.error(`Error: ${await formatCliError(error)}`);
-    process.exitCode = 1;
-  }
-}
-if (import.meta.main) {
-  runCliEntrypoint();
-}
-var cli_default = createWpTypiaCli;
-export {
-  runCliEntrypoint,
-  main,
-  cli_default as default,
-  createWpTypiaCli
-};
-
-//# debugId=C2A72BC9D07456AF64756E2164756E21