cluxion-agentplugin-supercoder 0.1.0__py3-none-any.whl

cluxion_agentplugin_supercoder/__init__.py

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

cluxion_agentplugin_supercoder/cli.py

@@ -0,0 +1,27 @@
+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
+
+
+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()}
+        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,93 @@
+from __future__ import annotations
+
+"""Cursor logic — bounded file windows with hash verification."""
+
+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]]:
+    entries: list[dict[str, object]] = []
+    candidates = paths or _default_scan_paths(root)
+    for rel in candidates[: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
+
+
+def _default_scan_paths(root: Path) -> list[str]:
+    found: list[str] = []
+    for path in root.rglob("*"):
+        if len(found) >= 256:
+            break
+        if not path.is_file():
+            continue
+        rel = str(path.relative_to(root))
+        if any(part in {".git", "node_modules", ".venv", "dist", "target"} for part in path.parts):
+            continue
+        if path.suffix in {".py", ".rs", ".ts", ".tsx", ".js", ".go", ".md", ".toml", ".yaml", ".yml"}:
+            found.append(rel)
+    return found
+
+
+__all__ = ["LineWindow", "cursor_map", "read_window"]

cluxion_agentplugin_supercoder/core/hash_patch.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+"""Hash-verified safe patch — ported from cluxion-os _hash_edit_core."""
+
+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 @@
+from __future__ import annotations
+
+"""Line budget policy — blocks oversized reads and writes."""
+
+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/queue.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+"""Coding work unit queue — deterministic, no model calls."""
+
+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"]

cluxion_agentplugin_supercoder/core/safety.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+"""Fail-closed safety gates for tool calls."""
+
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class SafetyDecision:
+    decision: str
+    reason: str
+
+
+_DESTRUCTIVE = (
+    "rm -rf",
+    "git reset --hard",
+    "git push --force",
+    "drop table",
+    "truncate table",
+    "kubectl delete",
+)
+_SECRET_PARTS = (".env", "id_rsa", "credentials", "secrets")
+
+
+def pre_tool_gate(
+    tool_name: str,
+    args: dict[str, object],
+    *,
+    workspace: Path,
+    stale_cursor: bool = False,
+) -> SafetyDecision:
+    if stale_cursor:
+        return SafetyDecision("block", "stale cursor: file changed after read_window")
+    command = str(args.get("command", ""))
+    if any(token in command.lower() for token in _DESTRUCTIVE):
+        return SafetyDecision("block", "destructive command requires explicit approval")
+    for key in ("path", "file_path", "target"):
+        value = args.get(key)
+        if isinstance(value, str) and value:
+            decision = _path_gate(workspace, value)
+            if decision.decision == "block":
+                return decision
+    if tool_name in {"write_file", "patch"} and int(args.get("line_count", 0) or 0) > 400:
+        return SafetyDecision("block", "write exceeds 400-line soft cap")
+    return SafetyDecision("allow", "passed safety gate")
+
+
+def _path_gate(workspace: Path, rel_or_abs: str) -> SafetyDecision:
+    candidate = Path(rel_or_abs)
+    resolved = (workspace / candidate).resolve() if not candidate.is_absolute() else candidate.resolve()
+    if not str(resolved).startswith(str(workspace.resolve())):
+        return SafetyDecision("block", "workspace escape blocked")
+    if any(part in _SECRET_PARTS for part in resolved.parts):
+        return SafetyDecision("block", "secret file access blocked")
+    return SafetyDecision("allow", "path ok")
+
+
+__all__ = ["SafetyDecision", "pre_tool_gate"]

cluxion_agentplugin_supercoder/core/test_gate.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def _resolve_test_targets(root: Path, files_changed: list[str]) -> list[str]:
+    targets: list[str] = []
+    for raw in files_changed:
+        rel = raw.strip()
+        if not rel:
+            continue
+        path = Path(rel)
+        if path.parts and path.parts[0] == "tests" and path.name.startswith("test_") and path.suffix == ".py":
+            candidate = root / path
+            if candidate.exists():
+                targets.append(str(path))
+            continue
+        if "src" not in path.parts:
+            continue
+        stem = path.stem
+        module = path.parent.name
+        for name in (f"test_{stem}.py", f"test_{module}.py"):
+            candidate = root / "tests" / name
+            if candidate.exists():
+                targets.append(str(candidate.relative_to(root)))
+                break
+    return list(dict.fromkeys(targets))
+
+
+def suggest_test_commands(
+    files_changed: list[str] | None = None,
+    *,
+    command: str | None = None,
+    cwd: Path | None = None,
+) -> dict[str, object]:
+    root = (cwd or Path.cwd()).expanduser().resolve()
+    changed = [str(item) for item in (files_changed or []) if str(item).strip()]
+    targets = _resolve_test_targets(root, changed) if changed else []
+    explicit = (command or "").strip()
+    if explicit and explicit != "pytest -q":
+        primary = explicit
+        source = "explicit_command"
+    elif targets:
+        primary = "pytest -q " + " ".join(targets)
+        source = "mapped_from_files_changed"
+    else:
+        primary = explicit or "pytest -q"
+        source = "default"
+    return {
+        "ok": True,
+        "mode": "suggest_or_run",
+        "command": primary,
+        "targets": targets,
+        "files_changed": changed,
+        "source": source,
+        "alternatives": _alternatives(targets),
+        "note": (
+            "Run through host terminal tool; do not claim pass unless command succeeded. "
+            "Record stdout/stderr in supercoder_brief.tests_run."
+        ),
+    }
+
+
+def _alternatives(targets: list[str]) -> list[str]:
+    if not targets:
+        return ["pytest -q", "python -m pytest -q"]
+    joined = " ".join(targets)
+    return [f"pytest -q {joined}", f"python -m pytest -q {joined}"]
+
+
+__all__ = ["suggest_test_commands"]

cluxion_agentplugin_supercoder/plugin.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+
+from cluxion_agentplugin_supercoder import runner
+from cluxion_agentplugin_supercoder.core.test_gate import suggest_test_commands
+from cluxion_agentplugin_supercoder.schemas import (
+    BRIEF_SCHEMA,
+    CURSOR_MAP_SCHEMA,
+    PATCH_SCHEMA,
+    PLAN_SCHEMA,
+    READ_WINDOW_SCHEMA,
+    TEST_GATE_SCHEMA,
+)
+
+
+def register(ctx: object) -> None:
+    ctx.register_tool(name="supercoder_plan", toolset="supercoder", schema=PLAN_SCHEMA, handler=_wrap(runner.plan), emoji="🧩")
+    ctx.register_tool(
+        name="supercoder_read_window",
+        toolset="supercoder",
+        schema=READ_WINDOW_SCHEMA,
+        handler=_wrap(runner.read_window_tool),
+        emoji="📖",
+    )
+    ctx.register_tool(
+        name="supercoder_patch",
+        toolset="supercoder",
+        schema=PATCH_SCHEMA,
+        handler=_wrap(runner.patch_tool),
+        emoji="🩹",
+    )
+    ctx.register_tool(
+        name="supercoder_cursor_map",
+        toolset="supercoder",
+        schema=CURSOR_MAP_SCHEMA,
+        handler=_wrap(runner.cursor_map_tool),
+        emoji="🗺️",
+    )
+    ctx.register_tool(
+        name="supercoder_test_gate",
+        toolset="supercoder",
+        schema=TEST_GATE_SCHEMA,
+        handler=_handle_test_gate,
+        emoji="🧪",
+    )
+    ctx.register_tool(name="supercoder_brief", toolset="supercoder", schema=BRIEF_SCHEMA, handler=_handle_brief, emoji="📋")
+
+
+def _wrap(callback: Callable[[dict[str, object]], runner.ToolResult]) -> Callable[[dict[str, object]], str]:
+    def handler(args: dict[str, object], **_: object) -> str:
+        try:
+            return callback(args).to_json()
+        except (ValueError, FileNotFoundError, PermissionError) as exc:
+            return json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False, sort_keys=True)
+
+    return handler
+
+
+def _handle_test_gate(args: dict[str, object], **_: object) -> str:
+    from pathlib import Path
+
+    raw_files = args.get("files_changed", [])
+    files_changed = [str(item) for item in raw_files] if isinstance(raw_files, list) else []
+    cwd_raw = str(args.get("cwd", ".")).strip() or "."
+    payload = suggest_test_commands(
+        files_changed,
+        command=str(args.get("command", "")).strip() or None,
+        cwd=Path(cwd_raw).expanduser().resolve(),
+    )
+    return json.dumps(payload, ensure_ascii=False, sort_keys=True)
+
+
+def _handle_brief(args: dict[str, object], **_: object) -> str:
+    return json.dumps(
+        {
+            "ok": True,
+            "brief": {
+                "files_changed": args.get("files_changed", []),
+                "tests_run": args.get("tests_run", []),
+                "verification_status": args.get("verification_status", "unknown_after_check"),
+                "remaining_risks": args.get("remaining_risks", []),
+            },
+        },
+        ensure_ascii=False,
+        sort_keys=True,
+    )
+
+
+__all__ = ["register"]

