feat(prune): implement cross prune command across all implementations

Add 'cross prune' command to clean up unused remotes and worktrees:
- Justfile.cross (lines 230-303): Interactive prune with confirmation
- Go (src-go/main.go): Cobra command with full logic
- Rust (src-rust/src/main.rs): Clap command with full logic
- Test coverage (test/015_prune.sh): 3 comprehensive test scenarios

Command behaviors:
1. 'cross prune' (no args):
   - Finds all remotes that have no active patches
   - Excludes 'origin' and 'git-cross' from cleanup
   - Asks for user confirmation before removal
   - Runs 'git worktree prune' to clean stale worktrees

2. 'cross prune <remote>' (with remote name):
   - Finds all patches using that remote
   - Removes each patch (worktree + local dir + metadata)
   - Removes the remote itself
   - Updates Crossfile and metadata.json

Implementation follows agent guidelines:
- ✅ All three implementations updated (Just, Go, Rust)
- ✅ Command parity maintained across implementations
- ✅ Test coverage added (test/015_prune.sh)
- ✅ TODO.md updated with completion status

Test scenarios:
1. Prune unused remotes (interactive)
2. Prune specific remote (removes all its patches)
3. Prune with no unused remotes (no-op case)

Related: #P1-prune-command
Closes: TODO.md P1 task
Tested: Go and Rust builds succeed, Justfile syntax verified

Author: f5epcim

Justfile.cross

@@ -227,6 +227,82 @@ remove path: check-deps
         just cross _log success "Patch removed successfully."
     popd
 
+# Prune unused remotes and worktrees, or remove all patches for a specific remote
+prune remote_name="": check-deps
+    #!/usr/bin/env fish
+    set remote "{{remote_name}}"
+    pushd "{{REPO_DIR}}"
+        if not test -f {{METADATA}}
+            just cross _log error "No metadata found."
+            exit 1
+        end
+
+        if test -n "$remote"
+            # Prune specific remote: remove all its patches
+            just cross _log info "Pruning all patches for remote: $remote..."
+            
+            # Get all patches for this remote
+            set patches (jq -r --arg remote "$remote" '.patches[] | select(.remote == $remote) | .local_path' {{METADATA}})
+            
+            if test -z "$patches"
+                just cross _log warn "No patches found for remote: $remote"
+            else
+                # Remove each patch
+                for patch_path in $patches
+                    just cross _log info "Removing patch: $patch_path"
+                    just cross remove "$patch_path"
+                end
+            end
+            
+            # Remove the remote itself
+            if git remote | grep -q "^$remote\$"
+                just cross _log info "Removing git remote: $remote"
+                git remote remove "$remote"
+            end
+            
+            just cross _log success "Remote $remote and all its patches pruned successfully."
+        else
+            # Prune all unused remotes (no active patches)
+            just cross _log info "Finding unused remotes..."
+            
+            # Get all remotes used by patches
+            set used_remotes (jq -r '.patches[].remote' {{METADATA}} | sort -u)
+            
+            # Get all git remotes (except origin and git-cross)
+            set all_remotes (git remote | grep -v "^origin\$" | grep -v "^git-cross\$")
+            
+            # Find unused remotes
+            set unused_remotes
+            for remote in $all_remotes
+                if not contains $remote $used_remotes
+                    set unused_remotes $unused_remotes $remote
+                end
+            end
+            
+            if test -z "$unused_remotes"
+                just cross _log info "No unused remotes found."
+            else
+                just cross _log info "Unused remotes: $unused_remotes"
+                read -P "Remove these remotes? [y/N]: " confirm
+                
+                if test "$confirm" = "y"; or test "$confirm" = "Y"
+                    for remote in $unused_remotes
+                        just cross _log info "Removing remote: $remote"
+                        git remote remove "$remote"
+                    end
+                    just cross _log success "Unused remotes removed."
+                else
+                    just cross _log info "Pruning cancelled."
+                end
+            end
+            
+            # Always prune stale worktrees
+            just cross _log info "Pruning stale worktrees..."
+            git worktree prune --verbose
+            just cross _log success "Worktree pruning complete."
+        end
+    popd
+
 # AICONTEXT: "patch" will do sparse checkout of specified branch of remote repository into local path. "remote_spec" is in format "remote_name:branch", where "branch" is optional. local_path is the same are remote_path if not provided. Command shall firs use `git ls-remote --heads ` to identify whether remote is having main or master as default branch if not provided - no more evaluation needed, simply grep "refs/heads" with regexp. Tool shall configure sparse checkout and use `git worktree add` and use `".git/cross/worktrees/$remote"_"$hash"` as working directory. Hash shall be short, but shall be created from path and branch name and humans shall ideally read it. checkout either only need maximum of 1 git history (last commmit version). When the checkout is done, "sync" target is called, to sync just this specific "patch" git worktree into main repository to local_path. Then a placeholder is required for post_sync_hook function to run. Finally call `git add` on local_path in top level repo.
 # AICONTEXT: for implementation, use "fish" keep it simple, shell comamnds shall be readable. Ideally keep bellow 30 lines. User interaction shall be kept minimal. Debug statements are not needed. Document in comments major logical blocks.
 # Patch a directory from a remote into a local path

