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

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

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

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

{cluxion_agentplugin_supercoder-0.2.9 → cluxion_agentplugin_supercoder-0.2.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cluxion-agentplugin-supercoder"
-version = "0.2.9"
+version = "0.2.11"
 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.9 → cluxion_agentplugin_supercoder-0.2.11}/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
@@ -19,14 +20,22 @@ DEFAULT_FUZZY_THRESHOLD = 0.86
 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

{cluxion_agentplugin_supercoder-0.2.9 → cluxion_agentplugin_supercoder-0.2.11}/src/cluxion_agentplugin_supercoder/core/line_budget.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass
 
 
@@ -32,25 +33,35 @@ def budget_for(mode: str, *, requested_lines: int, remaining: int = 10_000) -> B
     return BudgetDecision(True, "within_budget", cap, remaining - requested_lines)
 
 
+_ASCII_CODING_KEYWORDS = (
+    "code",
+    "fix",
+    "implement",
+    "refactor",
+    "patch",
+    "test",
+    "bug",
+    "debug",
+)
+_KOREAN_CODING_KEYWORDS = (
+    "코드",
+    "수정",
+    "구현",
+    "리팩터",
+    "패치",
+    "테스트",
+    "버그",
+)
+_ASCII_CODING_PATTERNS = tuple(
+    re.compile(rf"\b{re.escape(keyword)}\b", re.IGNORECASE) for keyword in _ASCII_CODING_KEYWORDS
+)
+
+
 def is_coding_task(prompt: str) -> bool:
     text = prompt.lower()
-    needles = (
-        "code",
-        "fix",
-        "implement",
-        "refactor",
-        "patch",
-        "test",
-        "bug",
-        "코드",
-        "수정",
-        "구현",
-        "리팩터",
-        "패치",
-        "테스트",
-        "버그",
-    )
-    return any(needle in text for needle in needles)
+    if any(pattern.search(text) for pattern in _ASCII_CODING_PATTERNS):
+        return True
+    return any(keyword in text for keyword in _KOREAN_CODING_KEYWORDS)
 
 
 __all__ = ["BudgetDecision", "budget_for", "is_coding_task"]

{cluxion_agentplugin_supercoder-0.2.9 → cluxion_agentplugin_supercoder-0.2.11}/src/cluxion_agentplugin_supercoder/core/repo_map.py

