@clerc/plugin-completions 1.0.2 → 1.1.0

package/README.md

@@ -2,23 +2,9 @@
 
 [![NPM version](https://img.shields.io/npm/v/@clerc/plugin-completions?color=a1b858&label=)](https://www.npmjs.com/package/@clerc/plugin-completions)
 
-Clerc plugin to add shell completions to your cli.
+## Documenation
 
-## 📦 Installation
-
-```bash
-$ npm install @clerc/plugin-completions
-$ yarn add @clerc/plugin-completions
-$ pnpm add @clerc/plugin-completions
-```
-
-## 🚀 Usage
-
-```ts
-import { completionsPlugin } from "@clerc/plugin-completions";
-
-cli.use(completionsPlugin());
-```
+Read the [documentation](https://clerc.so1ve.dev/official-plugins/plugin-completions.html) for more details.
 
 ## 📝 License
 

package/dist/{index.d.ts → index.d.mts}

@@ -1,5 +1,5 @@
-import { ArgumentHandler, Command, OptionHandler } from "@bomb.sh/tab";
 import { Plugin } from "@clerc/core";
+import { ArgumentHandler, Command, OptionHandler } from "@bomb.sh/tab";
 
 //#region src/index.d.ts
 declare module "@clerc/core" {

package/dist/index.mjs

@@ -0,0 +1,1028 @@
+import e from "node:assert";
+import { Types, definePlugin, extractParameterInfo, normalizeFlagValue, normalizeParameterValue } from "@clerc/core";
+
+//#region ../../node_modules/.pnpm/@bomb.sh+tab@0.0.10_cac@6.7.14_citty@0.1.6/node_modules/@bomb.sh/tab/dist/t-Chww2rEs.js
+function t(e$1, t$1) {
+	return `#compdef ${e$1}
+compdef _${e$1} ${e$1}
+
+# zsh completion for ${e$1} -*- shell-script -*-
+
+__${e$1}_debug() {
+    local file="$BASH_COMP_DEBUG_FILE"
+    if [[ -n \${file} ]]; then
+        echo "$*" >> "\${file}"
+    fi
+}
+
+_${e$1}() {
+    local shellCompDirectiveError=${a.ShellCompDirectiveError}
+    local shellCompDirectiveNoSpace=${a.ShellCompDirectiveNoSpace}
+    local shellCompDirectiveNoFileComp=${a.ShellCompDirectiveNoFileComp}
+    local shellCompDirectiveFilterFileExt=${a.ShellCompDirectiveFilterFileExt}
+    local shellCompDirectiveFilterDirs=${a.ShellCompDirectiveFilterDirs}
+    local shellCompDirectiveKeepOrder=${a.ShellCompDirectiveKeepOrder}
+
+    local lastParam lastChar flagPrefix requestComp out directive comp lastComp noSpace keepOrder
+    local -a completions
+
+    __${e$1}_debug "\\n========= starting completion logic =========="
+    __${e$1}_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]}" )
+    __${e$1}_debug "Truncated words[*]: \${words[*]},"
+
+    lastParam=\${words[-1]}
+    lastChar=\${lastParam[-1]}
+    __${e$1}_debug "lastParam: \${lastParam}, lastChar: \${lastChar}"
+
+    # For zsh, when completing a flag with an = (e.g., ${e$1} -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.
+        __${e$1}_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="${t$1} complete -- \${quoted_args[*]}"
+
+    __${e$1}_debug "About to call: eval \${requestComp}"
+
+    # Use eval to handle any environment variables and such
+    out=$(eval \${requestComp} 2>/dev/null)
+    __${e$1}_debug "completion output: \${out}"
+
+    # Extract the directive integer following a : from the last line
+    local lastLine
+    while IFS='\n' read -r line; do
+        lastLine=\${line}
+    done < <(printf "%s\n" "\${out[@]}")
+    __${e$1}_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.
+        __${e$1}_debug "No directive found.  Setting to default"
+        directive=0
+    fi
+
+    __${e$1}_debug "directive: \${directive}"
+    __${e$1}_debug "completions: \${out}"
+    __${e$1}_debug "flagPrefix: \${flagPrefix}"
+
+    if [ $((directive & shellCompDirectiveError)) -ne 0 ]; then
+        __${e$1}_debug "Completion received error. Ignoring completions."
+        return
+    fi
+
+    local activeHelpMarker="%"
+    local endIndex=\${#activeHelpMarker}
+    local startIndex=$((\${#activeHelpMarker}+1))
+    local hasActiveHelp=0
+    while IFS='\n' read -r comp; do
+        # Check if this is an activeHelp statement (i.e., prefixed with $activeHelpMarker)
+        if [ "\${comp[1,$endIndex]}" = "$activeHelpMarker" ];then
+            __${e$1}_debug "ActiveHelp found: $comp"
+            comp="\${comp[$startIndex,-1]}"
+            if [ -n "$comp" ]; then
+                compadd -x "\${comp}"
+                __${e$1}_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/:}
+
+            __${e$1}_debug "Adding completion: \${comp}"
+            completions+=\${comp}
+            lastComp=$comp
+        fi
+    done < <(printf "%s\n" "\${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
+            __${e$1}_debug "Adding activeHelp delimiter"
+            compadd -x "--"
+            hasActiveHelp=0
+        fi
+    fi
+
+    if [ $((directive & shellCompDirectiveNoSpace)) -ne 0 ]; then
+        __${e$1}_debug "Activating nospace."
+        noSpace="-S ''"
+    fi
+
+    if [ $((directive & shellCompDirectiveKeepOrder)) -ne 0 ]; then
+        __${e$1}_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}"
+
+        __${e$1}_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
+            __${e$1}_debug "Listing directories in $subdir"
+            pushd "\${subdir}" >/dev/null 2>&1
+        else
+            __${e$1}_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
+        __${e$1}_debug "Calling _describe"
+        if eval _describe $keepOrder "completions" completions -Q \${flagPrefix} \${noSpace}; then
+            __${e$1}_debug "_describe found some completions"
+
+            # Return the success of having called _describe
+            return 0
+        else
+            __${e$1}_debug "_describe did not find completions."
+            __${e$1}_debug "Checking if we should do file completion."
+            if [ $((directive & shellCompDirectiveNoFileComp)) -ne 0 ]; then
+                __${e$1}_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
+                __${e$1}_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]}" = "_${e$1}" ]; then
+    _${e$1}
+fi
+`;
+}
+function n(e$1, t$1) {
+	let n$1 = e$1.replace(/[-:]/g, `_`);
+	return `# bash completion for ${e$1}
+
+# Define shell completion directives
+readonly ShellCompDirectiveError=${a.ShellCompDirectiveError}
+readonly ShellCompDirectiveNoSpace=${a.ShellCompDirectiveNoSpace}
+readonly ShellCompDirectiveNoFileComp=${a.ShellCompDirectiveNoFileComp}
+readonly ShellCompDirectiveFilterFileExt=${a.ShellCompDirectiveFilterFileExt}
+readonly ShellCompDirectiveFilterDirs=${a.ShellCompDirectiveFilterDirs}
+readonly ShellCompDirectiveKeepOrder=${a.ShellCompDirectiveKeepOrder}
+
+# Function to debug completion
+__${n$1}_debug() {
+    if [[ -n \${BASH_COMP_DEBUG_FILE:-} ]]; then
+        echo "$*" >> "\${BASH_COMP_DEBUG_FILE}"
+    fi
+}
+
+# Function to handle completions
+__${n$1}_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="${t$1} 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 __${n$1}_complete ${e$1}
+`;
+}
+function r(e$1, t$1) {
+	let n$1 = e$1.replace(/[-:]/g, `_`);
+	return `# fish completion for ${e$1} -*- shell-script -*-
+
+# Define shell completion directives
+set -l ShellCompDirectiveError ${a.ShellCompDirectiveError}
+set -l ShellCompDirectiveNoSpace ${a.ShellCompDirectiveNoSpace}
+set -l ShellCompDirectiveNoFileComp ${a.ShellCompDirectiveNoFileComp}
+set -l ShellCompDirectiveFilterFileExt ${a.ShellCompDirectiveFilterFileExt}
+set -l ShellCompDirectiveFilterDirs ${a.ShellCompDirectiveFilterDirs}
+set -l ShellCompDirectiveKeepOrder ${a.ShellCompDirectiveKeepOrder}
+
+function __${n$1}_debug
+    set -l file "$BASH_COMP_DEBUG_FILE"
+    if test -n "$file"
+        echo "$argv" >> $file
+    end
+end
+
+function __${n$1}_perform_completion
+    __${n$1}_debug "Starting __${n$1}_perform_completion"
+
+    # Extract all args except the completion flag
+    set -l args (string match -v -- "--completion=" (commandline -opc))
+    
+    # Extract the current token being completed
+    set -l current_token (commandline -ct)
+    
+    # Check if current token starts with a dash
+    set -l flag_prefix ""
+    if string match -q -- "-*" $current_token
+        set flag_prefix "--flag="
+    end
+    
+    __${n$1}_debug "Current token: $current_token"
+    __${n$1}_debug "All args: $args"
+
+    # Call the completion program and get the results
+    set -l requestComp "${t$1} complete -- $args"
+    __${n$1}_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 sub -s 1 -l 1 -- $line) = ":"
+            # The directive
+            set -l directive (string sub -s 2 -- $line)
+            set -l directive_num (math $directive)
+            break
+        end
+    end
+    
+    # No directive specified, use default
+    if not set -q directive_num
+        set directive_num 0
+    end
+    
+    __${n$1}_debug "Directive: $directive_num"
+
+    # Process completions based on directive
+    if test $directive_num -eq $ShellCompDirectiveError
+        # Error code. No completion.
+        __${n$1}_debug "Received error directive: aborting."
+        return 1
+    end
+
+    # Filter out the directive (last line)
+    if test (count $results) -gt 0 -a (string sub -s 1 -l 1 -- $results[-1]) = ":"
+        set results $results[1..-2]
+    end
+
+    # No completions, let fish handle file completions unless forbidden
+    if test (count $results) -eq 0
+        if test $directive_num -ne $ShellCompDirectiveNoFileComp
+            __${n$1}_debug "No completions, performing file completion"
+            return 1
+        end
+        __${n$1}_debug "No completions, but file completion forbidden"
+        return 0
+    end
+
+    # Filter file extensions
+    if test $directive_num -eq $ShellCompDirectiveFilterFileExt
+        __${n$1}_debug "File extension filtering"
+        set -l file_extensions
+        for item in $results
+            if test -n "$item" -a (string sub -s 1 -l 1 -- $item) != "-"
+                set -a file_extensions "*$item"
+            end
+        end
+        __${n$1}_debug "File extensions: $file_extensions"
+        
+        # Use the file extensions as completions
+        set -l completions
+        for ext in $file_extensions
+            # Get all files matching the extension
+            set -a completions (string replace -r '^.*/' '' -- $ext)
+        end
+        
+        for item in $completions
+            echo -e "$item\t"
+        end
+        return 0
+    end
+
+    # Filter directories
+    if test $directive_num -eq $ShellCompDirectiveFilterDirs
+        __${n$1}_debug "Directory filtering"
+        set -l dirs
+        for item in $results
+            if test -d "$item"
+                set -a dirs "$item/"
+            end
+        end
+        
+        for item in $dirs
+            echo -e "$item\t"
+        end
+        return 0
+    end
+
+    # Process remaining completions
+    for item in $results
+        if test -n "$item"
+            # Check if the item has a description
+            if string match -q "*\t*" -- "$item"
+                set -l completion_parts (string split \t -- "$item")
+                set -l comp $completion_parts[1]
+                set -l desc $completion_parts[2]
+                
+                # Add the completion and description
+                echo -e "$comp\t$desc"
+            else
+                # Add just the completion
+                echo -e "$item\t"
+            end
+        end
+    end
+    
+    # If directive contains NoSpace, tell fish not to add a space after completion
+    if test (math "$directive_num & $ShellCompDirectiveNoSpace") -ne 0
+        return 2
+    end
+    
+    return 0
+end
+
+# Set up the completion for the ${e$1} command
+complete -c ${e$1} -f -a "(eval __${n$1}_perform_completion)"
+`;
+}
+function i(e$1, t$1) {
+	let n$1 = e$1.replace(/[-:]/g, `_`);
+	return `# powershell completion for ${e$1} -*- shell-script -*-
+
+  [Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+    function __${e$1}_debug {
+        if ($env:BASH_COMP_DEBUG_FILE) {
+            "$args" | Out-File -Append -FilePath "$env:BASH_COMP_DEBUG_FILE"
+        }
+    }
+
+    filter __${e$1}_escapeStringWithSpecialChars {
+        $_ -replace '\\s|#|@|\\$|;|,|''|\\{|\\}|\\(|\\)|"|\\||<|>|&','\`$&'
+    }
+
+[scriptblock]$__${n$1}CompleterBlock = {
+    param(
+            $WordToComplete,
+            $CommandAst,
+            $CursorPosition
+        )
+
+    # Get the current command line and convert into a string
+    $Command = $CommandAst.CommandElements
+    $Command = "$Command"
+
+    __${e$1}_debug ""
+    __${e$1}_debug "========= starting completion logic =========="
+    __${e$1}_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)
+    }
+    __${e$1}_debug "Truncated command: $Command"
+
+    $ShellCompDirectiveError=${a.ShellCompDirectiveError}
+    $ShellCompDirectiveNoSpace=${a.ShellCompDirectiveNoSpace}
+    $ShellCompDirectiveNoFileComp=${a.ShellCompDirectiveNoFileComp}
+    $ShellCompDirectiveFilterFileExt=${a.ShellCompDirectiveFilterFileExt}
+    $ShellCompDirectiveFilterDirs=${a.ShellCompDirectiveFilterDirs}
+    $ShellCompDirectiveKeepOrder=${a.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)
+
+    $RequestComp = "& ${t$1} complete -- $Arguments"
+    __${e$1}_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]
+    }
+    __${e$1}_debug "New WordToComplete: $WordToComplete"
+
+
+    # Check for flag with equal sign
+    $IsEqualFlag = ($WordToComplete -Like "--*=*" )
+    if ( $IsEqualFlag ) {
+        __${e$1}_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.
+        __${e$1}_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" + ' ""'
+        }
+    }
+
+    __${e$1}_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
+    }
+    __${e$1}_debug "The completion directive is: $Directive"
+
+    # remove directive (last element) from out
+    $Out = $Out | Where-Object { $_ -ne $Out[-1] }
+    __${e$1}_debug "The completions are: $Out"
+
+    if (($Directive -band $ShellCompDirectiveError) -ne 0 ) {
+        # Error code.  No completion.
+        __${e$1}_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)
+        __${e$1}_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
+        __${e$1}_debug "ShellCompDirectiveNoSpace is called"
+        $Space = ""
+    }
+
+    if ((($Directive -band $ShellCompDirectiveFilterFileExt) -ne 0 ) -or
+       (($Directive -band $ShellCompDirectiveFilterDirs) -ne 0 ))  {
+        __${e$1}_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 ) {
+            __${e$1}_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 ) {
+        __${e$1}_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
+    __${e$1}_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) {
+                    __${e$1}_debug "Only one completion left"
+
+                    # insert space after value
+                    [System.Management.Automation.CompletionResult]::new($($comp.Name | __${e$1}_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 | __${e$1}_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 | __${e$1}_escapeStringWithSpecialChars), "$($comp.Name)", 'ParameterValue', "$($comp.Description)")
+            }
+        }
+
+    }
+}
+
+Register-ArgumentCompleter -CommandName '${e$1}' -ScriptBlock $__${n$1}CompleterBlock
+`;
+}
+const a = {
+	ShellCompDirectiveError: 1,
+	ShellCompDirectiveNoSpace: 2,
+	ShellCompDirectiveNoFileComp: 4,
+	ShellCompDirectiveFilterFileExt: 8,
+	ShellCompDirectiveFilterDirs: 16,
+	ShellCompDirectiveKeepOrder: 32,
+	shellCompDirectiveMaxValue: 64,
+	ShellCompDirectiveDefault: 0
+};
+var o = class {
+	name;
+	variadic;
+	command;
+	handler;
+	constructor(e$1, t$1, n$1, r$1 = !1) {
+		this.command = e$1, this.name = t$1, this.handler = n$1, this.variadic = r$1;
+	}
+}, s = class {
+	value;
+	description;
+	command;
+	handler;
+	alias;
+	isBoolean;
+	constructor(e$1, t$1, n$1, r$1, i$1, a$1) {
+		this.command = e$1, this.value = t$1, this.description = n$1, this.handler = r$1, this.alias = i$1, this.isBoolean = a$1;
+	}
+}, c = class {
+	value;
+	description;
+	options = /* @__PURE__ */ new Map();
+	arguments = /* @__PURE__ */ new Map();
+	parent;
+	constructor(e$1, t$1) {
+		this.value = e$1, this.description = t$1;
+	}
+	option(e$1, t$1, n$1, r$1) {
+		let i$1, a$1, o$1;
+		typeof n$1 == `function` ? (i$1 = n$1, a$1 = r$1, o$1 = !1) : typeof n$1 == `string` ? (i$1 = void 0, a$1 = n$1, o$1 = !0) : (i$1 = void 0, a$1 = void 0, o$1 = !0);
+		let c$1 = new s(this, e$1, t$1, i$1, a$1, o$1);
+		return this.options.set(e$1, c$1), this;
+	}
+	argument(e$1, t$1, n$1 = !1) {
+		let r$1 = new o(this, e$1, t$1, n$1);
+		return this.arguments.set(e$1, r$1), this;
+	}
+}, l = class extends c {
+	commands = /* @__PURE__ */ new Map();
+	completions = [];
+	directive = a.ShellCompDirectiveDefault;
+	constructor() {
+		super(``, ``);
+	}
+	command(e$1, t$1) {
+		let n$1 = new c(e$1, t$1);
+		return this.commands.set(e$1, n$1), n$1;
+	}
+	stripOptions(e$1) {
+		let t$1 = [], n$1 = 0;
+		for (; n$1 < e$1.length;) {
+			let r$1 = e$1[n$1];
+			if (r$1.startsWith(`-`)) {
+				n$1++;
+				let t$2 = !1, i$1 = this.findOption(this, r$1);
+				if (i$1) t$2 = i$1.isBoolean ?? !1;
+				else for (let [, e$2] of this.commands) {
+					let n$2 = this.findOption(e$2, r$1);
+					if (n$2) {
+						t$2 = n$2.isBoolean ?? !1;
+						break;
+					}
+				}
+				!t$2 && n$1 < e$1.length && !e$1[n$1].startsWith(`-`) && n$1++;
+			} else t$1.push(r$1), n$1++;
+		}
+		return t$1;
+	}
+	matchCommand(e$1) {
+		e$1 = this.stripOptions(e$1);
+		let t$1 = [], n$1 = [], r$1 = null;
+		for (let i$1 = 0; i$1 < e$1.length; i$1++) {
+			let a$1 = e$1[i$1];
+			t$1.push(a$1);
+			let o$1 = this.commands.get(t$1.join(` `));
+			if (o$1) r$1 = o$1;
+			else {
+				n$1 = e$1.slice(i$1, e$1.length);
+				break;
+			}
+		}
+		return [r$1 || this, n$1];
+	}
+	shouldCompleteFlags(e$1, t$1) {
+		if (t$1.startsWith(`-`)) return !0;
+		if (e$1?.startsWith(`-`)) {
+			let t$2 = this.findOption(this, e$1);
+			if (!t$2) {
+				for (let [, n$1] of this.commands) if (t$2 = this.findOption(n$1, e$1), t$2) break;
+			}
+			return !(t$2 && t$2.isBoolean);
+		}
+		return !1;
+	}
+	shouldCompleteCommands(e$1) {
+		return !e$1.startsWith(`-`);
+	}
+	handleFlagCompletion(e$1, t$1, n$1, r$1) {
+		let i$1;
+		if (n$1.includes(`=`)) {
+			let [e$2] = n$1.split(`=`);
+			i$1 = e$2;
+		} else r$1?.startsWith(`-`) && (i$1 = r$1);
+		if (i$1) {
+			let t$2 = this.findOption(e$1, i$1);
+			if (t$2?.handler) {
+				let n$2 = [];
+				t$2.handler.call(t$2, (e$2, t$3) => n$2.push({
+					value: e$2,
+					description: t$3
+				}), e$1.options), this.completions = n$2;
+			}
+			return;
+		}
+		if (n$1.startsWith(`-`)) {
+			let t$2 = n$1.startsWith(`-`) && !n$1.startsWith(`--`), r$2 = n$1.replace(/^-+/, ``);
+			for (let [i$2, a$1] of e$1.options) t$2 && a$1.alias && `-${a$1.alias}`.startsWith(n$1) ? this.completions.push({
+				value: `-${a$1.alias}`,
+				description: a$1.description
+			}) : !t$2 && i$2.startsWith(r$2) && this.completions.push({
+				value: `--${i$2}`,
+				description: a$1.description
+			});
+		}
+	}
+	findOption(e$1, t$1) {
+		let n$1 = e$1.options.get(t$1);
+		if (n$1 || (n$1 = e$1.options.get(t$1.replace(/^-+/, ``)), n$1)) return n$1;
+		for (let [n$2, r$1] of e$1.options) if (r$1.alias && `-${r$1.alias}` === t$1) return r$1;
+	}
+	handleCommandCompletion(e$1, t$1) {
+		let n$1 = this.stripOptions(e$1);
+		for (let [e$2, r$1] of this.commands) {
+			if (e$2 === ``) continue;
+			let i$1 = e$2.split(` `);
+			i$1.slice(0, n$1.length).every((e$3, t$2) => e$3 === n$1[t$2]) && i$1[n$1.length]?.startsWith(t$1) && this.completions.push({
+				value: i$1[n$1.length],
+				description: r$1.description
+			});
+		}
+	}
+	handlePositionalCompletion(e$1, t$1) {
+		let n$1 = e$1.value.split(` `).length, r$1 = Math.max(0, t$1.length - n$1), i$1 = Array.from(e$1.arguments.entries());
+		if (i$1.length > 0) {
+			let t$2;
+			if (r$1 < i$1.length) {
+				let [e$2, n$2] = i$1[r$1];
+				t$2 = n$2;
+			} else {
+				let e$2 = i$1[i$1.length - 1][1];
+				e$2.variadic && (t$2 = e$2);
+			}
+			if (t$2 && t$2.handler && typeof t$2.handler == `function`) {
+				let n$2 = [];
+				t$2.handler.call(t$2, (e$2, t$3) => n$2.push({
+					value: e$2,
+					description: t$3
+				}), e$1.options), this.completions.push(...n$2);
+			}
+		}
+	}
+	complete(e$1) {
+		this.directive = a.ShellCompDirectiveNoFileComp;
+		let t$1 = /* @__PURE__ */ new Set();
+		this.completions.filter((e$2) => t$1.has(e$2.value) ? !1 : (t$1.add(e$2.value), !0)).filter((t$2) => {
+			if (e$1.includes(`=`)) {
+				let [, n$1] = e$1.split(`=`);
+				return t$2.value.startsWith(n$1);
+			}
+			return t$2.value.startsWith(e$1);
+		}).forEach((e$2) => console.log(`${e$2.value}\t${e$2.description ?? ``}`)), console.log(`:${this.directive}`);
+	}
+	parse(e$1) {
+		this.completions = [];
+		let t$1 = e$1[e$1.length - 1] === ``;
+		t$1 && e$1.pop();
+		let n$1 = e$1[e$1.length - 1] || ``, r$1 = e$1.slice(0, -1);
+		t$1 && (n$1 !== `` && r$1.push(n$1), n$1 = ``);
+		let [i$1] = this.matchCommand(r$1), a$1 = r$1[r$1.length - 1];
+		if (this.shouldCompleteFlags(a$1, n$1)) this.handleFlagCompletion(i$1, r$1, n$1, a$1);
+		else {
+			if (a$1?.startsWith(`-`) && n$1 === `` && t$1) {
+				let e$2 = this.findOption(this, a$1);
+				if (!e$2) {
+					for (let [, t$2] of this.commands) if (e$2 = this.findOption(t$2, a$1), e$2) break;
+				}
+				if (e$2 && e$2.isBoolean) {
+					this.complete(n$1);
+					return;
+				}
+			}
+			this.shouldCompleteCommands(n$1) && this.handleCommandCompletion(r$1, n$1), i$1 && i$1.arguments.size > 0 && this.handlePositionalCompletion(i$1, r$1);
+		}
+		this.complete(n$1);
+	}
+	setup(a$1, o$1, s$1) {
+		switch (e(s$1 === `zsh` || s$1 === `bash` || s$1 === `fish` || s$1 === `powershell`, `Unsupported shell`), s$1) {
+			case `zsh`: {
+				let e$1 = t(a$1, o$1);
+				console.log(e$1);
+				break;
+			}
+			case `bash`: {
+				let e$1 = n(a$1, o$1);
+				console.log(e$1);
+				break;
+			}
+			case `fish`: {
+				let e$1 = r(a$1, o$1);
+				console.log(e$1);
+				break;
+			}
+			case `powershell`: {
+				let e$1 = i(a$1, o$1);
+				console.log(e$1);
+				break;
+			}
+		}
+	}
+};
+const u = new l();
+
+//#endregion
+//#region src/t.ts
+function registerFlag(tc, flagName, def) {
+	const normalized = normalizeFlagValue(def);
+	const desc = normalized.description ?? "";
+	if (normalized.type === Boolean) tc.option(flagName, desc, normalized.short);
+	else {
+		const handler = normalized.completions?.handler ?? (async () => {});
+		tc.option(flagName, desc, handler, normalized.short);
+	}
+}
+function registerGlobalFlags(globalFlags, tc) {
+	for (const [flagName, def] of Object.entries(globalFlags)) registerFlag(tc, flagName, def);
+}
+function buildTabModel(t$1, globalFlags, commands) {
+	registerGlobalFlags(globalFlags, t$1);
+	for (const cmd of commands.values()) {
+		if (cmd.completions?.show === false) continue;
+		let command = t$1;
+		if (cmd.name !== "") {
+			command = t$1.command(cmd.name, cmd.description ?? "");
+			registerGlobalFlags(globalFlags, command);
+		}
+		cmd.completions?.handler?.(command);
+		for (const def of cmd.parameters ?? []) {
+			const normalized = normalizeParameterValue(def);
+			const { name, isVariadic } = extractParameterInfo(normalized.key);
+			command.argument(name, normalized.completions?.handler, isVariadic);
+		}
+		for (const [flagName, def] of Object.entries(cmd.flags ?? {})) registerFlag(command, flagName, def);
+	}
+}
+
+//#endregion
+//#region src/index.ts
+const completionsPlugin = () => definePlugin({ setup: (cli) => {
+	const t$1 = new l();
+	const supportedShellEnum = Types.Enum("zsh", "bash", "fish", "powershell");
+	cli.command("completions", "Generate shell completion scripts", {
+		flags: { shell: {
+			description: "Shell type",
+			type: supportedShellEnum
+		} },
+		parameters: [{
+			key: "[shell]",
+			description: "Shell type",
+			type: supportedShellEnum
+		}]
+	}).on("completions", async (ctx) => {
+		const shell = ctx.parameters.shell ?? ctx.flags.shell;
+		if (!shell) throw new Error("Shell type is required. Please provide it via --shell flag or [shell] parameter.");
+		buildTabModel(t$1, cli._globalFlags, cli._commands);
+		t$1.setup(cli._scriptName, cli._scriptName, shell);
+	});
+	cli.command("complete", {
+		help: { show: false },
+		completions: { show: false },
+		parameters: ["--", "[input...]"]
+	}).on("complete", async (ctx) => {
+		buildTabModel(t$1, cli._globalFlags, cli._commands);
+		const { input } = ctx.parameters;
+		t$1.parse(input);
+	});
+	return cli;
+} });
+
+//#endregion
+export { completionsPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clerc/plugin-completions",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "author": "Ray <i@mk1.io> (https://github.com/so1ve)",
   "type": "module",
   "description": "Clerc plugin completions",
@@ -25,34 +25,24 @@
   "license": "MIT",
   "sideEffects": false,
   "exports": {
-    ".": "./dist/index.js"
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
   },
   "bin": {
     "my-cli": "./src/a.mjs"
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "dist/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "*": [
-        "./dist/*",
-        "./dist/index.d.ts"
-      ]
-    }
-  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "files": [
     "dist"
   ],
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "@bomb.sh/tab": "^0.0.10"
-  },
   "devDependencies": {
-    "@clerc/utils": "1.0.2",
-    "@clerc/core": "1.0.2"
+    "@bomb.sh/tab": "^0.0.10",
+    "@clerc/core": "1.1.0"
   },
   "peerDependencies": {
     "@clerc/core": "*"

package/dist/index.js

@@ -1,70 +0,0 @@
-import { RootCommand } from "@bomb.sh/tab";
-import { Types, definePlugin, extractParameterInfo, normalizeFlagValue, normalizeParameterValue } from "@clerc/core";
-
-//#region src/t.ts
-function registerFlag(tc, flagName, def) {
-	const normalized = normalizeFlagValue(def);
-	const desc = normalized.description ?? "";
-	if (normalized.type === Boolean) tc.option(flagName, desc, normalized.short);
-	else {
-		const handler = normalized.completions?.handler ?? (async () => {});
-		tc.option(flagName, desc, handler, normalized.short);
-	}
-}
-function registerGlobalFlags(globalFlags, tc) {
-	for (const [flagName, def] of Object.entries(globalFlags)) registerFlag(tc, flagName, def);
-}
-function buildTabModel(t, globalFlags, commands) {
-	registerGlobalFlags(globalFlags, t);
-	for (const cmd of commands.values()) {
-		if (cmd.completions?.show === false) continue;
-		let command = t;
-		if (cmd.name !== "") {
-			command = t.command(cmd.name, cmd.description ?? "");
-			registerGlobalFlags(globalFlags, command);
-		}
-		cmd.completions?.handler?.(command);
-		for (const def of cmd.parameters ?? []) {
-			const normalized = normalizeParameterValue(def);
-			const { name, isVariadic } = extractParameterInfo(normalized.key);
-			command.argument(name, normalized.completions?.handler, isVariadic);
-		}
-		for (const [flagName, def] of Object.entries(cmd.flags ?? {})) registerFlag(command, flagName, def);
-	}
-}
-
-//#endregion
-//#region src/index.ts
-const completionsPlugin = () => definePlugin({ setup: (cli) => {
-	const t = new RootCommand();
-	const supportedShellEnum = Types.Enum("zsh", "bash", "fish", "powershell");
-	cli.command("completions", "Generate shell completion scripts", {
-		flags: { shell: {
-			description: "Shell type",
-			type: supportedShellEnum
-		} },
-		parameters: [{
-			key: "[shell]",
-			description: "Shell type",
-			type: supportedShellEnum
-		}]
-	}).on("completions", async (ctx) => {
-		const shell = ctx.parameters.shell ?? ctx.flags.shell;
-		if (!shell) throw new Error("Shell type is required. Please provide it via --shell flag or [shell] parameter.");
-		buildTabModel(t, cli._globalFlags, cli._commands);
-		t.setup(cli._scriptName, cli._scriptName, shell);
-	});
-	cli.command("complete", {
-		help: { show: false },
-		completions: { show: false },
-		parameters: ["--", "[input...]"]
-	}).on("complete", async (ctx) => {
-		buildTabModel(t, cli._globalFlags, cli._commands);
-		const { input } = ctx.parameters;
-		t.parse(input);
-	});
-	return cli;
-} });
-
-//#endregion
-export { completionsPlugin };