devcouncil 0.1.0 → 0.1.1

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

@@ -0,0 +1,237 @@
+import asyncio
+from pathlib import Path
+from types import SimpleNamespace
+
+import typer
+from rich.console import Console
+
+from devcouncil.cli.commands import plan as plan_command
+from devcouncil.cli.commands import report as report_command
+from devcouncil.cli.commands import run as run_command
+from devcouncil.app.config import load_config
+from devcouncil.cli.commands.init import initialize_project
+from devcouncil.storage.db import get_db
+from devcouncil.storage.repositories import ArtifactGraphRepository, StateRepository, TaskRepository
+from devcouncil.app.state_machine import ProjectPhase
+from devcouncil.live.summary import live_review_summary
+from devcouncil.reporting.report_builder import ReportBuilder
+
+
+console = Console()
+
+SUPPORTED_EXECUTORS = {
+    "codex",
+    "codex-cli",
+    "gemini",
+    "gemini-cli",
+    "claude",
+    "claude-code",
+    "claude-cli",
+    "native",
+    "mini",
+    "openhands",
+}
+
+AGENT_REPORT_FILE = Path(".devcouncil/reports/latest.json")
+
+
+def _normalize_executor(executor: str) -> str:
+    return executor.strip().lower().replace("_", "-")
+
+
+def _configured_executor(root: Path) -> str:
+    try:
+        configured = load_config(root).execution.default_executor
+    except FileNotFoundError:
+        configured = "codex"
+    return _normalize_executor(configured or "codex")
+
+
+def _load_tasks(root: Path):
+    db = get_db(root)
+    if not db:
+        return []
+    with db.get_session() as session:
+        return TaskRepository(session).get_all()
+
+
+def _load_tasks_by_id(root: Path, task_ids: list[str]):
+    db = get_db(root)
+    if not db:
+        return [], task_ids
+    with db.get_session() as session:
+        repo = TaskRepository(session)
+        tasks = []
+        missing = []
+        for task_id in task_ids:
+            task = repo.get_by_id(task_id)
+            if task is None:
+                missing.append(task_id)
+            else:
+                tasks.append(task)
+        return tasks, missing
+
+
+def _unique_task_ids(task_ids: list[str]) -> list[str]:
+    seen = set()
+    unique = []
+    for task_id in task_ids:
+        if task_id in seen:
+            continue
+        seen.add(task_id)
+        unique.append(task_id)
+    return unique
+
+
+def _record_project_done(root: Path) -> None:
+    db = get_db(root)
+    if not db:
+        return
+    with db.get_session() as session:
+        StateRepository(session).record_phase(ProjectPhase.PROJECT_DONE.value)
+
+
+def _record_project_blocked(root: Path) -> None:
+    db = get_db(root)
+    if not db:
+        return
+    with db.get_session() as session:
+        StateRepository(session).record_phase(ProjectPhase.TASK_BLOCKED.value)
+
+
+def _render_final_report(root: Path, json_report: bool) -> str:
+    db = get_db(root)
+    if not db:
+        raise RuntimeError("DevCouncil state is unavailable in this directory.")
+    with db.get_session() as session:
+        graph = ArtifactGraphRepository(session).load_graph()
+    live_review = live_review_summary(root)
+    if json_report:
+        return ReportBuilder.build_json(graph, live_review=live_review)
+    return ReportBuilder.build_markdown(graph, live_review=live_review)
+
+
+def _write_report_file(root: Path, report_file: Path, content: str) -> Path:
+    path = report_file.expanduser()
+    if not path.is_absolute():
+        path = root / path
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content, encoding="utf-8")
+    return path
+
+
+def _command_label(ctx: typer.Context) -> str:
+    command = ctx.info_name or "e2e"
+    return f"dev {command}"
+
+
+def go(
+    ctx: typer.Context,
+    goal: str = typer.Argument(..., help="Implementation goal to plan, execute, verify, and report."),
+    executor: str | None = typer.Option(
+        None,
+        "--executor",
+        "-e",
+        help="Automated executor to use. Defaults to execution.default_executor in .devcouncil/config.yaml.",
+    ),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Use mock planning responses for local smoke testing."),
+    continue_on_blocked: bool = typer.Option(
+        False,
+        "--continue-on-blocked",
+        help="Continue later tasks even if an earlier task is blocked by verification.",
+    ),
+    json_report: bool = typer.Option(False, "--json-report", "--json", help="Print the final report as JSON."),
+    report_file: Path | None = typer.Option(
+        None,
+        "--report-file",
+        help="Write the final report to a file. Relative paths resolve from --project-root.",
+    ),
+    agent: bool = typer.Option(
+        False,
+        "--agent",
+        help="Use coding-agent defaults: JSON report plus .devcouncil/reports/latest.json.",
+    ),
+    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
+):
+    """
+    Run the full DevCouncil loop in one command.
+    """
+    root = project_root.expanduser().resolve()
+    initialize_project(root, quiet=True)
+    if agent:
+        json_report = True
+        if report_file is None:
+            report_file = AGENT_REPORT_FILE
+
+    normalized_executor = _normalize_executor(executor) if executor else _configured_executor(root)
+    command_label = _command_label(ctx)
+    if normalized_executor == "manual":
+        console.print(
+            f"[red]`{command_label}` requires an automated executor. "
+            "Use `dev run TASK-ID --executor manual` for handoff mode.[/red]"
+        )
+        raise typer.Exit(code=2)
+    if normalized_executor not in SUPPORTED_EXECUTORS:
+        console.print(
+            f"[red]Unsupported executor for `{command_label}`: "
+            f"{normalized_executor}. Supported: {', '.join(sorted(SUPPORTED_EXECUTORS))}.[/red]"
+        )
+        raise typer.Exit(code=2)
+
+    console.print(f"[bold]Planning goal:[/bold] {goal}")
+    planned_task_ids = asyncio.run(plan_command.run_plan_flow(goal, dry_run=dry_run, persist=True, project_root=root))
+
+    task_ids = _unique_task_ids(planned_task_ids or [])
+    tasks, missing_task_ids = _load_tasks_by_id(root, task_ids)
+    if missing_task_ids:
+        console.print(f"[red]Planning returned task IDs that were not persisted: {', '.join(missing_task_ids)}[/red]")
+        raise typer.Exit(code=1)
+    if not tasks:
+        console.print("[red]Planning did not produce any approved tasks.[/red]")
+        raise typer.Exit(code=1)
+
+    failed: list[str] = []
+    executed_task_ids: list[str] = []
+    for task in tasks:
+        if task.status in {"verified", "done"}:
+            console.print(f"[green]Skipping {task.id}; already {task.status}.[/green]")
+            continue
+
+        console.print(f"\n[bold]Executing {task.id}[/bold] with [bold]{normalized_executor}[/bold]...")
+        executed_task_ids.append(task.id)
+        run_command.run(task.id, executor=normalized_executor, project_root=root)
+
+        latest = {item.id: item for item in _load_tasks(root)}.get(task.id)
+        latest_status = latest.status if latest else "missing"
+        if latest_status not in {"verified", "done"}:
+            failed.append(f"{task.id} ({latest_status})")
+            if latest_status != "blocked" or not continue_on_blocked:
+                console.print(f"[red]Stopping because {task.id} ended as {latest_status}.[/red]")
+                break
+
+    if not executed_task_ids:
+        failed.append("all planned tasks were already completed before execution")
+
+    if not failed:
+        _record_project_done(root)
+    else:
+        _record_project_blocked(root)
+
+    console.print("\n[bold]Final DevCouncil report[/bold]")
+    report_command.report(
+        SimpleNamespace(invoked_subcommand=None),
+        planning_only=False,
+        json_format=json_report,
+        github=False,
+        github_pr_comment=False,
+        gitlab_pr_comment=False,
+        project_root=root,
+    )
+    if report_file is not None:
+        output = _render_final_report(root, json_report=json_report)
+        written = _write_report_file(root, report_file, output)
+        console.print(f"[green]Final report written to {written}[/green]")
+
+    if failed:
+        console.print(f"\n[red]Unfinished task(s): {', '.join(failed)}[/red]")
+        raise typer.Exit(code=1)

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

