Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting

• @codex fix this CI failure
• @codex address that feedback

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting

• @codex fix this CI failure
• @codex address that feedback

cmd/wtp/add.go (1)

398-403: Filter suggestions by current prefix

Currently prints all branches. Filter by the typed prefix to avoid overwhelming candidates and to align with other completions.

 func completeBranches(_ context.Context, cmd *cli.Command) {
-	current, previous := completionArgsFromCommand(cmd)
+	current, previous := completionArgsFromCommand(cmd)
 	if maybeCompleteFlagSuggestions(cmd, current, previous) {
 		return
 	}
+
+	prefix := strings.TrimSuffix(current, "*")
 
 	var buf bytes.Buffer
 	if err := getBranches(&buf); err != nil {
 		return
 	}
 
 	// Output each line using fmt.Println for urfave/cli compatibility
 	scanner := bufio.NewScanner(&buf)
 	for scanner.Scan() {
-		fmt.Println(scanner.Text())
+		line := scanner.Text()
+		if prefix != "" && !strings.HasPrefix(line, prefix) {
+			continue
+		}
+		fmt.Println(line)
 	}
 }

Also applies to: 410-414

README.md (1)

255-258: Docs LGTM; optional copyedits for clarity

Nice update. Optional tightening:

• “No rc edits needed” → “No RC edits needed.”
• “Need to refresh inside an existing shell?” → “To refresh in the current shell, run:”
• Bash note: “Homebrew’s Bash 5.x” → “Homebrew Bash 5.x”
• “You can use it in two ways:” → “Use it in either of two ways:”
• “go install users” → “go-install users”

No functional changes needed. As per coding guidelines.

Also applies to: 260-261, 279-283, 288-290, 303-307, 323-326

cmd/wtp/cd.go (1)

358-370: Add prefix filtering to completion output

You compute currentNormalized but don’t filter by it. Limit candidates to those starting with the prefix.

 func completeWorktreesForCd(_ context.Context, cmd *cli.Command) {
 	current, previous := completionArgsFromCommand(cmd)
 
 	if maybeCompleteFlagSuggestions(cmd, current, previous) {
 		return
 	}
 
 	currentNormalized := strings.TrimSuffix(current, "*")
 
 	if currentNormalized == "" && len(previous) > 0 {
 		return
 	}
@@
 	scanner := bufio.NewScanner(&buf)
 	for scanner.Scan() {
 		raw := scanner.Text()
 		candidate := strings.TrimSuffix(raw, "*")
 
 		if candidate == "" {
 			continue
 		}
 
+		if currentNormalized != "" && !strings.HasPrefix(candidate, currentNormalized) {
+			continue
+		}
+
 		if _, exists := used[candidate]; exists {
 			continue
 		}
 
 		if currentNormalized != "" && candidate == currentNormalized {
 			continue
 		}
 
 		fmt.Println(candidate)
 	}
 }

Also applies to: 388-404

cmd/wtp/testdata/completion/bash_input.sh (1)

14-14: Minor shellcheck nits in fixture (safe to ignore if mirroring upstream)

• Line 14: base is unused (SC2034).
• Line 29: COMPREPLY=($(...)) warns about word splitting (SC2207).

If this file intentionally mirrors upstream input for patching tests, keep as-is. If it ships to users, remove base and consider mapfile/read -a to populate COMPREPLY safely.

Also applies to: 29-29

cmd/wtp/flag_completion_test.go (2)

12-33: Flag completion (long flag) test is solid

Covers matching and excludes --generate-shell-completion from output. Consider t.Parallel() for faster suite runs.

---

35-56: Broaden assertions for single-hyphen case

Test is good. Optionally:

• Add t.Parallel().
• Assert that short alias "-f" or "--force" is present explicitly.
• Also assert exclusion of --generate-shell-completion here for symmetry.

cmd/wtp/testdata/completion/fish_expected.fish (1)

25-41: Fixture looks correct

The dynamic completion helper is fine as an expected artifact. If you see noisy stderr from wtp during completion, consider redirecting stderr in the helper in future iterations, but no change needed for this expected file.

cmd/wtp/completion_config.go (2)

20-44: Restore c.Writer with defer to avoid leaks on early returns/panics

