devcouncil 0.1.1 → 0.2.0

package/src/devcouncil/cli/commands/cost.py

@@ -0,0 +1,57 @@
+import json
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from devcouncil.telemetry.cost import group_cost
+
+app = typer.Typer(help="Inspect DevCouncil model-call cost, grouped by task and run.")
+console = Console()
+
+
+@app.command("show")
+def show(
+    json_format: bool = typer.Option(False, "--json", help="Output machine-readable JSON."),
+    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
+):
+    """Report estimated model-call cost grouped by task_id and run_id.
+
+    Reads the local ``model_calls.jsonl`` ledger only — fully offline. Records
+    written before per-task attribution (or made without a task/run context) are
+    grouped under ``(unattributed)``.
+    """
+    root = project_root.expanduser().resolve()
+    summary = group_cost(root)
+
+    if json_format:
+        typer.echo(json.dumps(summary, indent=2))
+        return
+
+    console.print(
+        f"[bold]Total Cost:[/bold] ${summary['total_cost']:.4f} "
+        f"across {summary['total_calls']} model call(s)"
+    )
+
+    def _render(title: str, groups: dict) -> None:
+        if not groups:
+            return
+        table = Table(title=title)
+        table.add_column("Group", style="cyan")
+        table.add_column("Cost ($)", justify="right")
+        table.add_column("Calls", justify="right")
+        table.add_column("Prompt", justify="right")
+        table.add_column("Completion", justify="right")
+        for name, stats in sorted(groups.items(), key=lambda kv: kv[1]["cost"], reverse=True):
+            table.add_row(
+                name,
+                f"{stats['cost']:.4f}",
+                str(stats["calls"]),
+                str(stats["prompt_tokens"]),
+                str(stats["completion_tokens"]),
+            )
+        console.print(table)
+
+    _render("Cost by Task", summary["by_task"])
+    _render("Cost by Run", summary["by_run"])

package/src/devcouncil/cli/commands/dashboard.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+import webbrowser
 
 import typer
 from rich.console import Console
@@ -15,6 +16,7 @@ def dashboard(
     ctx: typer.Context,
     host: str = typer.Option("127.0.0.1", "--host", help="Dashboard bind host."),
     port: int = typer.Option(8765, "--port", help="Dashboard bind port."),
+    open_browser: bool = typer.Option(False, "--open", help="Open the dashboard URL in the default browser before serving."),
     project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
 ):
     """Serve a local live dashboard with project status, tasks, coverage, and traces."""
