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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cluxion-agentplugin-supercoder
-Version: 0.2.5
+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.5 → cluxion_agentplugin_supercoder-0.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cluxion-agentplugin-supercoder"
-version = "0.2.5"
+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.5 → cluxion_agentplugin_supercoder-0.2.7}/src/cluxion_agentplugin_supercoder/__init__.py

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

{cluxion_agentplugin_supercoder-0.2.5 → 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:
@@ -114,19 +140,48 @@ def _candidate_spans(text: str, reference: str, line_drift: int) -> list[tuple[i
 
 def _best_fuzzy_span(text: str, reference: str) -> tuple[int, int, str, float, bool] | None:
     best: tuple[int, int, str, float] | None = None
+    best_lines: tuple[int, int] | None = None
     ambiguous = False
+    lines = text.splitlines(keepends=True)
+    offsets = [0]
+    for line in lines:
+        offsets.append(offsets[-1] + len(line))
     for start, end, block in _candidate_spans(text, reference, MAX_LINE_DRIFT):
+        # compute line range [start_line, end_line) for overlap test
+        start_line = 0
+        while start_line < len(offsets) - 1 and offsets[start_line + 1] <= start:
+            start_line += 1
+        end_line = start_line
+        while end_line < len(offsets) - 1 and offsets[end_line] < end:
+            end_line += 1
         score = SequenceMatcher(None, block, reference, autojunk=False).ratio()
         if best is None or score > best[3]:
             best = (start, end, block, score)
+            best_lines = (start_line, end_line)
             ambiguous = False
         elif score >= DEFAULT_FUZZY_THRESHOLD and best and abs(score - best[3]) < 0.015:
+            # only treat as ambiguous if a genuinely different (non-overlapping) location matches closely
+            if best_lines is not None and not (end_line <= best_lines[0] or start_line >= best_lines[1]):
+                continue  # overlapping window on same location -> not real ambiguity
             ambiguous = True
     if best is None:
         return None
     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,
@@ -139,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.7/tests/test_hash_patch.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+import concurrent.futures
+import contextlib
+import os
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from cluxion_agentplugin_supercoder.core.hash_patch import apply_patch, file_hash
+
+
+def test_exact_patch(tmp_path: Path) -> None:
+    path = tmp_path / "a.py"
+    path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8")
+    expected = file_hash(path.read_text(encoding="utf-8"))
+    result = apply_patch(path, old_text="beta\n", new_text="BETA\n", expected_file_hash=expected)
+    assert result.success is True
+    assert "BETA" in path.read_text(encoding="utf-8")
+
+
+def test_stale_patch_blocked(tmp_path: Path) -> None:
+    path = tmp_path / "a.py"
+    path.write_text("one\n", encoding="utf-8")
+    result = apply_patch(path, old_text="one\n", new_text="two\n", expected_file_hash="0" * 64)
+    assert result.success is False
+    assert "changed" in result.message
+
+
+def test_missing_file_fails_closed(tmp_path: Path) -> None:
+    result = apply_patch(tmp_path / "absent.py", old_text="x", new_text="y")
+    assert result.success is False
+    assert result.strategy == "missing_file"
+
+
+def test_fuzzy_patch_tolerates_minor_drift(tmp_path: Path) -> None:
+    path = tmp_path / "a.py"
+    body = "def handler(request):\n    value = compute(request)\n    return value\n"
+    path.write_text(body, encoding="utf-8")
+    # old_text drifts from the file by one comment line the model forgot.
+    drifted = "def handler(request):\n    value = compute(request)  # cached\n    return value\n"
+    result = apply_patch(path, old_text=drifted, new_text="def handler(request):\n    return compute(request)\n")
+    assert result.success is True
+    assert result.strategy == "fuzzy"
+    assert 0.86 <= result.similarity < 1.0
+    assert path.read_text(encoding="utf-8") == "def handler(request):\n    return compute(request)\n"
+
+
+def test_low_similarity_is_no_match(tmp_path: Path) -> None:
+    path = tmp_path / "a.py"
+    path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8")
+    result = apply_patch(path, old_text="completely different content\n", new_text="x\n")
+    assert result.success is False
+    assert result.strategy == "no_match"
+
+
+def test_ambiguous_fuzzy_candidates_refuse_to_guess(tmp_path: Path) -> None:
+    # Two near-identical blocks: a fuzzy match could land on either, so the
+    # patch must fail instead of silently editing the wrong one.
+    path = tmp_path / "a.py"
+    block = "def f():\n    return 1\n"
+    path.write_text(block + "\n" + block, encoding="utf-8")
+    near = "def f():\n    return 2\n"
+    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"
+
+
+def test_exact_match_uses_first_occurrence(tmp_path: Path) -> None:
+    path = tmp_path / "a.py"
+    path.write_text("x = 1\ny = 2\nx = 1\n", encoding="utf-8")
+    result = apply_patch(path, old_text="x = 1\n", new_text="x = 9\n")
+    assert result.success is True
+    assert path.read_text(encoding="utf-8") == "x = 9\ny = 2\nx = 1\n"
+
+
+def test_sha256_prefix_and_bad_hash_rejected(tmp_path: Path) -> None:
+    path = tmp_path / "a.py"
+    path.write_text("one\n", encoding="utf-8")
+    prefixed = "sha256:" + file_hash("one\n")
+    result = apply_patch(path, old_text="one\n", new_text="two\n", expected_file_hash=prefixed)
+    assert result.success is True
+    path.write_text("one\n", encoding="utf-8")
+    with pytest.raises(ValueError):
+        apply_patch(path, old_text="one\n", new_text="two\n", expected_file_hash="abc")
+
+
+def test_fuzzy_short_2line_block_with_drift_applies(tmp_path: Path) -> None:
+    # regression: 2-line unique target with minor drift (trailing space + typo) must apply
+    # even though different window widths produce overlapping candidates
+    path = tmp_path / "multi.py"
+    body = """def foo():
+    x = 1
+    return x
+
+def bar():
+    y = 2
+    return y
+"""
+    path.write_text(body, encoding="utf-8")
+    # drifted old_text: trailing space on first line of block, one-char typo on second
+    drifted = "    y = 2 \n    return z\n"
+    new = "    y = 42\n    return y\n"
+    result = apply_patch(path, old_text=drifted, new_text=new)
+    assert result.success is True
+    assert result.strategy == "fuzzy"
+    content = path.read_text(encoding="utf-8")
+    assert "y = 42" in content
+    assert "return y" in content
+    assert "def bar():" in content
+
+
+def test_duplicate_blocks_still_ambiguous(tmp_path: Path) -> None:
+    # genuine duplicate (non-overlapping) must still refuse
+    path = tmp_path / "dups.py"
+    block = "def f():\n    return 1\n"
+    path.write_text(block + "\n" + block, encoding="utf-8")
+    near = "def f():\n    return 2\n"
+    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.5 → cluxion_agentplugin_supercoder-0.2.7}/uv.lock

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

cluxion_agentplugin_supercoder-0.2.5/tests/test_hash_patch.py

@@ -1,82 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-import pytest
-
-from cluxion_agentplugin_supercoder.core.hash_patch import apply_patch, file_hash
-
-
-def test_exact_patch(tmp_path: Path) -> None:
-    path = tmp_path / "a.py"
-    path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8")
-    expected = file_hash(path.read_text(encoding="utf-8"))
-    result = apply_patch(path, old_text="beta\n", new_text="BETA\n", expected_file_hash=expected)
-    assert result.success is True
-    assert "BETA" in path.read_text(encoding="utf-8")
-
-
-def test_stale_patch_blocked(tmp_path: Path) -> None:
-    path = tmp_path / "a.py"
-    path.write_text("one\n", encoding="utf-8")
-    result = apply_patch(path, old_text="one\n", new_text="two\n", expected_file_hash="0" * 64)
-    assert result.success is False
-    assert "changed" in result.message
-
-
-def test_missing_file_fails_closed(tmp_path: Path) -> None:
-    result = apply_patch(tmp_path / "absent.py", old_text="x", new_text="y")
-    assert result.success is False
-    assert result.strategy == "missing_file"
-
-
-def test_fuzzy_patch_tolerates_minor_drift(tmp_path: Path) -> None:
-    path = tmp_path / "a.py"
-    body = "def handler(request):\n    value = compute(request)\n    return value\n"
-    path.write_text(body, encoding="utf-8")
-    # old_text drifts from the file by one comment line the model forgot.
-    drifted = "def handler(request):\n    value = compute(request)  # cached\n    return value\n"
-    result = apply_patch(path, old_text=drifted, new_text="def handler(request):\n    return compute(request)\n")
-    assert result.success is True
-    assert result.strategy == "fuzzy"
-    assert 0.86 <= result.similarity < 1.0
-    assert path.read_text(encoding="utf-8") == "def handler(request):\n    return compute(request)\n"
-
-
-def test_low_similarity_is_no_match(tmp_path: Path) -> None:
-    path = tmp_path / "a.py"
-    path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8")
-    result = apply_patch(path, old_text="completely different content\n", new_text="x\n")
-    assert result.success is False
-    assert result.strategy == "no_match"
-
-
-def test_ambiguous_fuzzy_candidates_refuse_to_guess(tmp_path: Path) -> None:
-    # Two near-identical blocks: a fuzzy match could land on either, so the
-    # patch must fail instead of silently editing the wrong one.
-    path = tmp_path / "a.py"
-    block = "def f():\n    return 1\n"
-    path.write_text(block + "\n" + block, encoding="utf-8")
-    near = "def f():\n    return 2\n"
-    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"
-
-
-def test_exact_match_uses_first_occurrence(tmp_path: Path) -> None:
-    path = tmp_path / "a.py"
-    path.write_text("x = 1\ny = 2\nx = 1\n", encoding="utf-8")
-    result = apply_patch(path, old_text="x = 1\n", new_text="x = 9\n")
-    assert result.success is True
-    assert path.read_text(encoding="utf-8") == "x = 9\ny = 2\nx = 1\n"
-
-
-def test_sha256_prefix_and_bad_hash_rejected(tmp_path: Path) -> None:
-    path = tmp_path / "a.py"
-    path.write_text("one\n", encoding="utf-8")
-    prefixed = "sha256:" + file_hash("one\n")
-    result = apply_patch(path, old_text="one\n", new_text="two\n", expected_file_hash=prefixed)
-    assert result.success is True
-    path.write_text("one\n", encoding="utf-8")
-    with pytest.raises(ValueError):
-        apply_patch(path, old_text="one\n", new_text="two\n", expected_file_hash="abc")