local-coding-agent 1.1.0__py3-none-any.whl

local_coding_agent/acp_server/_tools.py

@@ -0,0 +1,126 @@
+"""ACP tool catalog schemas."""
+
+from typing import Any
+
+ACP_TOOLS: list[dict[str, Any]] = [
+    {
+        "name": "spill_read",
+        "description": "Read or paginate a spilled tool output artifact (R24).",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "locator": {"type": "string", "description": "Spill locator token (e.g. locator:spill:... or path)"},
+                "offset": {"type": "integer", "description": "0-based line offset", "default": 0},
+                "limit": {"type": "integer", "description": "Maximum number of lines to read", "default": 1000},
+            },
+            "required": ["locator"],
+        },
+    },
+    {
+        "name": "grep",
+        "description": "Fast ripgrep / regex code search across workspace (R24).",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "query": {"type": "string", "description": "Search query or regex pattern"},
+                "paths": {"type": "array", "items": {"type": "string"}, "description": "Optional glob filters or paths"},
+                "regex": {"type": "boolean", "description": "Treat query as regular expression", "default": False},
+                "case_sensitive": {"type": "boolean", "description": "Perform case-sensitive matching", "default": False},
+                "max_results": {"type": "integer", "description": "Maximum match results", "default": 100},
+                "workspace": {"type": "string", "description": "Workspace root directory override"},
+            },
+            "required": ["query"],
+        },
+    },
+    {
+        "name": "lsp",
+        "description": "Run LSP code intelligence query (definition, references, hover, symbols) (R25).",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "operation": {
+                    "type": "string",
+                    "enum": ["definition", "references", "hover", "symbols"],
+                    "description": "LSP operation",
+                },
+                "file": {"type": "string", "description": "Target source file path"},
+                "line": {"type": "integer", "description": "0-based line number", "default": 0},
+                "char": {"type": "integer", "description": "0-based character/column offset", "default": 0},
+                "workspace": {"type": "string", "description": "Workspace root directory override"},
+            },
+            "required": ["operation", "file"],
+        },
+    },
+    {
+        "name": "skeletonize",
+        "description": "Parse and skeletonize code symbols using AST compactor (R17).",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "file": {"type": "string", "description": "Target source file path"},
+                "symbols": {"type": "array", "items": {"type": "string"}, "description": "Target symbols to retain in full"},
+            },
+            "required": ["file"],
+        },
+    },
+    {
+        "name": "lint_patch",
+        "description": "Fast pre-test semantic linter checking patch in memory (R18).",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "patch": {"type": "string", "description": "Unified diff or SEARCH/REPLACE patch to check"},
+                "workspace": {"type": "string", "description": "Workspace root directory override"},
+            },
+            "required": ["patch"],
+        },
+    },
+    {
+        "name": "read_file",
+        "description": "Read one UTF-8 file from workspace.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string", "description": "File path relative to workspace"},
+                "workspace": {"type": "string", "description": "Workspace root directory override"},
+            },
+            "required": ["path"],
+        },
+    },
+    {
+        "name": "list_files",
+        "description": "List files below workspace directory.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string", "description": "Directory path relative to workspace", "default": "."},
+                "workspace": {"type": "string", "description": "Workspace root directory override"},
+            },
+        },
+    },
+    {
+        "name": "run_tests",
+        "description": "Run test or shell check command in workspace.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "command": {"type": "string", "description": "Shell command to execute"},
+                "workspace": {"type": "string", "description": "Workspace root directory override"},
+                "timeout": {"type": "number", "description": "Timeout in seconds", "default": 60},
+            },
+            "required": ["command"],
+        },
+    },
+    {
+        "name": "propose_patch",
+        "description": "Validate whether a patch applies cleanly to the workspace.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "patch": {"type": "string", "description": "Patch content to validate"},
+                "workspace": {"type": "string", "description": "Workspace root directory override"},
+            },
+            "required": ["patch"],
+        },
+    },
+]

local_coding_agent/ast_compactor.py

