feat(patch): add guided 3-way import recovery

Author: cst8t

src-tauri/src/git/cli.rs

@@ -67,6 +67,10 @@ impl CliGitHandler {
     const PATCH_EXPORT_NO_COMMITS_SELECTED: &'static str =
         "GITMUN_ERROR_PATCH_EXPORT_NO_COMMITS_SELECTED";
     const PATCH_EXPORT_WRITTEN: &'static str = "GITMUN_PATCH_EXPORT_WRITTEN";
+    const PATCH_IMPORT_APPLIED: &'static str = "GITMUN_PATCH_IMPORT_APPLIED";
+    const PATCH_IMPORT_CONFLICTS: &'static str = "GITMUN_PATCH_IMPORT_CONFLICTS";
+    const PATCH_IMPORT_THREE_WAY_BLOCKED: &'static str =
+        "GITMUN_ERROR_PATCH_IMPORT_THREE_WAY_BLOCKED";
 
     fn preferred_mime_from_path(file_path: &str) -> Option<String> {
         let mut first: Option<String> = None;
@@ -806,6 +810,7 @@ impl CliGitHandler {
         if staged {
             args.push("--cached");
         }
+        args.push("--full-index");
         args.push("--binary");
         args.push("--");
         args.extend(paths.iter().map(String::as_str));
@@ -817,6 +822,7 @@ impl CliGitHandler {
         if staged {
             args.push("--cached");
         }
+        args.push("--full-index");
         args.push("--binary");
         args.push("--");
         Self::run_git_allow_exit_codes(&args, Some(repo_path), &[1])
@@ -825,7 +831,15 @@ impl CliGitHandler {
     fn git_untracked_patch(repo_path: &Path, path: &str) -> GitResult<String> {
         let null_device = if cfg!(windows) { "NUL" } else { "/dev/null" };
         let output = Self::run_git_allow_exit_codes(
-            &["diff", "--no-index", "--binary", "--", null_device, path],
+            &[
+                "diff",
+                "--no-index",
+                "--full-index",
+                "--binary",
+                "--",
+                null_device,
+                path,
+            ],
             Some(repo_path),
             &[1],
         )?;
@@ -893,7 +907,14 @@ impl CliGitHandler {
         let base_hash = parts.next().unwrap_or(Self::EMPTY_TREE_HASH);
 
         Self::run_git_allow_exit_codes(
-            &["diff", "--binary", base_hash, resolved_hash, "--"],
+            &[
+                "diff",
+                "--full-index",
+                "--binary",
+                base_hash,
+                resolved_hash,
+                "--",
+            ],
             Some(repo_path),
             &[1],
         )
@@ -989,6 +1010,81 @@ impl CliGitHandler {
         Ok(output)
     }
 
+    fn patch_three_way_blocked_message() -> String {
+        Self::PATCH_IMPORT_THREE_WAY_BLOCKED.to_string()
+    }
+
+    fn status_has_tracked_changes(output: &str) -> bool {
+        output
+            .lines()
+            .map(str::trim)
+            .any(|line| !line.is_empty() && !line.starts_with("?? "))
+    }
+
+    fn status_has_unmerged_files(output: &str) -> bool {
+        output.lines().any(|line| {
+            let Some(status) = line.get(0..2) else {
+                return false;
+            };
+            matches!(status, "DD" | "AU" | "UD" | "UA" | "DU" | "AA" | "UU")
+        })
+    }
+
+    fn ensure_clean_for_three_way_patch(repo_path: &Path) -> GitResult<()> {
+        let output = Self::run_git(
+            &["status", "--porcelain=v1", "--untracked-files=no"],
+            Some(repo_path),
+        )?;
+        if Self::status_has_tracked_changes(&output) {
+            return Err(GitError::InvalidInput(
+                Self::patch_three_way_blocked_message(),
+            ));
+        }
+        Ok(())
+    }
+
+    fn apply_patch_three_way(repo_path: &Path, patch_path: &str) -> GitResult<OperationResult> {
+        Self::ensure_clean_for_three_way_patch(repo_path)?;
+
+        match Self::run_git(
+            &["apply", "--3way", "--binary", patch_path],
+            Some(repo_path),
+        ) {
+            Ok(output) => Ok(Self::operation_result(
+                Self::PATCH_IMPORT_APPLIED.to_string(),
+                output,
+                repo_path,
+            )),
+            Err(GitError::CommandFailed {
+                command,
+                stderr,
+                exit_code,
+            }) => {
+                let status_output = Self::run_git(&["status", "--porcelain=v1"], Some(repo_path))?;
+                if Self::status_has_unmerged_files(&status_output) {
+                    return Ok(Self::operation_result(
+                        Self::PATCH_IMPORT_CONFLICTS.to_string(),
+                        stderr,
+                        repo_path,
+                    ));
+                }
+
+                if stderr.contains("does not match index") {
+                    return Err(GitError::InvalidInput(
+                        Self::patch_three_way_blocked_message(),
+                    ));
+                }
+
+                Err(GitError::CommandFailed {
+                    command,
+                    stderr,
+                    exit_code,
+                })
+            }
+            Err(error) => Err(error),
+        }
+    }
+
     fn submodule_index_commit(repo_path: &Path, path: &str) -> Option<String> {
         let output = Self::run_git_allow_exit_codes(
             &["ls-files", "--stage", "--", path],
@@ -2639,11 +2735,15 @@ impl GitOperationHandler for CliGitHandler {
     }
 
     fn import_patch_file(&self, request: &ImportPatchRequest) -> GitResult<OperationResult> {
-        self.check_patch_file(request)?;
-
         let repo_path = Self::normalise_repo_path(&request.repo_path)?;
         let patch_path = Self::validate_patch_path(&request.patch_path)?;
         let patch_path_string = patch_path.to_string_lossy().to_string();
+
+        if request.three_way {
+            return Self::apply_patch_three_way(&repo_path, &patch_path_string);
+        }
+
+        self.check_patch_file(request)?;
         let output = Self::run_git(&["apply", "--binary", &patch_path_string], Some(&repo_path))?;
 
         Ok(Self::operation_result(

src-tauri/src/git/types.rs

@@ -296,6 +296,8 @@ pub struct Settings {
 pub struct ImportPatchRequest {
     pub repo_path: String,
     pub patch_path: String,
+    #[serde(default)]
+    pub three_way: bool,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]

src-tauri/tests/git.rs

@@ -238,6 +238,19 @@ fn import_patch_request(repo: &TempDir, patch_path: &Path) -> ImportPatchRequest
     ImportPatchRequest {
         repo_path: repo.path().to_str().unwrap().to_string(),
         patch_path: patch_path.to_str().unwrap().to_string(),
+        three_way: false,
+    }
+}
+
+fn import_patch_request_with_three_way(
+    repo: &TempDir,
+    patch_path: &Path,
+    three_way: bool,
+) -> ImportPatchRequest {
+    ImportPatchRequest {
+        repo_path: repo.path().to_str().unwrap().to_string(),
+        patch_path: patch_path.to_str().unwrap().to_string(),
+        three_way,
     }
 }
 
@@ -255,6 +268,23 @@ fn export_patch_request(
     }
 }
 
+fn assert_patch_contains_full_index(output: &str) {
+    let index_line = output
+        .lines()
+        .find(|line| line.starts_with("index "))
+        .expect("patch has index line");
+    let ids = index_line
+        .trim_start_matches("index ")
+        .split_whitespace()
+        .next()
+        .expect("index line has object ids");
+    let (old, new) = ids
+        .split_once("..")
+        .expect("index line separates object ids");
+    assert_eq!(old.len(), 40);
+    assert_eq!(new.len(), 40);
+}
+
 fn export_commit_patch_request(
     repo: &TempDir,
     patch_path: &Path,
@@ -420,6 +450,104 @@ fn import_patch_rejects_non_applicable_patch_without_modifying_files() {
     assert_eq!(read_file(dir.path(), "file.txt"), "different\n");
 }
 
+#[test]
+fn import_patch_three_way_returns_conflict_result_for_drifted_full_index_patch() {
+    let dir = init_repo();
+    write_file(dir.path(), "file.txt", "base\n");
+    git(dir.path(), &["add", "file.txt"]);
+    git(dir.path(), &["commit", "-m", "add base file"]);
+    let base_hash = head_hash(dir.path());
+
+    write_file(dir.path(), "file.txt", "patch\n");
+    git(dir.path(), &["add", "file.txt"]);
+    git(dir.path(), &["commit", "-m", "patch change"]);
+    let patch = dir.path().join("change.patch");
+    let patch_content = git_stdout(
+        dir.path(),
+        &["diff", "--full-index", "--binary", &base_hash, "HEAD", "--"],
+    );
+    fs::write(&patch, format!("{patch_content}\n")).expect("write patch");
+
+    git(dir.path(), &["reset", "--hard", &base_hash]);
+    write_file(dir.path(), "file.txt", "target\n");
+    git(dir.path(), &["add", "file.txt"]);
+    git(dir.path(), &["commit", "-m", "target drift"]);
+
+    let result = handler()
+        .import_patch_file(&import_patch_request_with_three_way(&dir, &patch, true))
+        .expect("three-way import result");
+
+    assert_eq!(result.message, "GITMUN_PATCH_IMPORT_CONFLICTS");
+    assert!(
+        git_stdout(dir.path(), &["status", "--porcelain"])
+            .lines()
+            .any(|line| line.starts_with("UU file.txt"))
+    );
+    assert!(read_file(dir.path(), "file.txt").contains("<<<<<<<"));
+}
+
+#[test]
+fn import_patch_three_way_failure_without_blob_data_leaves_files_unchanged() {
+    let dir = init_repo();
+    write_file(dir.path(), "file.txt", "different\n");
+    git(dir.path(), &["add", "file.txt"]);
+    git(dir.path(), &["commit", "-m", "add file"]);
+
+    let patch = dir.path().join("change.patch");
+    fs::write(
+        &patch,
+        "diff --git a/file.txt b/file.txt\n\
+         index 624785c..172491a 100644\n\
+         --- a/file.txt\n\
+         +++ b/file.txt\n\
+         @@ -1 +1 @@\n\
+         -before\n\
+         +after\n",
+    )
+    .expect("write patch");
+
+    let result =
+        handler().import_patch_file(&import_patch_request_with_three_way(&dir, &patch, true));
+
+    assert!(result.is_err());
+    assert_eq!(read_file(dir.path(), "file.txt"), "different\n");
+    assert!(
+        git_stdout(dir.path(), &["status", "--porcelain"])
+            .lines()
+            .all(|line| !line.starts_with("UU "))
+    );
+}
+
+#[test]
+fn import_patch_three_way_blocks_dirty_tracked_files() {
+    let dir = init_repo();
+    write_file(dir.path(), "file.txt", "base\n");
+    git(dir.path(), &["add", "file.txt"]);
+    git(dir.path(), &["commit", "-m", "add base file"]);
+    let base_hash = head_hash(dir.path());
+
+    write_file(dir.path(), "file.txt", "patch\n");
+    git(dir.path(), &["add", "file.txt"]);
+    git(dir.path(), &["commit", "-m", "patch change"]);
+    let patch = dir.path().join("change.patch");
+    let patch_content = git_stdout(
+        dir.path(),
+        &["diff", "--full-index", "--binary", &base_hash, "HEAD", "--"],
+    );
+    fs::write(&patch, format!("{patch_content}\n")).expect("write patch");
+
+    git(dir.path(), &["reset", "--hard", &base_hash]);
+    write_file(dir.path(), "file.txt", "local\n");
+
+    let error = handler()
+        .import_patch_file(&import_patch_request_with_three_way(&dir, &patch, true))
+        .expect_err("dirty files block three-way apply")
+        .to_string();
+
+    assert!(error.contains("GITMUN_ERROR_PATCH_IMPORT_THREE_WAY_BLOCKED"));
+    assert_eq!(read_file(dir.path(), "file.txt"), "local\n");
+}
+
 #[test]
 fn export_staged_patch_contains_only_staged_changes() {
     let dir = init_repo();
@@ -444,6 +572,7 @@ fn export_staged_patch_contains_only_staged_changes() {
 
     assert!(output.contains("diff --git a/staged.txt b/staged.txt"));
     assert!(!output.contains("unstaged.txt"));
+    assert_patch_contains_full_index(&output);
 }
 
 #[test]
@@ -469,6 +598,7 @@ fn export_unstaged_patch_contains_tracked_unstaged_and_untracked_files() {
     assert!(output.contains("diff --git a/tracked.txt b/tracked.txt"));
     assert!(output.contains("diff --git a/new.txt b/new.txt"));
     assert!(output.contains("new file mode"));
+    assert_patch_contains_full_index(&output);
 }
 
 #[test]
@@ -497,6 +627,7 @@ fn export_all_concatenates_staged_unstaged_and_untracked_changes() {
     assert!(output.contains("diff --git a/staged.txt b/staged.txt"));
     assert!(output.contains("diff --git a/unstaged.txt b/unstaged.txt"));
     assert!(output.contains("diff --git a/new.txt b/new.txt"));
+    assert_patch_contains_full_index(&output);
 }
 
 #[test]
@@ -544,6 +675,7 @@ fn export_selected_honours_staged_and_unstaged_file_selections() {
     assert!(output.contains("diff --git a/unstaged.txt b/unstaged.txt"));
     assert!(output.contains("diff --git a/new.txt b/new.txt"));
     assert!(!output.contains("ignored.txt"));
+    assert_patch_contains_full_index(&output);
 }
 
 #[test]
@@ -562,6 +694,7 @@ fn export_commit_patch_contains_selected_commit_changes() {
 
     assert!(output.contains("diff --git a/commit.txt b/commit.txt"));
     assert!(output.contains("+first"));
+    assert_patch_contains_full_index(&output);
 }
 
 #[test]