Use a defer to guarantee writer restoration instead of duplicating assignments on both paths.

 func configureCompletionCommand(cmd *cli.Command) {
@@
   cmd.Action = func(ctx context.Context, c *cli.Command) error {
     writer := c.Writer
     if writer == nil {
       writer = os.Stdout
     }
 
     var buf bytes.Buffer
     c.Writer = &buf
+    defer func() { c.Writer = writer }()
 
-    if err := originalAction(ctx, c); err != nil {
-      c.Writer = writer
-      return err
-    }
-
-    c.Writer = writer
+    if err := originalAction(ctx, c); err != nil {
+      return err
+    }
@@
     script := patchCompletionScript(shell, buf.String())
     _, err := writer.Write([]byte(script))
     return err
   }
 }

---

130-136: Quote ${cur} and consider a more robust patch to future-proof against urfave/cli changes

• Quote the compgen arg to avoid word-splitting/globbing (and to satisfy ShellCheck).
• The target match is an exact multi-line string; consider a fallback that patches when indentation or whitespace differs.

-const replacement = "    opts=$(eval \"${requestComp}\" 2>/dev/null)\n" +
-    "    opts=$(_wtp_sanitize_completion_list <<<\"${opts}\")\n" +
-    "    COMPREPLY=($(compgen -W \"${opts}\" -- ${cur}))"
+const replacement = "    opts=$(eval \"${requestComp}\" 2>/dev/null)\n" +
+    "    opts=$(_wtp_sanitize_completion_list <<<\"${opts}\")\n" +
+    "    COMPREPLY=($(compgen -W \"${opts}\" -- \"${cur}\"))"

Optional hardening (if target isn’t found): search for the COMPREPLY line by prefix and replace that line only; or use a small regexp. This will make the patch resilient to minor upstream template tweaks. [Chill mode]

cmd/wtp/flag_completion.go (2)

101-107: Optional: simpler hyphen rule

Current logic prefixes up to two hyphens based on name length. If you prefer an explicit rule, use 1 hyphen for single-rune names, else 2. Behavior is equivalent for most cases; readability only.

if utf8.RuneCountInString(name) == 1 {
  return "-" + name
}
return "--" + name

---

136-152: go.mod Go version meets slices.Index requirement; optional hyphen rule simplification

• go.mod declares Go 1.24.4, so using slices.Index (Go 1.21+) is valid.
• Optional: simplify flag prefix logic by using “-” for single-rune flags and “--” for longer flags.

cmd/wtp/completion_config_test.go (1)

11-40: Consider tests for completionArgsFromCommand and filterCompletionArgs

Nice coverage. Add small table-driven tests for:

• completionArgsFromCommand: empty args, only completion flag, several args with completion flag removed.
• filterCompletionArgs: ensure only the completion flag is filtered.

Also applies to: 82-103, 115-137

cmd/wtp/testdata/completion/bash_expected.sh (1)

28-49: Silence ShellCheck warnings: quote ${cur}; drop unused 'base'

Optional improvements (will require aligning patch or input template):

• Quote ${cur} in compgen.
• Remove unused local ‘base’.

-    local cur opts base words
+    local cur opts words
@@
-    COMPREPLY=($(compgen -W "${opts}" -- ${cur}))
+    COMPREPLY=($(compgen -W "${opts}" -- "${cur}"))

If you adopt the quoted ${cur}, also adjust patchBashCompletionScript replacement to emit the quoted form so tests stay green. Based on static analysis hints.

Also applies to: 45-47

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: CR
PR: satococoa/wtp#0
File: AGENTS.md:0-0
Timestamp: 2025-10-07T15:56:11.510Z
Learning: Applies to cmd/wtp/** : Command behavior: wtp completion <shell> generates pure completion scripts via urfave/cli

Learnt from: CR
PR: satococoa/wtp#0
File: AGENTS.md:0-0
Timestamp: 2025-10-07T15:56:11.510Z
Learning: Applies to cmd/wtp/** : Command behavior: wtp hook <shell> emits shell functions that intercept wtp cd; wtp shell-init <shell> combines completion and hook output

Learnt from: CR
PR: satococoa/wtp#0
File: AGENTS.md:0-0
Timestamp: 2025-10-07T15:56:11.510Z
Learning: Applies to cmd/wtp/completion.go : Use getWorktreeNameFromPath() to resolve worktree display names consistently across completion, errors, and parsing

Learnt from: CR
PR: satococoa/wtp#0
File: AGENTS.md:0-0
Timestamp: 2025-10-07T15:56:11.510Z
Learning: Applies to README.md : Update README when user-facing behavior changes

Learnt from: CR
PR: satococoa/wtp#0
File: AGENTS.md:0-0
Timestamp: 2025-10-07T15:56:11.510Z
Learning: Applies to cmd/wtp/** : Command behavior: wtp cd prints only the absolute worktree path with no side effects

Learnt from: CR
PR: satococoa/wtp#0
File: AGENTS.md:0-0
Timestamp: 2025-10-07T15:56:11.510Z
Learning: Applies to cmd/wtp/** : CLI entrypoint and commands are implemented under cmd/wtp

cmd/wtp/completion_config.go (1)

106-137: Make bash patch resilient; also quote ${cur}

The exact strings.Replace against a fixed block is brittle across upstream cli changes. Add a regex-based fallback and ensure we always inject the sanitizer before COMPREPLY. Also quote ${cur} to avoid word-splitting.

Apply this diff:

@@
-import (
+import (
 	"bytes"
 	"context"
 	"os"
 	"strings"
 
 	"github.com/urfave/cli/v3"
+	"regexp"
 )
@@
 func patchBashCompletionScript(script string) string {
 	if strings.Contains(script, "_wtp_sanitize_completion_list") {
 		return script
 	}
@@
-	script = strings.Replace(script, "__wtp_bash_autocomplete() {", helper+"\n__wtp_bash_autocomplete() {", 1)
+	script = strings.Replace(script, "__wtp_bash_autocomplete() {", helper+"\n__wtp_bash_autocomplete() {", 1)
 
-	const target = "    opts=$(eval \"${requestComp}\" 2>/dev/null)\n    COMPREPLY=($(compgen -W \"${opts}\" -- ${cur}))"
-	const replacement = "    opts=$(WTP_SHELL_COMPLETION=1 eval \"${requestComp}\" 2>/dev/null)\n" +
-		"    opts=$(_wtp_sanitize_completion_list <<<\"${opts}\")\n" +
-		"    COMPREPLY=($(compgen -W \"${opts}\" -- ${cur}))"
+	const target = "    opts=$(eval \"${requestComp}\" 2>/dev/null)\n    COMPREPLY=($(compgen -W \"${opts}\" -- ${cur}))"
+	const replacement = "    opts=$(WTP_SHELL_COMPLETION=1 eval \"${requestComp}\" 2>/dev/null)\n" +
+		"    opts=$(_wtp_sanitize_completion_list <<<\"${opts}\")\n" +
+		"    COMPREPLY=($(compgen -W \"${opts}\" -- \"${cur}\"))"
 
-	script = strings.Replace(script, target, replacement, 1)
+	// Try exact block replace first
+	replaced := strings.Replace(script, target, replacement, 1)
+	if replaced != script {
+		return replaced
+	}
+
+	// Fallback: regex-driven patching (handles whitespace/indent changes)
+	// 1) Prefix WTP_SHELL_COMPLETION=1 to the opts eval line.
+	reOpts := regexp.MustCompile(`(?m)^(\s*)opts=\$\(\s*eval\s+("?\$\{requestComp\}"?\s*)2>/dev/null\)\s*$`)
+	replaced = reOpts.ReplaceAllString(script, `${1}opts=$(WTP_SHELL_COMPLETION=1 eval ${2}2>/dev/null)`)
+
+	// 2) Ensure sanitizer runs immediately before COMPREPLY assignment.
+	reReply := regexp.MustCompile(`(?m)^(\s*)COMPREPLY=\(\$\(compgen -W\s+"?\$\{opts\}"?\s+--\s+("?)(\$\{?cur\}?)(\2)\)\)\s*$`)
+	replaced = reReply.ReplaceAllString(replaced, `${1}opts=$(_wtp_sanitize_completion_list <<<"${opts}")`+"\n"+`${0}`)
+
+	return replaced
 }

cmd/wtp/completion_config.go (3)

58-104: Harden fish output emission (avoid globbing/splitting); use printf

echo can glob/split in fish. Prefer printf to emit candidates verbatim.

Apply this diff:

-				echo $parts[1]
+				printf "%s\n" -- $parts[1]
...
-		echo $line
+		printf "%s\n" -- $line

---

130-134: Quote ${cur} in compgen

Prevents accidental word-splitting/globbing on current token.

Apply this diff:

-		"    COMPREPLY=($(compgen -W \"${opts}\" -- ${cur}))"
+		"    COMPREPLY=($(compgen -W \"${opts}\" -- \"${cur}\"))"

---

20-44: Slight cleanup: defer writer restore

Use defer to guarantee restoration on early returns and reduce repetition.

Apply this diff:

 	cmd.Action = func(ctx context.Context, c *cli.Command) error {
 		writer := c.Writer
 		if writer == nil {
 			writer = os.Stdout
 		}
 
 		var buf bytes.Buffer
 		c.Writer = &buf
+		defer func() { c.Writer = writer }()
 
-		if err := originalAction(ctx, c); err != nil {
-			c.Writer = writer
-			return err
-		}
-
-		c.Writer = writer
+		if err := originalAction(ctx, c); err != nil {
+			return err
+		}

cmd/wtp/testdata/completion/bash_expected.sh (2)

30-30: Remove unused local

base is unused. Drop it to satisfy shellcheck (SC2034).

Apply this diff:

-    local cur opts base words
+    local cur opts words

---

46-46: Quote ${cur} in compgen

Avoids word-splitting/globbing on the current token.

Apply this diff:

-    COMPREPLY=($(compgen -W "${opts}" -- ${cur}))
+    COMPREPLY=($(compgen -W "${opts}" -- "${cur}"))

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: CR
PR: satococoa/wtp#0
File: AGENTS.md:0-0
Timestamp: 2025-10-07T15:56:11.510Z
Learning: Applies to cmd/wtp/** : Command behavior: wtp completion <shell> generates pure completion scripts via urfave/cli

Learnt from: CR
PR: satococoa/wtp#0
File: AGENTS.md:0-0
Timestamp: 2025-10-07T15:56:11.510Z
Learning: Applies to cmd/wtp/** : Command behavior: wtp hook <shell> emits shell functions that intercept wtp cd; wtp shell-init <shell> combines completion and hook output

cmd/wtp/flag_completion.go (2)

116-140: Early return prevents blocking positional suggestions.

The function correctly returns false when current is empty (line 117-119), which allows positional argument completion to proceed. This addresses the concern raised in previous reviews about blocking positional suggestions after flags.

The empty block at lines 128-129 is intentional (handles sentinel -- separator) and documented with a comment, so the static analysis warning can be safely ignored.

---

142-158: Bounds checks are correct.

The array access is properly guarded:

• Line 144 ensures index > 0 before accessing os.Args[index-1] (line 148)
• Line 150 ensures index >= sentinelArgOffset (which is 2) before accessing os.Args[index-2] (line 151)

Since slices.Index returns a valid index when the element is found, these checks guarantee safe array access.

cmd/wtp/flag_completion_test.go (2)

55-56: Tighten assertions for consistent formatting.

The OR conditions are overly permissive. Based on formatCompletion, multi-character names like "with-branch" and "force" should always receive double hyphens (--), never single hyphens. The test will pass even if the formatting is incorrect.

Apply this diff to use exact assertions:

-	require.True(t, strings.Contains(output, "--with-branch") || strings.Contains(output, "-with-branch"))
-	require.True(t, strings.Contains(output, "--force") || strings.Contains(output, "-force"))
+	require.Contains(t, output, "--with-branch")
+	require.Contains(t, output, "--force")

---

71-82: LGTM!

The test validates that single-hyphen sentinels in the previous list are correctly ignored. Both test cases confirm proper handling of the sentinel pattern.

Consider adding a test case for the double-hyphen sentinel (--) to ensure complete coverage of the sentinel handling logic at line 128 of flag_completion.go:

func TestMaybeCompleteFlagSuggestions_IgnoresDoubleDashSentinel(t *testing.T) {
	cmd := &cli.Command{
		Writer: io.Discard,
		Flags: []cli.Flag{
			&cli.BoolFlag{Name: "force"},
		},
	}

	require.False(t, maybeCompleteFlagSuggestions(cmd, "feature", []string{"--"}))
	require.False(t, maybeCompleteFlagSuggestions(cmd, "", []string{"--"}))
}

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

cmd/wtp/flag_completion.go (1)

142-158: OS args backtrack is bounds-safe; optional readability tweak.

Current guards prevent underflow when accessing index-2. For clarity, invert the condition to exit early:

 	if candidate == "-" || candidate == "--" {
-		if index >= sentinelArgOffset {
-			candidate = os.Args[index-2]
-		} else {
-			return "", false
-		}
+		if index < sentinelArgOffset {
+			return "", false
+		}
+		candidate = os.Args[index-2]
 	}

cmd/wtp/flag_completion.go (1)

69-75: Broaden visibility check for urfave/cli compatibility.

Support both IsVisible() and Visible() to be resilient across versions.

-func isFlagVisible(flag cli.Flag) bool {
-	if visibility, ok := flag.(interface{ IsVisible() bool }); ok && !visibility.IsVisible() {
-		return false
-	}
-	return true
-}
+func isFlagVisible(flag cli.Flag) bool {
+	// urfave/cli variants expose either IsVisible() or Visible().
+	if v, ok := any(flag).(interface{ IsVisible() bool }); ok {
+		return v.IsVisible()
+	}
+	if v, ok := any(flag).(interface{ Visible() bool }); ok {
+		return v.Visible()
+	}
+	return true
+}

Based on learnings.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

cmd/wtp/flag_completion_test.go (1)

56-57: Tighten test assertions for multi-character flag names.

The || conditions at lines 56-57 are overly permissive. According to formatCompletion, multi-character flag names like "with-branch" always receive two hyphens ("--with-branch"), never one. The fallback branches ("-with-branch" and "-force") can never be true and may mask bugs.

Use separate assertions for short-form aliases (single-char) vs long-form flags, or remove the fallback branches entirely.

Apply this diff to make assertions more precise:

 	output := buf.String()
-	require.True(t, strings.Contains(output, "--with-branch") || strings.Contains(output, "-with-branch"))
-	require.True(t, strings.Contains(output, "--force") || strings.Contains(output, "-force"))
+	require.Contains(t, output, "--with-branch", "Expected long form of multi-char flag")
+	// Check for either long form or short alias
+	require.True(t, 
+		strings.Contains(output, "--force") || strings.Contains(output, "-f"),
+		"Expected either long form or short alias for force flag")

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

cmd/wtp/completion_config.go (1)

158-166: Make Bash patching resilient to upstream generator changes.

Exact-match multi-line replace on requestComp/COMPREPLY is brittle if urfave/cli alters whitespace or variable names. Prefer a regex-based patch over the specific assignment+COMPREPLY block, or add a fallback when the target isn’t found.

Keeps golden tests but reduces future breakage if cli/v3 changes its bash generator.

cmd/wtp/completion_config.go (2)

79-83: Simplify replace loop (fix gosimple S1017).

The Contains check is unnecessary. strings.Replace with n=1 is a no-op when target is absent. This also clears the linter warning.

As per coding guidelines and static analysis hints.

-	for _, r := range replacements {
-		if strings.Contains(script, r.target) {
-			script = strings.Replace(script, r.target, r.replacement, 1)
-		}
-	}
+	for _, r := range replacements {
+		script = strings.Replace(script, r.target, r.replacement, 1)
+	}

---

69-77: Bring long Zsh patterns under lll=120.

The inline target/replacement literals exceed 120 chars. Split them with concatenation to satisfy lll without changing behavior.

As per coding guidelines and static analysis hints.

-	replacements := []struct {
-		target      string
-		replacement string
-	}{
-		{
-			target:      `opts=("${(@f)$(${words[@]:0:#words[@]-1} ${current} --generate-shell-completion)}")`,
-			replacement: `opts=("${(@f)$(env WTP_SHELL_COMPLETION=1 ${words[@]:0:#words[@]-1} ${current} --generate-shell-completion)}")`,
-		},
-		{
-			target:      `opts=("${(@f)$(${words[@]:0:#words[@]-1} --generate-shell-completion)}")`,
-			replacement: `opts=("${(@f)$(env WTP_SHELL_COMPLETION=1 ${words[@]:0:#words[@]-1} --generate-shell-completion)}")`,
-		},
-	}
+	// Keep patterns within 120 columns.
+	zshCurrentTarget := "opts=(\"${(@f)$(" +
+		"${words[@]:0:#words[@]-1} ${current} --generate-shell-completion)}\")"
+	zshCurrentReplacement := "opts=(\"${(@f)$(env WTP_SHELL_COMPLETION=1 " +
+		"${words[@]:0:#words[@]-1} ${current} --generate-shell-completion)}\")"
+	zshSubCmdTarget := "opts=(\"${(@f)$(" +
+		"${words[@]:0:#words[@]-1} --generate-shell-completion)}\")"
+	zshSubCmdReplacement := "opts=(\"${(@f)$(env WTP_SHELL_COMPLETION=1 " +
+		"${words[@]:0:#words[@]-1} --generate-shell-completion)}\")"
+
+	replacements := []struct {
+		target      string
+		replacement string
+	}{
+		{target: zshCurrentTarget, replacement: zshCurrentReplacement},
+		{target: zshSubCmdTarget, replacement: zshSubCmdReplacement},
+	}

cmd/wtp/flag_completion.go (1)

126-133: Remove empty block and fold sentinel check.

Clean up the no-op branch and satisfy revive’s empty-block warning.

As per coding guidelines and linter.

-	if len(previous) > 0 {
-		last := strings.TrimSuffix(previous[len(previous)-1], "*")
-		if last == "-" || last == "--" {
-			// Sentinel separating flags from positionals; ignore for flag completion.
-		} else if last != "" && last != currentNormalized && tryFlagCompletion(cmd, last) {
-			return true
-		}
-	}
+	if len(previous) > 0 {
+		last := strings.TrimSuffix(previous[len(previous)-1], "*")
+		// Sentinel ("-" or "--") separates flags from positionals; ignore for flag completion.
+		if last != "-" && last != "--" &&
+			last != "" && last != currentNormalized &&
+			tryFlagCompletion(cmd, last) {
+			return true
+		}
+	}

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: CR
PR: satococoa/wtp#0
File: AGENTS.md:0-0
Timestamp: 2025-10-07T15:56:11.510Z
Learning: Applies to cmd/wtp/** : Command behavior: wtp completion <shell> generates pure completion scripts via urfave/cli

cmd/wtp/completion_config_test.go (1)

125-127: Remove loop var copy in Go 1.22+ (optional).

tc := tc can be dropped; closures now capture per-iteration values.

-    tc := tc
     t.Run(tc.shell, func(t *testing.T) {

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: CR
PR: satococoa/wtp#0
File: AGENTS.md:0-0
Timestamp: 2025-10-07T15:56:11.510Z
Learning: Applies to cmd/wtp/** : CLI entrypoint and commands are implemented under cmd/wtp

Learnt from: CR
PR: satococoa/wtp#0
File: AGENTS.md:0-0
Timestamp: 2025-10-07T15:56:11.510Z
Learning: Applies to cmd/wtp/** : Command behavior: wtp completion <shell> generates pure completion scripts via urfave/cli

Learnt from: CR
PR: satococoa/wtp#0
File: AGENTS.md:0-0
Timestamp: 2025-10-07T15:56:11.510Z
Learning: Applies to cmd/wtp/** : Command behavior: wtp hook <shell> emits shell functions that intercept wtp cd; wtp shell-init <shell> combines completion and hook output

cmd/wtp/completion_config.go (1)

139-170: String replace is brittle against upstream changes; prefer regex or anchored patterns

Exact string matching for the bash patch can silently fail on minor upstream formatting changes. Consider regex (e.g., locate the eval/COMPREPLY block by pattern) or generating from a small template with placeholders to make the patch resilient.

cmd/wtp/flag_completion.go (1)

116-137: Don’t block positional completions after a trailing space

Current logic treats the previous token as a flag even when the user has finished it (current is empty after a space), so commands like “wtp remove --force ” keep suggesting flags and never reach worktree names.

Gate previous/OS-args flag completion on “cursor still within the token” (suffix “*”) and avoid using OS-args when we’ve moved past the flag.

Apply:

 func maybeCompleteFlagSuggestions(cmd *cli.Command, current string, previous []string) bool {
   currentNormalized := strings.TrimSuffix(current, "*")
   if currentNormalized != "" && tryFlagCompletion(cmd, currentNormalized) {
     return true
   }
 
-  if len(previous) > 0 {
-    last := strings.TrimSuffix(previous[len(previous)-1], "*")
-    // Sentinel separating flags from positionals; ignore for flag completion.
-    if last != "" && last != "-" && last != "--" && last != currentNormalized && tryFlagCompletion(cmd, last) {
-      return true
-    }
-  }
+  // Only consider the previous token as a flag candidate if the cursor is still inside it (no trailing space).
+  var prevInWord bool
+  if len(previous) > 0 {
+    prevRaw := previous[len(previous)-1]
+    prevInWord = strings.HasSuffix(prevRaw, "*")
+    last := strings.TrimSuffix(prevRaw, "*")
+    // Sentinel separating flags from positionals; ignore for flag completion.
+    if prevInWord && last != "" && last != "-" && last != "--" && last != currentNormalized && tryFlagCompletion(cmd, last) {
+      return true
+    }
+  }
 
-  if candidate, ok := flagCandidateFromOSArgs(); ok {
-    if candidate != "" && candidate != currentNormalized && tryFlagCompletion(cmd, candidate) {
-      return true
-    }
-  }
+  // OS-args fallback only when cursor is within a token (or we have a non-empty current).
+  if candidate, ok := flagCandidateFromOSArgs(); ok {
+    if (currentNormalized != "" || prevInWord) &&
+      candidate != "" && candidate != currentNormalized && tryFlagCompletion(cmd, candidate) {
+      return true
+    }
+  }
 
   return false
 }

This enables positional suggestions after a space and keeps flag completion responsive while typing the flag itself. Based on learnings.

cmd/wtp/testdata/completion/zsh_expected.zsh (1)

1-2: Optional: drop redundant directive

Having both “#compdef wtp” and “compdef _wtp wtp” is redundant. Keeping only the compdef line is sufficient.

cmd/wtp/completion_config.go (2)

60-89: Same fragility concern for zsh patch

zsh patch relies on matching precise lines. Use regex-based replacement (or generate the function body from a template) to avoid breakage when urfave/cli tweaks spacing or quoting.

---

172-192: Arg normalization is safe but only affects app.Run args

normalizeCompletionArgs returns a new args slice for app.Run; OS-args fallbacks read from os.Args. If divergence ever matters, consider threading normalized args to the fallback path, or document that OS-args use raw argv by design.

cmd/wtp/completion_config_test.go (3)

19-21: Consider extracting repeated DeepEqual assertions into a helper.

The same pattern appears four times. Extracting it would reduce duplication and improve maintainability.

Add a helper function:

func assertEqualSlices(t *testing.T, got, want []string) {
	t.Helper()
	if !reflect.DeepEqual(got, want) {
		t.Fatalf("got %v, want %v", got, want)
	}
}

Then replace each occurrence:

-		if !reflect.DeepEqual(got, want) {
-			t.Fatalf("normalizeCompletionArgs() = %v, want %v", got, want)
-		}
+		assertEqualSlices(t, got, want)

Also applies to: 30-32, 40-42, 49-51

---

186-187: Consider truncating or diffing large outputs in error messages.

Dumping the full expected and actual content (potentially 1400+ bytes each) makes test failures difficult to read. Consider truncating after the first N characters or using a diff format.

Apply this diff to improve error readability:

+	const maxLen = 200
+	truncateMsg := func(s string) string {
+		if len(s) <= maxLen {
+			return s
+		}
+		return s[:maxLen] + fmt.Sprintf("... (%d more bytes)", len(s)-maxLen)
+	}
+
-	t.Fatalf("completion script %s mismatch (expected len %d, got %d):\n--- expected ---\n%s\n--- got ---\n%s",
-		name, len(expected), len(got), expected, got)
+	t.Fatalf("completion script %s mismatch (expected len %d, got %d):\n--- expected (truncated) ---\n%s\n--- got (truncated) ---\n%s",
+		name, len(expected), len(got), truncateMsg(expected), truncateMsg(got))

Alternatively, use a diff library like github.com/pmezard/go-difflib/difflib to show only the differences.

---

101-104: Document Fish completion behavior
The “fish” case in patchCompletionScript ignores its script argument and calls buildFishCompletionScript() instead. Add a comment in completion_config.go (or update the CLI docs) clarifying that Fish completions are always generated from scratch.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: CR
PR: satococoa/wtp#0
File: AGENTS.md:0-0
Timestamp: 2025-10-07T15:56:11.510Z
Learning: Applies to cmd/wtp/** : Command behavior: wtp completion <shell> generates pure completion scripts via urfave/cli

Learnt from: CR
PR: satococoa/wtp#0
File: AGENTS.md:0-0
Timestamp: 2025-10-07T15:56:11.510Z
Learning: Applies to cmd/wtp/** : Command behavior: wtp hook <shell> emits shell functions that intercept wtp cd; wtp shell-init <shell> combines completion and hook output

Learnt from: CR
PR: satococoa/wtp#0
File: AGENTS.md:0-0
Timestamp: 2025-10-07T15:56:11.510Z
Learning: Applies to cmd/wtp/** : CLI entrypoint and commands are implemented under cmd/wtp

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro