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

local_coding_agent/controller/_post_apply.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+from threading import Event
+
+from typing import Any
+
+from ..repository_tools import BoundedRepositoryTools, ToolCancelled, ToolPolicyError
+from ..semantic_linter import lint_patch_in_memory
+from ..task import TaskEnvelope
+from ..validators import _normalize_task_path, apply_patch, check_patch_applies, parse_unified_diff
+
+
+def run_post_apply_checks(
+    task: TaskEnvelope,
+    tools: BoundedRepositoryTools,
+    *,
+    active_cancel: Event | None,
+    audit: list[dict[str, Any]],
+) -> tuple[list[dict[str, Any]], bool]:
+    """Run each allowlisted check against the already-applied workspace.
+
+    Module-level so the mediated apply path in ``DelegationService`` reuses the
+    exact same evidence contract without re-entering the model loop. Raises
+    ``ToolCancelled`` when cancellation is requested between checks.
+    """
+    checks: list[dict[str, Any]] = []
+    if not task.checks:
+        raise ToolPolicyError("at least one targeted check is required before apply")
+    for command in task.checks:
+        if active_cancel is not None and active_cancel.is_set():
+            raise ToolCancelled("task was cancelled")
+        check = tools.execute("run_tests", {"command": command})
+        observed = {
+            "command": command,
+            "passed": check["passed"],
+            "evidence": check["evidence"],
+            "stdout": check.get("stdout", ""),
+            "stderr": check.get("stderr", ""),
+            "exit_code": check.get("exit_code"),
+        }
+        checks.append(observed)
+        audit.append(
+            {
+                "event": "post_apply_check",
+                "command": command,
+                "passed": check["passed"],
+                "exit_code": check.get("exit_code"),
+                "stdout": check.get("stdout", ""),
+                "stderr": check.get("stderr", ""),
+            }
+        )
+    return checks, all(check["passed"] for check in checks)
+
+
+def add_risk(result: dict[str, Any], kind: str, message: str) -> None:
+    risks = result.get("risks")
+    if not isinstance(risks, list):
+        risks = []
+        result["risks"] = risks
+    risks.append({"kind": kind, "message": message})
+
+
+def apply_failure(kind: str, message: str, audit: list[dict[str, Any]]) -> dict[str, Any]:
+    return {
+        "status": "failed",
+        "error": {"kind": kind, "message": message},
+        "audit": [*audit, {"event": "apply_rejected", "kind": kind}],
+    }
+
+
+def _file_digest(path: Path) -> str | None:
+    try:
+        return hashlib.sha256(path.read_bytes()).hexdigest()
+    except FileNotFoundError:
+        return None
+    except OSError:
+        return "unreadable"
+
+
+def _baseline(workspace: Path, changed: tuple[str, ...]) -> dict[str, str | None]:
+    return {name: _file_digest(workspace / name) for name in changed}
+
+
+def _restored(workspace: Path, baseline: dict[str, str | None]) -> bool:
+    return all(_file_digest(workspace / name) == digest for name, digest in baseline.items())
+
+
+def mediated_apply(
+    workspace: Path,
+    patch: str,
+    task: TaskEnvelope,
+    *,
+    cancel_event: Event | None = None,
+    audit: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Apply a reviewed patch under the full verification gate.
+
+    Single controller-owned implementation shared by the service, CLI and
+    desktop apply paths: refuse a patch with no targeted check, enforce the
+    declared file scope, pre-check and lint the patch, apply it, run the
+    allowlisted checks, and roll back to the recorded baseline on any failure.
+    A rollback is only reported as successful when the baseline digests are
+    actually restored; otherwise the workspace is reported as modified/unknown.
+    """
+
+    audit = list(audit) if audit is not None else []
+    if not isinstance(patch, str) or not patch.strip():
+        return apply_failure("no_patch", "proposal carries no resolved patch", audit)
+    if not task.checks:
+        return apply_failure(
+            "apply_requires_checks",
+            "applying a non-empty patch requires at least one targeted check",
+            audit,
+        )
+
+    changed, issues = parse_unified_diff(patch)
+    if issues:
+        return apply_failure("patch_parse_failed", "; ".join(issues), audit)
+    allowed = {_normalize_task_path(name) for name in task.files}
+    outside = [name for name in changed if _normalize_task_path(name) not in allowed]
+    if outside:
+        return apply_failure(
+            "patch_outside_scope",
+            f"patch touches files outside the declared scope: {', '.join(outside)}",
+            audit,
+        )
+
+    try:
+        applies, detail = check_patch_applies(workspace, patch)
+    except ValueError as error:
+        return apply_failure("apply_policy", str(error), audit)
+    if not applies:
+        return apply_failure(
+            "stale_workspace",
+            f"proposal no longer applies cleanly to the workspace: {detail}",
+            audit,
+        )
+
+    # Semantic linter pre-gate (R18): never mutate the workspace with a
+    # patch that introduces syntax errors.
+    lint_report = lint_patch_in_memory(str(workspace), patch)
+    if not lint_report.valid:
+        return apply_failure(
+            "semantic_lint_failed",
+            "; ".join(lint_report.prescriptions) or "patch failed static analysis",
+            audit,
+        )
+
+    baseline = _baseline(workspace, changed)
+    try:
+        tools = BoundedRepositoryTools(workspace, task, cancel_event=cancel_event)
+    except (ToolPolicyError, ValueError) as error:
+        return apply_failure("apply_policy", str(error), audit)
+
+    applied, apply_detail = apply_patch(workspace, patch)
+    if not applied:
+        return apply_failure("apply_failed", f"patch could not be applied: {apply_detail}", audit)
+    audit.append({"event": "patch_applied"})
+
+    result: dict[str, Any] = {"status": "accepted", "checks": [], "risks": [], "audit": audit}
+    try:
+        post_checks, post_checks_passed = run_post_apply_checks(
+            task, tools, active_cancel=cancel_event, audit=audit
+        )
+    except ToolCancelled:
+        result["status"] = "failed"
+        result["error"] = {"kind": "cancelled", "message": "post-apply checks were cancelled"}
+        audit.append({"event": "post_apply_cancelled"})
+    except ToolPolicyError as error:
+        result["status"] = "rejected"
+        result["error"] = {"kind": "post_apply_check_failed", "message": f"post-apply check could not complete: {error}"}
+        audit.append({"event": "post_apply_check_error", "detail": str(error)})
+    except Exception:  # noqa: BLE001 - apply boundary must roll back, never leave a half-applied patch.
+        result["status"] = "failed"
+        result["error"] = {"kind": "apply_error", "message": "post-apply checks raised an unexpected error"}
+        audit.append({"event": "post_apply_check_error", "detail": "unexpected_error"})
+    else:
+        result["checks"] = post_checks
+        if post_checks_passed:
+            result["applied"] = True
+            result["workspace_state"] = "original"
+            audit.append({"event": "post_apply_checks_passed"})
+            return result
+        result["status"] = "rejected"
+        result["error"] = {"kind": "post_apply_check_failed", "message": "a targeted check failed after applying the patch"}
+        audit.append({"event": "post_apply_check_failed"})
+
+    # Reached only on a cancelled / policy-error / unexpected-error / failed
+    # check: roll the patch back. A failed rollback is surfaced explicitly so
+    # a consumer never mistakes a still-modified workspace for a clean one.
+    try:
+        rollback_ok, rollback_detail = apply_patch(workspace, patch, reverse=True)
+    except Exception as error:  # noqa: BLE001 - expose uncertain workspace state
+        rollback_ok = False
+        rollback_detail = str(error)
+    if rollback_ok and not _restored(workspace, baseline):
+        # ponytail: git apply --reverse can exit 0 without reverting every file
+        # (e.g. a partially applied hunk). Compare baseline digests instead of
+        # trusting the exit code; verify by content if this ever false-positives.
+        rollback_ok = False
+        rollback_detail = "rollback did not restore the recorded baseline"
+
+    if rollback_ok:
+        result["rolled_back"] = True
+        result["workspace_state"] = "original"
+        audit.append({"event": "patch_rolled_back"})
+        return result
+
+    result["rolled_back"] = False
+    result["workspace_modified"] = True
+    result["workspace_state"] = "unknown"
+    add_risk(result, "rollback_failed", f"patch rollback failed: {rollback_detail}")
+    audit.append({"event": "rollback_failed", "detail": rollback_detail})
+    return result

local_coding_agent/delegator.py

@@ -0,0 +1,180 @@
+"""Harness-agnostic delegating agent: decompose, delegate, decompose further.
+
+The delegating agent owns the outer "expensive agent" loop: it breaks a wide
+task into bounded children using decomposition templates, delegates each child
+through the transport-neutral ``delegate`` seam, and on a decomposable failure
+re-splits that child at finer granularity. It does not know about MCP, stdio or
+the CLI, and never talks to the model directly.
+"""
+
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from typing import Any, Callable, Mapping, Sequence
+
+from .atomizer import TaskBudget, decompose
+from .service import DelegationRequest
+from .task import TaskEnvelope
+
+
+Delegate = Callable[[str, DelegationRequest], Mapping[str, Any]]
+
+
+@dataclass(frozen=True)
+class DecompositionTemplate:
+    """A named strategy that turns one task envelope into bounded children."""
+
+    name: str
+    split: Callable[[TaskEnvelope, TaskBudget], tuple[TaskEnvelope, ...]]
+
+
+def _split_by_files(task: TaskEnvelope, budget: TaskBudget) -> tuple[TaskEnvelope, ...]:
+    # ponytail: reuse atomizer.decompose; a context/checks-over-budget task is
+    # not file-splittable, so fall back to the unchanged envelope and let the
+    # delegate reject it with a machine-readable reason.
+    try:
+        return decompose(task, budget).children
+    except ValueError:
+        return (task,)
+
+
+def _split_per_file(task: TaskEnvelope, budget: TaskBudget) -> tuple[TaskEnvelope, ...]:
+    del budget
+    return tuple(
+        TaskEnvelope(
+            id=f"{task.id}#{index + 1}",
+            goal=task.goal,
+            files=(file,),
+            context=task.context,
+            constraints=task.constraints,
+            checks=task.checks,
+            acceptance=task.acceptance,
+        )
+        for index, file in enumerate(task.files)
+    )
+
+
+BY_FILES = DecompositionTemplate("by_files", _split_by_files)
+PER_FILE = DecompositionTemplate("per_file", _split_per_file)
+DEFAULT_TEMPLATES = (BY_FILES, PER_FILE)
+
+_DECOMPOSABLE_KINDS = frozenset(
+    {
+        "preflight_rejected",
+        "context_limit",
+        "max_turns",
+        "retry_budget_exhausted",
+        "too_many_files",
+        "too_many_checks",
+    }
+)
+
+
+def is_decomposable_failure(result: Mapping[str, Any]) -> bool:
+    """True when a child failure can be retried at finer granularity."""
+
+    error = result.get("error")
+    if not isinstance(error, Mapping):
+        return False
+    kind = error.get("kind")
+    if kind in _DECOMPOSABLE_KINDS:
+        return True
+    if kind == "controller_policy":
+        message = str(error.get("message", ""))
+        return "max_files" in message or "context" in message
+    return False
+
+
+class DelegatingAgent:
+    """Decompose a task into bounded children and delegate each one.
+
+    ``delegate`` is the harness-agnostic seam (e.g. ``DelegationService.delegate``)
+    with signature ``(caller_id, request) -> result``. ``workspace_ref`` and
+    ``model_profile`` are deployment configuration, not part of the task.
+    """
+
+    def __init__(
+        self,
+        delegate: Delegate,
+        *,
+        workspace_ref: str,
+        model_profile: str,
+        budget: TaskBudget | None = None,
+        templates: Sequence[DecompositionTemplate] = DEFAULT_TEMPLATES,
+        max_depth: int = 3,
+        max_parallel_children: int = 1,
+    ) -> None:
+        if max_depth <= 0:
+            raise ValueError("max_depth must be positive")
+        if not templates:
+            raise ValueError("templates must not be empty")
+        if max_parallel_children <= 0:
+            raise ValueError("max_parallel_children must be positive")
+        self.delegate = delegate
+        self.workspace_ref = workspace_ref
+        self.model_profile = model_profile
+        self.budget = budget or TaskBudget()
+        self.templates = tuple(templates)
+        self.max_depth = max_depth
+        self.max_parallel_children = max_parallel_children
+
+    def run(self, caller_id: str, task: TaskEnvelope) -> dict[str, Any]:
+        if not isinstance(caller_id, str) or not caller_id.strip():
+            raise ValueError("caller_id must be a non-empty string")
+        splits = [0]
+        leaves = self._dispatch(caller_id, task, 0, splits)
+        accepted = sum(1 for leaf in leaves if leaf["result"].get("status") == "accepted")
+        if accepted == len(leaves):
+            status = "accepted"
+        elif accepted:
+            status = "partial"
+        else:
+            status = "failed"
+        return {
+            "status": status,
+            "task_id": task.id,
+            "splits": splits[0],
+            "children": leaves,
+        }
+
+    def _dispatch(
+        self,
+        caller_id: str,
+        task: TaskEnvelope,
+        depth: int,
+        splits: list[int],
+    ) -> list[dict[str, Any]]:
+        template = self.templates[min(depth, len(self.templates) - 1)]
+        children = template.split(task, self.budget)
+        leaves: list[dict[str, Any]] = []
+
+        def run_child(child: TaskEnvelope, index: int) -> tuple[dict[str, Any], bool]:
+            request = DelegationRequest(
+                request_id=f"{task.id}@{depth}.{index}",
+                workspace_ref=self.workspace_ref,
+                model_profile=self.model_profile,
+                task=child,
+            )
+            result = self.delegate(caller_id, request)
+            return dict(result), is_decomposable_failure(result) and self._can_split_further(child, depth)
+
+        if self.max_parallel_children > 1 and len(children) > 1:
+            with ThreadPoolExecutor(max_workers=self.max_parallel_children) as pool:
+                outcomes = list(pool.map(lambda item: run_child(item[1], item[0]), enumerate(children)))
+        else:
+            outcomes = [run_child(child, index) for index, child in enumerate(children)]
+
+        for child, (result, decomposable) in zip(children, outcomes):
+            if decomposable:
+                splits[0] += 1
+                leaves.extend(self._dispatch(caller_id, child, depth + 1, splits))
+            else:
+                leaves.append({"task_id": child.id, "depth": depth, "result": result})
+        return leaves
+
+    def _can_split_further(self, task: TaskEnvelope, depth: int) -> bool:
+        if depth + 1 >= self.max_depth:
+            return False
+        next_template = self.templates[min(depth + 1, len(self.templates) - 1)]
+        return len(next_template.split(task, self.budget)) > 1

local_coding_agent/desktop/__init__.py

@@ -0,0 +1,8 @@
+"""Desktop AI Coding Harness module."""
+
+from __future__ import annotations
+
+from .app import launch_desktop_app
+from .server import DesktopServer
+
+__all__ = ["launch_desktop_app", "DesktopServer"]

local_coding_agent/desktop/app.py

@@ -0,0 +1,100 @@
+"""Desktop application launcher using pywebview with resilient browser fallback."""
+
+from __future__ import annotations
+
+import json
+import sys
+import time
+import webbrowser
+from pathlib import Path
+from typing import Any
+
+from .server import DesktopServer
+
+
+def launch_desktop_app(
+    host: str = "127.0.0.1",
+    port: int = 8765,
+    workspace: str | Path = ".",
+    default_profile: str = "qwen2.5-coder",
+    browser: bool = False,
+    headless: bool = False,
+) -> int:
+    """Launch the Desktop AI Coding Harness."""
+    server = DesktopServer(
+        host=host,
+        port=port,
+        workspace=workspace,
+        default_profile=default_profile,
+    )
+    server.start()
+    app_url = f"{server.url}/app"
+
+    if headless:
+        print(
+            json.dumps(
+                {
+                    "status": "ready",
+                    "url": app_url,
+                    "workspace": str(Path(workspace).resolve()),
+                },
+                ensure_ascii=False,
+            ),
+            flush=True,
+        )
+        try:
+            while True:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            pass
+        finally:
+            server.stop()
+        return 0
+
+    print("=" * 72)
+    print("  Local AI Coding Harness — Standalone Desktop Cockpit")
+    print(f"  Interface URL: {app_url}")
+    print(f"  Workspace:     {Path(workspace).resolve()}")
+    print("=" * 72)
+
+    has_webview = False
+    if not browser:
+        try:
+            import webview  # type: ignore[import-not-found]
+            has_webview = True
+        except ImportError:
+            has_webview = False
+
+    if has_webview and not browser:
+        try:
+            import webview  # type: ignore[import-not-found]
+
+            print("Launching native desktop window (WebView2 / Cocoa / WebKit)...")
+            webview.create_window(
+                "Local AI Coding Harness",
+                app_url,
+                width=1360,
+                height=840,
+                min_size=(960, 640),
+            )
+            webview.start()
+            server.stop()
+            print("Desktop window closed.")
+            return 0
+        except Exception as error:
+            print(f"Native desktop window initialization error: {error}. Falling back to default browser...")
+
+    # Fallback to system browser
+    print("Opening application in default web browser (Press Ctrl+C to stop)...")
+    try:
+        webbrowser.open(app_url)
+    except Exception:
+        pass
+
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        server.stop()
+        print("\nDesktop Harness stopped.")
+    return 0