@@ -0,0 +1,130 @@
+"""AST-Guided Context Compaction & Skeletonization (R17).
+
+Pre-processor that collapses non-target functions and classes down to signatures
+and docstrings using standard library AST parsing, reducing context footprint by 60–85%.
+"""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+from typing import Sequence
+
+
+class _SkeletonTransformer(ast.NodeTransformer):
+    def __init__(self, target_symbols: set[str]) -> None:
+        self.target_symbols = target_symbols
+        self.in_target_class = False
+
+    def _collapse_body(self, body: list[ast.stmt]) -> list[ast.stmt]:
+        docstring = ast.get_docstring(ast.Module(body=body, type_ignores=[]))
+        new_body: list[ast.stmt] = []
+        if docstring:
+            new_body.append(ast.Expr(value=ast.Constant(value=docstring)))
+        new_body.append(ast.Expr(value=ast.Constant(value=Ellipsis)))
+        return new_body
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
+        if self.in_target_class or node.name in self.target_symbols:
+            return node
+        node_copy = ast.FunctionDef(
+            name=node.name,
+            args=node.args,
+            body=self._collapse_body(node.body),
+            decorator_list=node.decorator_list,
+            returns=node.returns,
+            type_comment=getattr(node, "type_comment", None),
+            type_params=getattr(node, "type_params", []),
+        )
+        return node_copy
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> ast.AST:
+        if self.in_target_class or node.name in self.target_symbols:
+            return node
+        node_copy = ast.AsyncFunctionDef(
+            name=node.name,
+            args=node.args,
+            body=self._collapse_body(node.body),
+            decorator_list=node.decorator_list,
+            returns=node.returns,
+            type_comment=getattr(node, "type_comment", None),
+            type_params=getattr(node, "type_params", []),
+        )
+        return node_copy
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> ast.AST:
+        if node.name in self.target_symbols:
+            prev = self.in_target_class
+            self.in_target_class = True
+            try:
+                return self.generic_visit(node)
+            finally:
+                self.in_target_class = prev
+
+        # Transform internal methods
+        new_body: list[ast.stmt] = []
+        docstring = ast.get_docstring(ast.Module(body=node.body, type_ignores=[]))
+        if docstring:
+            new_body.append(ast.Expr(value=ast.Constant(value=docstring)))
+
+        for item in node.body:
+            if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                if item.name in self.target_symbols:
+                    new_body.append(item)
+                else:
+                    transformed = self.visit(item)
+                    if isinstance(transformed, ast.stmt):
+                        new_body.append(transformed)
+            elif isinstance(item, ast.Expr) and isinstance(item.value, ast.Constant) and isinstance(item.value.value, str):
+                # Docstring handled above
+                continue
+            elif isinstance(item, (ast.Assign, ast.AnnAssign)):
+                new_body.append(item)
+            else:
+                new_body.append(item)
+
+        if not new_body:
+            new_body.append(ast.Expr(value=ast.Constant(value=Ellipsis)))
+
+        node_copy = ast.ClassDef(
+            name=node.name,
+            bases=node.bases,
+            keywords=node.keywords,
+            body=new_body,
+            decorator_list=node.decorator_list,
+            type_params=getattr(node, "type_params", []),
+        )
+        return node_copy
+
+
+def skeletonize_python(source: str, target_symbols: Sequence[str] | None = None) -> str:
+    """Skeletonize Python code by collapsing non-target function and class bodies."""
+    if not source.strip():
+        return source
+
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return source
+
+    targets = set(target_symbols) if target_symbols else set()
+    transformer = _SkeletonTransformer(targets)
+    transformed_tree = transformer.visit(tree)
+    ast.fix_missing_locations(transformed_tree)
+
+    try:
+        return ast.unparse(transformed_tree)
+    except Exception:
+        return source
+
+
+def skeletonize_file(file_path: str, target_symbols: Sequence[str] | None = None) -> str:
+    """Skeletonize a file based on its extension."""
+    path = Path(file_path)
+    if not path.exists() or not path.is_file():
+        raise FileNotFoundError(f"File not found: {file_path}")
+
+    content = path.read_text(encoding="utf-8", errors="replace")
+    if path.suffix == ".py":
+        return skeletonize_python(content, target_symbols=target_symbols)
+    return content

local_coding_agent/atomizer.py

