Skip to content

fix: update fish script based on cobra #100

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
AmirSa12 merged 3 commits into from
Jan 24, 2026
+710 −321
Merged

fix: update fish script based on cobra #100

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
520a356
fix: update fish script based on cobra
AmirSa12 Jan 24, 2026
7e2b9d8
fix: lint
AmirSa12 Jan 24, 2026
5b29449
chore: add changeset
AmirSa12 Jan 24, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
5 changes: 5 additions & 0 deletions .changeset/witty-shoes-brake.md
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,5 @@
---
'@bomb.sh/tab': patch
---

Update fish shell completion script to match latest Cobra output. (#99)
299 changes: 192 additions & 107 deletions src/fish.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -19,14 +19,6 @@ export function generate(name: string, exec: string): string {

return `# fish completion for ${name} -*- shell-script -*-

# Define shell completion directives
set -l ShellCompDirectiveError ${ShellCompDirectiveError}
set -l ShellCompDirectiveNoSpace ${ShellCompDirectiveNoSpace}
set -l ShellCompDirectiveNoFileComp ${ShellCompDirectiveNoFileComp}
set -l ShellCompDirectiveFilterFileExt ${ShellCompDirectiveFilterFileExt}
set -l ShellCompDirectiveFilterDirs ${ShellCompDirectiveFilterDirs}
set -l ShellCompDirectiveKeepOrder ${ShellCompDirectiveKeepOrder}

function __${nameForVar}_debug
set -l file "$BASH_COMP_DEBUG_FILE"
if test -n "$file"
Expand All @@ -37,134 +29,227 @@ end
function __${nameForVar}_perform_completion
__${nameForVar}_debug "Starting __${nameForVar}_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

__${nameForVar}_debug "Current token: $current_token"
__${nameForVar}_debug "All args: $args"
# Extract all args except the last one
set -l args (commandline -opc)
# Extract the last arg and escape it in case it is a space or wildcard
set -l lastArg (string escape -- (commandline -ct))

__${nameForVar}_debug "args: $args"
__${nameForVar}_debug "last arg: $lastArg"

# Build the completion request command
set -l requestComp "${exec} complete -- (string join ' ' -- (string escape -- $args[2..-1])) $lastArg"

# Call the completion program and get the results
set -l requestComp "${exec} complete -- $args"
__${nameForVar}_debug "Calling $requestComp"
set -l results (eval $requestComp 2> /dev/null)

# Some programs may output extra empty lines after the directive.
# Let's ignore them or else it will break completion.
# Ref: https://github.com/spf13/cobra/issues/1279
for line in $results[-1..1]
if test (string sub -s 1 -l 1 -- $line) = ":"
# The directive
set -l directive (string sub -s 2 -- $line)
set -l directive_num (math $directive)
if test (string trim -- $line) = ""
# Found an empty line, remove it
set results $results[1..-2]
else
# Found non-empty line, we have our proper output
break
end
end

# No directive specified, use default
if not set -q directive_num
set directive_num 0

set -l comps $results[1..-2]
set -l directiveLine $results[-1]

# For Fish, when completing a flag with an = (e.g., <program> -n=<TAB>)
# completions must be prefixed with the flag
set -l flagPrefix (string match -r -- '-.*=' "$lastArg")

__${nameForVar}_debug "Comps: $comps"
__${nameForVar}_debug "DirectiveLine: $directiveLine"
__${nameForVar}_debug "flagPrefix: $flagPrefix"

for comp in $comps
printf "%s%s\\n" "$flagPrefix" "$comp"
end

__${nameForVar}_debug "Directive: $directive_num"

# Process completions based on directive
if test $directive_num -eq $ShellCompDirectiveError
# Error code. No completion.
__${nameForVar}_debug "Received error directive: aborting."
printf "%s\\n" "$directiveLine"
end

# This function limits calls to __${nameForVar}_perform_completion, by caching the result
function __${nameForVar}_perform_completion_once
__${nameForVar}_debug "Starting __${nameForVar}_perform_completion_once"

if test -n "$__${nameForVar}_perform_completion_once_result"
__${nameForVar}_debug "Seems like a valid result already exists, skipping __${nameForVar}_perform_completion"
return 0
end

set --global __${nameForVar}_perform_completion_once_result (__${nameForVar}_perform_completion)
if test -z "$__${nameForVar}_perform_completion_once_result"
__${nameForVar}_debug "No completions, probably due to a failure"
return 1
end

# 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]
__${nameForVar}_debug "Performed completions and set __${nameForVar}_perform_completion_once_result"
return 0
end

# This function is used to clear the cached result after completions are run
function __${nameForVar}_clear_perform_completion_once_result
__${nameForVar}_debug ""
__${nameForVar}_debug "========= clearing previously set __${nameForVar}_perform_completion_once_result variable =========="
set --erase __${nameForVar}_perform_completion_once_result
__${nameForVar}_debug "Successfully erased the variable __${nameForVar}_perform_completion_once_result"
end

function __${nameForVar}_requires_order_preservation
__${nameForVar}_debug ""
__${nameForVar}_debug "========= checking if order preservation is required =========="

__${nameForVar}_perform_completion_once
if test -z "$__${nameForVar}_perform_completion_once_result"
__${nameForVar}_debug "Error determining if order preservation is required"
return 1
end

# No completions, let fish handle file completions unless forbidden
if test (count $results) -eq 0
if test $directive_num -ne $ShellCompDirectiveNoFileComp
__${nameForVar}_debug "No completions, performing file completion"
return 1
end
__${nameForVar}_debug "No completions, but file completion forbidden"
set -l directive (string sub --start 2 $__${nameForVar}_perform_completion_once_result[-1])
__${nameForVar}_debug "Directive is: $directive"

set -l shellCompDirectiveKeepOrder ${ShellCompDirectiveKeepOrder}
set -l keeporder (math (math --scale 0 $directive / $shellCompDirectiveKeepOrder) % 2)
__${nameForVar}_debug "Keeporder is: $keeporder"

if test $keeporder -ne 0
__${nameForVar}_debug "This does require order preservation"
return 0
end

# Filter file extensions
if test $directive_num -eq $ShellCompDirectiveFilterFileExt
__${nameForVar}_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
__${nameForVar}_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
__${nameForVar}_debug "This doesn't require order preservation"
return 1
end

# This function does two things:
# - Obtain the completions and store them in the global __${nameForVar}_comp_results
# - Return false if file completion should be performed
function __${nameForVar}_prepare_completions
__${nameForVar}_debug ""
__${nameForVar}_debug "========= starting completion logic =========="

# Start fresh
set --erase __${nameForVar}_comp_results

__${nameForVar}_perform_completion_once
__${nameForVar}_debug "Completion results: $__${nameForVar}_perform_completion_once_result"

if test -z "$__${nameForVar}_perform_completion_once_result"
__${nameForVar}_debug "No completion, probably due to a failure"
# Might as well do file completion, in case it helps
return 1
end

# Filter directories
if test $directive_num -eq $ShellCompDirectiveFilterDirs
__${nameForVar}_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
set -l directive (string sub --start 2 $__${nameForVar}_perform_completion_once_result[-1])
set --global __${nameForVar}_comp_results $__${nameForVar}_perform_completion_once_result[1..-2]

__${nameForVar}_debug "Completions are: $__${nameForVar}_comp_results"
__${nameForVar}_debug "Directive is: $directive"

set -l shellCompDirectiveError ${ShellCompDirectiveError}
set -l shellCompDirectiveNoSpace ${ShellCompDirectiveNoSpace}
set -l shellCompDirectiveNoFileComp ${ShellCompDirectiveNoFileComp}
set -l shellCompDirectiveFilterFileExt ${ShellCompDirectiveFilterFileExt}
set -l shellCompDirectiveFilterDirs ${ShellCompDirectiveFilterDirs}

if test -z "$directive"
set directive 0
end

set -l compErr (math (math --scale 0 $directive / $shellCompDirectiveError) % 2)
if test $compErr -eq 1
__${nameForVar}_debug "Received error directive: aborting."
# Might as well do file completion, in case it helps
return 1
end

# 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"
set -l filefilter (math (math --scale 0 $directive / $shellCompDirectiveFilterFileExt) % 2)
set -l dirfilter (math (math --scale 0 $directive / $shellCompDirectiveFilterDirs) % 2)
if test $filefilter -eq 1; or test $dirfilter -eq 1
__${nameForVar}_debug "File extension filtering or directory filtering not supported"
# Do full file completion instead
return 1
end

set -l nospace (math (math --scale 0 $directive / $shellCompDirectiveNoSpace) % 2)
set -l nofiles (math (math --scale 0 $directive / $shellCompDirectiveNoFileComp) % 2)

__${nameForVar}_debug "nospace: $nospace, nofiles: $nofiles"

# If we want to prevent a space, or if file completion is NOT disabled,
# we need to count the number of valid completions.
# To do so, we will filter on prefix as the completions we have received
# may not already be filtered so as to allow fish to match on different
# criteria than the prefix.
if test $nospace -ne 0; or test $nofiles -eq 0
set -l prefix (commandline -t | string escape --style=regex)
__${nameForVar}_debug "prefix: $prefix"

set -l completions (string match -r -- "^$prefix.*" $__${nameForVar}_comp_results)
set --global __${nameForVar}_comp_results $completions
__${nameForVar}_debug "Filtered completions are: $__${nameForVar}_comp_results"

# Important not to quote the variable for count to work
set -l numComps (count $__${nameForVar}_comp_results)
__${nameForVar}_debug "numComps: $numComps"

if test $numComps -eq 1; and test $nospace -ne 0
# We must first split on \\t to get rid of the descriptions to be
# able to check what the actual completion will be.
# We don't need descriptions anyway since there is only a single
# real completion which the shell will expand immediately.
set -l split (string split --max 1 "\\t" $__${nameForVar}_comp_results[1])

# Fish won't add a space if the completion ends with any
# of the following characters: @=/:.,
set -l lastChar (string sub -s -1 -- $split)
if not string match -r -q "[@=/:.,]" -- "$lastChar"
# In other cases, to support the "nospace" directive we trick the shell
# by outputting an extra, longer completion.
__${nameForVar}_debug "Adding second completion to perform nospace directive"
set --global __${nameForVar}_comp_results $split[1] $split[1].
__${nameForVar}_debug "Completions are now: $__${nameForVar}_comp_results"
end
end

if test $numComps -eq 0; and test $nofiles -eq 0
# To be consistent with bash and zsh, we only trigger file
# completion when there are no other completions
__${nameForVar}_debug "Requesting file completion"
return 1
end
end

# 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 ${name} command
complete -c ${name} -f -a "(eval __${nameForVar}_perform_completion)"
# Since Fish completions are only loaded once the user triggers them, we trigger them ourselves
# so we can properly delete any completions provided by another script.
# Only do this if the program can be found, or else fish may print some errors; besides,
# the existing completions will only be loaded if the program can be found.
if type -q "${name}"
# The space after the program name is essential to trigger completion for the program
# and not completion of the program name itself.
# Also, we use '> /dev/null 2>&1' since '&>' is not supported in older versions of fish.
complete --do-complete "${name} " > /dev/null 2>&1
end

# Remove any pre-existing completions for the program since we will be handling all of them.
complete -c ${name} -e

# This will get called after the two calls below and clear the cached result
complete -c ${name} -n '__${nameForVar}_clear_perform_completion_once_result'
# The call to __${nameForVar}_prepare_completions will setup __${nameForVar}_comp_results
# which provides the program's completion choices.
# If this doesn't require order preservation, we don't use the -k flag
complete -c ${name} -n 'not __${nameForVar}_requires_order_preservation && __${nameForVar}_prepare_completions' -f -a '$__${nameForVar}_comp_results'
# Otherwise we use the -k flag
complete -k -c ${name} -n '__${nameForVar}_requires_order_preservation && __${nameForVar}_prepare_completions' -f -a '$__${nameForVar}_comp_results'
`;
}
Loading
Loading