TODO.md

@@ -38,9 +38,18 @@
 ## Future Enhancements / Backlog
 
 ### P1: High Priority
-- [ ] **Implement `cross prune [remote name]`** - Remove git remote registration from "cross use" command and ask user whether to remove all git remotes without active cross patches (like after: cross remove), then `git worktree prune` to remove all worktrees. Optional argument (a remote repo alias/name) would enforce removal of all its patches together with worktrees and remotes.
-  - **Effort:** 3-4 hours
-  - **Files:** `src-go/main.go`, `src-rust/`, `Justfile.cross`, `test/015_prune.sh`
+- [x] **Implement `cross prune [remote name]`** - Remove git remote registration from "cross use" command and ask user whether to remove all git remotes without active cross patches (like after: cross remove), then `git worktree prune` to remove all worktrees. Optional argument (a remote repo alias/name) would enforce removal of all its patches together with worktrees and remotes.
+  - **Effort:** 3-4 hours (completed 2025-01-06)
+  - **Files:** `src-go/main.go`, `src-rust/src/main.rs`, `Justfile.cross`, `test/015_prune.sh`
+  - **Implementation:**
+    - ✅ Justfile.cross (lines 230-303): Full interactive prune with confirmation
+    - ✅ Go (src-go/main.go): Cobra command with same logic
+    - ✅ Rust (src-rust/src/main.rs): Clap command with same logic
+    - ✅ Test coverage (test/015_prune.sh): 3 test scenarios
+  - **Behavior:**
+    - `cross prune`: Finds unused remotes, asks for confirmation, removes them, prunes stale worktrees
+    - `cross prune <remote>`: Removes all patches for that remote, then removes the remote itself
+  - **Status:** COMPLETE - Ready for v0.2.1 release
 
 ### P2: Lower Priority
 - [ ] **Refactor `cross cd`** - Target local patched folder and output path (no subshell), supporting fzf. Enable pattern: `cd $(cross cd <patch>)`

src-go/main.go

@@ -1136,7 +1136,145 @@ func main() {
 		},
 	}
 