@@ -7,21 +7,55 @@ from rich.console import Console
 from devcouncil.storage.db import get_db
 from devcouncil.storage.repositories import TaskRepository
 from devcouncil.execution.hook_policy import HookPolicy
+from devcouncil.telemetry.traces import TraceLogger
+from devcouncil.live.signals import write_signal
+from devcouncil.live.tasks import active_task_id
 
 app = typer.Typer()
 console = Console()
 
 
-def _project_root() -> Path:
+def _project_root(project_root: Path | None = None) -> Path:
+    if project_root:
+        return project_root.expanduser().resolve()
     configured = os.environ.get("DEVCOUNCIL_PROJECT_ROOT")
     return Path(configured).expanduser().resolve() if configured else Path(".").resolve()
-
+
+
+def _active_task(root: Path):
+    db = get_db(root)
+    if not db:
+        return None
+    with db.get_session() as session:
+        task_repo = TaskRepository(session)
+        running_tasks = [t for t in task_repo.get_all() if t.status == "running"]
+        return running_tasks[0] if running_tasks else None
+
+
+def _emit_decision(client: str, action: str, reason: str) -> None:
+    if action == "deny":
+        print(reason, file=sys.stderr)
+        raise typer.Exit(code=2)
+
+    if client in {"codex", "gemini"}:
+        payload = {"decision": "allow", "reason": reason, "suppressOutput": True}
+        if action == "warn":
+            payload["systemMessage"] = f"DevCouncil Warning: {reason}"
+        print(json.dumps(payload, separators=(",", ":")))
+        return
+
+    if action == "warn":
+        console.print(f"[yellow]DevCouncil Warning:[/yellow] {reason}")
+
+
 @app.command()
 def pre_tool_use(
-    tool_call_json: str | None = typer.Argument(None, help="The JSON string of the tool call from Claude Code")
+    tool_call_json: str | None = typer.Argument(None, help="The JSON string of the tool call from the coding CLI."),
+    client: str = typer.Option("claude", "--client", help="Hook client: claude, codex, gemini, cursor, or generic."),
+    project_root: Path | None = typer.Option(None, "--project-root", help="Repository root containing .devcouncil/."),
 ):
