lore-revision: Fix conflict markers glued to hunks lacking a trailing newline

When both sides of a conflict end the file without a trailing newline, the merge glues
the conflict markers onto the content lines and the file becomes unparseable — markers
are only recognizable at the start of a line:

```
<<<<<<< ours
This is line 2 changed.||||||| original
This is line 2.=======
This is line 2 also changed.>>>>>>> theirs
```

git merge-file --diff3 puts every marker on its own line for the same inputs.

Repro is easy: commit a file written with no trailing newline on two branches
from a common base, then `branch merge start`. With trailing newlines the markers come
out fine.

The bug was in the diffy crate. It is fixed there now (bmwill/diffy#85), and 0.5.2 makes
the behaviour selectable (bmwill/diffy#88).

## Updated per review

**No vendoring.** This is now a plain dependency bump to `diffy = "0.5.2"` plus
`MergeOptions::set_incomplete_hunk_style(IncompleteHunkStyle::Git)` in `merge3_text`.
The bump alone is not enough: 0.5.2 defaults to `IncompleteHunkStyle::Diff3`, which is
the old glued behaviour, so the setting is what does the work.

**Tests that resolve restores the content unchanged.** `scripts/test/test_merge_resolve.py`
gains three cases on a file whose last line has no trailing newline:

- every conflict marker occupies a whole line;
- `merge resolve mine` restores the committed bytes exactly;
- `merge resolve theirs` restores the committed bytes exactly.

They compare bytes rather than strings, so an added newline fails the assertion instead of
passing unnoticed. The inserted newline belongs to the marker rendering only — resolving
through the Lore API reads the `~mine` / `~theirs` sidecars and returns the side as it was
committed.

`lore-revision/tests/merge.rs` keeps a unit-level regression test for the marker shape.

## Testing

- `cargo test -p lore-revision` — 4 merge tests, 364 lib tests
- `pytest test_merge_resolve.py test_merge.py test_conflict.py` — 25 passed
- `pytest test_diff.py test_diff_git_baseline.py` — 64 passed (`PatchFormatter` is the
  other diffy consumer, so the diff output is covered too)

---

Disclosure: I used Claude to investigate the root cause of this bug and to
implement the fix. I reviewed and tested the changes myself.

```
Imported-PR: #119
Imported-From: 70ee9c0
Imported-Base: 715645d
Imported-Merge: 627c14d
Imported-Merge-Strategy: verbatim
Imported-Merged-Paths: 0
Imported-Author: Jochen Hunz (jochenhz)
Signed-off-by: Jochen Hunz <j.hunz@anchorpoint.app>
GH-URL: #119
```

Lore-RevId: 864
Lore-Signature: 5fd0a5f2f53be5504b8f1c8c002116d01d80bf35c260225822e787e62478fbc3

Author: jochenhz

Cargo.lock

@@ -61,7 +61,7 @@ config = { version = "0.15.15", features = ["toml"], default-features = false }
 ctor = "0.2"
 crossbeam = "0.8.4"
 dashmap = "6.1.0"
-diffy = "0.4.2"
+diffy = "0.5.2"
 directories = "6.0.0"
 enum_dispatch = "0.3.13"
 tracing-appender = "0.2.3"

Cargo.toml

@@ -32,7 +32,11 @@ pub fn merge3_text(
     mine_marker: Option<&str>,
     theirs_marker: Option<&str>,
 ) -> Result<String, String> {
-    let merge_result = diffy::merge(base, mine, theirs);
+    // `Git`, not diffy's `Diff3` default: `Diff3` glues the next marker onto a
+    // final line that lacks a newline, which is unparsable.
+    let merge_result = diffy::MergeOptions::new()
+        .set_incomplete_hunk_style(diffy::IncompleteHunkStyle::Git)
+        .merge(base, mine, theirs);
     let merge_conflicts = merge_result.is_err();
     let mut merge_output = match merge_result {
         Ok(str) | Err(str) => str,

lore-revision/src/merge.rs

@@ -35,6 +35,36 @@ mod tests {
         assert_eq!(result_string, expected_string);
     }
 
+    /// Fails without `IncompleteHunkStyle::Git`: the default glues the next
+    /// marker onto the last line when it has no trailing newline.
+    #[test]
+    fn test_conflict_without_trailing_newlines() {
+        let base_string = "This is line 1.
+This is line 2.";
+        let mine_string = "This is line 1.
+This is line 2 as I wrote it.";
+        let theirs_string = "This is line 1.
+This is line 2 as they wrote it.";
+
+        let result_string =
+            match merge3_text(base_string, mine_string, theirs_string, None, None, None) {
+                Err(str) | Ok(str) => str,
+            };
+
+        for marker in [
+            "<<<<<<< ours",
+            "||||||| original",
+            "=======",
+            ">>>>>>> theirs",
+        ] {
+            assert!(
+                result_string.lines().any(|line| line == marker),
+                "`{marker}` must occupy a line of its own, got:
+{result_string}"
+            );
+        }
+    }
+
     #[test]
     fn test_markers() {
         let base_string = "This is line 1.\nThis is line 2.\n";

lore-revision/tests/merge.rs

@@ -584,3 +584,72 @@ def test_merge_resolve_mine_no_paths(new_lore_repo):
         )
 
     repo.commit("Resolved all with mine (no paths)", offline=True)
+# ---------------------------------------------------------------------------
+# Test: a final line without a newline survives resolve unchanged
+# ---------------------------------------------------------------------------
+
+# `IncompleteHunkStyle::Git` inserts a newline after an incomplete final line so
+# the following conflict marker starts at column 0. These pin that the newline
+# belongs to the marker rendering only: resolving restores the side byte for
+# byte, exactly as it was committed.
+
+BASE_NO_EOL = b"line 1\nline 2"
+MINE_NO_EOL = b"line 1\nline 2 mine"
+THEIRS_NO_EOL = b"line 1\nline 2 theirs"
+
+
+@pytest.mark.smoke
+def test_merge_conflict_markers_own_line_without_trailing_newline(new_lore_repo):
+    """Every marker starts a line even when the conflicting hunk has no EOL."""
+    repo: Lore = new_lore_repo()
+    setup_merge_conflict(
+        repo, {"a.txt": (BASE_NO_EOL, MINE_NO_EOL, THEIRS_NO_EOL)}
+    )
+
+    with repo.open_file("a.txt", "rb") as f:
+        conflicted = f.read().decode()
+
+    for marker in ["<<<<<<< ours", "||||||| original", "=======", ">>>>>>> theirs"]:
+        assert any(line == marker for line in conflicted.split("\n")), (
+            f"{marker!r} must occupy a whole line, got {conflicted!r}"
+        )
+
+    repo.branch_merge_abort(offline=True)
+
+
+@pytest.mark.smoke
+def test_merge_resolve_mine_restores_missing_trailing_newline(new_lore_repo):
+    """resolve mine gives back the committed bytes, without the marker newline."""
+    repo: Lore = new_lore_repo()
+    setup_merge_conflict(
+        repo, {"a.txt": (BASE_NO_EOL, MINE_NO_EOL, THEIRS_NO_EOL)}
+    )
+
+    repo.branch_merge_resolve_mine(["a.txt"], offline=True, json=True)
+
+    with repo.open_file("a.txt", "rb") as f:
+        content = f.read()
+    assert content == MINE_NO_EOL, (
+        f"resolve mine must restore the exact bytes, got {content!r}"
+    )
+
+    repo.branch_merge_abort(offline=True)
+
+
+@pytest.mark.smoke
+def test_merge_resolve_theirs_restores_missing_trailing_newline(new_lore_repo):
+    """resolve theirs gives back the committed bytes, without the marker newline."""
+    repo: Lore = new_lore_repo()
+    setup_merge_conflict(
+        repo, {"a.txt": (BASE_NO_EOL, MINE_NO_EOL, THEIRS_NO_EOL)}
+    )
+
+    repo.branch_merge_resolve_theirs(["a.txt"], offline=True, json=True)
+
+    with repo.open_file("a.txt", "rb") as f:
+        content = f.read()
+    assert content == THEIRS_NO_EOL, (
+        f"resolve theirs must restore the exact bytes, got {content!r}"
+    )
+
+    repo.branch_merge_abort(offline=True)