cluxion-agentplugin-supercoder 0.2.6__tar.gz → 0.2.7__tar.gz

{cluxion_agentplugin_supercoder-0.2.6 → cluxion_agentplugin_supercoder-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cluxion-agentplugin-supercoder
-Version: 0.2.6
+Version: 0.2.7
 Summary: Universal agent coding harness plugin: cursor logic, safe patch, line budget, Rust index, test gates.
 Project-URL: Homepage, https://github.com/cluxion/cluxion-Agentplugin-supercoder
 Project-URL: Repository, https://github.com/cluxion/cluxion-Agentplugin-supercoder

{cluxion_agentplugin_supercoder-0.2.6 → cluxion_agentplugin_supercoder-0.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cluxion-agentplugin-supercoder"
-version = "0.2.6"
+version = "0.2.7"
 description = "Universal agent coding harness plugin: cursor logic, safe patch, line budget, Rust index, test gates."
 readme = "README.md"
 requires-python = ">=3.11"

{cluxion_agentplugin_supercoder-0.2.6 → cluxion_agentplugin_supercoder-0.2.7}/src/cluxion_agentplugin_supercoder/__init__.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
 
-__version__ = "0.2.6"
+__version__ = "0.2.7"
 
 __all__ = ["__version__"]

{cluxion_agentplugin_supercoder-0.2.6 → cluxion_agentplugin_supercoder-0.2.7}/src/cluxion_agentplugin_supercoder/core/hash_patch.py

@@ -3,15 +3,40 @@
 from __future__ import annotations
 
 import hashlib
+import os
+import tempfile
+from contextlib import contextmanager
 from dataclasses import dataclass
 from difflib import SequenceMatcher
 from pathlib import Path
 
+try:
+    import fcntl
+except ImportError:
+    fcntl = None  # type: ignore[assignment]
+
 DEFAULT_FUZZY_THRESHOLD = 0.86
 MAX_CONTEXT_SCAN = 8
 MAX_LINE_DRIFT = 2
 
 
+@contextmanager
+def _exclusive_lock(path: Path):
+    """Exclusive advisory lock on target file (fcntl.flock). Graceful degrade on non-POSIX."""
+    if fcntl is None or not path.exists():
+        yield
+        return
+    fd = os.open(str(path), os.O_RDWR)
+    try:
+        fcntl.flock(fd, fcntl.LOCK_EX)
+        yield
+    finally:
+        try:
+            fcntl.flock(fd, fcntl.LOCK_UN)
+        finally:
+            os.close(fd)
+
+
 @dataclass(frozen=True, slots=True)
 class PatchResult:
     success: bool
@@ -44,28 +69,29 @@ def apply_patch(
 ) -> PatchResult:
     if not path.exists():
         return _failed(str(path), "missing_file", expected_file_hash, "file not found")
-    text = path.read_text(encoding="utf-8")
-    current_hash = file_hash(text)
-    if expected_file_hash and current_hash != _normalize_hash(expected_file_hash):
-        return _failed(str(path), "stale_file", expected_file_hash, "file changed since cursor was created")
-    exact = _exact_spans(text, old_text)
-    if exact:
-        start, end = exact[0]
-        return _commit(path, text, start, end, new_text, "exact", expected_file_hash or current_hash, current_hash, 1.0)
-    fuzzy = _best_fuzzy_span(text, old_text)
-    if fuzzy and fuzzy[3] >= fuzzy_threshold and not fuzzy[4]:
-        return _commit(
-            path,
-            text,
-            fuzzy[0],
-            fuzzy[1],
-            new_text,
-            "fuzzy",
-            expected_file_hash or current_hash,
-            current_hash,
-            fuzzy[3],
-        )
-    return _failed(str(path), "no_match", expected_file_hash or current_hash, "patch target not found")
+    with _exclusive_lock(path):
+        text = path.read_text(encoding="utf-8")
+        current_hash = file_hash(text)
+        if expected_file_hash and current_hash != _normalize_hash(expected_file_hash):
+            return _failed(str(path), "stale_file", expected_file_hash, "file changed since cursor was created")
+        exact = _exact_spans(text, old_text)
+        if exact:
+            start, end = exact[0]
+            return _commit(path, text, start, end, new_text, "exact", expected_file_hash or current_hash, current_hash, 1.0)
+        fuzzy = _best_fuzzy_span(text, old_text)
+        if fuzzy and fuzzy[3] >= fuzzy_threshold and not fuzzy[4]:
+            return _commit(
+                path,
+                text,
+                fuzzy[0],
+                fuzzy[1],
+                new_text,
+                "fuzzy",
+                expected_file_hash or current_hash,
+                current_hash,
+                fuzzy[3],
+            )
+        return _failed(str(path), "no_match", expected_file_hash or current_hash, "patch target not found")
 
 
 def _normalize_newlines(content: str) -> str:
@@ -143,6 +169,19 @@ def _best_fuzzy_span(text: str, reference: str) -> tuple[int, int, str, float, b
     return best[0], best[1], best[2], best[3], ambiguous
 
 
+def _atomic_write(path: Path, content: str) -> None:
+    """Atomic replace via temp in same dir + fsync to prevent corruption on crash."""
+    dir_ = path.parent
+    with tempfile.NamedTemporaryFile(
+        mode="w", encoding="utf-8", dir=dir_, delete=False, suffix=".tmp"
+    ) as tmp:
+        tmp.write(content)
+        tmp.flush()
+        os.fsync(tmp.fileno())
+        tmp_path = Path(tmp.name)
+    os.replace(tmp_path, path)
+
+
 def _commit(
     path: Path,
     text: str,
@@ -155,7 +194,7 @@ def _commit(
     score: float,
 ) -> PatchResult:
     updated = f"{text[:start]}{new_content}{text[end:]}"
-    path.write_text(updated, encoding="utf-8")
+    _atomic_write(path, updated)
     return PatchResult(True, str(path), strategy, "patch applied", expected, matched, round(score, 4), 1)
 
 

{cluxion_agentplugin_supercoder-0.2.6 → cluxion_agentplugin_supercoder-0.2.7}/tests/test_hash_patch.py

@@ -1,5 +1,9 @@
 from __future__ import annotations
 
+import concurrent.futures
+import contextlib
+import os
+import tempfile
 from pathlib import Path
 
 import pytest
@@ -116,3 +120,82 @@ def test_duplicate_blocks_still_ambiguous(tmp_path: Path) -> None:
     result = apply_patch(path, old_text=near, new_text="def f():\n    return 3\n")
     assert result.success is False
     assert result.strategy == "no_match"
+
+
+# === Concurrency and atomicity tests ===
+
+def _worker_apply(i: int, path: Path) -> bool:
+    """Worker that applies a unique non-overlapping patch under lock."""
+    old = f"# UNIQUE_PATCH_{i}_START\n"
+    new = f"# UNIQUE_PATCH_{i}_DONE\n"
+    # distinct markers, no value chaining conflict
+    result = apply_patch(path, old_text=old, new_text=new)
+    return result.success
+
+
+def test_concurrent_patches_no_lost_update(tmp_path: Path) -> None:
+    """8 concurrent workers on same file: lock serializes, no lost updates, final coherent."""
+    path = tmp_path / "concurrent.py"
+    # initial content with 8 distinct unique markers
+    initial = "\n".join(f"# UNIQUE_PATCH_{i}_START" for i in range(8)) + "\n"
+    path.write_text(initial, encoding="utf-8")
+
+    # each patch changes its unique marker; lock ensures serialization, all succeed
+    with concurrent.futures.ThreadPoolExecutor(max_workers=8) as executor:
+        futures = [
+            executor.submit(_worker_apply, i, path) for i in range(8)
+        ]
+        successes = [f.result() for f in concurrent.futures.as_completed(futures)]
+
+    assert all(successes), "Some patches lost due to race"
+    final = path.read_text(encoding="utf-8")
+    # final should have all DONE markers, no START left
+    for i in range(8):
+        assert f"# UNIQUE_PATCH_{i}_DONE" in final
+        assert f"# UNIQUE_PATCH_{i}_START" not in final
+
+    # hash chain consistent (changed from initial)
+    new_hash = file_hash(final)
+    assert new_hash != file_hash(initial)
+
+
+def test_atomic_write_interruption_leaves_original_intact(tmp_path: Path) -> None:
+    """Simulated mid-write crash leaves ORIGINAL file intact (temp may remain, no truncate)."""
+    path = tmp_path / "atomic_test.txt"
+    original = "IMPORTANT ORIGINAL CONTENT\nDO NOT LOSE\n"
+    path.write_text(original, encoding="utf-8")
+    orig_hash = file_hash(original)
+
+    # simulate crash mid atomic write by patching _atomic_write temporarily
+    def crashing_atomic(p: Path, content: str) -> None:
+        dir_ = p.parent
+        with tempfile.NamedTemporaryFile(
+            mode="w", encoding="utf-8", dir=dir_, delete=False, suffix=".tmp"
+        ) as tmp:
+            tmp.write(content[:10])  # partial write
+            tmp.flush()
+            os.fsync(tmp.fileno())
+            # simulate kill before replace
+            raise RuntimeError("simulated crash mid-write")
+
+    original_atomic = None
+    try:
+        # monkey patch for test
+        import cluxion_agentplugin_supercoder.core.hash_patch as hp
+
+        original_atomic = hp._atomic_write
+        hp._atomic_write = crashing_atomic
+        with contextlib.suppress(RuntimeError):
+            hp._atomic_write(path, "CORRUPTED NEW CONTENT\n")
+        # after crash, original must be untouched
+        after = path.read_text(encoding="utf-8")
+        assert after == original, "Atomic write failed: original was corrupted or truncated"
+        assert file_hash(after) == orig_hash
+    finally:
+        import cluxion_agentplugin_supercoder.core.hash_patch as hp
+
+        if original_atomic is not None:
+            hp._atomic_write = original_atomic
+        # cleanup any leftover temp if test created
+        for f in tmp_path.glob("*.tmp"):
+            f.unlink(missing_ok=True)

{cluxion_agentplugin_supercoder-0.2.6 → cluxion_agentplugin_supercoder-0.2.7}/uv.lock

@@ -160,7 +160,7 @@ wheels = [
 
 [[package]]
 name = "cluxion-agentplugin-supercoder"
-version = "0.2.6"
+version = "0.2.7"
 source = { editable = "." }
 dependencies = [
     { name = "psutil" },