devcouncil 0.3.0 → 0.4.0

package/src/devcouncil/integrations/mcp/handlers/trace.py

@@ -0,0 +1,65 @@
+"""Run trace and timeline MCP tool handlers."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from mcp.types import TextContent
+
+from devcouncil.integrations.mcp.util import (
+    error_text,
+    int_argument,
+    json_text,
+    required_string_argument,
+)
+from devcouncil.telemetry.traces import read_trace_events
+
+
+async def handle_tail_trace(root: Path, arguments: dict) -> list[TextContent]:
+    limit = int_argument(arguments, "limit", 20, minimum=1, maximum=200)
+    events = list(read_trace_events(root))[-limit:]
+    return json_text({"events": [event.model_dump(by_alias=True) for event in events]})
+
+
+async def handle_run_timeline(root: Path, arguments: dict) -> list[TextContent]:
+    from devcouncil.execution.run_trace import load_timeline
+
+    reference, arg_error = required_string_argument(arguments, "reference")
+    if arg_error:
+        return arg_error
+    assert reference is not None
+    limit = int_argument(arguments, "limit", 40, minimum=1, maximum=500)
+    try:
+        tl = load_timeline(root, reference, event_limit=limit)
+    except ValueError as exc:
+        return error_text(str(exc), code="not_found", reference=reference)
+    return json_text({"ok": True, **tl.model_dump(mode="json")})
+
+
+async def handle_run_supervise(
+    root: Path,
+    arguments: dict,
+    *,
+    load_router: Callable[[Path], Any],
+) -> list[TextContent]:
+    from devcouncil.execution.run_trace import load_timeline, supervise_run
+
+    reference, arg_error = required_string_argument(arguments, "reference")
+    if arg_error:
+        return arg_error
+    assert reference is not None
+    try:
+        tl = load_timeline(root, reference)
+    except ValueError as exc:
+        return error_text(str(exc), code="not_found", reference=reference)
+    verdict = await supervise_run(root, tl, load_router(root))
+    return json_text({
+        "ok": True,
+        "reference": reference,
+        "run_id": tl.run_id,
+        "task_id": tl.task_id,
+        "reversible": tl.reversible,
+        **verdict.model_dump(mode="json"),
+    })

package/src/devcouncil/integrations/mcp/handlers/verify.py

@@ -0,0 +1,45 @@
+"""Verify MCP tool handler."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Callable
+
+from mcp.types import TextContent
+
+from devcouncil.integrations.mcp.util import (
+    json_text,
+    optional_string_argument,
+    parse_cli_json,
+    required_string_argument,
+    run_cli_command,
+)
+
+
+async def handle_verify_task(
+    root: Path,
+    db: object,
+    arguments: dict,
+    *,
+    load_router: Callable[[Path], object | None],
+) -> list[TextContent]:
+    del db, load_router  # routed through CLI service layer
+    task_id, arg_error = required_string_argument(arguments, "task_id")
+    if arg_error:
+        return arg_error
+    lease_token, arg_error = required_string_argument(arguments, "lease_token")
+    if arg_error:
+        return arg_error
+    assert task_id is not None and lease_token is not None
+    sandbox = optional_string_argument(arguments, "sandbox") or "local"
+    cli_args = [
+        "verify-leased", task_id,
+        "--lease-token", lease_token,
+        "--sandbox", sandbox,
+        "--json",
+    ]
+    payload, cli_error = parse_cli_json(run_cli_command(cli_args, root))
+    if cli_error:
+        return cli_error
+    assert payload is not None
+    return json_text(payload)

package/src/devcouncil/integrations/mcp/handlers/wiki.py

@@ -0,0 +1,60 @@
+"""Codebase wiki MCP tool handlers."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from mcp.types import TextContent
+
+from devcouncil.integrations.mcp.util import (
+    error_text,
+    json_text,
+    optional_string_argument,
+    run_cli_command,
+    truncate_text,
+)
+from devcouncil.knowledge.wiki_read import read_wiki_page
+
+
+def _apply_body_truncation(payload: dict) -> dict:
+    if "body" not in payload:
+        return payload
+    body, truncated = truncate_text(str(payload.get("body") or ""))
+    updated = dict(payload)
+    updated["body"] = body
+    updated["truncated"] = truncated or bool(payload.get("truncated"))
+    return updated
+
+
+async def handle_wiki_page(root: Path, arguments: dict) -> list[TextContent]:
+    page = optional_string_argument(arguments, "page")
+    query = optional_string_argument(arguments, "query")
+    result = run_cli_command(
+        _wiki_cli_args(page=page, query=query),
+        root,
+    )
+    if result.get("ok"):
+        import json
+
+        try:
+            payload = json.loads(str(result.get("stdout") or "{}"))
+        except json.JSONDecodeError:
+            payload = read_wiki_page(root, page=page, query=query)
+    else:
+        payload = read_wiki_page(root, page=page, query=query)
+    if not payload.get("ok", True):
+        return error_text(
+            str(payload.get("error") or "Wiki read failed"),
+            code=str(payload.get("code") or "error"),
+            **{k: v for k, v in payload.items() if k not in {"ok", "error", "code"}},
+        )
+    return json_text(_apply_body_truncation(payload))
+
+
+def _wiki_cli_args(*, page: str | None, query: str | None) -> list[str]:
+    args = ["wiki", "read", "--json"]
+    if page:
+        args.extend(["--page", page])
+    if query:
+        args.extend(["--query", query])
+    return args

package/src/devcouncil/integrations/mcp/handlers/write.py

@@ -0,0 +1,69 @@
+"""Write and patch MCP tool handlers."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from mcp.types import TextContent
+
+from devcouncil.integrations.mcp.util import (
+    error_text,
+    json_text,
+    parse_cli_json,
+    required_string_argument,
+    run_cli_command,
+)
+
+
+async def handle_write_file(root: Path, db: object, arguments: dict) -> list[TextContent]:
+    del db  # routed through CLI service layer
+    task_id, arg_error = required_string_argument(arguments, "task_id")
+    if arg_error:
+        return arg_error
+    lease_token, arg_error = required_string_argument(arguments, "lease_token")
+    if arg_error:
+        return arg_error
+    rel_path, arg_error = required_string_argument(arguments, "path")
+    if arg_error:
+        return arg_error
+    content = arguments.get("content")
+    if not isinstance(content, str):
+        return error_text("content must be a string", code="invalid_arguments", argument="content")
+    assert task_id is not None and lease_token is not None and rel_path is not None
+    cli_args = [
+        "write", task_id,
+        "--lease-token", lease_token,
+        "--path", rel_path,
+        "--content", content,
+        "--json",
+    ]
+    payload, cli_error = parse_cli_json(run_cli_command(cli_args, root))
+    if cli_error:
+        return cli_error
+    assert payload is not None
+    return json_text(payload)
+
+
+async def handle_apply_patch(root: Path, db: object, arguments: dict) -> list[TextContent]:
+    del db  # routed through CLI service layer
+    task_id, arg_error = required_string_argument(arguments, "task_id")
+    if arg_error:
+        return arg_error
+    lease_token, arg_error = required_string_argument(arguments, "lease_token")
+    if arg_error:
+        return arg_error
+    unified_diff = arguments.get("unified_diff")
+    if not isinstance(unified_diff, str) or not unified_diff.strip():
+        return error_text("unified_diff must be a non-empty string", code="invalid_arguments", argument="unified_diff")
+    assert task_id is not None and lease_token is not None
+    cli_args = [
+        "apply-patch", task_id,
+        "--lease-token", lease_token,
+        "--unified-diff", unified_diff,
+        "--json",
+    ]
+    payload, cli_error = parse_cli_json(run_cli_command(cli_args, root))
+    if cli_error:
+        return cli_error
+    assert payload is not None
+    return json_text(payload)