@@ -0,0 +1,77 @@
+"""Formal task budget and deterministic decomposition (R7 task atomization)."""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+from .task import TaskEnvelope
+
+
+@dataclass(frozen=True)
+class TaskBudget:
+    max_files: int = 5
+    max_context_bytes: int = 32_000
+    max_checks: int = 3
+
+    def __post_init__(self) -> None:
+        if self.max_files <= 0:
+            raise ValueError("max_files must be positive")
+        if self.max_context_bytes <= 0:
+            raise ValueError("max_context_bytes must be positive")
+        if self.max_checks <= 0:
+            raise ValueError("max_checks must be positive")
+
+
+@dataclass(frozen=True)
+class PreflightReport:
+    accepted: bool
+    reason: str | None
+    issues: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class Decomposition:
+    children: tuple[TaskEnvelope, ...]
+
+
+def preflight(task: TaskEnvelope, budget: TaskBudget) -> PreflightReport:
+    if len(task.files) > budget.max_files:
+        return PreflightReport(False, "too_many_files", ("too_many_files",))
+    if len(task.context.encode("utf-8")) > budget.max_context_bytes:
+        return PreflightReport(False, "context_too_large", ("context_too_large",))
+    if len(task.checks) > budget.max_checks:
+        return PreflightReport(False, "too_many_checks", ("too_many_checks",))
+    return PreflightReport(True, None, ())
+
+
+def decompose(task: TaskEnvelope, budget: TaskBudget) -> Decomposition:
+    if len(task.context.encode("utf-8")) > budget.max_context_bytes:
+        raise ValueError("cannot decompose task: context_too_large")
+    if len(task.checks) > budget.max_checks:
+        raise ValueError("cannot decompose task: too_many_checks")
+
+    report = preflight(task, budget)
+    if not report.accepted and report.reason != "too_many_files":
+        raise ValueError(f"cannot decompose task: {report.reason}")
+
+    count = math.ceil(len(task.files) / budget.max_files)
+    if count <= 1:
+        return Decomposition((task,))
+
+    children = []
+    for index in range(count):
+        start = index * budget.max_files
+        files = task.files[start : start + budget.max_files]
+        children.append(
+            TaskEnvelope(
+                id=f"{task.id}#{index + 1}",
+                goal=task.goal,
+                files=files,
+                context=task.context,
+                constraints=task.constraints,
+                checks=task.checks,
+                acceptance=task.acceptance,
+            )
+        )
+    return Decomposition(tuple(children))

local_coding_agent/benchmark/__init__.py

@@ -0,0 +1,57 @@
+"""Comparable, proposal-only benchmark for local coding models."""
+
+from __future__ import annotations
+
+from ._cases import BenchmarkCase, default_cases
+from ._oracles import (
+    _unique_oracle,
+    _limit_oracle,
+    _utf8_oracle,
+    _no_mutation_oracle,
+    _count_positives_oracle,
+    _max_value_oracle,
+    _abs_sum_oracle,
+    _reverse_str_oracle,
+    _filter_evens_oracle,
+    _count_words_oracle,
+    _dict_default_oracle,
+    _strip_text_oracle,
+    _join_words_oracle,
+    _last_element_oracle,
+    _sorted_copy_oracle,
+    _replace_dash_oracle,
+    _starts_with_oracle,
+    _dot_product_oracle,
+    _min_value_oracle,
+    _title_case_oracle,
+)
+from ._runner import (
+    BenchmarkCaseResult,
+    ChatModel,
+    InstrumentedModel,
+    run_benchmark,
+    run_case,
+    write_artifact,
+)
+from ._stats import _percent, _wilson_score_interval
+from ._summary import (
+    CAPABILITY_FAILURE_CATEGORIES,
+    CONTRACT_FRICTION_CATEGORIES,
+    categorize_failure_taxonomy,
+    summarize_results,
+)
+
+__all__ = [
+    "BenchmarkCase",
+    "ChatModel",
+    "InstrumentedModel",
+    "BenchmarkCaseResult",
+    "default_cases",
+    "run_case",
+    "run_benchmark",
+    "summarize_results",
+    "write_artifact",
+    "categorize_failure_taxonomy",
+    "CONTRACT_FRICTION_CATEGORIES",
+    "CAPABILITY_FAILURE_CATEGORIES",
+]