fix(hooks): update pair-sync ref after auto-sync to avoid false conflicts

Author: TTTPOB

jupyter_jcli/commands/hooks_cmd.py

@@ -343,29 +343,46 @@ def _apply_merge_and_decide(
     logger=None,
 ) -> None:
     """Write merged content and emit allow/deny based on which file changed."""
+    from jupyter_jcli.canonicalize import canonicalize_py_text
+    from jupyter_jcli import pair_baseline
     from jupyter_jcli.pair_io import emit_py_percent, update_ipynb_sources
-    from jupyter_jcli.parser import parse_py_percent
+    from jupyter_jcli.parser import ParsedFile, parse_py_percent
 
     try:
         target_before = target.read_bytes()
     except OSError:
         return
 
     wrote_target = False
+    synced = False
+    merged_py_text: str | None = None
+    canonical_merged_py: str | None = None
 
-    if result.py_needs_update:
+    def _prepare_merged_py() -> tuple[str | None, str | None]:
         try:
             py_parsed = parse_py_percent(str(py_path))
-            from jupyter_jcli.parser import ParsedFile
             merged_parsed = ParsedFile(
                 kernel_name=py_parsed.kernel_name,
                 cells=result.merged_cells,
                 source_path=py_parsed.source_path,
                 front_matter_raw=py_parsed.front_matter_raw,
             )
-            new_text = emit_py_percent(merged_parsed)
+            merged_text = emit_py_percent(merged_parsed)
+            return merged_text, canonicalize_py_text(merged_text)
+        except Exception as exc:  # noqa: BLE001
+            if logger is not None:
+                logger.record_exception(exc)
+            return None, None
+
+    if result.py_needs_update:
+        try:
+            if merged_py_text is None:
+                merged_py_text, canonical_merged_py = _prepare_merged_py()
+            if merged_py_text is None:
+                raise RuntimeError("could not prepare merged py text")
             if py_path.read_bytes() == target_before or py_path != target:
-                py_path.write_text(new_text, encoding="utf-8")
+                py_path.write_text(merged_py_text, encoding="utf-8")
+                synced = True
                 if py_path == target:
                     wrote_target = True
                 else:
