cluxion-agentplugin-supercoder 0.2.10__tar.gz → 0.2.12__tar.gz

{cluxion_agentplugin_supercoder-0.2.10 → cluxion_agentplugin_supercoder-0.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cluxion-agentplugin-supercoder
-Version: 0.2.10
+Version: 0.2.12
 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.10 → cluxion_agentplugin_supercoder-0.2.12}/plugin.yaml

@@ -1,5 +1,5 @@
 name: cluxion-agentplugin-supercoder
-version: 0.2.2
+version: 0.2.12
 description: "Universal agent coding harness: cursor, safe patch, line budget, Rust index."
 author: cluxion
 kind: standalone

{cluxion_agentplugin_supercoder-0.2.10 → cluxion_agentplugin_supercoder-0.2.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cluxion-agentplugin-supercoder"
-version = "0.2.10"
+version = "0.2.12"
 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.10 → cluxion_agentplugin_supercoder-0.2.12}/src/cluxion_agentplugin_supercoder/core/hash_patch.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import hashlib
 import os
 import tempfile
+import threading
 from contextlib import contextmanager
 from dataclasses import dataclass
 from difflib import SequenceMatcher
@@ -16,17 +17,26 @@ except ImportError:
     fcntl = None  # type: ignore[assignment]
 
 DEFAULT_FUZZY_THRESHOLD = 0.86
+AMBIGUITY_MARGIN = 0.015
 MAX_CONTEXT_SCAN = 8
 MAX_LINE_DRIFT = 2
 
+_thread_fallback_lock = threading.Lock()
+
+
+def _lock_path(path: Path) -> Path:
+    return path.parent / f".{path.name}.cluxion-lock"
+
 
 @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
+    """Exclusive advisory lock on stable sidecar file (fcntl.flock). Graceful degrade on non-POSIX."""
+    if fcntl is None:
+        with _thread_fallback_lock:
+            yield
         return
-    fd = os.open(str(path), os.O_RDWR)
+    lock_path = _lock_path(path)
+    fd = os.open(str(lock_path), os.O_CREAT | os.O_RDWR, 0o600)
     try:
         fcntl.flock(fd, fcntl.LOCK_EX)
         yield