@@ -22,5 +24,8 @@ def dashboard(
         return
     root = project_root.expanduser().resolve()
     initialize_project(root, quiet=True)
-    console.print(f"Serving DevCouncil dashboard at http://{host}:{port}")
+    url = f"http://{host}:{port}"
+    console.print(f"Serving DevCouncil dashboard at {url}")
+    if open_browser:
+        webbrowser.open(url)
     run_dashboard(root, host=host, port=port)

package/src/devcouncil/cli/commands/doctor.py

@@ -6,12 +6,80 @@ from pathlib import Path
 from rich.console import Console
 from rich.table import Table
 
-from devcouncil.app.config import load_config, load_local_secrets, provider_api_key_env_var
+from devcouncil.app.config import get_gcloud_access_token, load_config, load_local_secrets, provider_api_key_env_var
+from devcouncil.executors.agent_registry import (
+    CODING_CLI_INTEGRATION_INFO,
+    CODING_CLI_PROBE_ORDER,
+    CODING_CLI_VERSION_COMMANDS,
+    detect_available_coding_cli,
+    resolve_automated_executor,
+)
 from devcouncil.llm.provider import SUPPORTED_MODEL_PROVIDERS, validate_model_provider
 
 app = typer.Typer()
 console = Console()
 
+
+def _probe_ollama(base_url: str) -> tuple[bool, str]:
+    """Best-effort reachability check for a local Ollama server.
+
+    ``base_url`` carries the OpenAI-compatible ``/v1`` suffix; the native
+    ``/api/version`` endpoint lives one level up. Returns (reachable, detail);
+    any failure is reported, never raised.
+    """
+    root = base_url.rstrip("/")
+    if root.endswith("/v1"):
+        root = root[: -len("/v1")].rstrip("/")
+    try:
+        import httpx
+
+        resp = httpx.get(f"{root}/api/version", timeout=3.0)
+        if resp.status_code < 400:
+            version = ""
+            try:
+                version = (resp.json() or {}).get("version", "")
+            except Exception:
+                version = ""
+            return True, f"Reachable at {root}" + (f" (v{version})." if version else ".")
+        return False, f"Server at {root} returned HTTP {resp.status_code}."
+    except Exception:
+        return False, f"No Ollama server reachable at {root}."
+
+
+def _probe_ollama_models(base_url: str) -> tuple[bool, set[str]]:
+    """Best-effort list of locally-pulled Ollama model tags via native ``/api/tags``.
+
+    Returns (queried_ok, names). ``names`` holds the reported tags (e.g.
+    ``qwen2.5-coder:7b``). Any failure returns (False, set()) and is never raised — a
+    green liveness probe with no pulled model is the most common "configured but doesn't
+    work" trap, so this turns it into an actionable row."""
+    root = base_url.rstrip("/")
+    if root.endswith("/v1"):
+        root = root[: -len("/v1")].rstrip("/")
+    try:
+        import httpx
+
+        resp = httpx.get(f"{root}/api/tags", timeout=3.0)
+        if resp.status_code >= 400:
+            return False, set()
+        models = (resp.json() or {}).get("models", []) or []
+        names = {str(m.get("name", "")).strip() for m in models if m.get("name")}
+        return True, {n for n in names if n}
+    except Exception:
+        return False, set()
+
+
+def _ollama_model_present(model: str, pulled: set[str]) -> bool:
+    """Whether ``model`` is among the pulled tags, tolerant of the implicit ``:latest``
+    tag Ollama adds to untagged models."""
+    if model in pulled:
+        return True
+    base = model.split(":", 1)[0]
+    # configured "qwen2.5-coder" matches a pulled "qwen2.5-coder:latest", and vice versa.
+    candidates = {model, f"{model}:latest", base, f"{base}:latest"}
+    return any(tag in candidates or tag.split(":", 1)[0] == base and ":" not in model for tag in pulled)
+
+
 def render_doctor_check(project_root: Path = Path(".")):
     def _command_version(command: list[str]) -> str | None:
         executable = shutil.which(command[0])
@@ -66,33 +134,39 @@ def render_doctor_check(project_root: Path = Path(".")):
     else:
         table.add_row("ripgrep (rg)", "[yellow]Missing[/yellow]", "ripgrep is highly recommended for fast repo mapping.")
 
-    # Check supported coding CLIs
-    codex_ver = _command_version(["codex", "--version"])
-    if codex_ver:
-        table.add_row(
-            "Codex CLI",
-            "[green]OK[/green]",
-            f"{codex_ver}. Setup: dev integrate codex --apply (or dev setup --integrate --apply).",
-        )
-    else:
-        table.add_row(
-            "Codex CLI",
-            "[yellow]Missing[/yellow]",
-            "Optional. Install Codex, then run 'dev integrate codex --apply' (or 'dev setup --integrate --apply').",
-        )
+    # Check supported coding CLIs (driven by the agent registry, so new
+    # built-in agents show up here without doctor edits).
+    for name in CODING_CLI_PROBE_ORDER:
+        info = CODING_CLI_INTEGRATION_INFO.get(name)
+        if info is None:
+            continue
+        version = None
+        for probe in CODING_CLI_VERSION_COMMANDS.get(name, ()):
+            version = _command_version(list(probe))
+            if version:
+                break
+        if version:
+            table.add_row(info.label, "[green]OK[/green]", f"{version}. Setup: {info.notes}.")
+        else:
+            table.add_row(
+                info.label,
+                "[yellow]Missing[/yellow]",
+                f"Optional. Install {info.label}, then use: {info.notes}.",
+            )
 
-    gemini_ver = _command_version(["gemini", "--version"])
-    if gemini_ver:
+    detected = detect_available_coding_cli(project_root)
+    resolved = resolve_automated_executor(project_root, None)
+    if detected:
         table.add_row(
-            "Gemini CLI",
+            "Recommended coding CLI",
             "[green]OK[/green]",
-            f"{gemini_ver}. Setup: dev integrate gemini --apply (or dev setup --integrate --apply).",
+            f"Use --executor {resolved} for dev go / dev run (detected on PATH).",
         )
     else:
         table.add_row(
-            "Gemini CLI",
+            "Recommended coding CLI",
             "[yellow]Missing[/yellow]",
-            "Optional. Install Gemini CLI, then run 'dev integrate gemini --apply' (or 'dev setup --integrate --apply').",
+            "No built-in coding CLI on PATH. Run dev integrate recommend after installing one.",
         )
 
     try:
@@ -108,6 +182,109 @@ def render_doctor_check(project_root: Path = Path(".")):
             "[red]Unsupported[/red]",
             f"{provider} is configured, but this runtime supports: {supported}.",
         )
