roundtable-cli 0.4.0__py3-none-any.whl

roundtable/mcp.py

@@ -0,0 +1,248 @@
+"""MCP server that exposes roundtable operations as callable tools.
+
+Typical workflow an LLM should follow:
+  1. roundtable_init        — set up .roundtable/ if this is a fresh project
+  2. roundtable_plan        — generate a plan from a goal string
+  3. roundtable_approve     — mark the plan approved (required before run)
+  4. roundtable_run         — start the run (non-blocking; returns immediately)
+  5. roundtable_status      — poll until status == "done" or "failed"
+
+Optionally call roundtable_map first to generate ARCHITECTURE.md + PRD.md from
+an existing codebase before planning.
+
+Entry point (stdio, for Claude Code / Claude Desktop):
+    roundtable mcp
+    roundtable-mcp
+
+Register in Claude Code .claude/settings.json:
+    {
+        "mcpServers": {
+            "roundtable": { "command": "roundtable-mcp" }
+        }
+    }
+
+Requires: pip install 'roundtable-cli[mcp]'
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+
+def _build_server() -> Any:
+    try:
+        from mcp.server.fastmcp import FastMCP  # type: ignore[import]
+    except ImportError:
+        print(
+            "error: 'mcp' package not installed — run: pip install 'roundtable-cli[mcp]'",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    mcp = FastMCP(
+        "roundtable",
+        instructions=(
+            "Roundtable orchestrates multi-agent LLM tasks. "
+            "Workflow: roundtable_init (once) → roundtable_plan → roundtable_approve → roundtable_run. "
+            "roundtable_run is non-blocking; poll roundtable_status until status is 'done' or 'failed'. "
+            "All tools accept a `project` argument (path to the project directory; defaults to '.')."
+        ),
+    )
+
+    # ------------------------------------------------------------------ #
+    # Helpers
+    # ------------------------------------------------------------------ #
+
+    def _cli(*args: str) -> str:
+        r = subprocess.run(
+            ["roundtable", *args],
+            capture_output=True, text=True,
+        )
+        out = (r.stdout or "").strip()
+        err = (r.stderr or "").strip()
+        if r.returncode not in (0,):
+            return f"error (exit {r.returncode}): {err or out or '(no output)'}"
+        return out or err or "ok"
+
+    def _read_state(project: str) -> dict[str, Any]:
+        from .store import Store
+        from .insights import build_state
+        return build_state(Store(Path(project).resolve()))
+
+    # ------------------------------------------------------------------ #
+    # Tools
+    # ------------------------------------------------------------------ #
+
+    @mcp.tool()
+    def roundtable_init(directory: str = ".") -> str:
+        """Initialize a .roundtable/ directory and default config in the given project directory."""
+        return _cli("init", directory, "--no-models")
+
+    @mcp.tool()
+    def roundtable_map(
+        target: str = ".",
+        project: str = ".",
+        model: str | None = None,
+    ) -> str:
+        """Scan a codebase and generate ARCHITECTURE.md and PRD.md under .roundtable/docs/.
+
+        Use this before roundtable_plan when you want to base the plan on an
+        existing codebase rather than a bare goal string.
+
+        Args:
+            target:  Path to the codebase to scan (default: project root).
+            project: Roundtable project root where .roundtable/ lives (default: '.').
+            model:   Override the analyst agent/model (e.g. 'claude:opus').
+        """
+        args = ["map", "--project", project, "--target", target]
+        if model:
+            args += ["--model", model]
+        return _cli(*args)
+
+    @mcp.tool()
+    def roundtable_plan(
+        goal: str,
+        project: str = ".",
+        model: str | None = None,
+    ) -> str:
+        """Generate a multi-agent execution plan from a goal string.
+
+        Writes plan.json and PLAN.md under .roundtable/plan/. The plan must be
+        approved with roundtable_approve before it can be run.
+
+        Args:
+            goal:    Natural-language description of what the agents should build or do.
+            project: Roundtable project root (default: '.').
+            model:   Override the planner agent/model (e.g. 'claude:opus').
+        """
+        args = ["plan", "--goal", goal, "--project", project]
+        if model:
+            args += ["--model", model]
+        return _cli(*args)
+
+    @mcp.tool()
+    def roundtable_approve(project: str = ".") -> str:
+        """Approve the current plan so it can be executed by roundtable_run.
+
+        Args:
+            project: Roundtable project root (default: '.').
+        """
+        return _cli("approve", "--project", project)
+
+    @mcp.tool()
+    def roundtable_run(project: str = ".", approve: bool = False) -> str:
+        """Start executing the approved plan in the background (non-blocking).
+
+        Returns immediately after starting the run process. Use roundtable_status
+        to monitor progress. The run continues even if this MCP server exits.
+
+        Args:
+            project: Roundtable project root (default: '.').
+            approve: If True, auto-approve the plan before running (combines
+                     roundtable_approve + roundtable_run in one call).
+        """
+        from . import runctl
+        from .store import Store
+
+        store = Store(Path(project).resolve())
+        pid, msg = runctl.start_run(store, approve=approve)
+        if pid is None:
+            return f"error: {msg}. Call roundtable_status to monitor, or roundtable_stop to cancel."
+        return (
+            f"Run started (pid={pid}). "
+            "Agents are now executing tasks in the background. "
+            "Call roundtable_status() to monitor progress."
+        )
+
+    @mcp.tool()
+    def roundtable_stop(project: str = ".") -> str:
+        """Stop a running roundtable execution.
+
+        Reads the PID from the run.pid file and sends SIGTERM to gracefully
+        stop the process group when possible.
+
+        Args:
+            project: Roundtable project root (default: '.').
+        """
+        from . import runctl
+        from .store import Store
+
+        store = Store(Path(project).resolve())
+        _, msg = runctl.stop_run(store)
+        return msg
+
+    @mcp.tool()
+    def roundtable_status(project: str = ".") -> str:
+        """Return the current run state as JSON.
+
+        Includes: overall status, per-phase/task progress, active tasks,
+        per-agent stats, timing, and recent events.
+
+        Args:
+            project: Roundtable project root (default: '.').
+        """
+        state = _read_state(project)
+        return json.dumps(state, indent=2)
+
+    # ------------------------------------------------------------------ #
+    # Resources (read-only context; always operates on cwd / project='.')
+    @mcp.tool()
+    def roundtable_usage(project: str = ".") -> str:
+        """Return aggregated provider usage stats (calls, tokens, duration).
+
+        Reads 'usage' events from the run log and returns a summary. Only
+        available after a run completes or partially completes.
+
+        Args:
+            project: Roundtable project root (default: '.').
+        """
+        from .store import Store
+
+        store = Store(Path(project).resolve())
+        events = store.read_events()
+        usage_events = [e for e in events if e.get("type") == "usage"]
+        if not usage_events:
+            return json.dumps({"message": "no usage data recorded yet"})
+        # Return the most recent usage snapshot.
+        latest = usage_events[-1]
+        return json.dumps({
+            k: v for k, v in latest.items()
+            if k not in ("type", "ts", "msg")
+        }, indent=2)
+
+    # ------------------------------------------------------------------ #
+
+    @mcp.resource("roundtable://plan")
+    def resource_plan() -> str:
+        """The current plan.json — phases, tasks, runners, and approval state."""
+        from .store import Store
+        store = Store(Path(".").resolve())
+        p = store.manifest_path
+        if not p.exists():
+            return json.dumps({"error": "no plan found — call roundtable_plan first"})
+        return p.read_text()
+
+    @mcp.resource("roundtable://state")
+    def resource_state() -> str:
+        """Live run state snapshot (same data as roundtable_status tool, project='.')."""
+        return json.dumps(_read_state("."), indent=2)
+
+    @mcp.resource("roundtable://logs")
+    def resource_logs() -> str:
+        """Last 50 run events from run.log as a JSON array (newest first)."""
+        from .store import Store
+        store = Store(Path(".").resolve())
+        events = store.read_events()
+        return json.dumps(list(reversed(events[-50:])), indent=2)
+
+    return mcp
+
+
+def run_server() -> None:
+    """Entry point: start the roundtable MCP server over stdio."""
+    server = _build_server()
+    server.run()

roundtable/modelpick.py

@@ -0,0 +1,309 @@
+"""Interactive per-role model selection for `roundtable models` and `roundtable init`.
+
+Lists the models actually connected to the configured backend and lets you pick one
+per role (planner / main / phase / task) with a two-step *provider -> model* prompt,
+then writes the choices into ``roundtable.config.yaml`` (preserving the rest of the
+file). Works for two backends:
+
+* ``pi``  — the pi-family tool reports its own catalog: ``omp models --json`` (rich)
+            or ``pi --list-models`` (best-effort text). "provider" is the model's
+            provider (anthropic, opencode-go, ...); the chosen ref is ``{model: sel}``.
+* ``cli`` — each configured agent's ``models_command`` (via :mod:`.discovery`).
+            "provider" is the agent (claude, opencode, ...); the ref is
+            ``{agent, model}``.
+
+Listing/parsing are pure functions; the picker takes injectable ``input_fn``/``out``
+so it can be driven from tests without a real terminal.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import re
+import shutil
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Callable
+
+from .config import CONFIG_FILENAME, Config
+from .discovery import AgentStatus, discover
+from .models import AgentRef
+
+ROLES = ["planner", "main", "phase", "task"]
+
+
+@dataclass
+class ModelChoice:
+    label: str          # human-readable line shown in the picker
+    ref: AgentRef       # what gets written to the config for this choice
+
+
+@dataclass
+class ModelGroup:
+    name: str           # provider (pi backend) or agent (cli backend)
+    installed: bool = True
+    note: str = ""      # why there are no choices, if empty
+    choices: list[ModelChoice] = field(default_factory=list)
+
+
+# --------------------------------------------------------------------------- #
+# Listing / grouping (pure where possible)
+# --------------------------------------------------------------------------- #
+def list_model_groups(config: Config, *, timeout: float = 20.0) -> list[ModelGroup]:
+    """Model groups for the configured backend (empty for litellm/scripted)."""
+    if config.provider == "pi":
+        return _pi_groups(config, timeout)
+    if config.provider == "cli":
+        return _cli_groups(config, timeout)
+    return []
+
+
+def _pi_groups(config: Config, timeout: float) -> list[ModelGroup]:
+    flavor = (config.pi.flavor or "pi").lower()
+    cmd = list(config.pi.command) or (["omp"] if flavor == "omp" else ["pi"])
+    if shutil.which(cmd[0]) is None:
+        return [ModelGroup(name=cmd[0], installed=False, note="not on PATH")]
+    argv = cmd + (["models", "--json"] if flavor == "omp" else ["--list-models"])
+    try:
+        res = subprocess.run(argv, capture_output=True, text=True, timeout=timeout)
+    except (subprocess.TimeoutExpired, OSError) as e:  # pragma: no cover - env-specific
+        return [ModelGroup(name=cmd[0], installed=False, note=f"model query failed: {e}")]
+    if res.returncode != 0:
+        tail = (res.stderr or res.stdout).strip().splitlines()
+        return [ModelGroup(name=cmd[0], installed=False,
+                           note=f"exited {res.returncode}" + (f": {tail[-1][:80]}" if tail else ""))]
+    if flavor == "omp":
+        try:
+            data = json.loads(res.stdout)
+        except json.JSONDecodeError:
+            return [ModelGroup(name="omp", installed=False, note="`omp models --json` returned non-JSON")]
+        return omp_groups_from_json(data)
+    return pi_groups_from_text(res.stdout)
+
+
+def omp_groups_from_json(data: object) -> list[ModelGroup]:
+    """Parse ``omp models --json`` ({"models":[{provider,selector,name,contextWindow,...}]})."""
+    recs = data.get("models") if isinstance(data, dict) else data
+    groups: dict[str, ModelGroup] = {}
+    for r in recs or []:
+        if not isinstance(r, dict):
+            continue
+        prov = r.get("provider") or "?"
+        sel = r.get("selector") or (f"{prov}/{r['id']}" if r.get("id") else None)
+        if not sel:
+            continue
+        name = r.get("name") or r.get("id") or sel
+        ctx = r.get("contextWindow")
+        ctx_s = f"  · {ctx // 1000}K" if isinstance(ctx, int) and ctx >= 1000 else ""
+        groups.setdefault(prov, ModelGroup(name=prov)).choices.append(
+            ModelChoice(label=f"{name}{ctx_s}   [{sel}]", ref=AgentRef(model=sel))
+        )
+    return [groups[k] for k in sorted(groups)]
+
+
+def pi_groups_from_text(text: str) -> list[ModelGroup]:
+    """Best-effort parse of ``pi --list-models`` text output (one model id per line)."""
+    groups: dict[str, ModelGroup] = {}
+    for line in text.splitlines():
+        s = line.strip()
+        if not s or s.startswith(("#", "-", "Usage", "Available", "Models")):
+            continue
+        tok = s.split()[0]
+        if "/" not in tok and " " in s:  # a header-ish line, skip
+            continue
+        prov = tok.split("/")[0] if "/" in tok else "pi"
+        groups.setdefault(prov, ModelGroup(name=prov)).choices.append(
+            ModelChoice(label=tok, ref=AgentRef(model=tok))
+        )
+    if not any(g.choices for g in groups.values()):
+        return [ModelGroup(name="pi", installed=False,
+                           note="`pi --list-models` returned no parseable models; edit config manually")]
+    return [groups[k] for k in sorted(groups)]
+
+
+def _cli_groups(config: Config, timeout: float) -> list[ModelGroup]:
+    statuses = asyncio.run(discover(config.agents, timeout=timeout))
+    return groups_from_statuses(statuses)
+
+
+def groups_from_statuses(statuses: list[AgentStatus]) -> list[ModelGroup]:
+    """One group per cli agent; each model becomes a {agent, model} choice."""
+    groups: list[ModelGroup] = []
+    for st in sorted(statuses, key=lambda s: (not s.installed, s.name)):
+        g = ModelGroup(name=st.name, installed=st.installed, note=st.note)
+        for m in st.models:
+            g.choices.append(ModelChoice(label=m, ref=AgentRef(agent=st.name, model=m)))
+        groups.append(g)
+    return groups
+
+
+# --------------------------------------------------------------------------- #
+# Formatting helpers
+# --------------------------------------------------------------------------- #
+def fmt_ref(ref: AgentRef | None) -> str:
+    if ref is None:
+        return "(unset)"
+    if ref.agent and ref.model:
+        return f"{ref.agent}:{ref.model}"
+    return ref.model or ref.agent or "(unset)"
+
+
+def _ref_yaml(ref: AgentRef | None) -> str:
+    if ref is None or (not ref.agent and not ref.model):
+        return "{ }"
+    if ref.agent and ref.model:
+        return f"{{ agent: {ref.agent}, model: {ref.model} }}"
+    if ref.model:
+        return f"{{ model: {ref.model} }}"
+    return f"{{ agent: {ref.agent} }}"
+
+
+def current_refs(config: Config) -> dict[str, AgentRef]:
+    m = config.models
+    return {"planner": m.planner, "main": m.main, "phase": m.phase, "task": m.task}
+
+
+# --------------------------------------------------------------------------- #
+# Interactive picker (injectable I/O for tests)
+# --------------------------------------------------------------------------- #
+_MODEL_PAGE = 25  # long provider lists prompt for a filter above this many
+
+
+def pick_models(
+    groups: list[ModelGroup],
+    current: dict[str, AgentRef],
+    *,
+    roles: list[str] = ROLES,
+    input_fn: Callable[[str], str] | None = None,
+    out: Callable[[str], None] = print,
+) -> dict[str, AgentRef]:
+    """Two-step provider->model prompt per role. Returns only the roles the user
+    changed (empty dict if nothing changed / aborted)."""
+    if input_fn is None:  # resolved at call time so a patched builtins.input is honored
+        input_fn = input
+    usable = [g for g in groups if g.installed and g.choices]
+    if not usable:
+        out("no connected models found (check the tool is installed and authenticated).")
+        for g in groups:
+            if g.note:
+                out(f"  - {g.name}: {g.note}")
+        return {}
+
+    picks: dict[str, AgentRef] = {}
+    out("select a model per role — Enter keeps the current value, 'q' stops.\n")
+    try:
+        for role in roles:
+            out(f"── {role}  (current: {fmt_ref(current.get(role))})")
+            g = _choose_group(usable, input_fn, out)
+            if g is _QUIT:
+                break
+            if g is None:
+                out("   kept.\n")
+                continue
+            ref = _choose_model(g, input_fn, out)
+            if ref is _QUIT:
+                break
+            if ref is None:
+                out("   kept.\n")
+                continue
+            picks[role] = ref
+            out(f"   → {fmt_ref(ref)}\n")
+    except (EOFError, KeyboardInterrupt):
+        out("\naborted.")
+        return {}
+    return picks
+
+
+_QUIT = object()  # sentinel: user asked to stop
+
+
+def _choose_group(groups: list[ModelGroup], input_fn, out):
+    for i, g in enumerate(groups, 1):
+        out(f"   {i:>2}. {g.name}  ({len(g.choices)})")
+    raw = input_fn("   provider # (Enter=keep, q=quit): ").strip().lower()
+    if raw in ("q", "quit"):
+        return _QUIT
+    if raw == "":
+        return None
+    if raw.isdigit() and 1 <= int(raw) <= len(groups):
+        return groups[int(raw) - 1]
+    out("   ? invalid choice; keeping current.")
+    return None
+
+
+def _choose_model(group: ModelGroup, input_fn, out):
+    choices = group.choices
+    if len(choices) > _MODEL_PAGE:
+        flt = input_fn(f"   {len(choices)} models in {group.name}; type a filter (Enter=show all): ").strip().lower()
+        if flt:
+            choices = [c for c in choices if flt in c.label.lower()] or group.choices
+    for i, c in enumerate(choices, 1):
+        out(f"   {i:>2}. {c.label}")
+    raw = input_fn("   model # (Enter=keep, q=quit): ").strip().lower()
+    if raw in ("q", "quit"):
+        return _QUIT
+    if raw == "":
+        return None
+    if raw.isdigit() and 1 <= int(raw) <= len(choices):
+        return choices[int(raw) - 1].ref
+    out("   ? invalid choice; keeping current.")
+    return None
+
+
+# --------------------------------------------------------------------------- #
+# Config writing (surgical: replace only the models: block)
+# --------------------------------------------------------------------------- #
+def render_models_block(refs: dict[str, AgentRef], roles: list[str] = ROLES) -> str:
+    lines = ["models:"]
+    for r in roles:
+        lines.append(f"  {(r + ':'):<9}{_ref_yaml(refs.get(r))}")
+    return "\n".join(lines)
+
+
+def update_config_models(path: Path, refs: dict[str, AgentRef], roles: list[str] = ROLES) -> None:
+    """Replace the top-level ``models:`` block in the config, preserving the rest."""
+    text = path.read_text()
+    lines = text.splitlines()
+    start = next((i for i, l in enumerate(lines) if re.match(r"^models:\s*(#.*)?$", l)), None)
+    block = render_models_block(refs, roles).splitlines()
+    if start is None:
+        new = lines + ([""] if lines and lines[-1].strip() else []) + block
+    else:
+        end = start + 1
+        # Consume the block's role lines, but stop at an indented comment line so
+        # trailing comments inside the block are preserved (blank/dedented lines
+        # already end the block).
+        while end < len(lines) and lines[end].startswith((" ", "\t")):
+            if lines[end].lstrip().startswith("#"):
+                break
+            end += 1
+        new = lines[:start] + block + lines[end:]
+    path.write_text("\n".join(new) + ("\n" if text.endswith("\n") else ""))
+
+
+# --------------------------------------------------------------------------- #
+# Optional verification: ping each picked model once (no tools) to catch 401/500
+# --------------------------------------------------------------------------- #
+def verify_refs(config: Config, refs: dict[str, AgentRef], *, out: Callable[[str], None] = print) -> bool:
+    """Send a tiny no-tools prompt to each ref so runtime errors surface now, not
+    mid-run. Returns True if all succeeded."""
+    from .llm import CLIProvider, PiProvider
+
+    ok_all = True
+    out("verifying selections (one tiny call each) …")
+    for role, ref in refs.items():
+        try:
+            if config.provider == "pi":
+                prov = PiProvider(config.pi, timeout=60, max_retries=0)
+                asyncio.run(prov.complete(model=ref.model, system="", user="Reply with: ok", role="planner"))
+            else:
+                prov = CLIProvider(config.agents, timeout=60, max_retries=0)
+                asyncio.run(prov.complete(agent=ref.agent or None, model=ref.model,
+                                          system="", user="Reply with: ok", role="planner"))
+            out(f"   ✓ {role}  {fmt_ref(ref)}")
+        except Exception as e:  # noqa: BLE001 - report any backend failure
+            ok_all = False
+            out(f"   ✗ {role}  {fmt_ref(ref)} — {str(e).splitlines()[0][:100]}")
+    return ok_all