cluxion-agentplugin-supercoder 0.2.11__tar.gz → 0.2.13__tar.gz

{cluxion_agentplugin_supercoder-0.2.11 → cluxion_agentplugin_supercoder-0.2.13}/PKG-INFO

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

@@ -1,5 +1,5 @@
 name: cluxion-agentplugin-supercoder
-version: 0.2.11
+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.11 → cluxion_agentplugin_supercoder-0.2.13}/pyproject.toml

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

@@ -17,6 +17,7 @@ except ImportError:
     fcntl = None  # type: ignore[assignment]
 
 DEFAULT_FUZZY_THRESHOLD = 0.86
+AMBIGUITY_MARGIN = 0.015
 MAX_CONTEXT_SCAN = 8
 MAX_LINE_DRIFT = 2
 
@@ -76,6 +77,8 @@ def apply_patch(
     expected_file_hash: str = "",
     fuzzy_threshold: float = DEFAULT_FUZZY_THRESHOLD,
 ) -> PatchResult:
+    if not old_text:
+        return _failed(str(path), "empty_old_text", expected_file_hash, "old_text must be non-empty")
     if not path.exists():
         return _failed(str(path), "missing_file", expected_file_hash, "file not found")
     with _exclusive_lock(path):
@@ -119,6 +122,8 @@ def _normalize_hash(value: str) -> str:
 
 
 def _exact_spans(text: str, needle: str) -> list[tuple[int, int]]:
+    if not needle:
+        return []
     spans: list[tuple[int, int]] = []
     offset = 0
     while True:
@@ -130,6 +135,8 @@ def _exact_spans(text: str, needle: str) -> list[tuple[int, int]]:
 
 
 def _candidate_spans(text: str, reference: str, line_drift: int) -> list[tuple[int, int, str]]:
+    if not reference:
+        return []
     lines = text.splitlines(keepends=True)
     if not lines:
         return []
@@ -150,6 +157,8 @@ 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:
+    if not reference:
+        return None
     best: tuple[int, int, str, float] | None = None
     best_lines: tuple[int, int] | None = None
     ambiguous = False
@@ -157,6 +166,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
@@ -165,12 +176,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.11 → cluxion_agentplugin_supercoder-0.2.13}/tests/test_hash_patch.py

@@ -4,11 +4,139 @@ 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,
+    _exact_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_spans_empty_needle_returns_immediately() -> None:
+    assert _exact_spans("hello", "") == []
+
+
+def test_apply_patch_empty_old_text_fails_fast(tmp_path: Path) -> None:
+    path = tmp_path / "a.py"
+    path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8")
+    start = time.perf_counter()
+    result = apply_patch(path, old_text="", new_text="INSERT\n")
+    elapsed = time.perf_counter() - start
+    assert elapsed < 1.0
+    assert result.success is False
+    assert result.strategy == "empty_old_text"
+    assert "non-empty" in result.message
+    assert path.read_text(encoding="utf-8") == "alpha\nbeta\ngamma\n"
+
+
+def test_empty_reference_does_not_hang_fuzzy_path() -> None:
+    text = "\n".join(f"line_{i} = {i}" for i in range(500)) + "\n"
+    start = time.perf_counter()
+    assert _candidate_spans(text, "", MAX_LINE_DRIFT) == []
+    assert _best_fuzzy_span(text, "") is None
+    elapsed = time.perf_counter() - start
+    assert elapsed < 1.0
 
 
 def test_exact_patch(tmp_path: Path) -> None:

{cluxion_agentplugin_supercoder-0.2.11 → cluxion_agentplugin_supercoder-0.2.13}/uv.lock

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