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

local_coding_agent/__init__.py

@@ -0,0 +1,314 @@
+"""Bounded controller components for delegating small coding tasks."""
+
+__version__ = "1.1.0"
+
+
+from .acp_server import (
+    ACP_TOOLS,
+    AcpCodec,
+    AcpServer,
+    AcpSession,
+)
+from .ast_compactor import skeletonize_file, skeletonize_python
+from .atomizer import Decomposition, PreflightReport, TaskBudget, decompose, preflight
+
+from .calibration import calibrate_for_model, calibrate_workers, model_vram_bytes
+from .context_manager import (
+    ContextAssembler,
+    HarnessState,
+    compact_tool_exchanges,
+    purge_diff_residues,
+)
+from .controller import Controller
+from .delegator import DelegatingAgent, DecompositionTemplate, is_decomposable_failure
+from .doctor import (
+    CheckResult,
+    DoctorFixReport,
+    DoctorReport,
+    diagnose_environment,
+    remediate_environment,
+)
+from .mcp_config import generate_mcp_config_dict, get_client_config_path, integrate_mcp_config
+from .mcp_server import build_server
+from .memory import LoadedModel, MemoryBudgetError, MemoryOperationError, MemorySnapshot, ModelMemoryManager
+from .mode_router import (
+    DEFAULT_MODE_ROUTER_PROFILE,
+    MODES,
+    VALID_ROUTED,
+    ModeName,
+    build_mode_router,
+    classify_fast,
+    classify_mode,
+)
+from .monitor import MonitorServer
+from .lsp import (
+    FallbackLspEngine,
+    LspClient,
+    LspConnectionError,
+    LspError,
+    LspHoverResult,
+    LspLocation,
+    LspManager,
+    LspPosition,
+    LspRange,
+    LspResponseError,
+    LspSymbol,
+    LspTimeoutError,
+    MockLspServer,
+)
+from .observation_policy import (
+    FsObservationError,
+    FsObservationGate,
+    is_observed,
+    observe_file,
+    reset_session,
+    verify_edit_intent,
+)
+from .plan_mode import (
+    AskUserQuestionTool,
+    PlanArtifact,
+    PlanModeController,
+    PlanModeError,
+    PlanModePolicyError,
+    PlanModeState,
+    QuestionAnswer,
+    QuestionItem,
+    TodoChecklist,
+    TodoItem,
+    TodoStatus,
+)
+from .ollama_adapter import (
+    ModelProfile,
+    OllamaClient,
+    OllamaError,
+    OpenAICompatibleClient,
+    build_client,
+)
+from .ripgrep import RipgrepMatch, ripgrep_files, ripgrep_search
+from .semantic_linter import (
+    LinterDiagnostic,
+    LinterReport,
+    lint_patch_in_memory,
+    lint_source_code,
+)
+from .service import DelegationRequest, DelegationService
+from .smoke import run_smoke_test
+from .speculative_racing import SpeculativeRacer
+from .spill import (
+    DEFAULT_MAX_BYTES,
+    DEFAULT_MAX_LINES,
+    SpillRef,
+    SpillStore,
+    maybe_spill,
+    read_spill,
+    save_text,
+)
+from .stats import DelegationStats, JsonlStatsSink, TimedDelegationStats
+from .stdio import StdioDelegationAdapter
+from .hooks import (
+    ClaudeCodeHookAdapter,
+    CodexHookAdapter,
+    HookBridge,
+    HookDecision,
+)
+from .subagent import (
+    MailboxMessage,
+    SubagentContext,
+    SubagentCoordinator,
+    SubagentReport,
+)
+from .task import TaskEnvelope
+from .task_store import JsonFileTaskStore, TaskRecord, TaskStore
+from .terminal import (
+    TerminalError,
+    TerminalManager,
+    TerminalProcessExitedError,
+    TerminalSession,
+    TerminalSessionExistsError,
+    TerminalSessionInfo,
+    TerminalSessionNotFoundError,
+    TerminalTimeoutError,
+    execute_terminal_tool,
+    get_terminal_tool_schemas,
+    kill_process_tree,
+)
+from .validators import ValidationReport, validate_candidate
+from .worker_pool import BoundedWorkerPool
+from .session_events import (
+    ModelTurnEvent,
+    PrescriptionEvent,
+    SessionCompletedEvent,
+    SessionCreatedEvent,
+    SessionEvent,
+    SessionLog,
+    ToolCallEvent,
+    ToolResultEvent,
+    UserPromptEvent,
+    derive_messages,
+    event_from_dict,
+    event_to_dict,
+    fork_session,
+)
+from .session_query import (
+    SessionQueryEngine,
+    get_session_trace,
+    sanitize_fts5_query,
+    search_events,
+    search_sessions,
+)
+
+try:
+    from .tasks import TASKS_IDENTIFIER, TasksExtension
+except ImportError:  # pragma: no cover - mcp is an optional dependency
+    TasksExtension = None  # type: ignore[assignment]
+    TASKS_IDENTIFIER = "io.modelcontextprotocol/tasks"
+
+__all__ = [
+    "Controller",
+    "DelegationRequest",
+    "DelegationService",
+    "DelegationStats",
+    "JsonlStatsSink",
+    "TimedDelegationStats",
+    "BoundedWorkerPool",
+    "StdioDelegationAdapter",
+    "DelegatingAgent",
+    "DecompositionTemplate",
+    "is_decomposable_failure",
+    "Decomposition",
+    "PreflightReport",
+    "TaskBudget",
+    "decompose",
+    "preflight",
+    "calibrate_for_model",
+    "calibrate_workers",
+    "model_vram_bytes",
+    "LoadedModel",
+    "MemoryBudgetError",
+    "MemoryOperationError",
+    "MemorySnapshot",
+    "ModelMemoryManager",
+    "ModeName",
+    "MODES",
+    "VALID_ROUTED",
+    "build_mode_router",
+    "DEFAULT_MODE_ROUTER_PROFILE",
+    "classify_fast",
+    "classify_mode",
+    "ModelProfile",
+    "OllamaClient",
+    "OllamaError",
+    "OpenAICompatibleClient",
+    "build_client",
+    "build_server",
+    "TaskEnvelope",
+    "ValidationReport",
+    "validate_candidate",
+    "TasksExtension",
+    "TASKS_IDENTIFIER",
+    "diagnose_environment",
+    "DoctorReport",
+    "DoctorFixReport",
+    "remediate_environment",
+    "CheckResult",
+    "generate_mcp_config_dict",
+    "get_client_config_path",
+    "integrate_mcp_config",
+    "run_smoke_test",
+    "MonitorServer",
+    "TaskStore",
+    "TaskRecord",
+    "JsonFileTaskStore",
+    "HarnessState",
+    "ContextAssembler",
+    "compact_tool_exchanges",
+    "purge_diff_residues",
+    "skeletonize_python",
+    "skeletonize_file",
+    "LinterDiagnostic",
+    "LinterReport",
+    "lint_source_code",
+    "lint_patch_in_memory",
+    "SpeculativeRacer",
+    "FsObservationError",
+    "FsObservationGate",
+    "observe_file",
+    "is_observed",
+    "verify_edit_intent",
+    "reset_session",
+    "RipgrepMatch",
+    "ripgrep_search",
+    "ripgrep_files",
+    "DEFAULT_MAX_BYTES",
+    "DEFAULT_MAX_LINES",
+    "SpillRef",
+    "SpillStore",
+    "save_text",
+    "read_spill",
+    "maybe_spill",
+    "LspPosition",
+    "LspRange",
+    "LspLocation",
+    "LspHoverResult",
+    "LspSymbol",
+    "LspClient",
+    "MockLspServer",
+    "FallbackLspEngine",
+    "LspManager",
+    "LspError",
+    "LspTimeoutError",
+    "LspConnectionError",
+    "LspResponseError",
+    "TerminalSession",
+    "TerminalSessionInfo",
+    "TerminalManager",
+    "TerminalError",
+    "TerminalSessionNotFoundError",
+    "TerminalSessionExistsError",
+    "TerminalProcessExitedError",
+    "TerminalTimeoutError",
+    "get_terminal_tool_schemas",
+    "execute_terminal_tool",
+    "kill_process_tree",
+    "PlanModeState",
+    "PlanArtifact",
+    "PlanModeController",
+    "PlanModeError",
+    "PlanModePolicyError",
+    "QuestionItem",
+    "QuestionAnswer",
+    "AskUserQuestionTool",
+    "TodoStatus",
+    "TodoItem",
+    "TodoChecklist",
+    "HookBridge",
+    "HookDecision",
+    "CodexHookAdapter",
+    "ClaudeCodeHookAdapter",
+    "SubagentCoordinator",
+    "SubagentContext",
+    "MailboxMessage",
+    "SubagentReport",
+    "AcpServer",
+    "AcpSession",
+    "AcpCodec",
+    "ACP_TOOLS",
+    "SessionCreatedEvent",
+    "UserPromptEvent",
+    "ModelTurnEvent",
+    "ToolCallEvent",
+    "ToolResultEvent",
+    "PrescriptionEvent",
+    "SessionCompletedEvent",
+    "SessionEvent",
+    "SessionLog",
+    "derive_messages",
+    "fork_session",
+    "event_to_dict",
+    "event_from_dict",
+    "SessionQueryEngine",
+    "search_sessions",
+    "search_events",
+    "get_session_trace",
+    "sanitize_fts5_query",
+]

