cluxion-agentplugin-supercoder 0.2.0__cp311-abi3-win_amd64.whl

cluxion_agentplugin_supercoder/__init__.py

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

cluxion_agentplugin_supercoder/cli.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections.abc import Sequence
+
+from cluxion_agentplugin_supercoder import __version__
+from cluxion_agentplugin_supercoder.rust_bridge import index_available, resolve_backend
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="cluxion-supercoder")
+    parser.add_argument("--version", action="version", version=f"cluxion-agentplugin-supercoder {__version__}")
+    sub = parser.add_subparsers(dest="command")
+    sub.add_parser("check", help="Check plugin and Rust index availability")
+    args = parser.parse_args(argv)
+    if args.command == "check":
+        payload = {
+            "plugin": "cluxion-agentplugin-supercoder",
+            "version": __version__,
+            "rust_index": index_available(),
+            "index_backend": resolve_backend(),
+        }
+        print(json.dumps(payload, ensure_ascii=False, sort_keys=True))
+        return 0
+    parser.print_help(sys.stderr)
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cluxion_agentplugin_supercoder/core/cursor.py

@@ -0,0 +1,82 @@
+"""Cursor logic — bounded file windows with hash verification."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from cluxion_agentplugin_supercoder.core.hash_patch import file_hash
+
+
+@dataclass(frozen=True)
+class LineWindow:
+    path: str
+    start_line: int
+    end_line: int
+    content: str
+    content_hash: str
+    file_hash: str
+    purpose: str = "read"
+
+
+def read_window(
+    root: Path,
+    rel_path: str,
+    *,
+    start_line: int = 1,
+    max_lines: int = 120,
+    purpose: str = "read",
+) -> LineWindow:
+    path = (root / rel_path).resolve()
+    if not path.exists():
+        raise FileNotFoundError(rel_path)
+    if not str(path).startswith(str(root.resolve())):
+        raise PermissionError("path escapes workspace root")
+    text = path.read_text(encoding="utf-8")
+    lines = text.splitlines()
+    start = max(1, start_line)
+    end = min(len(lines), start + max_lines - 1)
+    if start > len(lines):
+        excerpt = ""
+        end = start
+    else:
+        excerpt = "\n".join(lines[start - 1 : end])
+    return LineWindow(
+        path=rel_path,
+        start_line=start,
+        end_line=end,
+        content=excerpt,
+        content_hash=file_hash(excerpt),
+        file_hash=file_hash(text),
+        purpose=purpose,
+    )
+
+
+def cursor_map(root: Path, *, paths: list[str] | None = None, max_files: int = 64) -> list[dict[str, object]]:
+    if paths is None:
+        from cluxion_agentplugin_supercoder.rust_bridge import scan_repo
+
+        scanned = scan_repo(root, max_files=max_files)
+        return [{**entry, "purpose": "index"} for entry in scanned]
+    entries: list[dict[str, object]] = []
+    for rel in paths[:max_files]:
+        path = root / rel
+        if not path.is_file():
+            continue
+        try:
+            text = path.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            continue
+        lines = text.count("\n") + (1 if text else 0)
+        entries.append(
+            {
+                "path": rel,
+                "file_hash": file_hash(text),
+                "total_lines": lines,
+                "purpose": "index",
+            }
+        )
+    return entries
+
+
+__all__ = ["LineWindow", "cursor_map", "read_window"]

cluxion_agentplugin_supercoder/core/hash_patch.py

@@ -0,0 +1,150 @@
+"""Hash-verified safe patch — ported from cluxion-os _hash_edit_core."""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+from difflib import SequenceMatcher
+from pathlib import Path
+
+DEFAULT_FUZZY_THRESHOLD = 0.86
+MAX_CONTEXT_SCAN = 8
+MAX_LINE_DRIFT = 2
+
+
+@dataclass(frozen=True, slots=True)
+class PatchResult:
+    success: bool
+    file_path: str
+    strategy: str
+    message: str
+    expected_hash: str
+    matched_hash: str | None = None
+    similarity: float = 0.0
+    replacements: int = 0
+
+
+def file_hash(content: str) -> str:
+    return hashlib.sha256(_normalize_newlines(content).encode("utf-8")).hexdigest()
+
+
+def hash_block(content: str, context_lines: int) -> str:
+    normalized = _normalize_newlines(content)
+    material = f"context_lines={context_lines}\0{normalized}"
+    return hashlib.sha256(material.encode("utf-8")).hexdigest()
+
+
+def apply_patch(
+    path: Path,
+    *,
+    old_text: str,
+    new_text: str,
+    expected_file_hash: str = "",
+    fuzzy_threshold: float = DEFAULT_FUZZY_THRESHOLD,
+) -> 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")
+
+
+def _normalize_newlines(content: str) -> str:
+    return content.replace("\r\n", "\n").replace("\r", "\n")
+
+
+def _normalize_hash(value: str) -> str:
+    raw = value.strip().lower()
+    if raw.startswith("sha256:"):
+        raw = raw.removeprefix("sha256:")
+    if len(raw) != 64:
+        raise ValueError("hash must be 64-char sha256")
+    return raw
+
+
+def _exact_spans(text: str, needle: str) -> list[tuple[int, int]]:
+    spans: list[tuple[int, int]] = []
+    offset = 0
+    while True:
+        start = text.find(needle, offset)
+        if start < 0:
+            return spans
+        spans.append((start, start + len(needle)))
+        offset = start + len(needle)
+
+
+def _candidate_spans(text: str, reference: str, line_drift: int) -> list[tuple[int, int, str]]:
+    lines = text.splitlines(keepends=True)
+    if not lines:
+        return []
+    offsets = [0]
+    for line in lines:
+        offsets.append(offsets[-1] + len(line))
+    target = max(1, len(reference.splitlines(keepends=True)))
+    lower = max(1, target - line_drift)
+    upper = min(len(lines), target + line_drift)
+    spans: list[tuple[int, int, str]] = []
+    for width in range(lower, upper + 1):
+        for start_line in range(0, len(lines) - width + 1):
+            start = offsets[start_line]
+            end = offsets[start_line + width]
+            block = text[start:end]
+            spans.append((start, end, block))
+    return spans
+
+
+def _best_fuzzy_span(text: str, reference: str) -> tuple[int, int, str, float, bool] | None:
+    best: tuple[int, int, str, float] | None = None
+    ambiguous = False
+    for start, end, block in _candidate_spans(text, reference, MAX_LINE_DRIFT):
+        score = SequenceMatcher(None, block, reference, autojunk=False).ratio()
+        if best is None or score > best[3]:
+            best = (start, end, block, score)
+            ambiguous = False
+        elif score >= DEFAULT_FUZZY_THRESHOLD and best and abs(score - best[3]) < 0.015:
+            ambiguous = True
+    if best is None:
+        return None
+    return best[0], best[1], best[2], best[3], ambiguous
+
+
+def _commit(
+    path: Path,
+    text: str,
+    start: int,
+    end: int,
+    new_content: str,
+    strategy: str,
+    expected: str,
+    matched: str,
+    score: float,
+) -> PatchResult:
+    updated = f"{text[:start]}{new_content}{text[end:]}"
+    path.write_text(updated, encoding="utf-8")
+    return PatchResult(True, str(path), strategy, "patch applied", expected, matched, round(score, 4), 1)
+
+
+def _failed(path: str, strategy: str, expected: str, message: str, score: float = 0.0) -> PatchResult:
+    return PatchResult(False, path, strategy, message, expected, None, round(score, 4), 0)
+
+
+__all__ = ["PatchResult", "apply_patch", "file_hash", "hash_block"]

cluxion_agentplugin_supercoder/core/line_budget.py

@@ -0,0 +1,56 @@
+"""Line budget policy — blocks oversized reads and writes."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class BudgetDecision:
+    allowed: bool
+    reason: str
+    max_lines: int
+    remaining_lines: int
+
+
+_DEFAULTS = {
+    "inspect": 120,
+    "patch_context": 100,
+    "review": 160,
+    "refactor_unit": 250,
+    "create_file": 400,
+    "test_log": 120,
+}
+
+
+def budget_for(mode: str, *, requested_lines: int, remaining: int = 10_000) -> BudgetDecision:
+    cap = _DEFAULTS.get(mode, 120)
+    if requested_lines > cap:
+        return BudgetDecision(False, f"line_budget_exceeded:{mode}", cap, remaining)
+    if requested_lines > remaining:
+        return BudgetDecision(False, "session_line_budget_exhausted", cap, remaining)
+    return BudgetDecision(True, "within_budget", cap, remaining - requested_lines)
+
+
+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)
+
+
+__all__ = ["BudgetDecision", "budget_for", "is_coding_task"]

cluxion_agentplugin_supercoder/core/lint_gate.py

@@ -0,0 +1,111 @@
+"""L2 lint gate: advisory lint findings for the file a patch just changed.
+
+The engine is ruff — a Rust linter shipped as a wheel dependency of this
+plugin, so the gate works everywhere without asking the host project to
+install anything. It runs on a single file, respects the target project's
+own ruff configuration (config discovery walks up from the file), and is
+suggest-only: findings ride along on the patch result and never block or
+revert a patch. Languages without a wired linter report ``checked: False``.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+from cluxion_agentplugin_supercoder.core.syntax_gate import language_for_path
+
+RUFF_BIN_ENV = "CLUXION_SUPERCODER_RUFF_BIN"
+LINTABLE_LANGUAGES = {"python"}
+MAX_REPORTED_FINDINGS = 20
+_TIMEOUT_SECONDS = 15.0
+
+
+def ruff_bin() -> str | None:
+    """Resolve the ruff executable: env override, venv sibling, then PATH."""
+    override = os.environ.get(RUFF_BIN_ENV, "").strip()
+    if override:
+        return override if Path(override).exists() else None
+    return _discover_ruff()
+
+
+@lru_cache(maxsize=1)
+def _discover_ruff() -> str | None:
+    name = "ruff.exe" if os.name == "nt" else "ruff"
+    sibling = Path(sys.executable).with_name(name)
+    if sibling.exists():
+        return str(sibling)
+    return shutil.which("ruff")
+
+
+def check_file(path: str | Path, *, cwd: str | Path | None = None) -> dict[str, Any]:
+    """Lint one file and return structured advisory findings."""
+    target = Path(path)
+    language = language_for_path(target)
+    if language not in LINTABLE_LANGUAGES:
+        return _unchecked(language or "", "no_linter")
+    binary = ruff_bin()
+    if binary is None:
+        return _unchecked(language, "no_tool")
+    command = [binary, "check", "--output-format", "json", "--force-exclude", "--no-cache", str(target)]
+    try:
+        proc = subprocess.run(
+            command,
+            cwd=str(cwd) if cwd is not None else None,
+            capture_output=True,
+            text=True,
+            timeout=_TIMEOUT_SECONDS,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return _unchecked(language, f"tool_error:{type(exc).__name__}")
+    # ruff exits 0 (clean) or 1 (findings); anything else is a tool failure.
+    if proc.returncode not in (0, 1):
+        return _unchecked(language, "tool_error:exit")
+    try:
+        raw = json.loads(proc.stdout or "[]")
+    except json.JSONDecodeError:
+        return _unchecked(language, "tool_error:output")
+    findings = [
+        {
+            "line": int(item.get("location", {}).get("row", 1)),
+            "column": int(item.get("location", {}).get("column", 1)),
+            "code": item.get("code") or "",
+            "message": str(item.get("message", "")),
+            "fixable": item.get("fix") is not None,
+        }
+        for item in raw
+        if isinstance(item, dict)
+    ]
+    total = len(findings)
+    return {
+        "ok": True,
+        "checked": True,
+        "language": language,
+        "tool": "ruff",
+        "clean": total == 0,
+        "findings": findings[:MAX_REPORTED_FINDINGS],
+        "finding_count": total,
+        "truncated": total > MAX_REPORTED_FINDINGS,
+    }
+
+
+def _unchecked(language: str, reason: str) -> dict[str, Any]:
+    return {
+        "ok": True,
+        "checked": False,
+        "language": language,
+        "reason": reason,
+        "clean": True,
+        "findings": [],
+        "finding_count": 0,
+        "truncated": False,
+    }
+
+
+__all__ = ["LINTABLE_LANGUAGES", "MAX_REPORTED_FINDINGS", "RUFF_BIN_ENV", "check_file", "ruff_bin"]

cluxion_agentplugin_supercoder/core/queue.py

@@ -0,0 +1,96 @@
+"""Coding work unit queue — deterministic, no model calls."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import StrEnum
+
+
+class WorkStatus(StrEnum):
+    PENDING = "pending"
+    RUNNING = "running"
+    BLOCKED = "blocked"
+    DEFERRED = "deferred"
+    COMPLETE = "complete"
+    FAILED = "failed"
+
+
+@dataclass
+class WorkUnit:
+    id: str
+    goal: str
+    priority: int = 2
+    allowed_paths: tuple[str, ...] = ()
+    line_budget: int = 250
+    status: WorkStatus = WorkStatus.PENDING
+    expected_evidence: tuple[str, ...] = ()
+    dependencies: tuple[str, ...] = ()
+
+
+@dataclass
+class TaskQueue:
+    task_id: str
+    units: list[WorkUnit] = field(default_factory=list)
+
+    def enqueue(self, unit: WorkUnit) -> None:
+        self.units.append(unit)
+
+    def next_unit(self) -> WorkUnit | None:
+        completed = {unit.id for unit in self.units if unit.status == WorkStatus.COMPLETE}
+        for unit in sorted(self.units, key=lambda item: (item.priority, item.id)):
+            if unit.status != WorkStatus.PENDING:
+                continue
+            if all(dep in completed for dep in unit.dependencies):
+                unit.status = WorkStatus.RUNNING
+                return unit
+        return None
+
+    def record(self, unit_id: str, *, success: bool, evidence: tuple[str, ...] = ()) -> dict[str, object]:
+        for unit in self.units:
+            if unit.id != unit_id:
+                continue
+            unit.status = WorkStatus.COMPLETE if success else WorkStatus.FAILED
+            unit.expected_evidence = evidence or unit.expected_evidence
+            return {
+                "task_id": self.task_id,
+                "unit_id": unit_id,
+                "status": unit.status.value,
+                "remaining": sum(1 for item in self.units if item.status == WorkStatus.PENDING),
+            }
+        raise KeyError(unit_id)
+
+
+def plan_coding_task(task_id: str, prompt: str) -> TaskQueue:
+    queue = TaskQueue(task_id=task_id)
+    queue.enqueue(WorkUnit("map", "Map repo and identify target files", priority=0, expected_evidence=("cursor_map",)))
+    queue.enqueue(
+        WorkUnit(
+            "edit",
+            f"Apply focused changes for: {prompt[:240]}",
+            priority=1,
+            dependencies=("map",),
+            expected_evidence=("files_changed",),
+        )
+    )
+    queue.enqueue(
+        WorkUnit(
+            "verify",
+            "Run targeted tests or lint for changed files",
+            priority=2,
+            dependencies=("edit",),
+            expected_evidence=("tests_run",),
+        )
+    )
+    queue.enqueue(
+        WorkUnit(
+            "brief",
+            "Summarize changes, verification, and remaining risks",
+            priority=3,
+            dependencies=("verify",),
+            expected_evidence=("brief",),
+        )
+    )
+    return queue
+
+
+__all__ = ["TaskQueue", "WorkStatus", "WorkUnit", "plan_coding_task"]