-    """
-    Claude Code hook: Inspects a tool call before execution.
+    """
+    Coding CLI hook: Inspects a tool call before execution.
     Exits with code 2 to block unauthorized file writes.
     """
     try:
@@ -30,32 +64,65 @@ def pre_tool_use(
         if not tool_call_json.strip():
             raise typer.Exit(code=0)
         call_data = json.loads(tool_call_json)
-        active_task = None
-        root = _project_root()
-        db = get_db(root)
-        if db:
-            with db.get_session() as session:
-                task_repo = TaskRepository(session)
-                running_tasks = [t for t in task_repo.get_all() if t.status == "running"]
-                active_task = running_tasks[0] if running_tasks else None
+        normalized_client = client.lower()
+        root = _project_root(project_root)
+        active_task = _active_task(root)
 
         decision = HookPolicy(project_root=root).evaluate(call_data, active_task)
-        if decision.action == "deny":
-            console.print(f"[red]DevCouncil Blocked Action:[/red] {decision.reason}")
-            sys.exit(2)
-        if decision.action == "warn":
-            console.print(f"[yellow]DevCouncil Warning:[/yellow] {decision.reason}")
+        _emit_decision(normalized_client, decision.action, decision.reason)
                 
     except json.JSONDecodeError:
         raise typer.Exit(code=0)
-
-@app.command()
-def post_task():
-    """
-    Claude Code hook: Runs after a task is completed.
-    Triggers deterministic verification.
-    """
-    console.print("[cyan]DevCouncil: Claude finished task. Triggering automatic verification...[/cyan]")
-    # In a real environment, this would invoke 'dev verify <active-task>'
-    # For the hook script, we just notify the user.
-    console.print("Run [bold]dev verify[/bold] to finalize implementation evidence.")
+
+@app.command()
+def post_tool_use(
+    tool_call_json: str | None = typer.Argument(None, help="The JSON string of the completed tool call."),
+    client: str = typer.Option("claude", "--client", help="Hook client: claude, codex, gemini, cursor, or generic."),
+    project_root: Path | None = typer.Option(None, "--project-root", help="Repository root containing .devcouncil/."),
+):
+    """
+    Coding CLI hook: Records a post-tool-use checkpoint for native hook clients.
+    """
+    _ = tool_call_json if tool_call_json is not None else sys.stdin.read()
+    _ = _project_root(project_root)
+    if client.lower() in {"codex", "gemini"}:
+        print(json.dumps({"decision": "allow", "suppressOutput": True}, separators=(",", ":")))
+
+@app.command()
+def agent_response(
+    event_json: str | None = typer.Argument(None, help="The JSON hook payload from the coding CLI."),
+    client: str = typer.Option("claude", "--client", help="Hook client: claude, codex, gemini, cursor, or generic."),
+    project_root: Path | None = typer.Option(None, "--project-root", help="Repository root containing .devcouncil/."),
+):
+    """
+    Coding CLI hook: records that an agent response is ready for DevCouncil watch review.
+    """
+    payload_text = event_json if event_json is not None else sys.stdin.read()
+    root = _project_root(project_root)
+    try:
+        payload = json.loads(payload_text) if payload_text.strip() else {}
+    except json.JSONDecodeError:
+        payload = {"raw": payload_text}
+    if isinstance(payload, dict) and not any(key in payload for key in ("task_id", "taskId", "task")):
+        active_id = active_task_id(root)
+        if active_id:
+            payload["task_id"] = active_id
+    signal_path = write_signal(root, client.lower(), payload)
+    TraceLogger(root).log_event(
+        "agent_response_ready",
+        {"client": client.lower(), "signal": str(signal_path)},
+        summary=f"{client} response ready for critique-card review.",
+    )
+    if client.lower() in {"codex", "gemini"}:
+        print(json.dumps({"decision": "allow", "suppressOutput": True}, separators=(",", ":")))
+
+@app.command()
+def post_task():
+    """
+    Coding CLI hook: Runs after a task is completed.
+    Triggers deterministic verification.
+    """
+    console.print("[cyan]DevCouncil: coding agent finished task. Triggering automatic verification...[/cyan]")
+    # In a real environment, this would invoke 'dev verify <active-task>'
+    # For the hook script, we just notify the user.
+    console.print("Run [bold]dev verify[/bold] to finalize implementation evidence.")

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

@@ -1,52 +1,54 @@
-import copy
-import typer
-import yaml
-from rich.console import Console
-from pathlib import Path
-from devcouncil.storage.db import Database
-from devcouncil.integrations.gitnexus import GitNexusIntegration
-from devcouncil.integrations.graphify import GraphifyIntegration
-
-app = typer.Typer()
-console = Console()
-
+import copy
+import typer
+import yaml
+from rich.console import Console
+from pathlib import Path
+from devcouncil.storage.db import Database
+from devcouncil.integrations.gitnexus import GitNexusIntegration
+from devcouncil.integrations.graphify import GraphifyIntegration
+
+app = typer.Typer()
+console = Console()
+
 DEFAULT_CONFIG = {
-    "project": {
-        "name": "devcouncil-project",
-        "root": ".",
-        "default_branch": "main",
-    },
-    "models": {
-        "provider": "openrouter",
-        "roles": {
-            "spec_writer": {"model": "anthropic/claude-3.5-sonnet"},
-            "planner_a": {"model": "anthropic/claude-3.5-sonnet"},
-            "planner_b": {"model": "google/gemini-pro-1.5"},
-            "critic_a": {"model": "openai/gpt-4o"},
-            "critic_b": {"model": "anthropic/claude-3-opus"},
-            "arbiter": {"model": "openai/gpt-4o"},
-            "native_agent": {"model": "anthropic/claude-3.5-sonnet"},
-            "implementation_reviewer": {"model": "openai/gpt-4o"},
-        }
-    },
-    "commands": {
-        "test": ["pytest", "npm test"],
-        "lint": ["flake8", "eslint"],
-        "typecheck": ["mypy", "tsc"]
-    },
-    "gates": {
-        "require_clean_git_before_task": True,
-        "block_orphan_diffs": True,
-        "block_missing_tests_for_high_requirements": True,
-        "block_dependency_changes_without_approval": True,
-        "block_schema_change_without_migration": True,
-        "block_failed_commands": True
-    },
-    "execution": {
-        "default_executor": "native",
-        "max_repair_attempts": 3,
-        "checkpoint_before_each_task": True
-    },
+    "project": {
+        "name": "devcouncil-project",
+        "root": ".",
+        "default_branch": "main",
+    },
+    "models": {
+        "provider": "openrouter",
+        "roles": {
+            "spec_writer": {"model": "anthropic/claude-3.5-sonnet"},
+            "prompt_enhancer": {"model": "anthropic/claude-3.5-sonnet"},
+            "planner_a": {"model": "anthropic/claude-3.5-sonnet"},
+            "planner_b": {"model": "google/gemini-pro-1.5"},
+            "critic_a": {"model": "openai/gpt-4o"},
+            "critic_b": {"model": "anthropic/claude-3-opus"},
+            "arbiter": {"model": "openai/gpt-4o"},
+            "native_agent": {"model": "anthropic/claude-3.5-sonnet"},
+            "implementation_reviewer": {"model": "openai/gpt-4o"},
+            "live_reviewer": {"model": "openai/gpt-4o"},
+        }
+    },
+    "commands": {
+        "test": ["pytest", "npm test"],
+        "lint": ["flake8", "eslint"],
+        "typecheck": ["mypy", "tsc"]
+    },
+    "gates": {
+        "require_clean_git_before_task": True,
+        "block_orphan_diffs": True,
+        "block_missing_tests_for_high_requirements": True,
+        "block_dependency_changes_without_approval": True,
+        "block_schema_change_without_migration": True,
+        "block_failed_commands": True
+    },
+    "execution": {
+        "default_executor": "native",
+        "max_repair_attempts": 3,
+        "checkpoint_before_each_task": True
+    },
     "privacy": {
         "redact_env_vars": True,
         "redact_secrets_in_logs": True,
@@ -63,6 +65,12 @@ DEFAULT_CONFIG = {
             "command": "code-review-graph",
             "optional": True,
         },
+        "live_review": {
+            "enabled": True,
+            "cards_path": ".devcouncil/live/cards",
+            "signals_path": ".devcouncil/live/signals",
+            "default_client": "claude",
+        },
     }
 }
 
@@ -72,6 +80,7 @@ def initialize_project(
     project_name: str | None = None,
     with_gitnexus: bool = False,
     with_graphify: bool = False,
+    quiet: bool = False,
 ) -> bool:
     """Initialize DevCouncil project state.
 
