refactor(cd/wt): move path check logic to command level

Move fzf selection and clipboard logic from shared helper to cd/wt commands.
This makes the flow clearer and implementation consistent across all three versions.

Flow:
- Path provided → call _open_shell/openShellInDir (opens shell)
- No path → use fzf selection, then copy to clipboard

Justfile.cross:
- _open_shell now only opens shell (path required)
- cd/wt commands handle path check and fzf/clipboard logic
- 3 lines in _open_shell, clear logic in cd/wt

Go (src-go/main.go):
- openShellInDir helper (path required, opens shell)
- cdCmd/wtCmd handle path check and fzf/clipboard logic
- Same structure as Justfile

Rust (src-rust/src/main.rs):
- open_shell_in_dir helper (path required, opens shell)
- Commands::Cd/Wt handle path check and fzf/clipboard logic
- Same structure as Justfile and Go

All three implementations now have identical logic flow.

Author: f5epcim

Justfile.cross

@@ -771,36 +771,47 @@ _copy_to_clipboard text:
         exit 1
     fi
 
-# Internal: Open shell or copy path (shared logic for cd/wt)
+# Internal: Open shell in target directory
 # target: "local_path" or "worktree"
+# path: must be provided (non-empty)
 [no-cd]
-_open_shell target path="":
+_open_shell target path:
     #!/usr/bin/env fish
-    # If no path provided, use fzf to select
-    set -l selected_path "{{path}}"
-    if test -z "$selected_path"
-        set selected_path (just cross list | tail -n +3 | fzf --height 40% 2>/dev/null | awk '{print $NF}')
-        test -z "$selected_path" && exit 0
-    end
-    # Resolve context and determine target directory
-    just cross _resolve_context2 "$selected_path" | source || exit 1
+    just cross _resolve_context2 "{{path}}" | source || exit 1
     set -l dir (test "{{target}}" = "local_path" && echo $local_path || echo $worktree)
-    # Open shell if path was provided, else copy to clipboard (fzf case)
-    test -n "{{path}}" && cd {{REPO_DIR}}/$dir && exec $SHELL || just cross _copy_to_clipboard {{REPO_DIR}}/$dir && just cross _log success "Path copied: $dir"
+    cd {{REPO_DIR}}/$dir && exec $SHELL
 
 # Go to worktree directory (for working with git history)
 # With path: opens subshell
 # Without path: uses fzf selection and copies to clipboard
 [no-cd]
 wt path="":
-    just cross _open_shell worktree "{{path}}"
+    #!/usr/bin/env fish
+    if test -n "{{path}}"
+        just cross _open_shell worktree "{{path}}"
+    else
+        set -l selected (just cross list | tail -n +3 | fzf --height 40% 2>/dev/null | awk '{print $NF}')
+        test -z "$selected" && exit 0
+        just cross _resolve_context2 "$selected" | source || exit 1
+        just cross _copy_to_clipboard {{REPO_DIR}}/$worktree
+        just cross _log success "Path copied: $worktree"
+    end
 
 # Go to local_path directory (for editing patched files)
 # With path: opens subshell
 # Without path: uses fzf selection and copies to clipboard
 [no-cd]
 cd path="":
-    just cross _open_shell local_path "{{path}}"
+    #!/usr/bin/env fish
+    if test -n "{{path}}"
+        just cross _open_shell local_path "{{path}}"
+    else
+        set -l selected (just cross list | tail -n +3 | fzf --height 40% 2>/dev/null | awk '{print $NF}')
+        test -z "$selected" && exit 0
+        just cross _resolve_context2 "$selected" | source || exit 1
+        just cross _copy_to_clipboard {{REPO_DIR}}/$local_path
+        just cross _log success "Path copied: $local_path"
+    end
 
 
 # AICONTEXT: "status" shows status of current local_path patch vs. WT, and WT upstream. Input argument is local_path (or understand user stand in the under git-cross'ed local_path and call this comand). It shall be called to get status of local_path from "list" command. Either the status of remote WT upstream (as resource consuming, shall be optional or only ocasional)

src-go/main.go

@@ -700,106 +700,59 @@ func main() {
 		return cmd.Run()
 	}
 