@@ -43,13 +43,17 @@ def build_repo_map(
     base = Path(root).resolve()
     if not base.is_dir():
         return {"ok": False, "error": f"root is not a directory: {base}"}
-    entries = rust_bridge.scan_repo(base, max_files=max(1, int(max_files)))
+    capped_max_files = max(1, int(max_files))
+    entries = rust_bridge.scan_repo(base, max_files=capped_max_files)
+    total_candidates = rust_bridge.count_scan_candidates(base)
+    files_capped = max(0, total_candidates - capped_max_files)
     entries = _rank_entries(entries)
 
     lines: list[str] = []
     used = 0
     files_mapped = 0
-    files_omitted = 0
+    files_omitted = files_capped
+    budget_exhausted = False
     outlined_files = 0
     symbol_total = 0
     budget = max(200, int(budget_chars))
@@ -57,7 +61,7 @@ def build_repo_map(
     for entry in entries:
         rel = str(entry.get("path", ""))
         total_lines = int(entry.get("total_lines", 0))
-        if files_omitted:  # budget already exhausted: only count the rest
+        if budget_exhausted:
             files_omitted += 1
             continue
         block = [f"{rel} ({total_lines}L)"]
@@ -80,6 +84,7 @@ def build_repo_map(
         block_text = "\n".join(block)
         if used + len(block_text) + 1 > budget:
             files_omitted += 1
+            budget_exhausted = True
             continue
         lines.append(block_text)
         used += len(block_text) + 1
@@ -90,7 +95,7 @@ def build_repo_map(
         "root": str(base),
         "backend": rust_bridge.resolve_backend(),
         "map": "\n".join(lines),
-        "files_scanned": len(entries),
+        "files_scanned": len(entries) + files_capped,
         "files_mapped": files_mapped,
         "files_omitted": files_omitted,
         "outlined_files": outlined_files,

{cluxion_agentplugin_supercoder-0.2.9 → cluxion_agentplugin_supercoder-0.2.11}/src/cluxion_agentplugin_supercoder/doctor/probes.py

@@ -120,6 +120,61 @@ def native_module_importable(ctx: DoctorContext) -> tuple[str, str]:
 
 # plugin-specific probes (deterministic ones only) - for supercoder we can add if symbols found
 # for now, handler_exception_coverage is cross-cutting
+_EXPECTED_TOOLS = (
+    "supercoder_plan",
+    "supercoder_read_window",
+    "supercoder_patch",
+    "supercoder_cursor_map",
+    "supercoder_syntax_gate",
+    "supercoder_lint_gate",
+    "supercoder_repo_map",
+    "supercoder_test_gate",
+    "supercoder_brief",
+    "supercoder_doctor",
+)
+
+
+@_register("hermes_contract_tool_registration")
+def hermes_contract_tool_registration(ctx: DoctorContext) -> tuple[str, str]:
+    try:
+        from cluxion_agentplugin_supercoder.plugin import register
+
+        class _MockCtx:
+            def __init__(self) -> None:
+                self.tools: list[tuple[str, str, dict, object, str]] = []
+
+            def register_tool(
+                self,
+                *,
+                name: str,
+                toolset: str,
+                schema: dict,
+                handler: object,
+                emoji: str,
+            ) -> None:
+                self.tools.append((name, toolset, schema, handler, emoji))
+
+        mock = _MockCtx()
+        register(mock)
+        registered = [name for name, *_ in mock.tools]
+        missing = [name for name in _EXPECTED_TOOLS if name not in registered]
+        if missing:
+            return "fail", f"missing tools: {', '.join(missing)}"
+        extras = [name for name in registered if name not in _EXPECTED_TOOLS]
+        if extras:
+            return "fail", f"unexpected tools: {', '.join(extras)}"
+        for name, toolset, schema, handler, _emoji in mock.tools:
+            if toolset != "supercoder":
+                return "fail", f"{name}: toolset={toolset!r}"
+            if not isinstance(schema, dict) or not schema.get("name"):
+                return "fail", f"{name}: invalid schema"
+            if not callable(handler):
+                return "fail", f"{name}: handler not callable"
+        return "pass", f"{len(_EXPECTED_TOOLS)} tools registered with schemas and handlers"
+    except Exception as e:
+        return "fail", f"registration error: {e}"
+
+
 @_register("handler_exception_coverage")
 def handler_exception_coverage(ctx: DoctorContext) -> tuple[str, str]:
     try:

{cluxion_agentplugin_supercoder-0.2.9 → cluxion_agentplugin_supercoder-0.2.11}/src/cluxion_agentplugin_supercoder/rust_bridge.py

@@ -107,14 +107,7 @@ def _parse_backend_json(raw: str, command: str) -> dict[str, object]:
     return parsed
 
 
-def _py_scan(
-    root: Path,
-    *,
-    max_files: int,
-    extensions: tuple[str, ...],
-) -> dict[str, object]:
-    from cluxion_agentplugin_supercoder.core.hash_patch import file_hash
-
+def _collect_candidates(root: Path, *, extensions: tuple[str, ...]) -> list[str]:
     candidates: list[str] = []
     for path in root.rglob("*"):
         if not path.is_file():
@@ -125,6 +118,27 @@ def _py_scan(
             continue
         candidates.append(str(path.relative_to(root)))
     candidates.sort()
+    return candidates
+
+
+def count_scan_candidates(
+    root: Path,
+    *,
+    extensions: tuple[str, ...] = DEFAULT_EXTENSIONS,
+) -> int:
+    """Return how many files match scan_repo criteria before the max_files cap."""
+    return len(_collect_candidates(root, extensions=extensions))
+
+
+def _py_scan(
+    root: Path,
+    *,
+    max_files: int,
+    extensions: tuple[str, ...],
+) -> dict[str, object]:
+    from cluxion_agentplugin_supercoder.core.hash_patch import file_hash
+
+    candidates = _collect_candidates(root, extensions=extensions)
     entries: list[dict[str, object]] = []
     for rel in candidates[:max_files]:
         try:
@@ -138,7 +152,12 @@ def _py_scan(
                 "total_lines": text.count("\n") + (1 if text else 0),
             }
         )
-    return {"ok": True, "entries": entries, "count": len(entries)}
+    return {
+        "ok": True,
+        "entries": entries,
+        "count": len(entries),
+        "total_candidates": len(candidates),
+    }
 
 
 def _binary() -> str:
@@ -158,6 +177,7 @@ __all__ = [
     "DEFAULT_MAX_FILES",
     "INDEX_BACKEND_ENV",
     "INDEX_BIN_ENV",
+    "count_scan_candidates",
     "index_available",
     "resolve_backend",
     "scan_repo",

{cluxion_agentplugin_supercoder-0.2.9 → cluxion_agentplugin_supercoder-0.2.11}/tests/test_doctor.py

@@ -223,6 +223,82 @@ def test_path_security_probe_detects_ungated_read(monkeypatch):
     assert status == "fail"
 
 
+def test_healthy_install_ok_and_exit_zero(monkeypatch):
+    monkeypatch.setattr(
+        "cluxion_agentplugin_supercoder.doctor.probes.shutil.which",
+        lambda name: "/usr/bin/hermes" if name == "hermes" else None,
+    )
+
+    def fake_run(cmd, **_kwargs):
+        joined = " ".join(cmd)
+        if "--version" in joined:
+            return subprocess.CompletedProcess(cmd, 0, "Hermes Agent v1.0.0", "")
+        if "--help" in joined:
+            return subprocess.CompletedProcess(cmd, 0, "-z --oneshot", "")
+        if "tools" in joined and "list" in joined:
+            return subprocess.CompletedProcess(cmd, 0, "supercoder", "")
+        return subprocess.CompletedProcess(cmd, 0, "", "")
+
+    monkeypatch.setattr(
+        "cluxion_agentplugin_supercoder.doctor.framework.subprocess.run",
+        fake_run,
+    )
+    cat = _catalog_path()
+    result = run_doctor(
+        cwd=Path.cwd(),
+        catalog_path=cat,
+        probes=PROBES,
+        plugin="supercoder",
+        version="0.2.4",
+    )
+    statuses = {c.check_id: c.status for c in result.checks}
+    assert statuses["hermes_contract_tool_registration"] == "pass"
+    assert result.ok is True
+    assert result.summary == "ok"
+    payload = json.loads(render_json(result))
+    assert payload["ok"] is True
+
+    from cluxion_agentplugin_supercoder.cli import main
+
+    assert main(["doctor"]) == 0
+
+
+def test_genuine_failure_still_degraded_exit_one(monkeypatch):
+    monkeypatch.setattr(
+        "cluxion_agentplugin_supercoder.doctor.probes.shutil.which",
+        lambda name: "/usr/bin/hermes" if name == "hermes" else None,
+    )
+
+    def fake_run(cmd, **_kwargs):
+        joined = " ".join(cmd)
+        if "--version" in joined:
+            return subprocess.CompletedProcess(cmd, 0, "Hermes Agent v1.0.0", "")
+        if "--help" in joined:
+            return subprocess.CompletedProcess(cmd, 0, "-z --oneshot", "")
+        if "tools" in joined and "list" in joined:
+            return subprocess.CompletedProcess(cmd, 1, "", "tools unavailable")
+        return subprocess.CompletedProcess(cmd, 0, "", "")
+
+    monkeypatch.setattr(
+        "cluxion_agentplugin_supercoder.doctor.framework.subprocess.run",
+        fake_run,
+    )
+    result = run_doctor(
+        cwd=Path.cwd(),
+        catalog_path=_catalog_path(),
+        probes=PROBES,
+        plugin="supercoder",
+        version="0.2.4",
+    )
+    statuses = {c.check_id: c.status for c in result.checks}
+    assert statuses["toolset_valid"] == "fail"
+    assert result.ok is False
+
+    from cluxion_agentplugin_supercoder.cli import main
+
+    assert main(["doctor"]) == 1
+
+
 def test_hermes_workspace_probe_detects_ungated_read(monkeypatch):
     from cluxion_agentplugin_supercoder.core.safety import SafetyDecision
     from cluxion_agentplugin_supercoder.doctor.probes import hermes_context_workspace_root

{cluxion_agentplugin_supercoder-0.2.9 → cluxion_agentplugin_supercoder-0.2.11}/tests/test_hash_patch.py

@@ -158,6 +158,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.9 → cluxion_agentplugin_supercoder-0.2.11}/tests/test_line_budget.py

@@ -32,3 +32,16 @@ def test_is_coding_task_korean_and_english() -> None:
     assert is_coding_task("fix the login bug")
     assert is_coding_task("이 버그 수정해줘")
     assert not is_coding_task("오늘 날씨 어때?")
+
+
+def test_is_coding_task_word_boundaries_avoid_false_positives() -> None:
+    assert not is_coding_task("what is the latest news")
+    assert not is_coding_task("add a prefix to each line")
+    assert not is_coding_task("who won the contest yesterday")
+
+
+def test_is_coding_task_true_positives_with_word_boundaries() -> None:
+    assert is_coding_task("fix the bug in main.py")
+    assert is_coding_task("add a unit test for login")
+    assert is_coding_task("refactor the auth module")
+    assert is_coding_task("debug the timeout issue")

{cluxion_agentplugin_supercoder-0.2.9 → cluxion_agentplugin_supercoder-0.2.11}/tests/test_repo_map.py

@@ -82,6 +82,17 @@ def test_rust_outline_in_tree_sitter_tiers_fails_open_in_python(backend: str, sa
         assert ("method", "run") in pairs
 
 
+def test_max_files_cap_is_surfaced_honestly(backend: str, tmp_path: Path) -> None:
+    for index in range(6):
+        (tmp_path / f"mod_{index}.py").write_text(f"def fn_{index}():\n    pass\n", encoding="utf-8")
+    result = repo_map.build_repo_map(tmp_path, max_files=3, budget_chars=8000)
+    assert result["truncated"] is True
+    assert result["files_omitted"] > 0
+    assert result["files_mapped"] + result["files_omitted"] == result["files_scanned"] == 6
+    assert result["files_omitted"] == 3
+    assert result["files_mapped"] == 3
+
+
 def test_budget_omits_files_honestly(backend: str, sample_repo: Path) -> None:
     # budget_chars clamps to a 200-char floor, so overflow it with real files.
     for index in range(8):

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

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