local_coding_agent/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

local_coding_agent/acp_server/__init__.py

@@ -0,0 +1,38 @@
+"""Universal Agent Client Protocol (ACP) Server & Interop Gateway (R29).
+
+Adapted from DeepSeek Harness @deepseek-ai/dsh-acp.
+Implements the standard JSON-RPC 2.0 Agent Client Protocol over stdio with
+both Content-Length header and newline-delimited JSONL framing support.
+Exposes session lifecycle, prompting, cancellation, and repo tools to
+external AI-native editors (Zed, Cursor, VS Code, JetBrains, OpenCode).
+"""
+
+from ._codec import AcpCodec
+from ._protocol import (
+    JSONRPC_INTERNAL_ERROR,
+    JSONRPC_INVALID_PARAMS,
+    JSONRPC_INVALID_REQUEST,
+    JSONRPC_METHOD_NOT_FOUND,
+    JSONRPC_PARSE_ERROR,
+    PROTOCOL_VERSION,
+    SERVER_NAME,
+    SERVER_VERSION,
+)
+from ._server import AcpServer
+from ._session import AcpSession
+from ._tools import ACP_TOOLS
+
+__all__ = [
+    "PROTOCOL_VERSION",
+    "SERVER_NAME",
+    "SERVER_VERSION",
+    "JSONRPC_PARSE_ERROR",
+    "JSONRPC_INVALID_REQUEST",
+    "JSONRPC_METHOD_NOT_FOUND",
+    "JSONRPC_INVALID_PARAMS",
+    "JSONRPC_INTERNAL_ERROR",
+    "ACP_TOOLS",
+    "AcpCodec",
+    "AcpSession",
+    "AcpServer",
+]

