devcouncil 0.3.1 → 0.4.0

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

@@ -0,0 +1,56 @@
+"""Task scope update MCP tool handler."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from mcp.types import TextContent
+
+from devcouncil.integrations.mcp.util import (
+    json_text,
+    optional_string_list_argument,
+    parse_cli_json,
+    required_string_argument,
+    run_cli_command,
+)
+
+
+async def handle_update_task_scope(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
+    assert task_id is not None and lease_token is not None
+    expected_tests, arg_error = optional_string_list_argument(arguments, "expected_tests")
+    if arg_error:
+        return arg_error
+    allowed_commands, arg_error = optional_string_list_argument(arguments, "allowed_commands")
+    if arg_error:
+        return arg_error
+    planned_files, arg_error = optional_string_list_argument(arguments, "planned_files")
+    if arg_error:
+        return arg_error
+    create_planned_files, arg_error = optional_string_list_argument(arguments, "create_planned_files")
+    if arg_error:
+        return arg_error
+    cli_args = [
+        "scope", "update", task_id,
+        "--lease-token", lease_token,
+        "--json",
+    ]
+    for test in expected_tests:
+        cli_args.extend(["--expected-test", test])
+    for cmd in allowed_commands:
+        cli_args.extend(["--allowed-command", cmd])
+    for path in planned_files:
+        cli_args.extend(["--planned-file", path])
+    for path in create_planned_files:
+        cli_args.extend(["--planned-file-create", path])
+    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/status.py

@@ -0,0 +1,114 @@
+"""Status, gaps, and next-actions MCP tool handlers."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from mcp.types import TextContent
+
+from devcouncil.integrations.mcp.util import (
+    error_text,
+    int_argument,
+    json_text,
+    optional_string_argument,
+    required_string_argument,
+    run_cli_command,
+)
+
+
+def _cli_json(root: Path, args: list[str]) -> tuple[dict | None, list[TextContent] | None]:
+    result = run_cli_command(args, root)
+    if not result.get("ok"):
+        stderr = str(result.get("stderr") or "CLI command failed")
+        return None, error_text(stderr, code="cli_failed")
+    try:
+        return json.loads(str(result.get("stdout") or "{}")), None
+    except json.JSONDecodeError:
+        return None, error_text("CLI command returned invalid JSON", code="cli_parse_error")
+
+
+async def handle_status(root: Path, db: object, arguments: dict) -> list[TextContent]:
+    del db  # routed through CLI service layer
+    result = run_cli_command(["status", "--json"], root)
+    if not result.get("ok"):
+        stderr = str(result.get("stderr") or "status command failed")
+        return error_text(stderr, code="cli_failed")
+    try:
+        payload = json.loads(str(result.get("stdout") or "{}"))
+    except json.JSONDecodeError:
+        return error_text("status command returned invalid JSON", code="cli_parse_error")
+    if not payload.get("initialized"):
+        return error_text("DevCouncil not initialized in this directory.", code="not_initialized")
+    summary = payload.get("coverage_summary") or {}
+    phase = payload.get("phase", "UNKNOWN")
+    status_str = (
+        f"Phase: {phase}\n"
+        f"Requirements: {summary.get('total_requirements', 0)} ({summary.get('requirements_without_tasks', 0)} unmapped)\n"
+        f"Tasks: {summary.get('total_tasks', 0)} ({summary.get('tasks_without_requirements', 0)} orphaned)\n"
+        f"Gaps: {summary.get('total_gaps', 0)} ({summary.get('blocking_gaps', 0)} blocking)\n"
+    )
+    return [TextContent(type="text", text=status_str)]
+
+
+async def handle_report(root: Path, db: object, arguments: dict) -> list[TextContent]:
+    del db  # routed through CLI service layer
+    result = run_cli_command(["report"], root)
+    if not result.get("ok"):
+        stderr = str(result.get("stderr") or "report command failed")
+        return error_text(stderr, code="cli_failed")
+    return [TextContent(type="text", text=str(result.get("stdout") or ""))]
+
+
+async def handle_get_gaps(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
+    assert task_id is not None
+    blocking_only = bool(arguments.get("blocking_only", False))
+    cli_args = ["gaps", "--json", "--task-id", task_id]
+    if blocking_only:
+        cli_args.append("--blocking-only")
+    payload, cli_error = _cli_json(root, cli_args)
+    if cli_error:
+        return cli_error
+    assert payload is not None
+    if not payload.get("initialized", True):
+        return error_text("DevCouncil not initialized in this directory.", code="not_initialized")
+    return json_text(payload)
+
+
+async def handle_get_next_actions(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
+    assert task_id is not None
+    payload, cli_error = _cli_json(root, ["gaps", "--json", "--task-id", task_id, "--next-actions"])
+    if cli_error:
+        return cli_error
+    assert payload is not None
+    if not payload.get("ok", True):
+        return error_text(
+            str(payload.get("error") or "next-actions command failed"),
+            code="cli_failed",
+        )
+    return json_text(payload)
+
+
+async def handle_list_tasks(root: Path, db: object, arguments: dict) -> list[TextContent]:
+    del db  # routed through CLI service layer
+    status_filter = optional_string_argument(arguments, "status")
+    if status_filter == "":
+        return error_text("status must be a string", code="invalid_arguments", argument="status")
+    limit = int_argument(arguments, "limit", 100, minimum=1, maximum=500)
+    offset = int_argument(arguments, "offset", 0, minimum=0, maximum=1_000_000)
+    cli_args = ["tasks", "--json", "--limit", str(limit), "--offset", str(offset)]
+    if status_filter:
+        cli_args.extend(["--status", status_filter])
+    payload, cli_error = _cli_json(root, cli_args)
+    if cli_error:
+        return cli_error
+    assert payload is not None
+    return json_text(payload)

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

@@ -0,0 +1,100 @@
+"""Task lookup and prompt MCP tool handlers."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from mcp.types import TextContent
+
+from devcouncil.integrations.mcp.util import (
+    error_text,
+    json_text,
+    required_string_argument,
+    run_cli_command,
+)
+from devcouncil.utils.json_persist import dump_json
+
+
+def _cli_json(root: Path, args: list[str]) -> tuple[dict | None, list[TextContent] | None]:
+    result = run_cli_command(args, root)
+    if not result.get("ok"):
+        stderr = str(result.get("stderr") or "CLI command failed")
+        return None, error_text(stderr, code="cli_failed")
+    try:
+        return json.loads(str(result.get("stdout") or "{}")), None
+    except json.JSONDecodeError:
+        return None, error_text("CLI command returned invalid JSON", code="cli_parse_error")
+
+
+async def handle_get_task(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
+    assert task_id is not None
+    payload, cli_error = _cli_json(root, ["show", task_id, "--json"])
+    if cli_error:
+        return cli_error
+    assert payload is not None
+    task = payload.get("task")
+    if not isinstance(task, dict):
+        return error_text(f"Task {task_id} not found.", code="not_found", task_id=str(task_id))
+    return [TextContent(type="text", text=dump_json(task, indent=2))]
+
+
+async def handle_get_prompt(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
+    assert task_id is not None
+    payload, cli_error = _cli_json(root, ["prompt", task_id, "--json"])
+    if cli_error:
+        return cli_error
+    assert payload is not None
+    if not payload.get("ok"):
+        return error_text(
+            str(payload.get("error") or f"Task {task_id} not found."),
+            code="not_found",
+            task_id=str(task_id),
+        )
+    prompt = payload.get("prompt")
+    if not isinstance(prompt, str):
+        return error_text("prompt command returned no prompt text", code="cli_parse_error")
+    return [TextContent(type="text", text=prompt)]
+
+
+async def handle_prepare_execution(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
+    assert task_id is not None
+    show_payload, show_error = _cli_json(root, ["show", task_id, "--json"])
+    if show_error:
+        return show_error
+    assert show_payload is not None
+    task = show_payload.get("task")
+    if not isinstance(task, dict):
+        return error_text(f"Task {task_id} not found.", code="not_found", task_id=str(task_id))
+    prompt_payload, prompt_error = _cli_json(root, ["prompt", task_id, "--json"])
+    if prompt_error:
+        return prompt_error
+    assert prompt_payload is not None
+    if not prompt_payload.get("ok"):
+        return error_text(
+            str(prompt_payload.get("error") or f"Task {task_id} not found."),
+            code="not_found",
+            task_id=str(task_id),
+        )
+    prompt = prompt_payload.get("prompt")
+    if not isinstance(prompt, str):
+        return error_text("prompt command returned no prompt text", code="cli_parse_error")
+    return json_text({
+        "task_id": task.get("id", task_id),
+        "prompt": prompt,
+        "planned_files": task.get("planned_files") or [],
+        "allowed_commands": task.get("allowed_commands") or [],
+        "expected_tests": task.get("expected_tests") or [],
+    })