cluxion_agentplugin_supercoder/runner.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+
+from cluxion_agentplugin_supercoder.core.cursor import cursor_map, read_window
+from cluxion_agentplugin_supercoder.core.hash_patch import apply_patch
+from cluxion_agentplugin_supercoder.core.line_budget import budget_for, is_coding_task
+from cluxion_agentplugin_supercoder.core.queue import plan_coding_task
+from cluxion_agentplugin_supercoder.core.safety import pre_tool_gate
+
+
+@dataclass(frozen=True)
+class ToolResult:
+    ok: bool
+    payload: dict[str, object]
+
+    def to_json(self) -> str:
+        return json.dumps({"ok": self.ok, **self.payload}, ensure_ascii=False, sort_keys=True)
+
+
+def _workspace(payload: Mapping[str, object]) -> Path:
+    cwd = str(payload.get("cwd", ".")).strip() or "."
+    return Path(cwd).expanduser().resolve()
+
+
+def plan(payload: Mapping[str, object]) -> ToolResult:
+    prompt = str(payload.get("prompt", "")).strip()
+    if not prompt:
+        raise ValueError("prompt is required")
+    if not is_coding_task(prompt):
+        return ToolResult(True, {"mode": "bypass", "reason": "not_a_coding_task"})
+    task_id = str(payload.get("task_id", "task-default"))
+    queue = plan_coding_task(task_id, prompt)
+    return ToolResult(
+        True,
+        {
+            "mode": "coding_queue",
+            "task_id": task_id,
+            "units": [
+                {
+                    "id": unit.id,
+                    "goal": unit.goal,
+                    "priority": unit.priority,
+                    "status": unit.status.value,
+                    "dependencies": list(unit.dependencies),
+                }
+                for unit in queue.units
+            ],
+        },
+    )
+
+
+def read_window_tool(payload: Mapping[str, object]) -> ToolResult:
+    root = _workspace(payload)
+    rel = str(payload.get("path", "")).strip()
+    start = int(payload.get("start_line", 1))
+    max_lines = int(payload.get("max_lines", 120))
+    decision = budget_for("inspect", requested_lines=max_lines)
+    if not decision.allowed:
+        return ToolResult(False, {"error": decision.reason, "max_lines": decision.max_lines})
+    window = read_window(root, rel, start_line=start, max_lines=max_lines, purpose=str(payload.get("purpose", "read")))
+    return ToolResult(
+        True,
+        {
+            "path": window.path,
+            "start_line": window.start_line,
+            "end_line": window.end_line,
+            "content": window.content,
+            "content_hash": window.content_hash,
+            "file_hash": window.file_hash,
+        },
+    )
+
+
+def patch_tool(payload: Mapping[str, object]) -> ToolResult:
+    root = _workspace(payload)
+    rel = str(payload.get("path", "")).strip()
+    gate = pre_tool_gate("patch", payload, workspace=root, stale_cursor=bool(payload.get("stale_cursor", False)))
+    if gate.decision == "block":
+        return ToolResult(False, {"error": gate.reason})
+    result = apply_patch(
+        root / rel,
+        old_text=str(payload.get("old_text", "")),
+        new_text=str(payload.get("new_text", "")),
+        expected_file_hash=str(payload.get("expected_file_hash", "")),
+    )
+    return ToolResult(
+        result.success,
+        {
+            "file_path": result.file_path,
+            "strategy": result.strategy,
+            "message": result.message,
+            "expected_hash": result.expected_hash,
+            "matched_hash": result.matched_hash,
+            "similarity": result.similarity,
+        },
+    )
+
+
+def cursor_map_tool(payload: Mapping[str, object]) -> ToolResult:
+    root = _workspace(payload)
+    paths = payload.get("paths")
+    rel_paths = [str(item) for item in paths] if isinstance(paths, list) else None
+    entries = cursor_map(root, paths=rel_paths)
+    return ToolResult(True, {"entries": entries, "count": len(entries)})
+
+
+__all__ = ["ToolResult", "cursor_map_tool", "patch_tool", "plan", "read_window_tool"]

