devcouncil 0.2.0 → 0.2.1

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

@@ -1,69 +0,0 @@
-import json
-from typing import NoReturn
-
-import typer
-from pathlib import Path
-from rich.console import Console
-
-from devcouncil.cli.commands.init import initialize_project
-from devcouncil.execution.handoff import HandoffService
-from devcouncil.executors.agent_registry import load_cli_agent_specs, normalize_agent_name
-
-console = Console()
-
-
-def handoff(
-    task_id: str = typer.Argument(...),
-    from_agent: str = typer.Option(..., "--from"),
-    to_agent: str = typer.Option(..., "--to"),
-    instruction: str = typer.Option("", "--instruction"),
-    json_format: bool = typer.Option(False, "--json", help="Output machine-readable JSON the agent can chain on."),
-    project_root: Path = typer.Option(Path("."), "--project-root"),
-):
-    """
-    Hand off a task between coding CLI agents.
-    """
-    def _fail(message: str) -> NoReturn:
-        if json_format:
-            typer.echo(json.dumps({"ok": False, "task_id": task_id, "error": message}, indent=2))
-        else:
-            console.print(f"[red]{message}[/red]")
-        raise typer.Exit(code=1)
-
-    root = project_root.expanduser().resolve()
-    initialize_project(root, quiet=True)
-    specs = load_cli_agent_specs(root)
-    from_name = normalize_agent_name(from_agent)
-    to_name = normalize_agent_name(to_agent)
-    if from_name not in specs or to_name not in specs:
-        _fail("Unknown agent name. Use dev agents list.")
-
-    try:
-        manifest, path, run_id = HandoffService(root).create(
-            task_id,
-            from_name,
-            to_name,
-            instruction=instruction,
-        )
-    except ValueError as exc:
-        _fail(str(exc))
-
-    next_command = f"dev run {task_id} --executor {to_name}"
-    if json_format:
-        typer.echo(json.dumps({
-            "ok": True,
-            "task_id": task_id,
-            "from": from_name,
-            "to": to_name,
-            "manifest_path": str(path),
-            "run_id": run_id,
-            "next_command": next_command,
-        }, indent=2))
-        return
-
-    console.print(f"[green]Handoff manifest:[/green] {path}")
-    console.print(f"[cyan]Next:[/cyan] {next_command}")
-    console.print(f"[dim]Run artifacts: .devcouncil/runs/{run_id}[/dim]")
-    if instruction:
-        console.print(f"[dim]Instruction: {instruction}[/dim]")
-    _ = manifest

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