-	// Shared helper function for cd/wt commands
-	// If args provided: open subshell in target directory
-	// If no args (fzf): copy selected path to clipboard
-	openShellInPatch := func(args []string, targetType string) error {
+	// Helper: Open shell in target directory (path must be provided)
+	openShellInDir := func(path string, targetType string) error {
 		meta, _ := loadMetadata()
 		if len(meta.Patches) == 0 {
 			fmt.Println("No patches configured.")
 			return nil
 		}
 
-		var patch *Patch
-		pathProvided := len(args) > 0 // Track if user provided explicit path
-
-		if pathProvided {
-			// User provided explicit path
-			path := strings.TrimSpace(args[0])
-			patch = findPatchForPath(meta, path)
-			if patch == nil {
-				for i := range meta.Patches {
-					if meta.Patches[i].LocalPath == path {
-						patch = &meta.Patches[i]
-						break
-					}
-				}
-			}
-			if patch == nil {
-				return fmt.Errorf("patch not found for path: %s", path)
-			}
-		} else {
-			// No path provided - use fzf selection
-			selected, err := selectPatchInteractive(&meta)
-			if err != nil {
-				targetName := "local_path"
-				if targetType == "worktree" {
-					targetName = "worktree"
-				}
-				logInfo(fmt.Sprintf("fzf not available. Showing patch list; rerun with a path to enter %s.", targetName))
-				table := tablewriter.NewWriter(os.Stdout)
-				table.Header("REMOTE", "REMOTE PATH", "LOCAL PATH")
-				for _, p := range meta.Patches {
-					table.Append(p.Remote, p.RemotePath, p.LocalPath)
+		// Find patch for provided path
+		patch := findPatchForPath(meta, path)
+		if patch == nil {
+			for i := range meta.Patches {
+				if meta.Patches[i].LocalPath == path {
+					patch = &meta.Patches[i]
+					break
 				}
-				table.Render()
-				return nil
 			}
-			if selected == nil {
-				logInfo("No selection made.")
-				return nil
-			}
-			patch = selected
 		}
-
 		if patch == nil {
-			return nil
+			return fmt.Errorf("patch not found for path: %s", path)
 		}
 
-		// Determine target directory based on type
+		// Determine target directory
 		var targetDir string
-		var targetName string
 		if targetType == "worktree" {
 			targetDir = patch.Worktree
-			targetName = "worktree"
 		} else {
 			targetDir = patch.LocalPath
-			targetName = "local_path"
 		}
 
 		if _, err := os.Stat(targetDir); os.IsNotExist(err) {
-			return fmt.Errorf("%s not found: %s", targetName, targetDir)
+			return fmt.Errorf("%s not found: %s", targetType, targetDir)
 		}
 
-		// Apply logic based on whether path was provided
-		if pathProvided {
-			// Path provided: open subshell
-			shell := os.Getenv("SHELL")
-			if shell == "" {
-				shell = "/bin/sh"
-			}
-
-			if dry != "" {
-				fmt.Printf("%s cd %s\n", dry, targetDir)
-				fmt.Printf("%s exec %s\n", dry, shell)
-				return nil
-			}
+		// Open subshell
+		shell := os.Getenv("SHELL")
+		if shell == "" {
+			shell = "/bin/sh"
+		}
 
-			logInfo(fmt.Sprintf("Opening shell in %s", targetDir))
-			c := exec.Command(shell)
-			c.Dir = targetDir
-			c.Stdin = os.Stdin
-			c.Stdout = os.Stdout
-			c.Stderr = os.Stderr
-			return c.Run()
-		} else {
-			// No path (fzf selection): copy to clipboard
-			if err := copyToClipboard(targetDir); err != nil {
-				return fmt.Errorf("failed to copy to clipboard: %v", err)
-			}
-			logSuccess(fmt.Sprintf("Path copied to clipboard: %s", targetDir))
+		if dry != "" {
+			fmt.Printf("%s cd %s\n", dry, targetDir)
+			fmt.Printf("%s exec %s\n", dry, shell)
 			return nil
 		}
+
+		logInfo(fmt.Sprintf("Opening shell in %s", targetDir))
+		c := exec.Command(shell)
+		c.Dir = targetDir
+		c.Stdin = os.Stdin
+		c.Stdout = os.Stdout
+		c.Stderr = os.Stderr
+		return c.Run()
 	}
 
 	cdCmd := &cobra.Command{
@@ -810,7 +763,38 @@ func main() {
 With path: opens subshell in the specified local_path directory.
 Without path: uses fzf to select a patch, then copies the path to clipboard.`,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return openShellInPatch(args, "local_path")
+			meta, _ := loadMetadata()
+			if len(meta.Patches) == 0 {
+				fmt.Println("No patches configured.")
+				return nil
+			}
+
+			if len(args) > 0 {
+				// Path provided: open shell
+				return openShellInDir(strings.TrimSpace(args[0]), "local_path")
+			} else {
+				// No path: use fzf and copy to clipboard
+				selected, err := selectPatchInteractive(&meta)
+				if err != nil {
+					logInfo("fzf not available. Showing patch list; rerun with a path.")
+					table := tablewriter.NewWriter(os.Stdout)
+					table.Header("REMOTE", "REMOTE PATH", "LOCAL PATH")
+					for _, p := range meta.Patches {
+						table.Append(p.Remote, p.RemotePath, p.LocalPath)
+					}
+					table.Render()
+					return nil
+				}
+				if selected == nil {
+					logInfo("No selection made.")
+					return nil
+				}
+				if err := copyToClipboard(selected.LocalPath); err != nil {
+					return fmt.Errorf("failed to copy to clipboard: %v", err)
+				}
+				logSuccess(fmt.Sprintf("Path copied to clipboard: %s", selected.LocalPath))
+				return nil
+			}
 		},
 	}
 
@@ -822,7 +806,38 @@ Without path: uses fzf to select a patch, then copies the path to clipboard.`,
 With path: opens subshell in the specified worktree directory.
 Without path: uses fzf to select a patch, then copies the path to clipboard.`,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return openShellInPatch(args, "worktree")
+			meta, _ := loadMetadata()
+			if len(meta.Patches) == 0 {
+				fmt.Println("No patches configured.")
+				return nil
+			}
+
+			if len(args) > 0 {
+				// Path provided: open shell
+				return openShellInDir(strings.TrimSpace(args[0]), "worktree")
+			} else {
+				// No path: use fzf and copy to clipboard
+				selected, err := selectPatchInteractive(&meta)
+				if err != nil {
+					logInfo("fzf not available. Showing patch list; rerun with a path.")
+					table := tablewriter.NewWriter(os.Stdout)
+					table.Header("REMOTE", "REMOTE PATH", "LOCAL PATH")
+					for _, p := range meta.Patches {
+						table.Append(p.Remote, p.RemotePath, p.LocalPath)
+					}
+					table.Render()
+					return nil
+				}
+				if selected == nil {
+					logInfo("No selection made.")
+					return nil
+				}
+				if err := copyToClipboard(selected.Worktree); err != nil {
+					return fmt.Errorf("failed to copy to clipboard: %v", err)
+				}
+				logSuccess(fmt.Sprintf("Path copied to clipboard: %s", selected.Worktree))
+				return nil
+			}
 		},
 	}