devcouncil 0.1.1 → 0.2.1

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

@@ -1,237 +0,0 @@
-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

@@ -1,128 +0,0 @@
-import typer
-import json
-import os
-import sys
-from pathlib import Path
-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(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 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: Inspects a tool call before execution.
-    Exits with code 2 to block unauthorized file writes.
-    """
-    try:
-        if tool_call_json is None:
-            tool_call_json = sys.stdin.read()
-        if not tool_call_json.strip():
-            raise typer.Exit(code=0)
-        call_data = json.loads(tool_call_json)
-        normalized_client = client.lower()
-        root = _project_root(project_root)
-        active_task = _active_task(root)
-
-        decision = HookPolicy(project_root=root).evaluate(call_data, active_task)
-        _emit_decision(normalized_client, decision.action, decision.reason)
-                
-    except json.JSONDecodeError:
-        raise typer.Exit(code=0)
-
-@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,153 +0,0 @@
-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"},
-            "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,
-        "store_prompts_locally": True
-    },
-    "integrations": {
-        "agent_flow": {
-            "enabled": False,
-            "trace_path": ".devcouncil/logs/traces.jsonl",
-            "mode": "jsonl",
-        },
-        "code_review_graph": {
-            "enabled": False,
-            "command": "code-review-graph",
-            "optional": True,
-        },
-        "live_review": {
-            "enabled": True,
-            "cards_path": ".devcouncil/live/cards",
-            "signals_path": ".devcouncil/live/signals",
-            "default_client": "claude",
-        },
-    }
-}
-
-
-def initialize_project(
-    project_root: Path = Path("."),
-    project_name: str | None = None,
-    with_gitnexus: bool = False,
-    with_graphify: bool = False,
-    quiet: bool = False,
-) -> bool:
-    """Initialize DevCouncil project state.
-
-    Returns True when a fresh .devcouncil directory was created.
-    """
-    project_root = project_root.resolve()
-    dev_dir = project_root / ".devcouncil"
-    created = False
-
-    if not dev_dir.exists():
-        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)
-        (dev_dir / "checkpoints").mkdir(exist_ok=True)
-        (dev_dir / "logs").mkdir(exist_ok=True)
-
-        config_path = dev_dir / "config.yaml"
-        config = copy.deepcopy(DEFAULT_CONFIG)
-        if project_name:
-            config["project"]["name"] = project_name
-        else:
-            config["project"]["name"] = project_root.name
-
-        with open(config_path, "w") as f:
-            yaml.dump(config, f, default_flow_style=False)
-
-        db = Database(dev_dir / "state.sqlite")
-        db.create_db_and_tables()
-        if not quiet:
-            console.print(f"[green]Successfully initialized DevCouncil in {dev_dir}[/green]")
-        created = True
-
-    if with_gitnexus:
-        nexus = GitNexusIntegration(project_root)
-        nexus.initialize()
-
-    if with_graphify:
-        graphify = GraphifyIntegration(project_root)
-        graphify.initialize()
-
-    return created
-
-
-@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"),
-):
-    """
-    Initialize DevCouncil in the current directory.
-    """
-    if ctx.invoked_subcommand is not None:
-        return
-
-    dev_dir = Path(".devcouncil")
-    if dev_dir.exists() and not (with_gitnexus or with_graphify):
-        console.print("[yellow]DevCouncil is already initialized in this directory.[/yellow]")
-        console.print("Use --gitnexus or --graphify to add upgrade paths.")
-        raise typer.Exit()
-
-    initialize_project(
-        Path("."),
-        project_name=project_name,
-        with_gitnexus=with_gitnexus,
-        with_graphify=with_graphify,
-    )