@@ -1,237 +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):
-    # Resolve the *single* unambiguous running task. active_task_id returns None when
-    # zero or multiple tasks are running, so we never authorize a write against the
-    # wrong task; the policy engine then denies for task=None (fail-closed).
-    active_id = active_task_id(root)
-    if not active_id:
-        return None
-    db = get_db(root)
-    if not db:
-        return None
-    with db.get_session() as session:
-        return TaskRepository(session).get_by_id(active_id)
-
-
-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}")
-
-
-def _emit_unevaluable(client: str, reason: str, strict: bool, *, action: str = "warn") -> None:
-    """Decide what to do when a tool call cannot be evaluated (empty/malformed/error).
-
-    Fail-closed in strict mode (block), otherwise surface a warning but allow — and
-    never leak an undefined exit code, which would silently disable the only pre-action
-    gate."""
-    _emit_decision(client, "deny" if strict else action, f"{reason}{' (strict mode: blocking)' if strict else ''}")
-
-
-@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/."),
-    strict: bool = typer.Option(
-        False,
-        "--strict",
-        envvar="DEVCOUNCIL_HOOK_STRICT",
-        help="Fail closed (block) when a tool call cannot be parsed or evaluated.",
-    ),
-):
-    """
-    Coding CLI hook: Inspects a tool call before execution.
-    Exits with code 2 to block unauthorized file writes.
-    """
-    normalized_client = client.lower()
-    try:
-        if tool_call_json is None:
-            tool_call_json = sys.stdin.read()
-        # Empty payload: nothing to evaluate. Benign in normal use, so allow — but make
-        # it observable, and block under --strict.
-        if not tool_call_json.strip():
-            return _emit_unevaluable(normalized_client, "Empty tool-call payload; nothing to evaluate.", strict, action="allow")
-        try:
-            call_data = json.loads(tool_call_json)
-        except json.JSONDecodeError:
-            # A real tool call we cannot parse must not silently pass the gate.
-            return _emit_unevaluable(normalized_client, "Tool-call payload was not valid JSON; could not enforce policy.", strict)
-        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 typer.Exit:
-        raise
-    except Exception as exc:  # never emit an undefined exit code from a crashing hook
-        return _emit_unevaluable(normalized_client, f"Hook error: {exc}", strict)
-
-@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(
-    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: Runs after a task is completed.
-
-    When ``execution.verify_on_post_task`` is enabled, this runs deterministic
-    verification of the active task and records gaps; otherwise it just reminds the
-    user to run ``dev verify`` (the default, to keep hooks fast/cheap).
-    """
-    root = _project_root(project_root)
-    try:
-        from devcouncil.app.config import load_config
-        verify_enabled = load_config(root).execution.verify_on_post_task
-    except Exception:
-        verify_enabled = False
-
-    if not verify_enabled:
-        console.print("[cyan]DevCouncil: coding agent finished task.[/cyan]")
-        console.print("Run [bold]dev verify[/bold] to finalize implementation evidence.")
-        _emit_post_task_allow(client)
-        return
-
-    summary = _verify_active_task(root)
-    console.print(summary)
-    _emit_post_task_allow(client)
-
-
-def _emit_post_task_allow(client: str) -> None:
-    if client.lower() in {"codex", "gemini"}:
-        print(json.dumps({"decision": "allow", "suppressOutput": True}, separators=(",", ":")))
-
-
-def _verify_active_task(root: Path) -> str:
-    """Run deterministic verification of the active task and persist gaps/evidence.
-    Returns a human summary line. Best-effort: never raises out of a hook."""
-    try:
-        import asyncio
-
-        from devcouncil.domain.evidence import CommandResult, DiffCoverageEvidence, DiffEvidence, TestEvidence
-        from devcouncil.storage.repositories import (
-            EvidenceRepository,
-            GapRepository,
-            RequirementRepository,
-        )
-        from devcouncil.verification.next_actions import split_next_actions
-        from devcouncil.verification.verifier import Verifier
-
-        active_id = active_task_id(root)
-        db = get_db(root)
-        if not active_id or not db:
-            return "Run [bold]dev verify[/bold] to finalize implementation evidence."
-        with db.get_session() as session:
-            task = TaskRepository(session).get_by_id(active_id)
-            if not task:
-                return "Run [bold]dev verify[/bold] to finalize implementation evidence."
-            reqs = RequirementRepository(session).get_all()
-            gaps, evidence = asyncio.run(Verifier(root).verify_task(task, reqs))
-            gap_repo = GapRepository(session)
-            ev_repo = EvidenceRepository(session)
-            gap_repo.delete_for_task(task.id)
-            ev_repo.delete_for_task(task.id)
-            for gap in gaps:
-                gap_repo.save(gap)
-            for ev in evidence:
-                if isinstance(ev, CommandResult):
-                    ev_repo.save_command_result(task.id, ev)
-                elif isinstance(ev, DiffCoverageEvidence):
-                    ev_repo.save_diff_coverage_evidence(ev)
-                elif isinstance(ev, DiffEvidence):
-                    ev_repo.save_diff_evidence(ev)
-                elif isinstance(ev, TestEvidence):
-                    ev_repo.save_test_evidence(ev, task.id)
-            blocking = [g for g in gaps if g.blocking]
-            task.status = "blocked" if blocking else "verified"
-            TaskRepository(session).save(task)
-        blocking_actions, _ = split_next_actions(gaps)
-        TraceLogger(root).log_event(
-            "post_task_verified",
-            {"task_id": active_id, "blocking": len(blocking)},
-            task_id=active_id,
-            summary=f"post_task verification: {task.status}",
-        )
-        if blocking:
-            return (
-                f"[yellow]{active_id} is blocked by {len(blocking)} gap(s); "
-                f"{len(blocking_actions)} next action(s). Run [bold]dev repair[/bold].[/yellow]"
-            )
-        return f"[green]{active_id} verified.[/green]"
-    except Exception as exc:  # never let a hook crash the agent
-        return f"[dim]post-task verification skipped: {exc}[/dim]"

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

@@ -1,289 +0,0 @@
-import copy
-from typing import Any
-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
-from devcouncil.llm.provider import build_role_model_config, validate_model_provider
-from devcouncil.repo.gitignore import ensure_gitignore
-
-app = typer.Typer()
-console = Console()
-
-# Per-stack default verification commands. A fresh project gets ONLY the commands
-# for the stack(s) actually detected in the repo, so the verifier never inherits a
-# cross-stack gate (e.g. `npm test`/`eslint`/`tsc` on a Python repo) that it would run
-# as a blocking fallback and fail for tooling/stack reasons instead of a real defect.
-_STACK_COMMAND_DEFAULTS: dict[str, dict[str, list[str]]] = {
-    "python": {"test": ["pytest"], "lint": ["ruff check ."], "typecheck": ["mypy ."]},
-    "node": {"test": ["npm test"], "lint": ["eslint ."], "typecheck": ["tsc --noEmit"]},
-}
-
-
-def _stack_aware_commands(project_root: Path) -> dict[str, list[str]]:
-    """Default test/lint/typecheck commands scoped to the repo's detected stack(s).
-
-    Returns empty lists when no stack is detected — empty is safe (no speculative
-    fallback gates) and far better than guessing wrong-stack tools."""
-    from devcouncil.repo.ci_scaffold import detect_stacks
-
-    commands: dict[str, list[str]] = {"test": [], "lint": [], "typecheck": []}
-    try:
-        stacks = detect_stacks(project_root)
-    except Exception:
-        return commands
-    for stack in sorted(stacks):
-        for key, cmds in _STACK_COMMAND_DEFAULTS.get(stack, {}).items():
-            for command in cmds:
-                if command not in commands[key]:
-                    commands[key].append(command)
-    return commands
-
-
-DEFAULT_CONFIG = {
-    "project": {
-        "name": "devcouncil-project",
-        "root": ".",
-        "default_branch": "main",
-    },
-    "models": {
-        "provider": "openrouter",
-        "roles": build_role_model_config("openrouter"),
-    },
-    "commands": {
-        "test": [],
-        "lint": [],
-        "typecheck": [],
-    },
-    "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": "manual",
-        "max_repair_attempts": 3,
-        "checkpoint_before_each_task": True,
-        "stream_cli_output": False,
-        "cursor_resume_mode": "off",
-        "coding_cli_probe_order": [],
-    },
-    "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",
-        },
-        "cli_agents": {
-            "enabled": True,
-            "profiles": {
-                "default": {
-                    "description": "Balanced local execution with DevCouncil verification.",
-                },
-                "yolo": {
-                    "description": "Faster local execution; DevCouncil still verifies the final diff.",
-                    "timeout_seconds": 3600,
-                    "prompt_preamble": "Profile: yolo. Move efficiently within the task scope.",
-                },
-                "prod": {
-                    "description": "Restrictive execution for high-risk repositories.",
-                    "timeout_seconds": 1800,
-                    "prompt_preamble": "Profile: prod. Keep edits minimal and explicitly within task scope.",
-                    "require_explicit_confirmation": True,
-                },
-            },
-            "agents": {},
-        },
-    }
-}
-
-
-def parse_role_model_overrides(values: list[str] | None) -> dict[str, str]:
-    overrides: dict[str, str] = {}
-    for value in values or []:
-        if "=" not in value:
-            raise ValueError(f"Invalid --role-model value '{value}'. Use ROLE=MODEL.")
-        role, model = value.split("=", 1)
-        role = role.strip()
-        model = model.strip()
-        if not role or not model:
-            raise ValueError(f"Invalid --role-model value '{value}'. Use ROLE=MODEL.")
-        overrides[role] = model
-    return overrides
-
-
-def _generate_initial_map(project_root: Path, quiet: bool) -> None:
-    """Best-effort repo map + agent guide generation on fresh init.
-
-    Imported lazily to avoid a circular import with the map command, and wrapped
-    so a mapping failure never blocks initialization.
-    """
-    try:
-        from devcouncil.cli.commands.map import generate_map_artifacts
-
-        generate_map_artifacts(project_root, project_root / ".devcouncil" / "repo_map.json")
-        if not quiet:
-            console.print("[green]Generated .devcouncil/repo_map.json and agent guides (AGENTS.md, CLAUDE.md).[/green]")
-    except Exception as exc:  # mapping is best-effort, never fatal
-        if not quiet:
-            console.print(f"[yellow]Skipped repo map generation: {exc}. Run 'dev map' later.[/yellow]")
-
-
-def _scaffold_initial_skills(project_root: Path, quiet: bool) -> None:
-    """Best-effort scaffolding of applicable engineering skills into .claude/skills/.
-
-    Always writes the core-engineering skill; adds domain skills (android, ios, web,
-    ...) whose file triggers match the repository. Never fatal.
-    """
-    try:
-        from devcouncil.skills.registry import scaffold_skills, select_skills
-
-        selected = select_skills(project_root=project_root)
-        written = scaffold_skills(project_root, selected)
-        if written and not quiet:
-            names = ", ".join(sorted(skill.name for skill in selected))
-            console.print(f"[green]Scaffolded {len(written)} skill(s) into .claude/skills/ ({names}).[/green]")
-    except Exception as exc:  # skill scaffolding is best-effort, never fatal
-        if not quiet:
-            console.print(f"[yellow]Skipped skill scaffolding: {exc}. Run 'dev skills scaffold' later.[/yellow]")
-
-
-def initialize_project(
-    project_root: Path = Path("."),
-    project_name: str | None = None,
-    model_provider: str = "openrouter",
-    model: str | None = None,
-    role_models: dict[str, str] | None = None,
-    with_gitnexus: bool = False,
-    with_graphify: bool = False,
-    with_map: bool = True,
-    with_skills: bool = True,
-    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: dict[str, Any] = copy.deepcopy(DEFAULT_CONFIG)
-        # Scope default verification commands to the repo's actual stack(s).
-        config["commands"] = _stack_aware_commands(project_root)
-        if project_name:
-            config["project"]["name"] = project_name
-        else:
-            config["project"]["name"] = project_root.name
-        provider = validate_model_provider(model_provider)
-        config["models"]["provider"] = provider
-        config["models"]["roles"] = build_role_model_config(
-            provider,
-            model=model,
-            role_models=role_models,
-        )
-
-        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_map:
-            _generate_initial_map(project_root, quiet)
-        if with_skills:
-            _scaffold_initial_skills(project_root, quiet)
-
-    if with_gitnexus:
-        nexus = GitNexusIntegration(project_root)
-        nexus.initialize()
-
-    if with_graphify:
-        graphify = GraphifyIntegration(project_root)
-        graphify.initialize()
-
-    ensure_gitignore(project_root)
-    return created
-
-
-@app.callback(invoke_without_command=True)
-def init(
-    ctx: typer.Context,
-    project_name: str = typer.Option(None, "--name", "-n", help="Project name"),
-    provider: str = typer.Option("openrouter", "--provider", help="Model provider for generated config."),
-    model: str | None = typer.Option(None, "--model", "-m", help="Model id to use for every default role."),
-    role_model: list[str] | None = typer.Option(
-        None,
-        "--role-model",
-        help="Per-role model override in ROLE=MODEL form. Can be repeated.",
-    ),
-    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"),
-    skip_map: bool = typer.Option(False, "--skip-map", help="Skip generating repo_map.json and agent guides on init."),
-    skip_skills: bool = typer.Option(False, "--skip-skills", help="Skip scaffolding engineering skills into .claude/skills/ on init."),
-):
-    """
-    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()
-
-    try:
-        role_models = parse_role_model_overrides(role_model)
-        model_provider = validate_model_provider(provider)
-    except ValueError as e:
-        console.print(f"[red]{e}[/red]")
-        raise typer.Exit(code=2) from e
-
-    initialize_project(
-        Path("."),
-        project_name=project_name,
-        model_provider=model_provider,
-        model=model,
-        role_models=role_models,
-        with_gitnexus=with_gitnexus,
-        with_graphify=with_graphify,
-        with_map=not skip_map,
-        with_skills=not skip_skills,
-    )