cluxion_agentplugin_supercoder/rust_bridge.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+from pathlib import Path
+
+
+def index_available() -> bool:
+    return shutil.which(_binary()) is not None
+
+
+def fast_file_hash(path: Path) -> str:
+    binary = _binary()
+    if shutil.which(binary) is None:
+        from cluxion_agentplugin_supercoder.core.hash_patch import file_hash
+
+        return file_hash(path.read_text(encoding="utf-8"))
+    completed = subprocess.run(
+        [binary, "hash"],
+        input=json.dumps({"path": str(path)}),
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+    if completed.returncode != 0:
+        from cluxion_agentplugin_supercoder.core.hash_patch import file_hash
+
+        return file_hash(path.read_text(encoding="utf-8"))
+    payload = json.loads(completed.stdout)
+    return str(payload.get("hash", ""))
+
+
+def _binary() -> str:
+    configured = os.environ.get("CLUXION_SUPERCODER_INDEX_BIN", "").strip()
+    if configured:
+        return configured
+    local = Path(__file__).resolve().parents[2] / "rust" / "supercoder_index" / "target" / "release" / "supercoder-index"
+    if local.exists():
+        return str(local)
+    return "supercoder-index"
+
+
+__all__ = ["fast_file_hash", "index_available"]

cluxion_agentplugin_supercoder/schemas.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+PLAN_SCHEMA = {
+    "name": "supercoder_plan",
+    "description": "Decompose a coding task into WorkUnit queue.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "prompt": {"type": "string"},
+            "task_id": {"type": "string"},
+            "cwd": {"type": "string"},
+        },
+        "required": ["prompt"],
+    },
+}
+
+READ_WINDOW_SCHEMA = {
+    "name": "supercoder_read_window",
+    "description": "Read a bounded line window with hashes.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "path": {"type": "string"},
+            "start_line": {"type": "integer", "default": 1},
+            "max_lines": {"type": "integer", "default": 120},
+            "cwd": {"type": "string"},
+        },
+        "required": ["path"],
+    },
+}
+
+PATCH_SCHEMA = {
+    "name": "supercoder_patch",
+    "description": "Apply hash-verified patch with stale cursor protection.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "path": {"type": "string"},
+            "old_text": {"type": "string"},
+            "new_text": {"type": "string"},
+            "expected_file_hash": {"type": "string"},
+            "cwd": {"type": "string"},
+        },
+        "required": ["path", "old_text", "new_text"],
+    },
+}
+
+CURSOR_MAP_SCHEMA = {
+    "name": "supercoder_cursor_map",
+    "description": "Build repo/file cursor index.",
+    "parameters": {
+        "type": "object",
+        "properties": {"cwd": {"type": "string"}, "paths": {"type": "array", "items": {"type": "string"}}},
+    },
+}
+
+TEST_GATE_SCHEMA = {
+    "name": "supercoder_test_gate",
+    "description": "Suggest targeted pytest commands from changed files; host terminal runs them.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "files_changed": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Paths edited in this task (maps src/* to tests/test_*.py when present).",
+            },
+            "command": {"type": "string", "description": "Override suggested command (optional)."},
+            "cwd": {"type": "string", "description": "Workspace root for test discovery."},
+        },
+    },
+}
+
+BRIEF_SCHEMA = {
+    "name": "supercoder_brief",
+    "description": "Summarize changes, verification, and remaining risks.",
+    "parameters": {"type": "object", "properties": {}},
+}

cluxion_agentplugin_supercoder-0.1.0.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: cluxion-agentplugin-supercoder
+Version: 0.1.0
+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
+Project-URL: Issues, https://github.com/cluxion/cluxion-Agentplugin-supercoder/issues
+Author-email: cluxion <algocean1204@users.noreply.github.com>
+License-Expression: Apache-2.0
+Keywords: claude-code,cluxion,codex,coding,hermes-agent,plugin
+Requires-Python: >=3.11
+Requires-Dist: psutil>=5.9
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# cluxion-Agentplugin-supercoder
+
+범용 에이전트 **코딩 하네스 플러그인** — **Hermes, Claude Code, Codex, Grok Build**에서 동일 core로 동작합니다.
+
+**Repository:** https://github.com/cluxion/cluxion-Agentplugin-supercoder
+
+## 한 줄 요약
+
+코딩 시 **큰 파일 추측·stale patch**를 막습니다. **연결된 AI**가 `supercoder_*` 도구로 bounded read·hash 검증 patch·evidence brief를 수행합니다.
+
+## 범용 에이전트 + Rust-First
+
+| 계층 | 구현 |
+|------|------|
+| **Rust** (`supercoder-index`) | file hash, repo scan |
+| **Python** (`core/`, `runner`) | cursor, patch, safety, plugin |
+| **Agent adapter** | Hermes plugin + `supercoder` toolset |
+
+patch 검증·인덱싱은 Rust, orchestration은 Python 래퍼입니다.
+
+## 이 플러그인의 역할
+
+- **Cursor logic** — line window, file/content hash
+- **Safe patch** — hash 검증, stale 차단
+- **Line budget** — 과도한 read/write 차단
+- **WorkUnit queue** — map → edit → verify → brief
+- **Safety gate** — workspace escape·destructive command 차단
+
+**모델·OAuth는 host 소유.** Supercoder는 plan·검증·evidence 계약만 제공합니다.
+
+## 연결된 AI가 하는 일
+
+```
+코딩 요청 → supercoder_plan
+         → cursor_map / read_window
+         → supercoder_patch (hash 필수)
+         → test_gate (host terminal 실행)
+         → supercoder_brief (evidence 필수)
+```
+
+비코딩 질문은 `bypass`로 오버헤드 최소화.
+
+## 빠른 시작
+
+```bash
+pip install cluxion-agentplugin-supercoder
+cluxion-supercoder check
+hermes plugins enable cluxion-agentplugin-supercoder
+```
+
+## 도구 (`supercoder` toolset)
+
+| Tool | 설명 |
+|------|------|
+| `supercoder_plan` | WorkUnit 큐 |
+| `supercoder_read_window` | line-bounded read |
+| `supercoder_patch` | hash 검증 patch |
+| `supercoder_cursor_map` | repo index |
+| `supercoder_test_gate` | 테스트 제안 |
+| `supercoder_brief` | evidence 요약 |
+
+## Adapters
+
+- `adapters/hermes/` — Hermes enable 가이드
+- `adapters/claude/skills/supercoder/` — Claude skill
+- `adapters/codex/config-snippet.toml` — Codex 참고
+
+## 문서
+
+- [Docs/README.md](Docs/README.md) — **처음 읽는 분** + 목차
+- [Docs/architecture.md](Docs/architecture.md)
+- [Docs/design.md](Docs/design.md)
+- [Docs/installation.md](Docs/installation.md)
+- [Docs/tools.md](Docs/tools.md)
+- [Docs/agent-surfaces.md](Docs/agent-surfaces.md)
+- [Docs/capabilities.md](Docs/capabilities.md)
+- [Docs/rust-architecture.md](Docs/rust-architecture.md)
+
+## License
+
+Apache-2.0