local_coding_agent/acp_server/_codec.py

@@ -0,0 +1,95 @@
+"""Stdio framing codec (Content-Length / JSONL)."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+class AcpCodec:
+    """Header & line framing codec for JSON-RPC 2.0 stdio."""
+
+    @staticmethod
+    def read_message(stream: Any, max_bytes: int = 10 * 1024 * 1024) -> tuple[dict[str, Any] | None, str]:
+        """Read a single JSON-RPC message from a binary or text stream.
+
+        Returns:
+            (message_dict, framing_type) where framing_type is "content-length" or "jsonl".
+            Returns (None, "") on EOF.
+        """
+        while True:
+            line = stream.readline()
+            if not line:
+                return None, ""
+            if isinstance(line, bytes):
+                line_str = line.decode("utf-8", errors="replace").strip()
+            else:
+                line_str = str(line).strip()
+            if line_str:
+                break
+
+        # Check for Content-Length header
+        if line_str.lower().startswith("content-length:"):
+            try:
+                parts = line_str.split(":", 1)
+                if len(parts) < 2:
+                    raise ValueError(f"Invalid Content-Length header: {line_str}")
+                content_length = int(parts[1].strip())
+            except ValueError:
+                raise ValueError(f"Invalid Content-Length header: {line_str}")
+
+            if content_length < 0:
+                raise ValueError(f"Content-Length must be non-negative: {content_length}")
+            if content_length > max_bytes:
+                raise ValueError(f"Content-Length {content_length} exceeds max allowed {max_bytes} bytes")
+
+            # Read remaining headers until empty line (bounded against header floods)
+            header_count = 0
+            while True:
+                header_line = stream.readline()
+                if not header_line:
+                    break
+                header_count += 1
+                if header_count > 50:
+                    raise ValueError("Too many header lines in request (max 50)")
+                if isinstance(header_line, bytes):
+                    h_str = header_line.decode("utf-8", errors="replace").strip()
+                else:
+                    h_str = str(header_line).strip()
+                if not h_str:
+                    break
+
+            # Read exact content_length bytes
+            body = stream.read(content_length)
+            if isinstance(body, bytes):
+                if len(body) < content_length:
+                    raise ValueError(f"Unexpected EOF reading message body: expected {content_length} bytes, got {len(body)}")
+                body_str = body.decode("utf-8", errors="replace")
+            else:
+                body_str = str(body)
+                if len(body_str.encode("utf-8")) < content_length and len(body_str) < content_length:
+                    raise ValueError(f"Unexpected EOF reading message body: expected {content_length} bytes")
+
+            parsed = json.loads(body_str)
+            if not isinstance(parsed, dict):
+                raise ValueError("JSON-RPC message must be an object")
+            return parsed, "content-length"
+        else:
+            # JSONL framing
+            if len(line_str.encode("utf-8")) > max_bytes:
+                raise ValueError(f"JSONL line exceeds max allowed {max_bytes} bytes")
+            parsed = json.loads(line_str)
+            if not isinstance(parsed, dict):
+                raise ValueError("JSON-RPC message must be an object")
+            return parsed, "jsonl"
+
+    @staticmethod
+    def format_message(message: dict[str, Any], framing: str = "jsonl") -> bytes:
+        """Format a JSON-RPC message dictionary into framed bytes."""
+        raw_json = json.dumps(message, ensure_ascii=False)
+        encoded = raw_json.encode("utf-8")
+        if framing == "content-length":
+            header = f"Content-Length: {len(encoded)}\r\n\r\n".encode("ascii")
+            return header + encoded
+        else:
+            return encoded + b"\n"

local_coding_agent/acp_server/_protocol.py

@@ -0,0 +1,13 @@
+"""ACP protocol constants and error codes."""
+
+from .. import __version__
+
+PROTOCOL_VERSION: str = "2026-08-20"
+SERVER_NAME: str = "local-coding-agent-acp"
+SERVER_VERSION: str = __version__
+
+JSONRPC_PARSE_ERROR: int = -32700
+JSONRPC_INVALID_REQUEST: int = -32600
+JSONRPC_METHOD_NOT_FOUND: int = -32601
+JSONRPC_INVALID_PARAMS: int = -32602
+JSONRPC_INTERNAL_ERROR: int = -32603