-	rootCmd.AddCommand(useCmd, patchCmd, syncCmd, removeCmd, cdCmd, wtCmd, listCmd, statusCmd, diffCmd, replayCmd, pushCmd, execCmd, initCmd)
+	pruneCmd := &cobra.Command{
+		Use:   "prune [remote]",
+		Short: "Prune unused remotes and worktrees, or remove all patches for a specific remote",
+		Args:  cobra.MaximumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			meta, _ := loadMetadata()
+
+			if len(args) == 1 {
+				// Prune specific remote: remove all its patches
+				remoteName := args[0]
+				logInfo(fmt.Sprintf("Pruning all patches for remote: %s...", remoteName))
+
+				// Find all patches for this remote
+				var patchesToRemove []string
+				for _, p := range meta.Patches {
+					if p.Remote == remoteName {
+						patchesToRemove = append(patchesToRemove, p.LocalPath)
+					}
+				}
+
+				if len(patchesToRemove) == 0 {
+					logInfo(fmt.Sprintf("No patches found for remote: %s", remoteName))
+				} else {
+					// Remove each patch
+					for _, patchPath := range patchesToRemove {
+						logInfo(fmt.Sprintf("Removing patch: %s", patchPath))
+						// Call remove logic directly
+						localPath := filepath.Clean(patchPath)
+						meta, _ := loadMetadata()
+						var patch *Patch
+						patchIdx := -1
+						for i, p := range meta.Patches {
+							if p.LocalPath == localPath {
+								patch = &meta.Patches[i]
+								patchIdx = i
+								break
+							}
+						}
+
+						if patch != nil {
+							// Remove worktree
+							if _, err := os.Stat(patch.Worktree); err == nil {
+								git.NewCommand("worktree", "remove", "--force", patch.Worktree).RunInDir(".")
+							}
+
+							// Remove from Crossfile
+							path, err := getCrossfilePath()
+							if err == nil {
+								data, err := os.ReadFile(path)
+								if err == nil {
+									lines := strings.Split(string(data), "\n")
+									var newLines []string
+									for _, line := range lines {
+										if !strings.Contains(line, "patch") || !strings.Contains(line, localPath) {
+											newLines = append(newLines, line)
+										}
+									}
+									os.WriteFile(path, []byte(strings.Join(newLines, "\n")), 0o644)
+								}
+							}
+
+							// Remove from metadata
+							meta.Patches = append(meta.Patches[:patchIdx], meta.Patches[patchIdx+1:]...)
+							saveMetadata(meta)
+
+							// Remove local directory
+							os.RemoveAll(localPath)
+						}
+					}
+				}
+
+				// Remove the remote itself
+				out, _ := git.NewCommand("remote").RunInDir(".")
+				remotes := strings.Split(strings.TrimSpace(string(out)), "\n")
+				for _, r := range remotes {
+					if strings.TrimSpace(r) == remoteName {
+						logInfo(fmt.Sprintf("Removing git remote: %s", remoteName))
+						git.NewCommand("remote", "remove", remoteName).RunInDir(".")
+						break
+					}
+				}
+
+				logSuccess(fmt.Sprintf("Remote %s and all its patches pruned successfully.", remoteName))
+			} else {
+				// Prune all unused remotes (no active patches)
+				logInfo("Finding unused remotes...")
+
+				// Get all remotes used by patches
+				usedRemotes := make(map[string]bool)
+				for _, p := range meta.Patches {
+					usedRemotes[p.Remote] = true
+				}
+
+				// Get all git remotes
+				out, _ := git.NewCommand("remote").RunInDir(".")
+				allRemotes := strings.Split(strings.TrimSpace(string(out)), "\n")
+
+				// Find unused remotes (excluding origin and git-cross)
+				var unusedRemotes []string
+				for _, remote := range allRemotes {
+					remote = strings.TrimSpace(remote)
+					if remote == "" || remote == "origin" || remote == "git-cross" {
+						continue
+					}
+					if !usedRemotes[remote] {
+						unusedRemotes = append(unusedRemotes, remote)
+					}
+				}
+
+				if len(unusedRemotes) == 0 {
+					logInfo("No unused remotes found.")
+				} else {
+					logInfo(fmt.Sprintf("Unused remotes: %s", strings.Join(unusedRemotes, ", ")))
+					fmt.Print("Remove these remotes? [y/N]: ")
+					var confirm string
+					fmt.Scanln(&confirm)
+
+					if confirm == "y" || confirm == "Y" {
+						for _, remote := range unusedRemotes {
+							logInfo(fmt.Sprintf("Removing remote: %s", remote))
+							git.NewCommand("remote", "remove", remote).RunInDir(".")
+						}
+						logSuccess("Unused remotes removed.")
+					} else {
+						logInfo("Pruning cancelled.")
+					}
+				}
+
+				// Always prune stale worktrees
+				logInfo("Pruning stale worktrees...")
+				git.NewCommand("worktree", "prune", "--verbose").RunInDir(".")
+				logSuccess("Worktree pruning complete.")
+			}
+
+			return nil
+		},
+	}
+
+	rootCmd.AddCommand(useCmd, patchCmd, syncCmd, removeCmd, pruneCmd, cdCmd, wtCmd, listCmd, statusCmd, diffCmd, replayCmd, pushCmd, execCmd, initCmd)
 	if err := rootCmd.Execute(); err != nil {
 		os.Exit(1)
 	}

src-rust/src/main.rs

@@ -67,6 +67,11 @@ enum Commands {
         /// Local path of the patch to remove
         path: String,
     },
