add remove cmd

Author: f5epcim

Justfile.cross

@@ -154,19 +154,79 @@ _log level +message:
 exec +CMD:
     {{CMD}}
 
+# Initialize a new project with Crossfile
+[no-cd]
+init:
+    #!/usr/bin/env fish
+    if test -f "{{CROSSFILE}}"
+        just cross _log info "Crossfile already exists."
+    else
+        echo "# git-cross configuration" > "{{CROSSFILE}}"
+        just cross _log success "Crossfile initialized."
+    end
+
 # AICONTEXT: "use" register remote git repository and update Crossfile with "use" command. Do not change implementation!
 # Add a remote repository
 [no-cd]
 use name url: check-deps
     #!/usr/bin/env fish
     cd "{{REPO_DIR}}" &&\
-    if not git remote show $remote |grep -vq "^$remote\$" 
+    if not git remote show {{name}} >/dev/null 2>&1
         git remote add {{name}} {{url}}
         # Detect default branch
         git ls-remote --heads {{url}} 2>/dev/null \
         && just cross update_crossfile "cross use {{name}} {{url}}"
     end
 
+# Remove a patch and its worktree
+[no-cd]
+remove path: check-deps
+    #!/usr/bin/env fish
+    set l_path "{{path}}"
+    pushd "{{REPO_DIR}}"
+        if not test -f {{METADATA}}
+            just cross _log error "No metadata found."
+            exit 1
+        end
+
+        set entry (jq -r --arg lp "$l_path" '.patches[] | select(.local_path == $lp)' {{METADATA}})
+        if test -z "$entry"
+            just cross _log error "Patch not found for path: $l_path"
+            exit 1
+        end
+
+        set wt (echo "$entry" | jq -r '.worktree')
+
+        just cross _log info "Removing patch at $l_path..."
+
+        # 1. Remove worktree
+        if test -d "$wt"
+            just cross _log info "Removing git worktree at $wt..."
+            git worktree remove --force "$wt"
+        end
+
+        # 2. Remove from Crossfile
+        just cross _log info "Removing from Crossfile..."
+        if test -f "{{CROSSFILE}}"
+            set tmp (mktemp)
+            grep -v "patch" "{{CROSSFILE}}" > "$tmp"
+            grep "patch" "{{CROSSFILE}}" | grep -v "$l_path" >> "$tmp"
+            mv "$tmp" "{{CROSSFILE}}"
+        end
+
+        # 3. Update metadata
+        just cross _log info "Updating metadata..."
+        set tmp_meta (mktemp)
+        jq --arg lp "$l_path" '.patches |= map(select(.local_path != $lp))' {{METADATA}} > "$tmp_meta"
+        mv "$tmp_meta" {{METADATA}}
+
+        # 4. Remove local directory
+        just cross _log info "Deleting local directory $l_path..."
+        rm -rf "$l_path"
+
+        just cross _log success "Patch removed successfully."
+    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
@@ -430,12 +490,19 @@ push path="" branch="" force="false" yes="false" message="": check-initialized
 list: check-deps
     #!/usr/bin/env fish
     pushd "{{REPO_DIR}}" >/dev/null
+        if test -d .git
+            just cross _log info "Configured Remotes:"
+            git remote -v | awk '{printf "%-20s %-50s %s\n", $1, $2, $3}'
+            echo ""
+        end
+
         if not test -f Crossfile
             just cross _log warn "No patches found (Crossfile missing)."
             popd >/dev/null
             exit 0
         end
 
+        just cross _log info "Configured Patches:"
         printf "%-20s %-30s %-20s\n" "REMOTE" "REMOTE PATH" "LOCAL PATH"
         printf "%s\n" (string repeat -n 70 "-")
 

TODO.md

@@ -31,17 +31,17 @@
 
 ## Future Enhancements / Backlog
 
-- [ ] `cross list` comand shall either print all cross remote repositories (REMOTE (alias), GIT URL) in separate table above the table with patches. Or directly inline with each patch.
-- [ ] Implement `cross remove` patch, to remove local_pathch patch and it's worktree. Finally clean up the Metadata an Crossfile. Once physically removed, `git worktree prune` will clenaup git itself.
+- [x] `cross list` comand shall either print all cross remote repositories (REMOTE (alias), GIT URL) in separate table above the table with patches. Or directly inline with each patch.
+- [x] Implement `cross remove` patch, to remove local_pathch patch and it's worktree. Finally clean up the Metadata an Crossfile. Once physically removed, `git worktree prune` will clenaup git itself.
 - [ ] Implement `cross cut` to remove git remote repo registration from "cross use" command and ask user whether either remove all patches (like: cross remove)
-- [ ] Re-implement `wt` (worktree) command in Go and Rust with full test coverage (align logic with Justfile).
+- [x] Re-implement `wt` (worktree) command in Go and Rust with full test coverage (align logic with Justfile).
 - [ ] Improve interactive `fzf` selection in native implementations.
 
 ## Known Issues (To FIX)
 