cluxion_agentplugin_supercoder-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+cluxion_agentplugin_supercoder/__init__.py,sha256=KAKeuFanmN4-M5U_soTZl7ymLes67dicCUq-yGdUBpQ,84
+cluxion_agentplugin_supercoder/cli.py,sha256=bI4ABt3k4EVGssKAz2XsgeWy5SKMliKLWOwDFe_kU-4,973
+cluxion_agentplugin_supercoder/plugin.py,sha256=PlacpR3K_B-3p807kFNijpyQRyvSb32IWhSJMqGYpA0,2962
+cluxion_agentplugin_supercoder/runner.py,sha256=ugS38uG9onQ2mRbGehqbLs68uHmUvPt6MTxpj0bTvIw,3964
+cluxion_agentplugin_supercoder/rust_bridge.py,sha256=1Kx_SULF3k-uTrusccoVfMzg9dlIrRz9NtCQD7ZjRgc,1262
+cluxion_agentplugin_supercoder/schemas.py,sha256=pb_Pymw0os8sSb8V98FgXA9O6WoDTduAjLF5IO1-Eng,2463
+cluxion_agentplugin_supercoder/core/cursor.py,sha256=OfTHnDBjRPyeSFbhqDCBdz20uifs3vA4iPeGmLc_GnI,2622
+cluxion_agentplugin_supercoder/core/hash_patch.py,sha256=_0wT2jNqRVs51BA4zKK9QcalCszJsBuzqVCJ1CvbSvo,4757
+cluxion_agentplugin_supercoder/core/line_budget.py,sha256=zI_pFTxNuFADjmRQJtmKVPMH2iDphIK1SICuL1z7E8Q,1325
+cluxion_agentplugin_supercoder/core/queue.py,sha256=HqlM9r__x0Lv7-CAedx-1pLsojDNlLcokrBBDhV1rts,2930
+cluxion_agentplugin_supercoder/core/safety.py,sha256=72YQNEBhBbqsqrQM_FXf-ecSjNyIQgYBRwwOCX1sOxI,1922
+cluxion_agentplugin_supercoder/core/test_gate.py,sha256=xyDfkYadSWmR4PZEX5b0ePhYpjfnc_4rufiN9Cc4sRw,2317
+cluxion_agentplugin_supercoder-0.1.0.dist-info/METADATA,sha256=_oFcnDxcj5i9_zFv7rJTy4hoAyyjE8kiXMbPK8q11_0,3424
+cluxion_agentplugin_supercoder-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+cluxion_agentplugin_supercoder-0.1.0.dist-info/entry_points.txt,sha256=qQpohjNavNMcFwAQasvyIrghVWKifJJ5T3iV_SP04io,232
+cluxion_agentplugin_supercoder-0.1.0.dist-info/RECORD,,

cluxion_agentplugin_supercoder-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

cluxion_agentplugin_supercoder-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,6 @@
+[console_scripts]
+cluxion-supercoder = cluxion_agentplugin_supercoder.cli:main
+
+[hermes_agent.plugins]
+cluxion-agentplugin-supercoder = cluxion_agentplugin_supercoder.plugin
+hermes-supercoder = cluxion_agentplugin_supercoder.plugin