@@ -148,6 +158,8 @@ def _best_fuzzy_span(text: str, reference: str) -> tuple[int, int, str, float, b
     offsets = [0]
     for line in lines:
         offsets.append(offsets[-1] + len(line))
+    sm = SequenceMatcher(autojunk=False)
+    sm.set_seq2(reference)
     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
@@ -156,12 +168,17 @@ def _best_fuzzy_span(text: str, reference: str) -> tuple[int, int, str, float, b
         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()
+        sm.set_seq1(block)
+        if best is not None:
+            prune_below = best[3] - AMBIGUITY_MARGIN
+            if sm.real_quick_ratio() < prune_below or sm.quick_ratio() < prune_below:
+                continue
+        score = sm.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:
+        elif score >= DEFAULT_FUZZY_THRESHOLD and best and abs(score - best[3]) < AMBIGUITY_MARGIN:
             # 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

{cluxion_agentplugin_supercoder-0.2.10 → cluxion_agentplugin_supercoder-0.2.12}/tests/test_hash_patch.py

@@ -4,11 +4,112 @@ import concurrent.futures
 import contextlib
 import os
 import tempfile
+import time
+from difflib import SequenceMatcher
 from pathlib import Path
 
 import pytest
 
-from cluxion_agentplugin_supercoder.core.hash_patch import apply_patch, file_hash
+from cluxion_agentplugin_supercoder.core.hash_patch import (
+    AMBIGUITY_MARGIN,
+    DEFAULT_FUZZY_THRESHOLD,
+    MAX_LINE_DRIFT,
+    _best_fuzzy_span,
+    _candidate_spans,
+    apply_patch,
+    file_hash,
+)
+
+
+def _best_fuzzy_span_legacy(text: str, reference: str) -> tuple[int, int, str, float, bool] | None:
+    """Pre-optimization reference implementation for byte-identical regression checks."""
+    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):
+        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]) < AMBIGUITY_MARGIN:
+            if best_lines is not None and not (end_line <= best_lines[0] or start_line >= best_lines[1]):
+                continue
+            ambiguous = True
+    if best is None:
+        return None
+    return best[0], best[1], best[2], best[3], ambiguous
+
+
+def _fuzzy_result_key(result: tuple[int, int, str, float, bool] | None) -> tuple | None:
+    if result is None:
+        return None
+    start, end, _block, score, ambiguous = result
+    return (start, end, score, ambiguous)
+
+
+@pytest.mark.parametrize(
+    ("text", "reference"),
+    [
+        pytest.param(
+            "\n".join(f"line_{i} = {i}" for i in range(20))
+            + "\n"
+            + "def target():\n    return 42\n"
+            + "\n".join(f"tail_{i} = {i}" for i in range(20))
+            + "\n",
+            "def target():\n    return 43\n",
+            id="exact-best-in-middle",
+        ),
+        pytest.param(
+            "def f():\n    return 1\n\n" + "def f():\n    return 1\n",
+            "def f():\n    return 2\n",
+            id="ambiguous-near-ties",
+        ),
+        pytest.param(
+            "alpha\nbeta\ngamma\ndelta\n",
+            "alpha\nBETA\ngamma\n",
+            id="clear-single-best",
+        ),
+        pytest.param(
+            "alpha\nbeta\ngamma\n",
+            "completely different content\n",
+            id="no-match",
+        ),
+    ],
+)
+def test_best_fuzzy_span_matches_legacy(text: str, reference: str) -> None:
+    legacy = _fuzzy_result_key(_best_fuzzy_span_legacy(text, reference))
+    optimized = _fuzzy_result_key(_best_fuzzy_span(text, reference))
+    assert optimized == legacy
+
+
+def test_best_fuzzy_span_large_file_benchmark() -> None:
+    """Optimized path should be materially faster on a ~500-line fuzzy search."""
+    filler = "\n".join(f"# filler line {i:03d} with some padding text" for i in range(480)) + "\n"
+    target = "def handler(request):\n    value = compute(request)\n    return value\n"
+    text = filler + target + filler
+    reference = "def handler(request):\n    value = compute(request)  # cached\n    return value\n"
+
+    legacy_start = time.perf_counter()
+    legacy = _best_fuzzy_span_legacy(text, reference)
+    legacy_elapsed = time.perf_counter() - legacy_start
+
+    optimized_start = time.perf_counter()
+    optimized = _best_fuzzy_span(text, reference)
+    optimized_elapsed = time.perf_counter() - optimized_start
+
+    assert _fuzzy_result_key(optimized) == _fuzzy_result_key(legacy)
+    assert optimized_elapsed < legacy_elapsed * 0.6
 
 
 def test_exact_patch(tmp_path: Path) -> None:
@@ -158,6 +259,24 @@ def test_concurrent_patches_no_lost_update(tmp_path: Path) -> None:
     assert new_hash != file_hash(initial)
 
 
+def test_concurrent_patches_no_lost_update_stress(tmp_path: Path) -> None:
+    """50 iterations of 8 concurrent workers: zero lost updates across all runs."""
+    for _ in range(50):
+        path = tmp_path / "concurrent_stress.py"
+        initial = "\n".join(f"# UNIQUE_PATCH_{i}_START" for i in range(8)) + "\n"
+        path.write_text(initial, encoding="utf-8")
+
+        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")
+        for i in range(8):
+            assert f"# UNIQUE_PATCH_{i}_DONE" in final
+            assert f"# UNIQUE_PATCH_{i}_START" not in final
+
+
 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"

{cluxion_agentplugin_supercoder-0.2.10 → cluxion_agentplugin_supercoder-0.2.12}/uv.lock

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