Add fish shell completion support (#1484)

* Add fish shell completion support

Cobra v1.9.1 already provides GenFishCompletion/GenFishCompletionFile,
so this wires fish into the existing completion command alongside bash
and zsh. Fish completions include inline descriptions during tab-complete.

- Add genFish() following the genBash/genZsh pattern
- Add fish detection in detectShell() and selectShell()
- Update Homebrew formula to generate and install stripe.fish
- Add completion_test.go (first tests for this file): detection,
  error paths, stdout generation, file creation, auto-detection
- Add stripe.fish to .gitignore

Closes #926

Committed-By-Agent: claude

* Address Copilot review feedback on shell detection

- Use filepath.Base() instead of strings.Contains() in detectShell()
  to prevent false positives when "fish" appears in a directory name
  (e.g. /home/shellfish/bin/csh no longer misdetects as fish)
- Differentiate error messages: "Unsupported shell" for explicit
  --shell with invalid value vs "Could not automatically detect"
  for the auto-detection path
- Add regression test for shellfish directory false-positive

Committed-By-Agent: claude

* fix: distinguish auto-detected vs explicit shell in completion output

When the user passes --shell explicitly, print "Generating <shell>
completion file" instead of "Detected <shell>". The "Detected" prefix
is now reserved for the auto-detection path where $SHELL is inspected.

Committed-By-Agent: claude

* fix: address review feedback on fish completion

- Add RegisterFlagCompletionFunc for --shell flag so tab-completion
  works on the completion command's own flag
- Use idiomatic value switch instead of boolean expression switch
- Simplify detectShell with multi-case return
- Add file creation tests for bash and zsh (parity with fish test)
- Extract runInTempDir test helper to reduce duplication

Committed-By-Agent: claude

* fix: remove unnecessary nolint directive on RegisterFlagCompletionFunc

Use blank identifier assignment instead of suppressing the errcheck
lint. The error can only occur if the flag name doesn't exist, which
is guaranteed not to happen since we register "shell" immediately above.

Committed-By-Agent: claude

* fix: lowercase error strings per Go conventions

Committed-By-Agent: claude

Author: mnorth-stripe

.gitignore

@@ -9,6 +9,7 @@ default_cassette.yaml
 .vscode/*.log
 stripe-completion.bash
 stripe-completion.zsh
+stripe.fish
 
 # Claude Code local configuration (auto-added)
 .claude/*.local.*

.goreleaser/mac.yml

@@ -60,11 +60,13 @@ brews:
     description: Stripe CLI utility
     install: |
       bin.install "stripe"
-      rm Dir["#{bin}/{stripe-completion.bash,stripe-completion.zsh}"]
+      rm Dir["#{bin}/{stripe-completion.bash,stripe-completion.zsh,stripe.fish}"]
       system bin/"stripe", "completion", "--shell", "bash"
       system bin/"stripe", "completion", "--shell", "zsh"
+      system bin/"stripe", "completion", "--shell", "fish"
       bash_completion.install "stripe-completion.bash"
       zsh_completion.install "stripe-completion.zsh"
+      fish_completion.install "stripe.fish"
       (zsh_completion/"_stripe").write <<~EOS
         #compdef stripe
         _stripe () {

pkg/cmd/completion.go

@@ -3,12 +3,11 @@ package cmd
 import (
 	"fmt"
 	"os"
-	"strings"
+	"path/filepath"
+	"runtime"
 
 	"github.com/spf13/cobra"
 
-	"runtime"
-
 	"github.com/stripe/stripe-cli/pkg/validators"
 )
 
@@ -24,16 +23,20 @@ func newCompletionCmd() *completionCmd {
 
 	cc.cmd = &cobra.Command{
 		Use:   "completion",
-		Short: "Generate bash and zsh completion scripts",
+		Short: "Generate bash, zsh, and fish completion scripts",
 		Args:  validators.NoArgs,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return selectShell(cc.shell, cc.writeToStdout)
 		},
 	}
 
-	cc.cmd.Flags().StringVar(&cc.shell, "shell", "", "The shell to generate completion commands for. Supports \"bash\" or \"zsh\"")
+	cc.cmd.Flags().StringVar(&cc.shell, "shell", "", "Shell to generate completions for: bash, zsh, or fish (auto-detected if omitted)")
 	cc.cmd.Flags().BoolVar(&cc.writeToStdout, "write-to-stdout", false, "Print completion script to stdout rather than creating a new file.")
 
+	_ = cc.cmd.RegisterFlagCompletionFunc("shell", func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		return []string{"bash", "zsh", "fish"}, cobra.ShellCompDirectiveNoFileComp
+	})
+
 	return cc
 }
 
@@ -84,30 +87,50 @@ Set up Stripe autocompletion:
 
 4. Either restart your terminal, or run the following command in your current session to enable immediately:
     source ~/.stripe/stripe-completion.bash`
+
+	fishCompletionInstructions = `
+1. Move ` + "`stripe.fish`" + ` to the fish completions directory:
+    mkdir -p ~/.config/fish/completions
+    mv stripe.fish ~/.config/fish/completions/stripe.fish
+
+Fish automatically loads completions from this directory, so no additional
+configuration is needed. Open a new terminal session and completions will
+be available.`
 )
 
 func selectShell(shell string, writeToStdout bool) error {
 	selected := shell
+	autoDetected := false
 	if selected == "" {
 		selected = detectShell()
+		autoDetected = selected != ""
 	}
 
 	switch selected {
 	case "zsh":
-		return genZsh(writeToStdout)
+		return genZsh(writeToStdout, autoDetected)
 	case "bash":
-		return genBash(writeToStdout)
+		return genBash(writeToStdout, autoDetected)
+	case "fish":
+		return genFish(writeToStdout, autoDetected)
 	default:
-		return fmt.Errorf("could not automatically detect your shell, please run the command with the `--shell` flag for either bash or zsh")
+		if shell != "" {
+			return fmt.Errorf("unsupported shell %q; supported shells are: bash, zsh, fish", shell)
+		}
+		return fmt.Errorf("could not automatically detect your shell; please run the command with the --shell flag for bash, zsh, or fish")
 	}
 }
 
-func genZsh(writeToStdout bool) error {
+func genZsh(writeToStdout bool, autoDetected bool) error {
 	if writeToStdout {
 		return rootCmd.GenZshCompletion(os.Stdout)
 	}
 
-	fmt.Println("Detected `zsh`, generating zsh completion file: stripe-completion.zsh")
+	if autoDetected {
+		fmt.Println("Detected `zsh`, generating zsh completion file: stripe-completion.zsh")
+	} else {
+		fmt.Println("Generating zsh completion file: stripe-completion.zsh")
+	}
 
 	err := rootCmd.GenZshCompletionFile("stripe-completion.zsh")
 	if err == nil {
@@ -117,12 +140,16 @@ func genZsh(writeToStdout bool) error {
 	return err
 }
 
-func genBash(writeToStdout bool) error {
+func genBash(writeToStdout bool, autoDetected bool) error {
 	if writeToStdout {
 		return rootCmd.GenBashCompletion(os.Stdout)
 	}
 
-	fmt.Println("Detected `bash`, generating bash completion file: stripe-completion.bash")
+	if autoDetected {
+		fmt.Println("Detected `bash`, generating bash completion file: stripe-completion.bash")
+	} else {
+		fmt.Println("Generating bash completion file: stripe-completion.bash")
+	}
 
 	err := rootCmd.GenBashCompletionFile("stripe-completion.bash")
 	if err == nil {
@@ -137,14 +164,33 @@ func genBash(writeToStdout bool) error {
 	return err
 }
 
+func genFish(writeToStdout bool, autoDetected bool) error {
+	if writeToStdout {
+		// true enables completion descriptions (fish displays them inline during tab-complete)
+		return rootCmd.GenFishCompletion(os.Stdout, true)
+	}
+
+	if autoDetected {
+		fmt.Println("Detected `fish`, generating fish completion file: stripe.fish")
+	} else {
+		fmt.Println("Generating fish completion file: stripe.fish")
+	}
+
+	// true enables completion descriptions (fish displays them inline during tab-complete)
+	err := rootCmd.GenFishCompletionFile("stripe.fish", true)
+	if err == nil {
+		fmt.Printf("%s%s\n", instructionsHeader, fishCompletionInstructions)
+	}
+
+	return err
+}
+
 func detectShell() string {
-	shell := os.Getenv("SHELL")
+	shell := filepath.Base(os.Getenv("SHELL"))
 
-	switch {
-	case strings.Contains(shell, "zsh"):
-		return "zsh"
-	case strings.Contains(shell, "bash"):
-		return "bash"
+	switch shell {
+	case "zsh", "bash", "fish":
+		return shell
 	default:
 		return ""
 	}

pkg/cmd/completion_test.go

@@ -0,0 +1,166 @@
+package cmd
+
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDetectShell(t *testing.T) {
+	tests := []struct {
+		name     string
+		envValue string
+		expected string
+	}{
+		{
+			name:     "detects bash from /bin/bash",
+			envValue: "/bin/bash",
+			expected: "bash",
+		},
+		{
+			name:     "detects zsh from /bin/zsh",
+			envValue: "/bin/zsh",
+			expected: "zsh",
+		},
+		{
+			name:     "detects fish from /usr/bin/fish",
+			envValue: "/usr/bin/fish",
+			expected: "fish",
+		},
+		{
+			name:     "detects fish from /opt/homebrew/bin/fish",
+			envValue: "/opt/homebrew/bin/fish",
+			expected: "fish",
+		},
+		{
+			name:     "detects bash even when path contains fish",
+			envValue: "/home/fishing/bin/bash",
+			expected: "bash",
+		},
+		{
+			name:     "detects zsh even when path contains fish",
+			envValue: "/home/shellfish/bin/zsh",
+			expected: "zsh",
+		},
+		{
+			name:     "does not false-positive on fish in directory name",
+			envValue: "/home/shellfish/bin/csh",
+			expected: "",
+		},
+		{
+			name:     "returns empty string for unknown shell",
+			envValue: "/bin/csh",
+			expected: "",
+		},
+		{
+			name:     "returns empty string when SHELL is empty",
+			envValue: "",
+			expected: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Setenv("SHELL", tt.envValue)
+			result := detectShell()
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestSelectShellErrors(t *testing.T) {
+	t.Run("explicit unsupported shell produces unsupported error", func(t *testing.T) {
+		err := selectShell("powershell", true)
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "unsupported shell")
+		assert.Contains(t, err.Error(), "powershell")
+	})
+
+	t.Run("empty shell with no SHELL env produces auto-detect error", func(t *testing.T) {
+		t.Setenv("SHELL", "")
+		err := selectShell("", true)
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "--shell")
+	})
+}
+
+func TestSelectShellWriteToStdout(t *testing.T) {
+	// rootCmd must be initialized for Cobra's completion generation to work.
+	// The init() function in root.go sets this up.
+	shells := []string{"bash", "zsh", "fish"}
+
+	for _, shell := range shells {
+		t.Run(shell, func(t *testing.T) {
+			err := selectShell(shell, true)
+			assert.NoError(t, err)
+		})
+	}
+}
+
+func TestSelectShellAutoDetectsFish(t *testing.T) {
+	t.Setenv("SHELL", "/usr/bin/fish")
+	err := selectShell("", true)
+	assert.NoError(t, err)
+}
+
+// runInTempDir executes fn in a temporary directory, restoring the original
+// working directory on cleanup.
+func runInTempDir(t *testing.T, fn func()) {
+	t.Helper()
+	originalWd, err := os.Getwd()
+	require.NoError(t, err)
+
+	tmpDir := t.TempDir()
+	require.NoError(t, os.Chdir(tmpDir))
+	t.Cleanup(func() {
+		if err := os.Chdir(originalWd); err != nil {
+			t.Errorf("failed to restore working directory: %v", err)
+		}
+	})
+
+	fn()
+}
+
+func TestGenShellCreatesFile(t *testing.T) {
+	tests := []struct {
+		name         string
+		genFunc      func(bool, bool) error
+		filename     string
+		contentMatch string
+	}{
+		{
+			name:         "bash",
+			genFunc:      genBash,
+			filename:     "stripe-completion.bash",
+			contentMatch: "bash completion",
+		},
+		{
+			name:         "zsh",
+			genFunc:      genZsh,
+			filename:     "stripe-completion.zsh",
+			contentMatch: "zsh completion",
+		},
+		{
+			name:         "fish",
+			genFunc:      genFish,
+			filename:     "stripe.fish",
+			contentMatch: "fish completion for stripe",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			runInTempDir(t, func() {
+				err := tt.genFunc(false, false)
+				require.NoError(t, err)
+
+				content, err := os.ReadFile(tt.filename)
+				require.NoError(t, err)
+				assert.NotEmpty(t, content)
+				assert.Contains(t, string(content), tt.contentMatch)
+			})
+		})
+	}
+}