+        console.print(table)
+        return
+    if provider == "ollama":
+        # Use the provider's own resolver so the displayed URL reflects OLLAMA_HOST
+        # (with scheme/-/v1 normalization), not just OLLAMA_BASE_URL.
+        from devcouncil.execution.prompt_builder import MAX_PROMPT_CHARS
+        from devcouncil.llm.provider import OllamaProvider
+
+        base_url = OllamaProvider._resolve_base_url()
+        num_ctx = OllamaProvider._resolve_num_ctx()
+        # DevCouncil's planning prompts reach ~MAX_PROMPT_CHARS chars (~4 chars/token);
+        # recommend a context window that covers the prompt plus headroom for output.
+        recommended_ctx = 16384
+        min_ctx = max(8192, (MAX_PROMPT_CHARS // 4))
+        table.add_row(
+            "OLLAMA",
+            "[green]OK[/green]",
+            f"Local provider; no API key required (server: {base_url}).",
+        )
+
+        # Is the local Ollama server actually up? A native /api/version probe is
+        # cheap and turns the most common failure ("provider configured but
+        # `ollama serve` not running") into an actionable row instead of a
+        # connection traceback on the first model call.
+        reachable, detail = _probe_ollama(base_url)
+        if reachable:
+            table.add_row("OLLAMA server", "[green]OK[/green]", detail)
+        else:
+            table.add_row(
+                "OLLAMA server",
+                "[yellow]WARN[/yellow]",
+                f"{detail} Start it with 'ollama serve' (or 'brew services start ollama').",
+            )
+
+        # A reachable server with the configured model NOT pulled is the most common
+        # "all-green doctor, 404 on first call" trap. Verify the role models exist locally.
+        if reachable:
+            try:
+                configured_models = sorted(
+                    {role.model for role in load_config(project_root).models.roles.values() if role.model}
+                )
+            except Exception:
+                configured_models = []
+            queried_ok, pulled = _probe_ollama_models(base_url)
+            if not queried_ok:
+                table.add_row(
+                    "OLLAMA models",
+                    "[yellow]WARN[/yellow]",
+                    "Could not list pulled models (/api/tags). Ensure each configured model is pulled.",
+                )
+            elif not configured_models:
+                table.add_row(
+                    "OLLAMA models",
+                    "[yellow]WARN[/yellow]",
+                    "No role models configured; run 'dev setup --provider ollama --model <model>'.",
+                )
+            else:
+                missing = [m for m in configured_models if not _ollama_model_present(m, pulled)]
+                if missing:
+                    pulls = "; ".join(f"ollama pull {m}" for m in missing)
+                    table.add_row(
+                        "OLLAMA models",
+                        "[yellow]WARN[/yellow]",
+                        f"Configured model(s) not pulled: {', '.join(missing)}. Pull first: {pulls}.",
+                    )
+                else:
+                    table.add_row(
+                        "OLLAMA models",
+                        "[green]OK[/green]",
+                        f"All configured models present locally ({', '.join(configured_models)}).",
+                    )
+
+        if num_ctx is None:
+            table.add_row(
+                "OLLAMA num_ctx",
+                "[yellow]WARN[/yellow]",
+                f"OLLAMA_NUM_CTX not set — Ollama's small default (~2048-4096) will "
+                f"truncate DevCouncil's large planning prompts. Set OLLAMA_NUM_CTX={recommended_ctx}.",
+            )
+        elif num_ctx < min_ctx:
+            table.add_row(
+                "OLLAMA num_ctx",
+                "[yellow]WARN[/yellow]",
+                f"OLLAMA_NUM_CTX={num_ctx} may be too small for planning prompts "
+                f"(~{MAX_PROMPT_CHARS // 4} tokens); recommend >= {recommended_ctx}.",
+            )
+        else:
+            table.add_row("OLLAMA num_ctx", "[green]OK[/green]", f"context window = {num_ctx} tokens.")
+
+        # Local model size is bounded by host memory — unified RAM on Apple Silicon,
+        # VRAM on a discrete-GPU box, system RAM otherwise. Surface a model that will
+        # actually fit on this host (any OS), not a one-size default.
+        from devcouncil import hardware
+
+        host = hardware.describe_host()
+        table.add_row(
+            host.platform_label,
+            "[green]OK[/green]",
+            f"{host.chip_label}, {host.memory_label}. "
+            f"Recommended local model: {host.recommended_ollama_model} "
+            f"(dev setup --provider ollama --model {host.recommended_ollama_model}).",
+        )
+
         console.print(table)
         return
     env_var = provider_api_key_env_var(provider)
@@ -116,9 +293,32 @@ def render_doctor_check(project_root: Path = Path(".")):
         table.add_row(env_var, "[green]OK[/green]", f"Found in environment for {provider}.")
     elif local_secrets.get(env_var):
         table.add_row(env_var, "[green]OK[/green]", f"Found in .devcouncil/secrets.env for {provider}.")
+    elif provider == "vertexai" and get_gcloud_access_token():
+        table.add_row(env_var, "[green]OK[/green]", "Resolvable via gcloud auth print-access-token.")
+        table.caption = "Resolvable via gcloud auth print-access-token."
     else:
         table.add_row(env_var, "[yellow]Missing[/yellow]", f"Required if using {provider} provider. Run 'dev setup'.")
 
+    if provider == "vertexai":
+        project = (
+            os.environ.get("VERTEXAI_PROJECT")
+            or os.environ.get("GOOGLE_CLOUD_PROJECT")
+            or local_secrets.get("VERTEXAI_PROJECT")
+            or local_secrets.get("GOOGLE_CLOUD_PROJECT")
+        )
+        if project:
+            source = "environment" if os.environ.get("VERTEXAI_PROJECT") or os.environ.get("GOOGLE_CLOUD_PROJECT") else ".devcouncil/secrets.env"
+            table.add_row("VERTEXAI_PROJECT", "[green]OK[/green]", f"Found in {source}.")
+        else:
+            table.add_row(
+                "VERTEXAI_PROJECT",
+                "[yellow]Missing[/yellow]",
+                "Required for vertexai. Run 'dev setup --provider vertexai --vertex-project PROJECT_ID'.",
+            )
+
+        location = os.environ.get("VERTEXAI_LOCATION") or local_secrets.get("VERTEXAI_LOCATION", "global")
+        table.add_row("VERTEXAI_LOCATION", "[green]OK[/green]", location)
+
     console.print(table)
 
 

package/src/devcouncil/cli/commands/evidence.py

@@ -0,0 +1,48 @@
+import json
+import typer
+from pathlib import Path
+from rich.console import Console
+
+from devcouncil.cli.commands.init import initialize_project
+from devcouncil.storage.db import get_db
+from devcouncil.storage.repositories import TaskRepository
+from devcouncil.verification.test_resolver import TestResolver
+from devcouncil.verification.verifier import Verifier
+
+app = typer.Typer(help="Evidence suggestion utilities.")
+console = Console()
+
+
+@app.command("suggest")
+def suggest(
+    task_id: str = typer.Argument(...),
+    apply: bool = typer.Option(False, "--apply"),
+    include_low_confidence: bool = typer.Option(False, "--include-low-confidence"),
+    project_root: Path = typer.Option(Path("."), "--project-root"),
+):
+    root = project_root.expanduser().resolve()
+    initialize_project(root, quiet=True)
+    db = get_db(root)
+    if not db:
+        console.print("[red]DevCouncil not initialized.[/red]")
+        raise typer.Exit(code=1)
+
+    with db.get_session() as session:
+        task = TaskRepository(session).get_by_id(task_id)
+        if not task:
+            console.print(f"[red]Task {task_id} not found.[/red]")
+            raise typer.Exit(code=1)
+        changed = Verifier(root).get_task_changed_files(task_id)
+        suggestions = TestResolver(root).suggest_for_task(task, changed)
+        if not include_low_confidence:
+            suggestions = [s for s in suggestions if s.confidence != "low"]
+        if apply:
+            for item in suggestions:
+                if item.confidence == "high" and item.command not in task.expected_tests:
+                    task.expected_tests.append(item.command)
+            TaskRepository(session).save(task)
+        typer.echo(json.dumps({
+            "task_id": task_id,
+            "suggestions": [s.model_dump() for s in suggestions],
+            "expected_tests": task.expected_tests,
+        }, indent=2))