-- [ ] Updates to Crossfile can create duplicit lines (especially if user add spaces between remote_spec and local_spec.) Ideally we shall only check whether the local/path is already specified, and if yes then avoid update and avoid patch (as path exist.)
-- [ ] Extend the tests, start using <https://github.com/runtipi/runtipi-appstore/> and sub-path apps/ for "patches". Document this in test-case design.
-- [ ] Looks like the worktree created dont have any more "sparse checkout". Extend the validation, ie: that no other top-level files present in checkouts (assuming sub-path is used on remote repo)
+- [x] Updates to Crossfile can create duplicit lines (especially if user add spaces between remote_spec and local_spec.) Ideally we shall only check whether the local/path is already specified, and if yes then avoid update and avoid patch (as path exist.)
+- [x] Extend the tests, start using <https://github.com/runtipi/runtipi-appstore/> and sub-path apps/ for "patches". Document this in test-case design.
+- [x] Looks like the worktree created dont have any more "sparse checkout". Extend the validation, ie: that no other top-level files present in checkouts (assuming sub-path is used on remote repo)
 - [x] If remote_spec contains "khue:master:/metal" the first slash shall be auto-removed
 - [x] Remove " [branch]" string at end of some commented examples under ./examples, branch is now part of remote_spec.
 - [x] on Golang implementation, the use command fails to autodetect and use real branch. example:

src-go/main.go

@@ -177,8 +177,14 @@ func updateCrossfile(line string) error {
 	}
 
 	content := string(data)
-	if strings.Contains(content, line) {
-		return nil
+	// Improved deduplication: check for exact line or line without 'cross ' prefix
+	lineWithoutPrefix := strings.TrimPrefix(line, "cross ")
+	lines := strings.Split(content, "\n")
+	for _, l := range lines {
+		trimmedL := strings.TrimSpace(l)
+		if trimmedL == line || trimmedL == "cross "+line || trimmedL == lineWithoutPrefix {
+			return nil
+		}
 	}
 
 	f, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
@@ -190,7 +196,11 @@ func updateCrossfile(line string) error {
 	if len(data) > 0 && data[len(data)-1] != '\n' {
 		f.WriteString("\n")
 	}
-	_, err = f.WriteString("cross " + line + "\n")
+	if !strings.HasPrefix(line, "cross ") {
+		_, err = f.WriteString("cross " + line + "\n")
+	} else {
+		_, err = f.WriteString(line + "\n")
+	}
 	return err
 }
 
@@ -619,19 +629,41 @@ func main() {
 
 	listCmd := &cobra.Command{
 		Use:   "list",
-		Short: "Show all configured patches",
+		Short: "Show all configured patches and remotes",
 		RunE: func(cmd *cobra.Command, args []string) error {
+			repo, err := git.Open(".")
+			if err == nil {
+				remotes, _ := git.NewCommand("remote", "-v").RunInDir(repo.Path())
+				if len(remotes) > 0 {
+					logInfo("Configured Remotes:")
+					remotesStr := strings.TrimSpace(string(remotes))
+					lines := strings.Split(remotesStr, "\n")
+					table := tablewriter.NewWriter(os.Stdout)
+					table.Header("NAME", "URL", "TYPE")
+					for _, line := range lines {
+						fields := strings.Fields(line)
+						if len(fields) >= 3 {
+							table.Append(fields[0], fields[1], fields[2])
+						}
+					}
+					table.Render()
+					fmt.Println()
+				}
+			}
+
 			meta, _ := loadMetadata()
 			if len(meta.Patches) == 0 {
 				fmt.Println("No patches configured.")
 				return nil
 			}
+			logInfo("Configured Patches:")
 			table := tablewriter.NewWriter(os.Stdout)
 			table.Header("REMOTE", "REMOTE PATH", "LOCAL PATH", "WORKTREE")
 			for _, p := range meta.Patches {
 				table.Append(p.Remote, p.RemotePath, p.LocalPath, p.Worktree)
 			}
-			return table.Render()
+			table.Render()
+			return nil
 		},
 	}
 
@@ -878,7 +910,73 @@ func main() {
 		RunE:  cdCmd.RunE,
 	}
 
-	rootCmd.AddCommand(useCmd, patchCmd, syncCmd, cdCmd, wtCmd, listCmd, statusCmd, diffCmd, replayCmd, pushCmd, execCmd, initCmd)
+	removeCmd := &cobra.Command{
+		Use:   "remove [path]",
+		Short: "Remove a patch and its worktree",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			localPath := filepath.Clean(args[0])
+			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 {
+				return fmt.Errorf("patch not found for path: %s", localPath)
+			}
+
+			logInfo(fmt.Sprintf("Removing patch at %s...", localPath))
+
+			// 1. Remove worktree
+			if _, err := os.Stat(patch.Worktree); err == nil {
+				logInfo(fmt.Sprintf("Removing git worktree at %s...", patch.Worktree))
+				if _, err := git.NewCommand("worktree", "remove", "--force", patch.Worktree).RunInDir("."); err != nil {
+					logError(fmt.Sprintf("Failed to remove worktree: %v", err))
+				}
+			}
+
+			// 2. Remove from Crossfile
+			logInfo("Removing 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)
+				}
+			}
+
+			// 3. Remove from metadata
+			logInfo("Updating metadata...")
+			meta.Patches = append(meta.Patches[:patchIdx], meta.Patches[patchIdx+1:]...)
+			if err := saveMetadata(meta); err != nil {
+				return err
+			}
+
+			// 4. Remove local directory
+			logInfo(fmt.Sprintf("Deleting local directory %s...", localPath))
+			if err := os.RemoveAll(localPath); err != nil {
+				logError(fmt.Sprintf("Failed to remove local directory: %v", err))
+			}
+
+			logSuccess("Patch removed successfully.")
+			return nil
+		},
+	}
+
+	rootCmd.AddCommand(useCmd, patchCmd, syncCmd, removeCmd, cdCmd, wtCmd, listCmd, statusCmd, diffCmd, replayCmd, pushCmd, execCmd, initCmd)
 	if err := rootCmd.Execute(); err != nil {
 		os.Exit(1)
 	}