@@ -382,6 +399,7 @@ def _apply_merge_and_decide(
         try:
             if target.read_bytes() == target_before or ipynb_path != target:
                 update_ipynb_sources(ipynb_path, result.merged_cells)
+                synced = True
                 if ipynb_path == target:
                     wrote_target = True
                 else:
@@ -394,6 +412,12 @@ def _apply_merge_and_decide(
                 logger.record_exception(exc)
             print(f"pair-drift-guard-pre: could not write {ipynb_path.name}: {exc}", file=sys.stderr)
 
+    if synced:
+        if canonical_merged_py is None:
+            _, canonical_merged_py = _prepare_merged_py()
+    if synced and canonical_merged_py is not None:
+        pair_baseline.write_baseline(py_path, canonical_merged_py)
+
     if wrote_target:
         other = ipynb_path if target == py_path else py_path
         _emit_decision(
@@ -607,10 +631,30 @@ def _sync_pair_after_edit(
     logger=None,
 ) -> None:
     """Write the merge result to the OTHER side (not the one the agent just edited)."""
+    from jupyter_jcli.canonicalize import canonicalize_py_text
+    from jupyter_jcli import pair_baseline
     from jupyter_jcli.pair_io import emit_py_percent, update_ipynb_sources
     from jupyter_jcli.parser import ParsedFile, parse_py_percent
 
     synced = False
+    merged_py_text: str | None = None
+    canonical_merged_py: str | None = None
+
+    def _prepare_merged_py() -> tuple[str | None, str | None]:
+        try:
+            py_parsed = parse_py_percent(str(py_path))
+            merged_parsed = ParsedFile(
+                kernel_name=py_parsed.kernel_name,
+                cells=result.merged_cells,
+                source_path=py_parsed.source_path,
+                front_matter_raw=py_parsed.front_matter_raw,
+            )
+            merged_text = emit_py_percent(merged_parsed)
+            return merged_text, canonicalize_py_text(merged_text)
+        except Exception as exc:  # noqa: BLE001
+            if logger is not None:
+                logger.record_exception(exc)
+            return None, None
 
     if result.ipynb_needs_update and ipynb_path != edited:
         try:
@@ -626,14 +670,11 @@ def _sync_pair_after_edit(
 
     if result.py_needs_update and py_path != edited:
         try:
-            py_parsed = parse_py_percent(str(py_path))
-            merged_parsed = ParsedFile(
-                kernel_name=py_parsed.kernel_name,
-                cells=result.merged_cells,
-                source_path=py_parsed.source_path,
-                front_matter_raw=py_parsed.front_matter_raw,
-            )
-            py_path.write_text(emit_py_percent(merged_parsed), encoding="utf-8")
+            if merged_py_text is None:
+                merged_py_text, canonical_merged_py = _prepare_merged_py()
+            if merged_py_text is None:
+                raise RuntimeError("could not prepare merged py text")
+            py_path.write_text(merged_py_text, encoding="utf-8")
             synced = True
         except Exception as exc:  # noqa: BLE001
             if logger is not None:
@@ -643,6 +684,11 @@ def _sync_pair_after_edit(
                 file=sys.stderr,
             )
 
+    if synced:
+        if canonical_merged_py is None:
+            _, canonical_merged_py = _prepare_merged_py()
+    if synced and canonical_merged_py is not None:
+        pair_baseline.write_baseline(py_path, canonical_merged_py)
     if synced:
         other = ipynb_path if edited == py_path else py_path
         _emit_decision(

tests/test_hooks_pair_drift.py

@@ -3,13 +3,16 @@
 from __future__ import annotations
 
 import json
+import os
+import subprocess
 from pathlib import Path
 from unittest.mock import patch
 
 import nbformat
 import pytest
 from click.testing import CliRunner
 
+from jupyter_jcli import pair_baseline
 from jupyter_jcli.cli import main
 from jupyter_jcli.drift import DriftResult
 
@@ -77,6 +80,43 @@ def _make_pair(tmp_path: Path, py_src: list[str], ipynb_src: list[str]) -> tuple
     return py, ipynb
 
 
+def _git(repo: Path, *args: str, env: dict[str, str] | None = None, check: bool = True) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["git", *args],
+        cwd=str(repo),
+        check=check,
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+
+
+def _git_env(ts: int) -> dict[str, str]:
+    env = os.environ.copy()
+    stamp = f"@{ts} +0000"
+    env["GIT_AUTHOR_DATE"] = stamp
+    env["GIT_COMMITTER_DATE"] = stamp
+    return env
+
+
+@pytest.fixture
+def git_repo(tmp_path: Path) -> Path:
+    subprocess.run(["git", "init"], cwd=str(tmp_path), check=True, capture_output=True)
+    subprocess.run(
+        ["git", "config", "user.email", "test@test.com"],
+        cwd=str(tmp_path),
+        check=True,
+        capture_output=True,
+    )
+    subprocess.run(
+        ["git", "config", "user.name", "Test User"],
+        cwd=str(tmp_path),
+        check=True,
+        capture_output=True,
+    )
+    return tmp_path
+
+
 # ---------------------------------------------------------------------------
 # pair-drift-guard-pre no longer handles NotebookEdit (moved to notebook-edit-guard)
 # ---------------------------------------------------------------------------
@@ -552,6 +592,92 @@ def test_ipynb_edit_in_post_is_silent(self, tmp_path):
         assert _decision(out) is None  # no output — Pre was the line of defense
 
 
+# ---------------------------------------------------------------------------
+# pair baseline integration — real git repo, no drift mock
+# ---------------------------------------------------------------------------
+
+class TestConsecutiveEdits:
+    def test_post_uses_sticky_ref_to_avoid_false_conflict(self, git_repo: Path, monkeypatch: pytest.MonkeyPatch):
+        py, ipynb = _make_pair(git_repo, ["x = 1"], ["x = 1"])
+        _git(git_repo, "add", "nb.py")
+        _git(git_repo, "commit", "-m", "init", env=_git_env(100))
+
+        py.write_text(py.read_text(encoding="utf-8").replace("x = 1", "x = 10"), encoding="utf-8")
+        monkeypatch.setenv("GIT_AUTHOR_DATE", "@150 +0000")
+        monkeypatch.setenv("GIT_COMMITTER_DATE", "@150 +0000")
+        code1, out1 = _invoke_post({"tool_name": "Edit", "tool_input": {"file_path": str(py)}})
+
+        assert code1 == 0
+        assert "Auto-synced" in _additional_context(out1)
+        first_ref = _git(
+            git_repo,
+            "log",
+            "-1",
+            "--format=%ct",
+            pair_baseline._ref_name("nb.py"),
+        ).stdout.strip()
+        nb1 = nbformat.read(str(ipynb), as_version=4)
+        assert [cell.source for cell in nb1.cells if cell.source.strip()] == ["x = 10"]
+
+        py.write_text(py.read_text(encoding="utf-8").replace("x = 10", "x = 20"), encoding="utf-8")
+        monkeypatch.setenv("GIT_AUTHOR_DATE", "@160 +0000")
+        monkeypatch.setenv("GIT_COMMITTER_DATE", "@160 +0000")
+        code2, out2 = _invoke_post({"tool_name": "Edit", "tool_input": {"file_path": str(py)}})
+
+        assert code2 == 0
+        assert "Auto-synced" in _additional_context(out2)
+        second_ref = _git(
+            git_repo,
+            "log",
+            "-1",
+            "--format=%ct",
+            pair_baseline._ref_name("nb.py"),
+        ).stdout.strip()
+        nb2 = nbformat.read(str(ipynb), as_version=4)
+        assert [cell.source for cell in nb2.cells if cell.source.strip()] == ["x = 20"]
+        assert int(second_ref) >= int(first_ref)
+
+
+class TestPreToPostChain:
+    def test_pre_merge_updates_ref_so_following_post_does_not_conflict(
+        self,
+        git_repo: Path,
+        monkeypatch: pytest.MonkeyPatch,
+    ):
+        py, ipynb = _make_pair(git_repo, ["x = 1"], ["x = 1"])
+        _git(git_repo, "add", "nb.py")
+        _git(git_repo, "commit", "-m", "init", env=_git_env(100))
+
+        py.write_text(py.read_text(encoding="utf-8").replace("x = 1", "x = 10"), encoding="utf-8")
+        monkeypatch.setenv("GIT_AUTHOR_DATE", "@150 +0000")
+        monkeypatch.setenv("GIT_COMMITTER_DATE", "@150 +0000")
+        code0, out0 = _invoke_post({"tool_name": "Edit", "tool_input": {"file_path": str(py)}})
+        assert code0 == 0
+        assert "Auto-synced" in _additional_context(out0)
+
+        nb = nbformat.read(str(ipynb), as_version=4)
+        nb.cells[0].source = "x = 30"
+        nbformat.write(nb, str(ipynb))
+
+        monkeypatch.setenv("GIT_AUTHOR_DATE", "@170 +0000")
+        monkeypatch.setenv("GIT_COMMITTER_DATE", "@170 +0000")
+        pre_code, pre_out = _invoke({"tool_name": "Edit", "tool_input": {"file_path": str(py)}})
+        assert pre_code == 0
+        assert _decision(pre_out) == "deny"
+        assert "Re-read" in _reason(pre_out) or "Someone else edited" in _reason(pre_out)
+        assert "x = 30" in py.read_text(encoding="utf-8")
+
+        py.write_text(py.read_text(encoding="utf-8").replace("x = 30", "x = 40"), encoding="utf-8")
+        monkeypatch.setenv("GIT_AUTHOR_DATE", "@180 +0000")
+        monkeypatch.setenv("GIT_COMMITTER_DATE", "@180 +0000")
+        post_code, post_out = _invoke_post({"tool_name": "Edit", "tool_input": {"file_path": str(py)}})
+
+        assert post_code == 0
+        assert "Auto-synced" in _additional_context(post_out)
+        nb_after = nbformat.read(str(ipynb), as_version=4)
+        assert [cell.source for cell in nb_after.cells if cell.source.strip()] == ["x = 40"]
+
+
 # ---------------------------------------------------------------------------
 # --debug smoke tests for pair-drift-guard-pre and pair-drift-guard-post
 # ---------------------------------------------------------------------------