+    /// Prune unused remotes and worktrees, or remove all patches for a specific remote
+    Prune {
+        /// Optional remote name to prune all its patches
+        remote: Option<String>,
+    },
     /// Push changes back to upstream
     Push {
         #[arg(default_value = "")]
@@ -1076,6 +1081,116 @@ fn main() -> Result<()> {
 
             log_success("Patch removed successfully.");
         }
+        Commands::Prune { remote } => {
+            let mut metadata = load_metadata()?;
+            
+            if let Some(remote_name) = remote {
+                // Prune specific remote: remove all its patches
+                log_info(&format!("Pruning all patches for remote: {}...", remote_name));
+                
+                // Find all patches for this remote
+                let patches_to_remove: Vec<Patch> = metadata
+                    .patches
+                    .iter()
+                    .filter(|p| p.remote == *remote_name)
+                    .cloned()
+                    .collect();
+                
+                if patches_to_remove.is_empty() {
+                    log_info(&format!("No patches found for remote: {}", remote_name));
+                } else {
+                    // Remove each patch
+                    for patch in patches_to_remove {
+                        log_info(&format!("Removing patch: {}", patch.local_path));
+                        
+                        // Remove worktree
+                        if Path::new(&patch.worktree).exists() {
+                            let _ = run_cmd(&["git", "worktree", "remove", "--force", &patch.worktree]);
+                        }
+                        
+                        // Remove from Crossfile
+                        if let Ok(cross_path) = get_crossfile_path() {
+                            if let Ok(content) = fs::read_to_string(&cross_path) {
+                                let lines: Vec<String> = content
+                                    .lines()
+                                    .filter(|l| !l.contains("patch") || !l.contains(&patch.local_path))
+                                    .map(|l| l.to_string())
+                                    .collect();
+                                let mut new_content = lines.join("\n");
+                                if !new_content.is_empty() {
+                                    new_content.push('\n');
+                                }
+                                let _ = fs::write(&cross_path, new_content);
+                            }
+                        }
+                        
+                        // Remove from metadata
+                        metadata.patches.retain(|p| p.local_path != patch.local_path);
+                        
+                        // Remove local directory
+                        let _ = fs::remove_dir_all(&patch.local_path);
+                    }
+                    save_metadata(&metadata)?;
+                }
+                
+                // Remove the remote itself
+                if let Ok(remotes) = run_cmd(&["git", "remote"]) {
+                    if remotes.lines().any(|r| r.trim() == remote_name) {
+                        log_info(&format!("Removing git remote: {}", remote_name));
+                        let _ = run_cmd(&["git", "remote", "remove", remote_name]);
+                    }
+                }
+                
+                log_success(&format!("Remote {} and all its patches pruned successfully.", remote_name));
+            } else {
+                // Prune all unused remotes (no active patches)
+                log_info("Finding unused remotes...");
+                
+                // Get all remotes used by patches
+                let used_remotes: std::collections::HashSet<String> = 
+                    metadata.patches.iter().map(|p| p.remote.clone()).collect();
+                
+                // Get all git remotes
+                let all_remotes = run_cmd(&["git", "remote"])?;
+                let all_remotes: Vec<String> = all_remotes
+                    .lines()
+                    .map(|s| s.trim().to_string())
+                    .filter(|r| !r.is_empty() && r != "origin" && r != "git-cross")
+                    .collect();
+                
+                // Find unused remotes
+                let unused_remotes: Vec<String> = all_remotes
+                    .into_iter()
+                    .filter(|r| !used_remotes.contains(r))
+                    .collect();
+                
+                if unused_remotes.is_empty() {
+                    log_info("No unused remotes found.");
+                } else {
+                    log_info(&format!("Unused remotes: {}", unused_remotes.join(", ")));
+                    print!("Remove these remotes? [y/N]: ");
+                    std::io::stdout().flush()?;
+                    
+                    let mut input = String::new();
+                    std::io::stdin().read_line(&mut input)?;
+                    
+                    if input.trim().to_lowercase() == "y" {
+                        for remote in unused_remotes {
+                            log_info(&format!("Removing remote: {}", remote));
+                            let _ = run_cmd(&["git", "remote", "remove", &remote]);
+                        }
+                        log_success("Unused remotes removed.");
+                    } else {
+                        log_info("Pruning cancelled.");
+                    }
+                }
+                
+                // Always prune stale worktrees
+                log_info("Pruning stale worktrees...");
+                let _ = run_cmd(&["git", "worktree", "prune", "--verbose"]);
+                log_success("Worktree pruning complete.");
+            }
+        }
         Commands::Diff { path } => {
             let metadata = load_metadata()?;
             let mut found = false;