@@ -82,7 +91,8 @@ def initialize_project(
     created = False
 
     if not dev_dir.exists():
-        console.print("Initializing DevCouncil...")
+        if not quiet:
+            console.print("Initializing DevCouncil...")
         dev_dir.mkdir(exist_ok=True)
         (dev_dir / "runs").mkdir(exist_ok=True)
         (dev_dir / "cache").mkdir(exist_ok=True)
@@ -101,7 +111,8 @@ def initialize_project(
 
         db = Database(dev_dir / "state.sqlite")
         db.create_db_and_tables()
-        console.print(f"[green]Successfully initialized DevCouncil in {dev_dir}[/green]")
+        if not quiet:
+            console.print(f"[green]Successfully initialized DevCouncil in {dev_dir}[/green]")
         created = True
 
     if with_gitnexus:
@@ -117,12 +128,12 @@ def initialize_project(
 
 @app.callback(invoke_without_command=True)
 def init(
-    ctx: typer.Context,
-    project_name: str = typer.Option(None, "--name", "-n", help="Project name"),
-    with_gitnexus: bool = typer.Option(False, "--gitnexus", help="Initialize GitNexus structural awareness"),
-    with_graphify: bool = typer.Option(False, "--graphify", help="Initialize Graphify knowledge graph engine"),
-):
-    """
+    ctx: typer.Context,
+    project_name: str = typer.Option(None, "--name", "-n", help="Project name"),
+    with_gitnexus: bool = typer.Option(False, "--gitnexus", help="Initialize GitNexus structural awareness"),
+    with_graphify: bool = typer.Option(False, "--graphify", help="Initialize Graphify knowledge graph engine"),
+):
+    """
     Initialize DevCouncil in the current directory.
     """
     if ctx.invoked_subcommand is not None: