devcouncil 0.1.0 → 0.1.1

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

@@ -1,18 +1,149 @@
 from pathlib import Path
+import os
 import shutil
+import sys
 
 import typer
+import yaml
 from rich.console import Console
 from rich.panel import Panel
 
+from devcouncil.app.config import load_config, load_local_secrets, provider_api_key_env_var
 from devcouncil.cli.commands.doctor import render_doctor_check
 from devcouncil.cli.commands.init import initialize_project
-from devcouncil.cli.commands.integrate import _codex_command, _configure, _gemini_command
+from devcouncil.cli.commands.integrate import (
+    _claude_command,
+    _codex_command,
+    _configure_native_hooks,
+    _configure,
+    _cursor_command,
+    _gemini_command,
+)
+from devcouncil.llm.provider import validate_model_provider
 
 app = typer.Typer()
 console = Console()
 
 
+def _set_model_provider(project_root: Path, provider: str) -> None:
+    normalized = validate_model_provider(provider)
+    config_path = project_root / ".devcouncil" / "config.yaml"
+    raw_config = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
+    raw_config.setdefault("models", {})
+    previous = raw_config["models"].get("provider", "openrouter")
+    raw_config["models"]["provider"] = normalized
+    config_path.write_text(yaml.dump(raw_config, default_flow_style=False), encoding="utf-8")
+    if previous != normalized:
+        console.print(f"[green]Updated model provider from {previous} to {normalized}.[/green]")
+
+
+def _write_local_secret(project_root: Path, env_var: str, value: str) -> Path:
+    if "\n" in value or "\r" in value:
+        raise ValueError("API keys cannot contain newlines.")
+    secrets = load_local_secrets(project_root)
+    secrets[env_var] = value
+    path = project_root / ".devcouncil" / "secrets.env"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    lines = [
+        "# Local DevCouncil secrets. This file is ignored by git.",
+        "# Process environment variables with the same name take precedence.",
+        *[f"{key}={val}" for key, val in sorted(secrets.items())],
+        "",
+    ]
+    path.write_text("\n".join(lines), encoding="utf-8")
+    return path
+
+
+def _configure_api_key(project_root: Path, api_key: str | None, skip_api_key: bool) -> None:
+    config = load_config(project_root)
+    provider = config.models.provider
+    env_var = provider_api_key_env_var(provider)
+    local_secrets = load_local_secrets(project_root)
+
+    if os.environ.get(env_var):
+        console.print(f"[green]{env_var} is already set in the environment.[/green]")
+        return
+    if local_secrets.get(env_var):
+        console.print(f"[green]{env_var} is already set in .devcouncil/secrets.env.[/green]")
+        return
+    if api_key:
+        _write_local_secret(project_root, env_var, api_key)
+        console.print(f"[green]Saved {env_var} to .devcouncil/secrets.env.[/green]")
+        return
+    if skip_api_key:
+        console.print(f"[yellow]Skipped {env_var} setup. Model-backed commands will ask again if it is missing.[/yellow]")
+        return
+    if not sys.stdin.isatty():
+        console.print(
+            f"[yellow]{env_var} is not set.[/yellow] "
+            f"Run [bold]dev setup --api-key YOUR_KEY[/bold] or set it in your shell before model-backed commands."
+        )
+        return
+
+    console.print()
+    console.print(Panel.fit(
+        "\n".join([
+            f"Provider: {provider}",
+            f"Required key: {env_var}",
+            "Press Enter without a value to skip for now.",
+        ]),
+        title="Model API Key",
+        border_style="cyan",
+    ))
+    entered = typer.prompt(f"{env_var}", default="", hide_input=True, show_default=False)
+    if not entered:
+        console.print(f"[yellow]Skipped {env_var} setup.[/yellow]")
+        return
+    _write_local_secret(project_root, env_var, entered)
+    console.print(f"[green]Saved {env_var} to .devcouncil/secrets.env.[/green]")
+
+
+def _is_interactive_terminal() -> bool:
+    return sys.stdin.isatty()
+
+
+def _configure_coding_cli_integrations(project_root: Path, apply: bool, gemini_scope: str) -> None:
+    console.print()
+    console.print("[bold]Coding CLI integration[/bold]")
+    commands = [
+        ("Codex CLI", _codex_command(project_root)),
+        ("Gemini CLI", _gemini_command(project_root, gemini_scope)),
+        ("Claude Code", _claude_command(project_root, "local")),
+        ("Cursor", _cursor_command(project_root)),
+    ]
+    results = []
+    for tool, command in commands:
+        if apply and not shutil.which(command[0]):
+            console.print(f"[yellow]{tool} CLI not found on PATH. Skipping optional integration.[/yellow]")
+            continue
+        results.append(_configure(tool, command, apply))
+    _configure_native_hooks(project_root, "all", apply)
+    if apply and any(not ok for ok in results):
+        raise typer.Exit(code=1)
+
+
+def _prompt_for_first_run_integrations(project_root: Path, apply: bool, gemini_scope: str) -> bool:
+    if not _is_interactive_terminal():
+        return False
+
+    console.print()
+    console.print(Panel.fit(
+        "\n".join([
+            "DevCouncil can configure supported coding CLIs now.",
+            "This adds MCP setup and native hook config for detected clients.",
+            "Missing optional clients are skipped.",
+        ]),
+        title="Coding CLI Setup",
+        border_style="cyan",
+    ))
+    if not typer.confirm("Set up coding CLI integrations now?", default=True):
+        console.print("[yellow]Skipped coding CLI integration setup.[/yellow]")
+        return False
+
+    _configure_coding_cli_integrations(project_root, apply=apply, gemini_scope=gemini_scope)
+    return True
+
+
 @app.callback(invoke_without_command=True)
 def setup(
     ctx: typer.Context,
@@ -22,9 +153,13 @@ def setup(
         help="Target project repository root. Defaults to the terminal's current directory.",
     ),
     name: str | None = typer.Option(None, "--name", "-n", help="Project name for .devcouncil/config.yaml."),
-    integrate: bool = typer.Option(False, "--integrate", help="Configure supported coding CLI MCP integrations."),
+    integrate: bool = typer.Option(False, "--integrate", help="Configure supported coding CLI MCP integrations and native hooks."),
     apply: bool = typer.Option(False, "--apply", help="Apply integration config instead of previewing commands."),
     gemini_scope: str = typer.Option("project", "--gemini-scope", help="Gemini MCP config scope: project or user."),
+    provider: str | None = typer.Option(None, "--provider", help="Set models.provider before configuring the API key."),
+    api_key: str | None = typer.Option(None, "--api-key", help="Store the configured provider API key in local .devcouncil/secrets.env."),
+    skip_api_key: bool = typer.Option(False, "--skip-api-key", help="Skip the first-run model API key prompt."),
+    skip_integrations: bool = typer.Option(False, "--skip-integrations", help="Skip the first-run coding CLI integration prompt."),
 ):
     """
     Initialize DevCouncil from a normal terminal in the target repository root.
@@ -43,38 +178,44 @@ def setup(
     if not created:
         console.print(f"[yellow]DevCouncil is already initialized at {root / '.devcouncil'}.[/yellow]")
 
+    if provider:
+        try:
+            _set_model_provider(root, provider)
+        except ValueError as e:
+            console.print(f"[red]{e}[/red]")
+            raise typer.Exit(code=2) from e
+
+    _configure_api_key(root, api_key, skip_api_key)
+
     console.print()
-    render_doctor_check()
+    render_doctor_check(root)
 
     if integrate:
-        console.print()
-        console.print("[bold]Coding CLI integration[/bold]")
-        commands = [
-            ("Codex CLI", _codex_command(root)),
-            ("Gemini CLI", _gemini_command(root, gemini_scope)),
-        ]
-        results = []
-        for tool, command in commands:
-            if apply and not shutil.which(command[0]):
-                console.print(f"[yellow]{tool} CLI not found on PATH. Skipping optional integration.[/yellow]")
-                continue
-            results.append(_configure(tool, command, apply))
-        if apply and any(not ok for ok in results):
-            raise typer.Exit(code=1)
+        _configure_coding_cli_integrations(root, apply=apply, gemini_scope=gemini_scope)
+    elif created and not skip_integrations:
+        _prompt_for_first_run_integrations(root, apply=True, gemini_scope=gemini_scope)
 
     console.print()
     console.print(Panel.fit(
         "\n".join([
             "[bold]Next commands[/bold]",
             f"Keep running DevCouncil commands in this terminal at: {root}",
+            "One-command agent path:",
+            "dev e2e \"Describe the implementation goal\"",
+            "",
+            "Manual sidecar path:",
             "dev plan \"Describe the implementation goal\"",
             "dev tasks",
             "dev run TASK-001 --executor manual",
             "dev prompt TASK-001",
             "Paste only the dev prompt output into your coding CLI.",
+            "Paste only the dev prompt output into your coding CLI, or run directly:",
+            "dev run TASK-001 --executor codex",
+            "dev run TASK-001 --executor gemini",
+            "dev run TASK-001 --executor claude",
             "dev verify TASK-001",
             "",
-            "Use [bold]dev setup --integrate[/bold] to preview coding CLI MCP setup.",
+            "Use [bold]dev setup --integrate[/bold] to preview coding CLI MCP and native hook setup.",
             "Use [bold]dev setup --integrate --apply[/bold] to configure detected clients.",
         ]),
         title="DevCouncil is ready",

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

@@ -1,57 +1,76 @@
-import typer
-from rich.console import Console
-from rich.panel import Panel
-from devcouncil.storage.db import get_db
-from devcouncil.storage.repositories import TaskRepository, RequirementRepository
-
-app = typer.Typer()
-console = Console()
-
-@app.callback(invoke_without_command=True)
-def show(
-    ctx: typer.Context,
-    task_id: str = typer.Argument(..., help="ID of the task to show"),
-):
-    """
-    Show details of a specific task.
-    """
-    if ctx.invoked_subcommand is not None:
-        return
-
-    db = get_db()
-    if not db:
-        console.print("[red]DevCouncil not initialized. Run 'dev init' first.[/red]")
-        raise typer.Exit(code=1)
-
-    with db.get_session() as session:
-        task_repo = TaskRepository(session)
-        req_repo = RequirementRepository(session)
-        
-        task = task_repo.get_by_id(task_id)
-        if not task:
-            console.print(f"[red]Task {task_id} not found.[/red]")
-            raise typer.Exit(code=1)
-        
-        reqs = req_repo.get_all()
-        req_map = {r.id: r for r in reqs}
-
-        output = f"[bold]Status:[/bold] {task.status}\n\n"
-        output += f"[bold]Description:[/bold]\n{task.description}\n\n"
-        
-        output += "[bold]Linked Requirements:[/bold]\n"
-        for req_id in task.requirement_ids:
-            req = req_map.get(req_id)
-            if req:
-                output += f"  - [cyan]{req.id}[/cyan]: {req.title}\n"
-            else:
-                output += f"  - [cyan]{req_id}[/cyan]: (Requirement not found)\n"
-                
-        output += "\n[bold]Planned Files:[/bold]\n"
-        for pf in task.planned_files:
-            output += f"  - {pf.path} ({pf.allowed_change}): {pf.reason}\n"
-            
-        output += "\n[bold]Expected Tests:[/bold]\n"
-        for et in task.expected_tests:
-            output += f"  - {et}\n"
-
-        console.print(Panel(output, title=f"Task {task.id}: {task.title}", expand=False))
+import json
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from devcouncil.cli.commands.init import initialize_project
+from devcouncil.storage.db import get_db
+from devcouncil.storage.repositories import TaskRepository, RequirementRepository
+
+app = typer.Typer()
+console = Console()
+
+@app.callback(invoke_without_command=True)
+def show(
+    ctx: typer.Context,
+    task_id: str = typer.Argument(..., help="ID of the task to 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/."),
+):
+    """
+    Show details of a specific task.
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+
+    root = project_root.expanduser().resolve()
+    initialize_project(root, quiet=True)
+    db = get_db(root)
+    if not db:
+        raise typer.Exit(code=1)
+
+    with db.get_session() as session:
+        task_repo = TaskRepository(session)
+        req_repo = RequirementRepository(session)
+        
+        task = task_repo.get_by_id(task_id)
+        if not task:
+            console.print(f"[red]Task {task_id} not found.[/red]")
+            raise typer.Exit(code=1)
+        
+        reqs = req_repo.get_all()
+        req_map = {r.id: r for r in reqs}
+
+        if json_format:
+            linked_requirements = [
+                req_map[req_id].model_dump()
+                for req_id in task.requirement_ids
+                if req_id in req_map
+            ]
+            typer.echo(json.dumps({
+                "task": task.model_dump(),
+                "linked_requirements": linked_requirements,
+            }, indent=2))
+            return
+
+        output = f"[bold]Status:[/bold] {task.status}\n\n"
+        output += f"[bold]Description:[/bold]\n{task.description}\n\n"
+        
+        output += "[bold]Linked Requirements:[/bold]\n"
+        for req_id in task.requirement_ids:
+            req = req_map.get(req_id)
+            if req:
+                output += f"  - [cyan]{req.id}[/cyan]: {req.title}\n"
+            else:
+                output += f"  - [cyan]{req_id}[/cyan]: (Requirement not found)\n"
+                
+        output += "\n[bold]Planned Files:[/bold]\n"
+        for pf in task.planned_files:
+            output += f"  - {pf.path} ({pf.allowed_change}): {pf.reason}\n"
+            
+        output += "\n[bold]Expected Tests:[/bold]\n"
+        for et in task.expected_tests:
+            output += f"  - {et}\n"
+
+        console.print(Panel(output, title=f"Task {task.id}: {task.title}", expand=False))

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

@@ -1,105 +1,117 @@
-from rich.console import Console
-from rich.table import Table
-from rich.panel import Panel
-from pathlib import Path
-import json
-from devcouncil.storage.db import get_db
-from devcouncil.storage.repositories import ArtifactGraphRepository
-from devcouncil.telemetry.cost import CostEstimator
-
-console = Console()
-
-def status():
-    """
-    Show the current status of the DevCouncil project.
-    """
-    db = get_db()
-    if not db:
-        console.print("[yellow]DevCouncil not initialized in this directory.[/yellow]")
-        console.print("Run [bold]dev init[/bold] to get started.")
-        return
-
-    with db.get_session() as session:
-        graph_repo = ArtifactGraphRepository(session)
-        graph = graph_repo.load_graph()
-        summary = graph.coverage_summary()
-
-        reqs = list(graph.requirements.values())
-        tasks = list(graph.tasks.values())
-        blocking_gaps = graph.blocking_gaps()
-
-        # Determine phase
-        if not reqs and not tasks:
-            phase = "NEW"
-        elif reqs and not tasks:
-            phase = "REQUIREMENTS_DRAFTED"
-        elif blocking_gaps:
-            phase = "TASK_BLOCKED"
-        elif tasks:
-            statuses = {t.status for t in tasks}
-            if "running" in statuses:
-                phase = "TASK_EXECUTING"
-            elif "blocked" in statuses:
-                phase = "TASK_BLOCKED"
-            elif all(s in ("verified", "done") for s in statuses):
-                phase = "PROJECT_DONE"
-            else:
-                phase = "PLAN_APPROVED"
-        else:
-            phase = "NEW"
-
-        # Phase color
-        phase_colors = {
-            "NEW": "yellow",
-            "REQUIREMENTS_DRAFTED": "cyan",
-            "PLAN_APPROVED": "green",
-            "TASK_EXECUTING": "blue",
-            "TASK_BLOCKED": "red",
-            "PROJECT_DONE": "green bold",
-        }
-        phase_color = phase_colors.get(phase, "white")
-
-        # Calculate cost
-        total_cost = 0.0
-        log_file = Path(".devcouncil/logs/model_calls.jsonl")
-        if log_file.exists():
-            with open(log_file, "r", encoding="utf-8") as f:
-                for line in f:
-                    try:
-                        entry = json.loads(line)
-                        total_cost += CostEstimator.estimate_cost(
-                            entry.get("response", {}).get("model", ""),
-                            entry.get("usage", {})
-                        )
-                    except Exception:
-                        continue
-
-        console.print(Panel(
-            f"[bold]Phase:[/bold] [{phase_color}]{phase}[/{phase_color}]\n"
-            f"[bold]Requirements:[/bold] {summary['total_requirements']} ({summary['requirements_without_tasks']} unmapped)\n"
-            f"[bold]Tasks:[/bold] {summary['total_tasks']} ({summary['tasks_without_requirements']} orphaned)\n"
-            f"[bold]Acceptance Criteria:[/bold] {summary['total_ac']} ({summary['ac_without_evidence']} unverified)\n"
-            f"[bold]Gaps:[/bold] {summary['total_gaps']} ({summary['blocking_gaps']} blocking)\n"
-            f"[bold]Total Cost:[/bold] ${total_cost:.4f}",
-            title="DevCouncil Status",
-            expand=False,
-        ))
-
-        if tasks:
-            table = Table(title="Task Summary")
-            table.add_column("Status", style="magenta")
-            table.add_column("Count", justify="right")
-
-            status_counts: dict[str, int] = {}
-            for t in tasks:
-                status_counts[t.status] = status_counts.get(t.status, 0) + 1
-            for s, count in sorted(status_counts.items()):
-                table.add_row(s, str(count))
-            console.print(table)
-
-        if blocking_gaps:
-            console.print(f"\n[red bold]WARNING: {len(blocking_gaps)} blocking gap(s) must be resolved:[/red bold]")
-            for g in blocking_gaps[:5]:
-                console.print(f"  - [red]{g.id}[/red]: {g.description[:80]}")
-            if len(blocking_gaps) > 5:
-                console.print(f"  ... and {len(blocking_gaps) - 5} more. Run [bold]dev report[/bold] for details.")
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from pathlib import Path
+import json
+import typer
+from devcouncil.cli.commands.init import initialize_project
+from devcouncil.app.project_status import compute_phase
+from devcouncil.storage.db import get_db
+from devcouncil.storage.repositories import ArtifactGraphRepository, StateRepository
+from devcouncil.telemetry.cost import CostEstimator
+from devcouncil.live.summary import live_review_summary
+
+console = Console()
+
+def _status_payload(project_root: Path) -> dict:
+    initialize_project(project_root, quiet=True)
+    db = get_db(project_root)
+    if not db:
+        return {"initialized": False, "phase": "UNINITIALIZED"}
+
+    with db.get_session() as session:
+        graph_repo = ArtifactGraphRepository(session)
+        graph = graph_repo.load_graph()
+        summary = graph.coverage_summary()
+
+        blocking_gaps = graph.blocking_gaps()
+        state = StateRepository(session).get_state()
+        phase = compute_phase(graph, state.current_phase if state else None)
+
+        total_cost = 0.0
+        log_file = project_root / ".devcouncil" / "logs" / "model_calls.jsonl"
+        if log_file.exists():
+            with open(log_file, "r", encoding="utf-8") as f:
+                for line in f:
+                    try:
+                        entry = json.loads(line)
+                        total_cost += CostEstimator.estimate_cost(
+                            entry.get("response", {}).get("model", ""),
+                            entry.get("usage", {}),
+                        )
+                    except Exception:
+                        continue
+
+        status_counts: dict[str, int] = {}
+        for task in graph.tasks.values():
+            status_counts[task.status] = status_counts.get(task.status, 0) + 1
+
+        return {
+            "initialized": True,
+            "phase": phase,
+            "coverage_summary": summary,
+            "total_cost": total_cost,
+            "task_status_counts": status_counts,
+            "blocking_gaps": [gap.model_dump() for gap in blocking_gaps],
+            "live_review": live_review_summary(project_root),
+        }
+
+
+def status(
+    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/."),
+):
+    """
+    Show the current status of the DevCouncil project.
+    """
+    root = project_root.expanduser().resolve()
+    payload = _status_payload(root)
+    if json_format:
+        typer.echo(json.dumps(payload, indent=2))
+        return
+
+    if not payload["initialized"]:
+        console.print("[yellow]DevCouncil state is not available in this directory.[/yellow]")
+        return
+
+    summary = payload["coverage_summary"]
+    phase = payload["phase"]
+    phase_colors = {
+        "NEW": "yellow",
+        "REQUIREMENTS_DRAFTED": "cyan",
+        "PLAN_APPROVED": "green",
+        "TASK_EXECUTING": "blue",
+        "TASK_BLOCKED": "red",
+        "PROJECT_DONE": "green bold",
+    }
+    phase_color = phase_colors.get(phase, "white")
+
+    console.print(Panel(
+        f"[bold]Phase:[/bold] [{phase_color}]{phase}[/{phase_color}]\n"
+        f"[bold]Requirements:[/bold] {summary['total_requirements']} ({summary['requirements_without_tasks']} unmapped)\n"
+        f"[bold]Tasks:[/bold] {summary['total_tasks']} ({summary['tasks_without_requirements']} orphaned)\n"
+        f"[bold]Acceptance Criteria:[/bold] {summary['total_ac']} ({summary['ac_without_evidence']} unverified)\n"
+        f"[bold]Gaps:[/bold] {summary['total_gaps']} ({summary['blocking_gaps']} blocking)\n"
+        f"[bold]Live Review:[/bold] {payload['live_review']['cards']['critical_open']} open critical, "
+        f"{len(payload['live_review']['blocking_cards'])} blocking in scope, "
+        f"{payload['live_review']['pending_signals']} pending signal(s)\n"
+        f"[bold]Total Cost:[/bold] ${payload['total_cost']:.4f}",
+        title="DevCouncil Status",
+        expand=False,
+    ))
+
+    if payload["task_status_counts"]:
+        table = Table(title="Task Summary")
+        table.add_column("Status", style="magenta")
+        table.add_column("Count", justify="right")
+        for state, count in sorted(payload["task_status_counts"].items()):
+            table.add_row(state, str(count))
+        console.print(table)
+
+    blocking_gaps = payload["blocking_gaps"]
+    if blocking_gaps:
+        console.print(f"\n[red bold]WARNING: {len(blocking_gaps)} blocking gap(s) must be resolved:[/red bold]")
+        for gap in blocking_gaps[:5]:
+            console.print(f"  - [red]{gap['id']}[/red]: {gap['description'][:80]}")
+        if len(blocking_gaps) > 5:
+            console.print(f"  ... and {len(blocking_gaps) - 5} more. Run [bold]dev report[/bold] for details.")