devcouncil 0.1.1 → 0.2.0

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

@@ -23,13 +23,17 @@ def _project_root(project_root: Path | None = None) -> Path:
 
 
 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:
-        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
+        return TaskRepository(session).get_by_id(active_id)
 
 
 def _emit_decision(client: str, action: str, reason: str) -> None:
@@ -48,31 +52,53 @@ def _emit_decision(client: str, action: str, reason: str) -> None:
         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():
-            raise typer.Exit(code=0)
-        call_data = json.loads(tool_call_json)
-        normalized_client = client.lower()
+            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 json.JSONDecodeError:
-        raise typer.Exit(code=0)
+    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(
@@ -117,12 +143,95 @@ def agent_response(
         print(json.dumps({"decision": "allow", "suppressOutput": True}, separators=(",", ":")))
 
 @app.command()
-def post_task():
+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.
-    Triggers deterministic verification.
+
+    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).
     """
-    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.")
+    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,4 +1,5 @@
 import copy
+from typing import Any
 import typer
 import yaml
 from rich.console import Console
@@ -6,10 +7,42 @@ 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",
@@ -18,23 +51,12 @@ DEFAULT_CONFIG = {
     },
     "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"},
-        }
+        "roles": build_role_model_config("openrouter"),
     },
     "commands": {
-        "test": ["pytest", "npm test"],
-        "lint": ["flake8", "eslint"],
-        "typecheck": ["mypy", "tsc"]
+        "test": [],
+        "lint": [],
+        "typecheck": [],
     },
     "gates": {
         "require_clean_git_before_task": True,
@@ -45,9 +67,12 @@ DEFAULT_CONFIG = {
         "block_failed_commands": True
     },
     "execution": {
-        "default_executor": "native",
+        "default_executor": "manual",
         "max_repair_attempts": 3,
-        "checkpoint_before_each_task": True
+        "checkpoint_before_each_task": True,
+        "stream_cli_output": False,
+        "cursor_resume_mode": "off",
+        "coding_cli_probe_order": [],
     },
     "privacy": {
         "redact_env_vars": True,
@@ -71,15 +96,90 @@ DEFAULT_CONFIG = {
             "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.
@@ -100,11 +200,20 @@ def initialize_project(
         (dev_dir / "logs").mkdir(exist_ok=True)
 
         config_path = dev_dir / "config.yaml"
-        config = copy.deepcopy(DEFAULT_CONFIG)
+        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)
@@ -115,6 +224,11 @@ def initialize_project(
             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()
@@ -123,6 +237,7 @@ def initialize_project(
         graphify = GraphifyIntegration(project_root)
         graphify.initialize()
 
+    ensure_gitignore(project_root)
     return created
 
 
@@ -130,8 +245,17 @@ def initialize_project(
 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.
@@ -145,9 +269,21 @@ def init(
         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,
     )