@react-grab/cli 0.0.97 → 0.0.98

package/dist/cli.cjs

@@ -2,6 +2,7 @@
 'use strict';
 
 var commander = require('commander');
+var e = require('assert');
 var pc = require('picocolors');
 var prompts3 = require('prompts');
 var child_process = require('child_process');
@@ -14,10 +15,1041 @@ var httpProxyMiddleware = require('http-proxy-middleware');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+var e__default = /*#__PURE__*/_interopDefault(e);
 var pc__default = /*#__PURE__*/_interopDefault(pc);
 var prompts3__default = /*#__PURE__*/_interopDefault(prompts3);
 var ora__default = /*#__PURE__*/_interopDefault(ora);
 
+function t(e3, t2) {
+  return `#compdef ${e3}
+compdef _${e3} ${e3}
+
+# zsh completion for ${e3} -*- shell-script -*-
+
+__${e3}_debug() {
+    local file="$BASH_COMP_DEBUG_FILE"
+    if [[ -n \${file} ]]; then
+        echo "$*" >> "\${file}"
+    fi
+}
+
+_${e3}() {
+    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
+
+    __${e3}_debug "\\n========= starting completion logic =========="
+    __${e3}_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]}" )
+    __${e3}_debug "Truncated words[*]: \${words[*]},"
+
+    lastParam=\${words[-1]}
+    lastChar=\${lastParam[-1]}
+    __${e3}_debug "lastParam: \${lastParam}, lastChar: \${lastChar}"
+
+    # For zsh, when completing a flag with an = (e.g., ${e3} -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.
+        __${e3}_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="${t2} complete -- \${quoted_args[*]}"
+
+    __${e3}_debug "About to call: eval \${requestComp}"
+
+    # Use eval to handle any environment variables and such
+    out=$(eval \${requestComp} 2>/dev/null)
+    __${e3}_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[@]}")
+    __${e3}_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.
+        __${e3}_debug "No directive found.  Setting to default"
+        directive=0
+    fi
+
+    __${e3}_debug "directive: \${directive}"
+    __${e3}_debug "completions: \${out}"
+    __${e3}_debug "flagPrefix: \${flagPrefix}"
+
+    if [ $((directive & shellCompDirectiveError)) -ne 0 ]; then
+        __${e3}_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
+            __${e3}_debug "ActiveHelp found: $comp"
+            comp="\${comp[$startIndex,-1]}"
+            if [ -n "$comp" ]; then
+                compadd -x "\${comp}"
+                __${e3}_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/:}
+
+            __${e3}_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
+            __${e3}_debug "Adding activeHelp delimiter"
+            compadd -x "--"
+            hasActiveHelp=0
+        fi
+    fi
+
+    if [ $((directive & shellCompDirectiveNoSpace)) -ne 0 ]; then
+        __${e3}_debug "Activating nospace."
+        noSpace="-S ''"
+    fi
+
+    if [ $((directive & shellCompDirectiveKeepOrder)) -ne 0 ]; then
+        __${e3}_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}"
+
+        __${e3}_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
+            __${e3}_debug "Listing directories in $subdir"
+            pushd "\${subdir}" >/dev/null 2>&1
+        else
+            __${e3}_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
+        __${e3}_debug "Calling _describe"
+        if eval _describe $keepOrder "completions" completions -Q \${flagPrefix} \${noSpace}; then
+            __${e3}_debug "_describe found some completions"
+
+            # Return the success of having called _describe
+            return 0
+        else
+            __${e3}_debug "_describe did not find completions."
+            __${e3}_debug "Checking if we should do file completion."
+            if [ $((directive & shellCompDirectiveNoFileComp)) -ne 0 ]; then
+                __${e3}_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
+                __${e3}_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]}" = "_${e3}" ]; then
+    _${e3}
+fi
+`;
+}
+function n(e3, t2) {
+  let n2 = e3.replace(/[-:]/g, `_`);
+  return `# bash completion for ${e3}
+
+# 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
+__${n2}_debug() {
+    if [[ -n \${BASH_COMP_DEBUG_FILE:-} ]]; then
+        echo "$*" >> "\${BASH_COMP_DEBUG_FILE}"
+    fi
+}
+
+# Function to handle completions
+__${n2}_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="${t2} 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 __${n2}_complete ${e3}
+`;
+}
+function r(e3, t2) {
+  let n2 = e3.replace(/[-:]/g, `_`);
+  return `# fish completion for ${e3} -*- 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 __${n2}_debug
+    set -l file "$BASH_COMP_DEBUG_FILE"
+    if test -n "$file"
+        echo "$argv" >> $file
+    end
+end
+
+function __${n2}_perform_completion
+    __${n2}_debug "Starting __${n2}_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
+    
+    __${n2}_debug "Current token: $current_token"
+    __${n2}_debug "All args: $args"
+
+    # Call the completion program and get the results
+    set -l requestComp "${t2} complete -- $args"
+    __${n2}_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
+    
+    __${n2}_debug "Directive: $directive_num"
+
+    # Process completions based on directive
+    if test $directive_num -eq $ShellCompDirectiveError
+        # Error code. No completion.
+        __${n2}_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
+            __${n2}_debug "No completions, performing file completion"
+            return 1
+        end
+        __${n2}_debug "No completions, but file completion forbidden"
+        return 0
+    end
+
+    # Filter file extensions
+    if test $directive_num -eq $ShellCompDirectiveFilterFileExt
+        __${n2}_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
+        __${n2}_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	"
+        end
+        return 0
+    end
+
+    # Filter directories
+    if test $directive_num -eq $ShellCompDirectiveFilterDirs
+        __${n2}_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	"
+        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 "*	*" -- "$item"
+                set -l completion_parts (string split 	 -- "$item")
+                set -l comp $completion_parts[1]
+                set -l desc $completion_parts[2]
+                
+                # Add the completion and description
+                echo -e "$comp	$desc"
+            else
+                # Add just the completion
+                echo -e "$item	"
+            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 ${e3} command
+complete -c ${e3} -f -a "(eval __${n2}_perform_completion)"
+`;
+}
+function i(e3, t2) {
+  let n2 = e3.replace(/[-:]/g, `_`);
+  return `# powershell completion for ${e3} -*- shell-script -*-
+
+  [Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+    function __${e3}_debug {
+        if ($env:BASH_COMP_DEBUG_FILE) {
+            "$args" | Out-File -Append -FilePath "$env:BASH_COMP_DEBUG_FILE"
+        }
+    }
+
+    filter __${e3}_escapeStringWithSpecialChars {
+        $_ -replace '\\s|#|@|\\$|;|,|''|\\{|\\}|\\(|\\)|"|\\||<|>|&','\`$&'
+    }
+
+[scriptblock]$__${n2}CompleterBlock = {
+    param(
+            $WordToComplete,
+            $CommandAst,
+            $CursorPosition
+        )
+
+    # Get the current command line and convert into a string
+    $Command = $CommandAst.CommandElements
+    $Command = "$Command"
+
+    __${e3}_debug ""
+    __${e3}_debug "========= starting completion logic =========="
+    __${e3}_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)
+    }
+    __${e3}_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)
+
+    $QuotedArgs = ($Arguments -split ' ' | ForEach-Object { "'" + ($_ -replace "'", "''") + "'" }) -join ' '
+    __${e3}_debug "QuotedArgs: $QuotedArgs"
+
+    $RequestComp = "& ${t2} complete '--' $QuotedArgs"
+    __${e3}_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]
+    }
+    __${e3}_debug "New WordToComplete: $WordToComplete"
+
+
+    # Check for flag with equal sign
+    $IsEqualFlag = ($WordToComplete -Like "--*=*" )
+    if ( $IsEqualFlag ) {
+        __${e3}_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.
+        __${e3}_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" + ' ""'
+        }
+    }
+
+    __${e3}_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
+    }
+    __${e3}_debug "The completion directive is: $Directive"
+
+    # remove directive (last element) from out
+    $Out = $Out | Where-Object { $_ -ne $Out[-1] }
+    __${e3}_debug "The completions are: $Out"
+
+    if (($Directive -band $ShellCompDirectiveError) -ne 0 ) {
+        # Error code.  No completion.
+        __${e3}_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)
+        __${e3}_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
+        __${e3}_debug "ShellCompDirectiveNoSpace is called"
+        $Space = ""
+    }
+
+    if ((($Directive -band $ShellCompDirectiveFilterFileExt) -ne 0 ) -or
+       (($Directive -band $ShellCompDirectiveFilterDirs) -ne 0 ))  {
+        __${e3}_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 ) {
+            __${e3}_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 ) {
+        __${e3}_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
+    __${e3}_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) {
+                    __${e3}_debug "Only one completion left"
+
+                    # insert space after value
+                    [System.Management.Automation.CompletionResult]::new($($comp.Name | __${e3}_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 | __${e3}_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 | __${e3}_escapeStringWithSpecialChars), "$($comp.Name)", 'ParameterValue', "$($comp.Description)")
+            }
+        }
+
+    }
+}
+
+Register-ArgumentCompleter -CommandName '${e3}' -ScriptBlock $__${n2}CompleterBlock
+`;
+}
+var a = { ShellCompDirectiveError: 1, ShellCompDirectiveNoSpace: 2, ShellCompDirectiveNoFileComp: 4, ShellCompDirectiveFilterFileExt: 8, ShellCompDirectiveFilterDirs: 16, ShellCompDirectiveKeepOrder: 32, ShellCompDirectiveDefault: 0 };
+var o = class {
+  name;
+  variadic;
+  command;
+  handler;
+  constructor(e3, t2, n2, r2 = false) {
+    this.command = e3, this.name = t2, this.handler = n2, this.variadic = r2;
+  }
+};
+var s = class {
+  value;
+  description;
+  command;
+  handler;
+  alias;
+  isBoolean;
+  constructor(e3, t2, n2, r2, i2, a2) {
+    this.command = e3, this.value = t2, this.description = n2, this.handler = r2, this.alias = i2, this.isBoolean = a2;
+  }
+};
+var c = class {
+  value;
+  description;
+  options = /* @__PURE__ */ new Map();
+  arguments = /* @__PURE__ */ new Map();
+  parent;
+  constructor(e3, t2) {
+    this.value = e3, this.description = t2;
+  }
+  option(e3, t2, n2, r2) {
+    let i2, a2, o3;
+    typeof n2 == `function` ? (i2 = n2, a2 = r2, o3 = false) : typeof n2 == `string` ? (i2 = void 0, a2 = n2, o3 = true) : (i2 = void 0, a2 = void 0, o3 = true);
+    let c3 = new s(this, e3, t2, i2, a2, o3);
+    return this.options.set(e3, c3), this;
+  }
+  argument(e3, t2, n2 = false) {
+    let r2 = new o(this, e3, t2, n2);
+    return this.arguments.set(e3, r2), this;
+  }
+};
+var l = class extends c {
+  commands = /* @__PURE__ */ new Map();
+  completions = [];
+  directive = a.ShellCompDirectiveDefault;
+  constructor() {
+    super(``, ``);
+  }
+  command(e3, t2) {
+    let n2 = new c(e3, t2);
+    return this.commands.set(e3, n2), n2;
+  }
+  stripOptions(e3) {
+    let t2 = [], n2 = 0;
+    for (; n2 < e3.length; ) {
+      let r2 = e3[n2];
+      if (r2.startsWith(`-`)) {
+        n2++;
+        let t3 = false, i2 = this.findOption(this, r2);
+        if (i2) t3 = i2.isBoolean ?? false;
+        else for (let [, e4] of this.commands) {
+          let n3 = this.findOption(e4, r2);
+          if (n3) {
+            t3 = n3.isBoolean ?? false;
+            break;
+          }
+        }
+        !t3 && n2 < e3.length && !e3[n2].startsWith(`-`) && n2++;
+      } else t2.push(r2), n2++;
+    }
+    return t2;
+  }
+  matchCommand(e3) {
+    e3 = this.stripOptions(e3);
+    let t2 = [], n2 = [], r2 = null;
+    for (let i2 = 0; i2 < e3.length; i2++) {
+      let a2 = e3[i2];
+      t2.push(a2);
+      let o3 = this.commands.get(t2.join(` `));
+      if (o3) r2 = o3;
+      else {
+        n2 = e3.slice(i2, e3.length);
+        break;
+      }
+    }
+    return [r2 || this, n2];
+  }
+  shouldCompleteFlags(e3, t2) {
+    if (t2.startsWith(`-`)) return true;
+    if (e3?.startsWith(`-`)) {
+      let t3 = this.findOption(this, e3);
+      if (!t3) {
+        for (let [, n2] of this.commands) if (t3 = this.findOption(n2, e3), t3) break;
+      }
+      return !(t3 && t3.isBoolean);
+    }
+    return false;
+  }
+  shouldCompleteCommands(e3) {
+    return !e3.startsWith(`-`);
+  }
+  handleFlagCompletion(e3, t2, n2, r2) {
+    let i2;
+    if (n2.includes(`=`)) {
+      let [e4] = n2.split(`=`);
+      i2 = e4;
+    } else if (r2?.startsWith(`-`)) {
+      let t3 = this.findOption(e3, r2);
+      t3 && !t3.isBoolean && (i2 = r2);
+    }
+    if (i2) {
+      let t3 = this.findOption(e3, i2);
+      if (t3?.handler) {
+        let n3 = [];
+        t3.handler.call(t3, (e4, t4) => n3.push({ value: e4, description: t4 }), e3.options), this.completions = n3;
+      }
+      return;
+    }
+    if (n2.startsWith(`-`)) {
+      let t3 = n2.startsWith(`-`) && !n2.startsWith(`--`), r3 = n2.replace(/^-+/, ``);
+      for (let [i3, a2] of e3.options) t3 && a2.alias && `-${a2.alias}`.startsWith(n2) ? this.completions.push({ value: `-${a2.alias}`, description: a2.description }) : !t3 && i3.startsWith(r3) && this.completions.push({ value: `--${i3}`, description: a2.description });
+    }
+  }
+  findOption(e3, t2) {
+    let n2 = e3.options.get(t2);
+    if (n2 || (n2 = e3.options.get(t2.replace(/^-+/, ``)), n2)) return n2;
+    for (let [n3, r2] of e3.options) if (r2.alias && `-${r2.alias}` === t2) return r2;
+  }
+  handleCommandCompletion(e3, t2) {
+    let n2 = this.stripOptions(e3);
+    for (let [e4, r2] of this.commands) {
+      if (e4 === ``) continue;
+      let i2 = e4.split(` `);
+      i2.slice(0, n2.length).every((e5, t3) => e5 === n2[t3]) && i2[n2.length]?.startsWith(t2) && this.completions.push({ value: i2[n2.length], description: r2.description });
+    }
+  }
+  handlePositionalCompletion(e3, t2) {
+    let n2 = e3.value.split(` `).length, r2 = Math.max(0, t2.length - n2), i2 = Array.from(e3.arguments.entries());
+    if (i2.length > 0) {
+      let t3;
+      if (r2 < i2.length) {
+        let [e4, n3] = i2[r2];
+        t3 = n3;
+      } else {
+        let e4 = i2[i2.length - 1][1];
+        e4.variadic && (t3 = e4);
+      }
+      if (t3 && t3.handler && typeof t3.handler == `function`) {
+        let n3 = [];
+        t3.handler.call(t3, (e4, t4) => n3.push({ value: e4, description: t4 }), e3.options), this.completions.push(...n3);
+      }
+    }
+  }
+  complete(e3) {
+    this.directive = a.ShellCompDirectiveNoFileComp;
+    let t2 = /* @__PURE__ */ new Set();
+    this.completions.filter((e4) => t2.has(e4.value) ? false : (t2.add(e4.value), true)).filter((t3) => {
+      if (e3.includes(`=`)) {
+        let [, n2] = e3.split(`=`);
+        return t3.value.startsWith(n2);
+      }
+      return t3.value.startsWith(e3);
+    }).forEach((e4) => console.log(`${e4.value}	${e4.description ?? ``}`)), console.log(`:${this.directive}`);
+  }
+  parse(e3) {
+    this.completions = [];
+    let t2 = e3[e3.length - 1] === ``;
+    t2 && e3.pop();
+    let n2 = e3[e3.length - 1] || ``, r2 = e3.slice(0, -1);
+    t2 && (n2 !== `` && r2.push(n2), n2 = ``);
+    let [i2] = this.matchCommand(r2), a2 = r2[r2.length - 1];
+    if (this.shouldCompleteFlags(a2, n2)) this.handleFlagCompletion(i2, r2, n2, a2);
+    else {
+      if (a2?.startsWith(`-`) && n2 === `` && t2) {
+        let e4 = this.findOption(this, a2);
+        if (!e4) {
+          for (let [, t3] of this.commands) if (e4 = this.findOption(t3, a2), e4) break;
+        }
+        if (e4 && e4.isBoolean) {
+          this.complete(n2);
+          return;
+        }
+      }
+      this.shouldCompleteCommands(n2) && this.handleCommandCompletion(r2, n2), i2 && i2.arguments.size > 0 && this.handlePositionalCompletion(i2, r2);
+    }
+    this.complete(n2);
+  }
+  setup(a2, o3, s3) {
+    switch (e__default.default(s3 === `zsh` || s3 === `bash` || s3 === `fish` || s3 === `powershell`, `Unsupported shell`), s3) {
+      case `zsh`: {
+        let e3 = t(a2, o3);
+        console.log(e3);
+        break;
+      }
+      case `bash`: {
+        let e3 = n(a2, o3);
+        console.log(e3);
+        break;
+      }
+      case `fish`: {
+        let e3 = r(a2, o3);
+        console.log(e3);
+        break;
+      }
+      case `powershell`: {
+        let e3 = i(a2, o3);
+        console.log(e3);
+        break;
+      }
+    }
+  }
+};
+var u = new l();
+var f = u;
+
+// ../../node_modules/.pnpm/@bomb.sh+tab@0.0.11_cac@6.7.14_citty@0.1.6_commander@14.0.2/node_modules/@bomb.sh/tab/dist/shared-BE1U9MBi.js
+function e2(e3 = `cli`) {
+  if (process.argv.indexOf(`--`) === -1) {
+    let t2 = `Error: You need to use -- to separate completion arguments.
+Example: ${e3} complete -- <args>`;
+    console.error(t2), process.exit(1);
+  }
+}
+
+// ../../node_modules/.pnpm/@bomb.sh+tab@0.0.11_cac@6.7.14_citty@0.1.6_commander@14.0.2/node_modules/@bomb.sh/tab/dist/commander.js
+var o2 = process.execPath;
+var s2 = process.argv.slice(1);
+var c2 = d(o2);
+var l2 = s2.map(d);
+var u2 = `${c2} ${process.execArgv.map(d).join(` `)} ${l2[0]}`;
+function d(e3) {
+  return e3.includes(` `) ? `'${e3}'` : e3;
+}
+function f2(o3) {
+  let s3 = o3.name();
+  p(o3), m(o3), o3.command(`complete [shell]`).description(`Generate shell completion scripts`).action(async (r2) => {
+    switch (r2) {
+      case `zsh`: {
+        let e3 = t(s3, u2);
+        console.log(e3);
+        break;
+      }
+      case `bash`: {
+        let e3 = n(s3, u2);
+        console.log(e3);
+        break;
+      }
+      case `fish`: {
+        let e3 = r(s3, u2);
+        console.log(e3);
+        break;
+      }
+      case `powershell`: {
+        let t2 = i(s3, u2);
+        console.log(t2);
+        break;
+      }
+      case `debug`: {
+        let e3 = /* @__PURE__ */ new Map();
+        h(o3, ``, e3), console.log(`Collected commands:`);
+        for (let [t2, n2] of e3.entries()) console.log(`- ${t2 || `<root>`}: ${n2.description() || `No description`}`);
+        break;
+      }
+      default:
+        console.error(`Unknown shell: ${r2}`), console.error(`Supported shells: zsh, bash, fish, powershell`), process.exit(1);
+    }
+  });
+  let c3 = o3.parse.bind(o3);
+  return o3.parse = function(e3, t2) {
+    let n2 = e3 || process.argv, i2 = n2.findIndex((e4) => e4 === `complete`), l3 = n2.findIndex((e4) => e4 === `--`);
+    if (i2 !== -1 && l3 !== -1 && l3 > i2) {
+      let e4 = n2.slice(l3 + 1);
+      return e2(s3), f.parse(e4), o3;
+    }
+    return c3(e3, t2);
+  }, f;
+}
+function p(e3) {
+  for (let t2 of e3.options) {
+    let e4 = t2.flags, n2 = e4.match(/^-([a-zA-Z]), --/)?.[1], i2 = e4.match(/--([a-zA-Z0-9-]+)/)?.[1];
+    i2 && (n2 ? f.option(i2, t2.description || ``, n2) : f.option(i2, t2.description || ``));
+  }
+}
+function m(e3) {
+  let t2 = /* @__PURE__ */ new Map();
+  h(e3, ``, t2);
+  for (let [e4, n2] of t2.entries()) {
+    if (e4 === ``) continue;
+    let t3 = f.command(e4, n2.description() || ``);
+    for (let e5 of n2.options) {
+      let n3 = e5.flags, r2 = n3.match(/^-([a-zA-Z]), --/)?.[1], i2 = n3.match(/--([a-zA-Z0-9-]+)/)?.[1];
+      i2 && (r2 ? t3.option(i2, e5.description || ``, r2) : t3.option(i2, e5.description || ``));
+    }
+  }
+}
+function h(e3, t2, n2) {
+  n2.set(t2, e3);
+  for (let r2 of e3.commands) r2.name() !== `complete` && h(r2, t2 ? `${t2} ${r2.name()}` : r2.name(), n2);
+}
 var detectPackageManager = async (projectRoot) => {
   const detected = await ni.detect({ cwd: projectRoot });
   if (detected && ["npm", "yarn", "pnpm", "bun"].includes(detected)) {
@@ -516,6 +1548,29 @@ var getPackagesToUninstall = (agent) => {
 var spinner = (text, options) => ora__default.default({ text, isSilent: options?.silent });
 
 // src/utils/templates.ts
+var AGENTS = [
+  "claude-code",
+  "cursor",
+  "opencode",
+  "codex",
+  "gemini",
+  "amp",
+  "ami",
+  "visual-edit"
+];
+var AGENT_NAMES = {
+  "claude-code": "Claude Code",
+  cursor: "Cursor",
+  opencode: "OpenCode",
+  codex: "Codex",
+  gemini: "Gemini",
+  amp: "Amp",
+  ami: "Ami",
+  "visual-edit": "Visual Edit"
+};
+var PROVIDERS = AGENTS.filter((agent) => agent !== "ami").map(
+  (agent) => `@react-grab/${agent}`
+);
 var NEXT_APP_ROUTER_SCRIPT = `{process.env.NODE_ENV === "development" && (
           <Script
             src="//unpkg.com/react-grab/dist/index.global.js"
@@ -587,8 +1642,6 @@ var WEBPACK_IMPORT_WITH_AGENT = (agent) => {
 }`;
 };
 var SCRIPT_IMPORT = 'import Script from "next/script";';
-
-// src/utils/transform.ts
 var hasReactGrabCode = (content) => {
   const fuzzyPatterns = [
     /["'`][^"'`]*react-grab/,
@@ -1609,16 +2662,7 @@ var previewPackageJsonAgentRemoval = (projectRoot, agent) => {
 };
 
 // src/commands/add.ts
-var VERSION = "0.0.97";
-var AGENT_NAMES = {
-  "claude-code": "Claude Code",
-  cursor: "Cursor",
-  opencode: "OpenCode",
-  codex: "Codex",
-  gemini: "Gemini",
-  amp: "Amp",
-  "visual-edit": "Visual Edit"
-};
+var VERSION = "0.0.98";
 var add = new commander.Command().name("add").description("add an agent integration").argument(
   "[agent]",
   "agent to add (claude-code, cursor, opencode, codex, gemini, amp, visual-edit)"
@@ -1646,16 +2690,7 @@ var add = new commander.Command().name("add").description("add an agent integrat
       process.exit(1);
     }
     preflightSpinner.succeed();
-    const allAgents = [
-      "claude-code",
-      "cursor",
-      "opencode",
-      "codex",
-      "gemini",
-      "amp",
-      "visual-edit"
-    ];
-    const availableAgents = allAgents.filter(
+    const availableAgents = AGENTS.filter(
       (agent) => !projectInfo.installedAgents.includes(agent)
     );
     if (availableAgents.length === 0) {
@@ -1667,7 +2702,7 @@ var add = new commander.Command().name("add").description("add an agent integrat
     let agentIntegration;
     let agentsToRemove = [];
     if (agentArg) {
-      if (!allAgents.includes(agentArg)) {
+      if (!AGENTS.includes(agentArg)) {
         logger.break();
         logger.error(`Invalid agent: ${agentArg}`);
         logger.error(
@@ -1954,7 +2989,7 @@ var add = new commander.Command().name("add").description("add an agent integrat
     handleError(error);
   }
 });
-var VERSION2 = "0.0.97";
+var VERSION2 = "0.0.98";
 var MODIFIER_KEY_NAMES = {
   metaKey: process.platform === "darwin" ? "\u2318 Command" : "\u229E Windows",
   ctrlKey: "Ctrl",
@@ -2168,7 +3203,7 @@ var configure = new commander.Command().name("configure").alias("config").descri
     handleError(error);
   }
 });
-var VERSION3 = "0.0.97";
+var VERSION3 = "0.0.98";
 var REPORT_URL = "https://react-grab.com/api/report-cli";
 var DOCS_URL = "https://github.com/aidenybai/react-grab";
 var reportToCli = async (type, config, error) => {
@@ -2206,16 +3241,6 @@ var UNSUPPORTED_FRAMEWORK_NAMES = {
   sveltekit: "SvelteKit",
   gatsby: "Gatsby"
 };
-var AGENT_NAMES2 = {
-  "claude-code": "Claude Code",
-  cursor: "Cursor",
-  opencode: "OpenCode",
-  codex: "Codex",
-  gemini: "Gemini",
-  amp: "Amp",
-  ami: "Ami",
-  "visual-edit": "Visual Edit"
-};
 var MODIFIER_KEY_NAMES2 = {
   metaKey: process.platform === "darwin" ? "\u2318 Command" : "\u229E Windows",
   ctrlKey: "Ctrl",
@@ -2265,20 +3290,12 @@ var init = new commander.Command().name("init").description("initialize React Gr
       logger.break();
       logger.success("React Grab is already installed.");
       logger.break();
-      const allAgents = [
-        "claude-code",
-        "cursor",
-        "opencode",
-        "codex",
-        "gemini",
-        "amp",
-        "visual-edit"
-      ];
+      const allAgents = AGENTS;
       const availableAgents = allAgents.filter(
         (agent) => !projectInfo.installedAgents.includes(agent)
       );
       if (projectInfo.installedAgents.length > 0) {
-        const installedNames = projectInfo.installedAgents.map((innerAgent) => AGENT_NAMES2[innerAgent] || innerAgent).join(", ");
+        const installedNames = projectInfo.installedAgents.map((innerAgent) => AGENT_NAMES[innerAgent] || innerAgent).join(", ");
         logger.log(
           `Currently installed agents: ${highlighter.info(installedNames)}`
         );
@@ -2290,7 +3307,7 @@ var init = new commander.Command().name("init").description("initialize React Gr
           type: "confirm",
           name: "wantAddAgent",
           message: `Would you like to add an ${highlighter.info("agent integration")}?`,
-          initial: true
+          initial: false
         });
         if (wantAddAgent === void 0) {
           logger.break();
@@ -2302,7 +3319,7 @@ var init = new commander.Command().name("init").description("initialize React Gr
             name: "agent",
             message: `Which ${highlighter.info("agent integration")} would you like to add?`,
             choices: availableAgents.map((innerAgent) => ({
-              title: AGENT_NAMES2[innerAgent],
+              title: AGENT_NAMES[innerAgent],
               value: innerAgent
             }))
           });
@@ -2313,18 +3330,18 @@ var init = new commander.Command().name("init").description("initialize React Gr
           const agentIntegration2 = agent;
           let agentsToRemove2 = [];
           if (projectInfo.installedAgents.length > 0) {
-            const installedNames = projectInfo.installedAgents.map((innerAgent) => AGENT_NAMES2[innerAgent] || innerAgent).join(", ");
+            const installedNames = projectInfo.installedAgents.map((innerAgent) => AGENT_NAMES[innerAgent] || innerAgent).join(", ");
             const { action } = await prompts3__default.default({
               type: "select",
               name: "action",
               message: "How would you like to proceed?",
               choices: [
                 {
-                  title: `Replace ${installedNames} with ${AGENT_NAMES2[agentIntegration2]}`,
+                  title: `Replace ${installedNames} with ${AGENT_NAMES[agentIntegration2]}`,
                   value: "replace"
                 },
                 {
-                  title: `Add ${AGENT_NAMES2[agentIntegration2]} alongside existing`,
+                  title: `Add ${AGENT_NAMES[agentIntegration2]} alongside existing`,
                   value: "add"
                 },
                 { title: "Cancel", value: "cancel" }
@@ -2368,7 +3385,7 @@ var init = new commander.Command().name("init").description("initialize React Gr
                   }
                   if (removalResult.success && !removalResult.noChanges && removalResult.newContent) {
                     const removeWriteSpinner = spinner(
-                      `Removing ${AGENT_NAMES2[agentToRemove] || agentToRemove} from ${removalResult.filePath}.`
+                      `Removing ${AGENT_NAMES[agentToRemove] || agentToRemove} from ${removalResult.filePath}.`
                     ).start();
                     const writeResult = applyTransform(removalResult);
                     if (!writeResult.success) {
@@ -2384,7 +3401,7 @@ var init = new commander.Command().name("init").description("initialize React Gr
                   }
                   if (removalPackageJsonResult.success && !removalPackageJsonResult.noChanges && removalPackageJsonResult.newContent) {
                     const removePackageJsonSpinner = spinner(
-                      `Removing ${AGENT_NAMES2[agentToRemove] || agentToRemove} from ${removalPackageJsonResult.filePath}.`
+                      `Removing ${AGENT_NAMES[agentToRemove] || agentToRemove} from ${removalPackageJsonResult.filePath}.`
                     ).start();
                     const packageJsonWriteResult = applyPackageJsonTransform(
                       removalPackageJsonResult
@@ -2512,7 +3529,7 @@ var init = new commander.Command().name("init").description("initialize React Gr
                     didAddAgent = true;
                     logger.break();
                     logger.success(
-                      `${AGENT_NAMES2[agentIntegration2]} has been added.`
+                      `${AGENT_NAMES[agentIntegration2]} has been added.`
                     );
                   }
                 } else {
@@ -2571,7 +3588,7 @@ var init = new commander.Command().name("init").description("initialize React Gr
                   didAddAgent = true;
                   logger.break();
                   logger.success(
-                    `${AGENT_NAMES2[agentIntegration2]} has been added.`
+                    `${AGENT_NAMES[agentIntegration2]} has been added.`
                   );
                 }
               }
@@ -2860,7 +3877,7 @@ var init = new commander.Command().name("init").description("initialize React Gr
     if (!isNonInteractive && !opts.agent) {
       logger.break();
       if (opts.force && projectInfo.installedAgents.length > 0) {
-        const installedNames = projectInfo.installedAgents.map((innerAgent) => AGENT_NAMES2[innerAgent] || innerAgent).join(", ");
+        const installedNames = projectInfo.installedAgents.map((innerAgent) => AGENT_NAMES[innerAgent] || innerAgent).join(", ");
         logger.warn(`Currently installed: ${installedNames}`);
         logger.break();
       }
@@ -2870,13 +3887,10 @@ var init = new commander.Command().name("init").description("initialize React Gr
         message: `Would you like to add an ${highlighter.info("agent integration")}?`,
         choices: [
           { title: "None", value: "none" },
-          { title: "Claude Code", value: "claude-code" },
-          { title: "Cursor", value: "cursor" },
-          { title: "OpenCode", value: "opencode" },
-          { title: "Codex", value: "codex" },
-          { title: "Gemini", value: "gemini" },
-          { title: "Amp", value: "amp" },
-          { title: "Visual Edit", value: "visual-edit" }
+          ...AGENTS.map((innerAgent) => ({
+            title: AGENT_NAMES[innerAgent],
+            value: innerAgent
+          }))
         ]
       });
       if (agent === void 0) {
@@ -2885,18 +3899,18 @@ var init = new commander.Command().name("init").description("initialize React Gr
       }
       agentIntegration = agent;
       if (opts.force && projectInfo.installedAgents.length > 0 && agentIntegration !== "none" && !projectInfo.installedAgents.includes(agentIntegration)) {
-        const installedNames = projectInfo.installedAgents.map((innerAgent) => AGENT_NAMES2[innerAgent] || innerAgent).join(", ");
+        const installedNames = projectInfo.installedAgents.map((innerAgent) => AGENT_NAMES[innerAgent] || innerAgent).join(", ");
         const { action } = await prompts3__default.default({
           type: "select",
           name: "action",
           message: "How would you like to proceed?",
           choices: [
             {
-              title: `Replace ${installedNames} with ${AGENT_NAMES2[agentIntegration]}`,
+              title: `Replace ${installedNames} with ${AGENT_NAMES[agentIntegration]}`,
               value: "replace"
             },
             {
-              title: `Add ${AGENT_NAMES2[agentIntegration]} alongside existing`,
+              title: `Add ${AGENT_NAMES[agentIntegration]} alongside existing`,
               value: "add"
             },
             { title: "Cancel", value: "cancel" }
@@ -2913,7 +3927,7 @@ var init = new commander.Command().name("init").description("initialize React Gr
         }
       }
     } else if (opts.agent && opts.force && projectInfo.installedAgents.length > 0 && !projectInfo.installedAgents.includes(opts.agent) && !isNonInteractive) {
-      const installedNames = projectInfo.installedAgents.map((innerAgent) => AGENT_NAMES2[innerAgent] || innerAgent).join(", ");
+      const installedNames = projectInfo.installedAgents.map((innerAgent) => AGENT_NAMES[innerAgent] || innerAgent).join(", ");
       logger.break();
       logger.warn(`Currently installed: ${installedNames}`);
       const { action } = await prompts3__default.default({
@@ -2922,11 +3936,11 @@ var init = new commander.Command().name("init").description("initialize React Gr
         message: "How would you like to proceed?",
         choices: [
           {
-            title: `Replace ${installedNames} with ${AGENT_NAMES2[agentIntegration]}`,
+            title: `Replace ${installedNames} with ${AGENT_NAMES[agentIntegration]}`,
             value: "replace"
           },
           {
-            title: `Add ${AGENT_NAMES2[agentIntegration]} alongside existing`,
+            title: `Add ${AGENT_NAMES[agentIntegration]} alongside existing`,
             value: "add"
           },
           { title: "Cancel", value: "cancel" }
@@ -3033,7 +4047,7 @@ var init = new commander.Command().name("init").description("initialize React Gr
         }
         if (removalResult.success && !removalResult.noChanges && removalResult.newContent) {
           const removeWriteSpinner = spinner(
-            `Removing ${AGENT_NAMES2[agentToRemove] || agentToRemove} from ${removalResult.filePath}.`
+            `Removing ${AGENT_NAMES[agentToRemove] || agentToRemove} from ${removalResult.filePath}.`
           ).start();
           const writeResult = applyTransform(removalResult);
           if (!writeResult.success) {
@@ -3047,7 +4061,7 @@ var init = new commander.Command().name("init").description("initialize React Gr
         }
         if (removalPackageJsonResult.success && !removalPackageJsonResult.noChanges && removalPackageJsonResult.newContent) {
           const removePackageJsonSpinner = spinner(
-            `Removing ${AGENT_NAMES2[agentToRemove] || agentToRemove} from ${removalPackageJsonResult.filePath}.`
+            `Removing ${AGENT_NAMES[agentToRemove] || agentToRemove} from ${removalPackageJsonResult.filePath}.`
           ).start();
           const packageJsonWriteResult = applyPackageJsonTransform(
             removalPackageJsonResult
@@ -3144,17 +4158,7 @@ var init = new commander.Command().name("init").description("initialize React Gr
     await reportToCli("error", void 0, error);
   }
 });
-var VERSION4 = "0.0.97";
-var AGENT_NAMES3 = {
-  "claude-code": "Claude Code",
-  cursor: "Cursor",
-  opencode: "OpenCode",
-  codex: "Codex",
-  gemini: "Gemini",
-  amp: "Amp",
-  ami: "Ami",
-  "visual-edit": "Visual Edit"
-};
+var VERSION4 = "0.0.98";
 var remove = new commander.Command().name("remove").description("remove an agent integration").argument(
   "[agent]",
   "agent to remove (claude-code, cursor, opencode, codex, gemini, amp, ami, visual-edit)"
@@ -3195,7 +4199,7 @@ var remove = new commander.Command().name("remove").description("remove an agent
         logger.break();
         logger.error(`Agent ${highlighter.info(agentArg)} is not installed.`);
         logger.log(
-          `Installed agents: ${projectInfo.installedAgents.map((innerAgent) => AGENT_NAMES3[innerAgent] || innerAgent).join(", ")}`
+          `Installed agents: ${projectInfo.installedAgents.map((innerAgent) => AGENT_NAMES[innerAgent] || innerAgent).join(", ")}`
         );
         logger.break();
         process.exit(1);
@@ -3208,7 +4212,7 @@ var remove = new commander.Command().name("remove").description("remove an agent
         name: "agent",
         message: `Which ${highlighter.info("agent integration")} would you like to remove?`,
         choices: projectInfo.installedAgents.map((innerAgent) => ({
-          title: AGENT_NAMES3[innerAgent] || innerAgent,
+          title: AGENT_NAMES[innerAgent] || innerAgent,
           value: innerAgent
         }))
       });
@@ -3227,7 +4231,7 @@ var remove = new commander.Command().name("remove").description("remove an agent
       process.exit(1);
     }
     const removingSpinner = spinner(
-      `Preparing to remove ${AGENT_NAMES3[agentToRemove] || agentToRemove}.`
+      `Preparing to remove ${AGENT_NAMES[agentToRemove] || agentToRemove}.`
     ).start();
     removingSpinner.succeed();
     const result = previewAgentRemoval(
@@ -3324,14 +4328,14 @@ var remove = new commander.Command().name("remove").description("remove an agent
     }
     logger.break();
     logger.log(
-      `${highlighter.success("Success!")} ${AGENT_NAMES3[agentToRemove] || agentToRemove} has been removed.`
+      `${highlighter.success("Success!")} ${AGENT_NAMES[agentToRemove] || agentToRemove} has been removed.`
     );
     logger.break();
   } catch (error) {
     handleError(error);
   }
 });
-var VERSION5 = "0.0.97";
+var VERSION5 = "0.0.98";
 var DEFAULT_PROXY_PORT = 2e3;
 var REACT_GRAB_SCRIPT = '<script src="https://unpkg.com/react-grab/dist/index.global.js"></script>';
 var buildProviderScript = (provider) => `<script src="https://unpkg.com/${provider}/dist/client.global.js"></script>`;
@@ -3400,13 +4404,13 @@ var start = new commander.Command().name("start").alias("proxy").description("st
         message: `Select a ${highlighter.info("provider")} to use:`,
         choices: [
           { title: "None", value: "" },
-          { title: "Claude Code", value: "@react-grab/claude-code" },
-          { title: "Cursor", value: "@react-grab/cursor" },
-          { title: "OpenCode", value: "@react-grab/opencode" },
-          { title: "Codex", value: "@react-grab/codex" },
-          { title: "Gemini", value: "@react-grab/gemini" },
-          { title: "Amp", value: "@react-grab/amp" },
-          { title: "Visual Edit", value: "@react-grab/visual-edit" }
+          ...PROVIDERS.map((provider2) => {
+            const agentName = provider2.replace("@react-grab/", "");
+            return {
+              title: AGENT_NAMES[agentName],
+              value: provider2
+            };
+          })
         ]
       });
       if (selectedProvider === void 0) {
@@ -3561,7 +4565,7 @@ var start = new commander.Command().name("start").alias("proxy").description("st
 
 // src/cli.ts
 process.noDeprecation = true;
-var VERSION6 = "0.0.97";
+var VERSION6 = "0.0.98";
 var VERSION_API_URL = "https://www.react-grab.com/api/version";
 process.on("SIGINT", () => process.exit(0));
 process.on("SIGTERM", () => process.exit(0));
@@ -3576,4 +4580,49 @@ program.addCommand(add);
 program.addCommand(remove);
 program.addCommand(configure);
 program.addCommand(start);
+var completion = f2(program);
+var initCommand = completion.commands.get("init");
+var initAgentOption = initCommand?.options.get("agent");
+if (initAgentOption) {
+  initAgentOption.handler = (complete) => {
+    for (const agent of AGENTS) {
+      complete(agent, "");
+    }
+  };
+}
+var addCommand = completion.commands.get("add");
+var addAgentArg = addCommand?.arguments.get("agent");
+if (addAgentArg) {
+  addAgentArg.handler = (complete) => {
+    for (const agent of AGENTS) {
+      complete(agent, "");
+    }
+  };
+}
+var removeCommand = completion.commands.get("remove");
+var removeAgentArg = removeCommand?.arguments.get("agent");
+if (removeAgentArg) {
+  removeAgentArg.handler = (complete) => {
+    for (const agent of AGENTS) {
+      complete(agent, "");
+    }
+  };
+}
+var startCommand = completion.commands.get("start");
+var startProviderOption = startCommand?.options.get("provider");
+if (startProviderOption) {
+  startProviderOption.handler = (complete) => {
+    for (const provider of PROVIDERS) {
+      complete(provider, "");
+    }
+  };
+}
+var startPortOption = startCommand?.options.get("port");
+if (startPortOption) {
+  startPortOption.handler = (complete) => {
+    complete("2000", "Default port");
+    complete("3000", "Common dev port");
+    complete("8080", "Alternative port");
+  };
+}
 program.parse();