fix: make shell completions work for git wt subcommand

When invoked as `git wt <TAB>`, each shell's git completion system
dispatches to a shell-specific handler. However, cobra's generated
completions assume the binary name is the first word (`git-wt`), so
the completion request is malformed when the command line starts with
`git wt`.

**zsh**: `_git` uses `(-)*:: :->option-or-argument` which shifts
words so that `words[1]` is the subcommand name (`wt`), not `git`.
Inject a shim at the top of `_git-wt()` that rewrites `words[1]`
from `wt` to `git-wt`.

**bash**: `_git` calls `_git_wt()` (underscore form) which does not
exist in cobra's output. Append a bridge function that rewrites
COMP_WORDS from `(git wt ...)` to `(git-wt ...)` and delegates to
`__start_git-wt`.

**fish**: Not addressed here as fish uses a fundamentally different
completion model (`complete -c`) with no automatic subcommand
discovery mechanism for external tools.

Closes #20

Change-Id: Id7c03ae859130c997b775c5da23f9ea26a6a6964

Author: ahmedelgabri

internal/cmd/completion.go

@@ -1,7 +1,10 @@
 package cmd
 
 import (
+	"bytes"
+	"io"
 	"os"
+	"strings"
 
 	"github.com/spf13/cobra"
 )
@@ -14,9 +17,9 @@ var completionCmd = &cobra.Command{
 	RunE: func(cmd *cobra.Command, args []string) error {
 		switch args[0] {
 		case "bash":
-			return rootCmd.GenBashCompletion(os.Stdout)
+			return genBashCompletion(rootCmd, os.Stdout)
 		case "zsh":
-			return rootCmd.GenZshCompletion(os.Stdout)
+			return genZshCompletion(rootCmd, os.Stdout)
 		case "fish":
 			return rootCmd.GenFishCompletion(os.Stdout, true)
 		default:
@@ -25,6 +28,68 @@ var completionCmd = &cobra.Command{
 	},
 }
 
+// bashGitSubcommandShim is appended to the bash completion so that "git wt"
+// completions work in addition to standalone "git-wt".
+//
+// Bash's git completion calls _git_wt (underscore form) when completing
+// "git wt ...". This bridge rewrites COMP_WORDS from (git wt ...) to
+// (git-wt ...) and delegates to cobra's generated entry point.
+const bashGitSubcommandShim = `
+# Bridge for "git wt" subcommand completion in bash.
+# Bash's git completion calls _git_wt() when completing "git wt ...".
+_git_wt() {
+    COMP_WORDS=(git-wt "${COMP_WORDS[@]:2}")
+    (( COMP_CWORD -= 1 ))
+    __start_git-wt
+}
+`
+
+// zshGitSubcommandShim is injected into the zsh completion function so that
+// completions work when invoked as "git wt" (a git subcommand) in addition
+// to the standalone "git-wt" command.
+//
+// zsh's _git uses '(-)*:: :->option-or-argument' which shifts words so that
+// words[1] is the subcommand name ("wt"), not "git". Cobra's __complete
+// mechanism needs words[1] to be the binary name ("git-wt"), so we rewrite it.
+const zshGitSubcommandShim = `    # Normalize "wt" to "git-wt" so completions work as a git subcommand.
+    # When zsh's _git dispatches here, words[1] is already "wt" (not "git").
+    if [[ "${words[1]}" = "wt" ]]; then
+        words[1]="git-wt"
+    fi
+
+`
+
+// genBashCompletion generates bash completions with a _git_wt bridge so that
+// completions work for both "git-wt" (standalone) and "git wt" (subcommand).
+func genBashCompletion(cmd *cobra.Command, w io.Writer) error {
+	var buf bytes.Buffer
+	if err := cmd.GenBashCompletion(&buf); err != nil {
+		return err
+	}
+
+	output := buf.String() + bashGitSubcommandShim
+
+	_, err := io.WriteString(w, output)
+	return err
+}
+
+// genZshCompletion generates zsh completions with an injected shim so that
+// completions work for both "git-wt" (standalone) and "git wt" (subcommand).
+func genZshCompletion(cmd *cobra.Command, w io.Writer) error {
+	var buf bytes.Buffer
+	if err := cmd.GenZshCompletion(&buf); err != nil {
+		return err
+	}
+
+	output := buf.String()
+
+	const marker = "_git-wt()\n{\n"
+	output = strings.Replace(output, marker, marker+zshGitSubcommandShim, 1)
+
+	_, err := io.WriteString(w, output)
+	return err
+}
+
 func init() {
 	rootCmd.AddCommand(completionCmd)
 }

internal/cmd/completion_test.go

@@ -0,0 +1,89 @@
+package cmd
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestGenBashCompletion_containsSubcommandBridge(t *testing.T) {
+	var buf bytes.Buffer
+	if err := genBashCompletion(rootCmd, &buf); err != nil {
+		t.Fatalf("genBashCompletion returned error: %v", err)
+	}
+
+	output := buf.String()
+
+	// The _git_wt bridge function definition should appear exactly once.
+	if count := strings.Count(output, "_git_wt() {"); count != 1 {
+		t.Errorf("expected _git_wt bridge to appear once, got %d", count)
+	}
+
+	// It should rewrite COMP_WORDS and delegate to __start_git-wt.
+	if !strings.Contains(output, `COMP_WORDS=(git-wt "${COMP_WORDS[@]:2}")`) {
+		t.Error("missing COMP_WORDS rewrite in _git_wt bridge")
+	}
+
+	if !strings.Contains(output, "__start_git-wt") {
+		t.Error("missing __start_git-wt delegation in _git_wt bridge")
+	}
+}
+
+func TestGenBashCompletion_preservesOriginal(t *testing.T) {
+	var buf bytes.Buffer
+	if err := genBashCompletion(rootCmd, &buf); err != nil {
+		t.Fatalf("genBashCompletion returned error: %v", err)
+	}
+
+	output := buf.String()
+
+	if !strings.Contains(output, "complete -o default -F __start_git-wt git-wt") &&
+		!strings.Contains(output, "complete -o default -o nospace -F __start_git-wt git-wt") {
+		t.Error("missing original complete registration for standalone git-wt")
+	}
+}
+
+func TestGenZshCompletion_containsSubcommandShim(t *testing.T) {
+	var buf bytes.Buffer
+	if err := genZshCompletion(rootCmd, &buf); err != nil {
+		t.Fatalf("genZshCompletion returned error: %v", err)
+	}
+
+	output := buf.String()
+
+	// The shim should appear exactly once inside the _git-wt() function.
+	if count := strings.Count(output, `words[1]="git-wt"`); count != 1 {
+		t.Errorf("expected subcommand normalization shim to appear once, got %d", count)
+	}
+
+	// Verify the shim comes after the function definition and before the
+	// first local variable declaration.
+	shimIdx := strings.Index(output, `Normalize "wt"`)
+	funcIdx := strings.Index(output, "_git-wt()\n{")
+	localIdx := strings.Index(output, "local shellCompDirectiveError")
+
+	if shimIdx == -1 || funcIdx == -1 || localIdx == -1 {
+		t.Fatal("missing expected sections in zsh completion output")
+	}
+
+	if !(funcIdx < shimIdx && shimIdx < localIdx) {
+		t.Error("subcommand shim is not in the expected position (after function opening, before locals)")
+	}
+}
+
+func TestGenZshCompletion_preservesCompdef(t *testing.T) {
+	var buf bytes.Buffer
+	if err := genZshCompletion(rootCmd, &buf); err != nil {
+		t.Fatalf("genZshCompletion returned error: %v", err)
+	}
+
+	output := buf.String()
+
+	if !strings.Contains(output, "#compdef git-wt") {
+		t.Error("missing #compdef header")
+	}
+
+	if !strings.Contains(output, "compdef _git-wt git-wt") {
+		t.Error("missing compdef registration")
+	}
+}