devcouncil 0.3.1 → 0.4.1

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

@@ -1,4 +1,5 @@
-import json
+from devcouncil.utils.json_persist import dump_json
+import logging
 import typer
 from pathlib import Path
 from rich.console import Console
@@ -8,9 +9,23 @@ from devcouncil.storage.db import get_db
 from devcouncil.storage.repositories import TaskRepository
 from devcouncil.verification.test_resolver import TestResolver
 from devcouncil.verification.verifier import Verifier
+from devcouncil.telemetry.stages import log_stage, log_step
 
 app = typer.Typer(help="Evidence suggestion utilities.")
 console = Console()
+logger = logging.getLogger(__name__)
+
+
+def _load_repo_map(root: Path) -> dict | None:
+    """Load `.devcouncil/repo_map.json` so test suggestions can use the map's
+    dependents/role_files index; returns None (name-based fallback) when absent."""
+    import json
+    from typing import Any, cast
+
+    try:
+        return cast(dict[Any, Any], json.loads((root / ".devcouncil" / "repo_map.json").read_text(encoding="utf-8")))
+    except (OSError, ValueError):
+        return None
 
 
 @app.command("suggest")
@@ -21,28 +36,34 @@ def suggest(
     project_root: Path = typer.Option(Path("."), "--project-root"),
 ):
     root = project_root.expanduser().resolve()
+    from devcouncil.telemetry.logging_setup import set_log_dir
+    set_log_dir(root)
+    logger.info("dev evidence suggest: task=%s apply=%s", task_id, apply)
     initialize_project(root, quiet=True)
     db = get_db(root)
     if not db:
         console.print("[red]DevCouncil not initialized.[/red]")
         raise typer.Exit(code=1)
 
-    with db.get_session() as session:
-        task = TaskRepository(session).get_by_id(task_id)
-        if not task:
-            console.print(f"[red]Task {task_id} not found.[/red]")
-            raise typer.Exit(code=1)
-        changed = Verifier(root).get_task_changed_files(task_id)
-        suggestions = TestResolver(root).suggest_for_task(task, changed)
-        if not include_low_confidence:
-            suggestions = [s for s in suggestions if s.confidence != "low"]
-        if apply:
-            for item in suggestions:
-                if item.confidence == "high" and item.command not in task.expected_tests:
-                    task.expected_tests.append(item.command)
-            TaskRepository(session).save(task)
-        typer.echo(json.dumps({
-            "task_id": task_id,
-            "suggestions": [s.model_dump() for s in suggestions],
-            "expected_tests": task.expected_tests,
-        }, indent=2))
+    with log_stage("evidence", project_root=root, task_id=task_id):
+        log_step("evidence/1: resolving test suggestions", project_root=root, task_id=task_id, trace=True)
+        with db.get_session() as session:
+            task = TaskRepository(session).get_by_id(task_id)
+            if not task:
+                console.print(f"[red]Task {task_id} not found.[/red]")
+                raise typer.Exit(code=1)
+            changed = Verifier(root).get_task_changed_files(task_id)
+            suggestions = TestResolver(root, _load_repo_map(root)).suggest_for_task(task, changed)
+            if not include_low_confidence:
+                suggestions = [s for s in suggestions if s.confidence != "low"]
+            if apply:
+                for item in suggestions:
+                    if item.confidence == "high" and item.command not in task.expected_tests:
+                        task.expected_tests.append(item.command)
+                TaskRepository(session).save(task)
+            typer.echo(dump_json({
+                "task_id": task_id,
+                "suggestions": [s.model_dump() for s in suggestions],
+                "expected_tests": task.expected_tests,
+            }, indent=2))
+        log_step("evidence/complete", project_root=root, task_id=task_id, trace=True)

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

@@ -0,0 +1,73 @@
+"""Export DevCouncil project state to a portable JSON snapshot (no secrets)."""
+
+from __future__ import annotations
+
+from devcouncil.utils.json_persist import dump_json
+import logging
+from pathlib import Path
+
+from devcouncil.utils.json_persist import write_json
+
+import typer
+from rich.console import Console
+
+from devcouncil.cli.commands.gaps import _gaps_payload
+from devcouncil.cli.commands.init import initialize_project
+from devcouncil.storage.db import get_db
+from devcouncil.storage.repositories import RequirementRepository, TaskRepository
+from devcouncil.telemetry.stages import log_stage, log_step
+
+console = Console()
+logger = logging.getLogger(__name__)
+
+EXPORT_RELATIVE = Path(".devcouncil") / "export" / "state.json"
+
+
+def _export_payload(project_root: Path) -> dict:
+    initialize_project(project_root, quiet=True)
+    db = get_db(project_root)
+    if not db:
+        return {"initialized": False, "requirements": [], "tasks": [], "gaps": {}}
+
+    with db.get_session() as session:
+        requirements = [req.model_dump() for req in RequirementRepository(session).get_all()]
+        tasks = [task.model_dump() for task in TaskRepository(session).get_all()]
+    gaps = _gaps_payload(project_root)
+    return {
+        "initialized": True,
+        "requirements": requirements,
+        "tasks": tasks,
+        "gaps": {
+            "blocking_count": gaps.get("blocking_count", 0),
+            "advisory_count": gaps.get("advisory_count", 0),
+            "total_count": gaps.get("total_count", 0),
+            "items": gaps.get("gaps", []),
+        },
+    }
+
+
+def export_state(
+    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
+    output: Path | None = typer.Option(None, "--output", "-o", help="Output path (default: .devcouncil/export/state.json)."),
+    json_format: bool = typer.Option(False, "--json", help="Print payload to stdout instead of writing a file."),
+):
+    """Write requirements, tasks, and gaps summary to .devcouncil/export/state.json."""
+    root = project_root.expanduser().resolve()
+    from devcouncil.telemetry.logging_setup import set_log_dir
+
+    set_log_dir(root)
+    logger.info("dev export: json=%s", json_format)
+
+    with log_stage("export", project_root=root):
+        log_step("export/1: building snapshot", project_root=root, trace=True)
+        payload = _export_payload(root)
+        if json_format:
+            typer.echo(dump_json(payload, indent=2))
+            log_step("export/complete", project_root=root, trace=True)
+            return
+
+        dest = (output or (root / EXPORT_RELATIVE)).expanduser().resolve()
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        write_json(dest, payload)
+        console.print(f"[green]Exported DevCouncil state[/green] to {dest}")
+        log_step("export/complete", project_root=root, path=str(dest), trace=True)

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

@@ -0,0 +1,175 @@
+import logging
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from devcouncil.cli.commands.init import initialize_project
+from devcouncil.storage.db import get_db
+from devcouncil.storage.repositories import ArtifactGraphRepository
+from devcouncil.telemetry.stages import log_stage, log_step
+from devcouncil.utils.json_persist import dump_json
+
+console = Console()
+logger = logging.getLogger(__name__)
+
+
+def _gaps_payload(
+    project_root: Path,
+    *,
+    blocking_only: bool = False,
+    task_id: str | None = None,
+) -> dict:
+    initialize_project(project_root, quiet=True)
+    db = get_db(project_root)
+    if not db:
+        return {"initialized": False, "gaps": [], "blocking_count": 0, "advisory_count": 0}
+
+    with db.get_session() as session:
+        if task_id:
+            from devcouncil.storage.repositories import GapRepository
+
+            gaps = GapRepository(session).get_for_task(task_id)
+            if blocking_only:
+                gaps = [g for g in gaps if g.blocking]
+            return {
+                "initialized": True,
+                "ok": True,
+                "task_id": task_id,
+                "gaps": [gap.model_dump() for gap in gaps],
+                "blocking_count": sum(1 for g in gaps if g.blocking),
+            }
+
+        graph = ArtifactGraphRepository(session).load_graph()
+        if blocking_only:
+            gaps = graph.blocking_gaps()
+        else:
+            gaps = sorted(graph.gaps.values(), key=lambda g: (not g.blocking, g.id))
+        blocking = [g for g in gaps if g.blocking]
+        advisory = [g for g in gaps if not g.blocking]
+        return {
+            "initialized": True,
+            "gaps": [gap.model_dump() for gap in gaps],
+            "blocking_count": len(blocking),
+            "advisory_count": len(advisory),
+            "total_count": len(gaps),
+        }
+
+
+def _next_actions_payload(project_root: Path, task_id: str) -> dict:
+    from devcouncil.integrations.mcp.util import allowed_next_tools
+    from devcouncil.storage.repositories import GapRepository, TaskRepository
+    from devcouncil.verification.next_actions import split_next_actions
+
+    initialize_project(project_root, quiet=True)
+    db = get_db(project_root)
+    if not db:
+        return {"ok": False, "error": "DevCouncil state is unavailable in this directory."}
+
+    with db.get_session() as session:
+        gaps = GapRepository(session).get_for_task(task_id)
+        task = TaskRepository(session).get_by_id(task_id)
+    blocking_actions, advisory_actions = split_next_actions(gaps)
+    has_blocking = any(g.blocking for g in gaps)
+    return {
+        "ok": True,
+        "task_id": task_id,
+        "next_actions": [a.model_dump() for a in blocking_actions],
+        "advisory_actions": [a.model_dump() for a in advisory_actions],
+        "allowed_next_tools": allowed_next_tools(task.status if task else "planned", has_blocking),
+    }
+
+
+def gaps(
+    json_format: bool = typer.Option(False, "--json", help="Output machine-readable JSON."),
+    blocking_only: bool = typer.Option(
+        False,
+        "--blocking-only",
+        help="Show only blocking gaps.",
+    ),
+    task_id: str | None = typer.Option(
+        None,
+        "--task-id",
+        help="Scope gaps to a single task (MCP-compatible payload).",
+    ),
+    next_actions: bool = typer.Option(
+        False,
+        "--next-actions",
+        help="Emit repair next-actions for --task-id instead of raw gaps.",
+    ),
+    fail_on_blocking: bool = typer.Option(
+        False,
+        "--fail-on-blocking",
+        help="Exit non-zero when blocking gaps remain.",
+    ),
+    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
+):
+    """List all verification gaps (blocking and advisory)."""
+    root = project_root.expanduser().resolve()
+    from devcouncil.telemetry.logging_setup import set_log_dir
+    set_log_dir(root)
+    logger.info(
+        "dev gaps: json=%s blocking_only=%s fail_on_blocking=%s",
+        json_format,
+        blocking_only,
+        fail_on_blocking,
+    )
+
+    with log_stage("gaps", project_root=root):
+        log_step("gaps/1: loading gaps", project_root=root, trace=True)
+        if next_actions:
+            if not task_id:
+                message = "--next-actions requires --task-id"
+                if json_format:
+                    typer.echo(dump_json({"ok": False, "error": message}, indent=2))
+                else:
+                    console.print(f"[red]{message}[/red]")
+                raise typer.Exit(code=1)
+            payload = _next_actions_payload(root, task_id)
+        else:
+            payload = _gaps_payload(root, blocking_only=blocking_only, task_id=task_id)
+
+        def _maybe_fail() -> None:
+            if fail_on_blocking and payload.get("blocking_count", 0) > 0:
+                raise typer.Exit(code=1)
+
+        if json_format:
+            typer.echo(dump_json(payload, indent=2))
+            _maybe_fail()
+            log_step("gaps/complete", project_root=root, trace=True)
+            return
+
+        if not payload["initialized"]:
+            console.print("[yellow]DevCouncil state is not available in this directory.[/yellow]")
+            log_step("gaps/complete", project_root=root, trace=True)
+            return
+
+        table = Table(title="DevCouncil Gaps")
+        table.add_column("ID", style="cyan", no_wrap=True)
+        table.add_column("Blocking", justify="center")
+        table.add_column("Severity")
+        table.add_column("Type")
+        table.add_column("Task")
+        table.add_column("Description")
+
+        for gap in payload["gaps"]:
+            blocking_style = "[red]yes[/red]" if gap.get("blocking") else "[dim]no[/dim]"
+            desc = (gap.get("description") or "")[:80]
+            table.add_row(
+                gap.get("id", ""),
+                blocking_style,
+                gap.get("severity", ""),
+                gap.get("gap_type", ""),
+                gap.get("task_id") or "",
+                desc,
+            )
+
+        console.print(table)
+        console.print(
+            f"\n[bold]{payload['total_count']}[/bold] gap(s): "
+            f"[red]{payload['blocking_count']} blocking[/red], "
+            f"[dim]{payload['advisory_count']} advisory[/dim]"
+        )
+
+        _maybe_fail()
+        log_step("gaps/complete", project_root=root, trace=True)

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

@@ -0,0 +1,76 @@
+"""`dev write` and `dev apply-patch` — policy-gated file writes through the CLI."""
+
+from __future__ import annotations
+
+import logging
+import sys
+from pathlib import Path
+
+import typer
+
+from devcouncil.execution.gated_write import apply_patch_payload, write_file_payload
+from devcouncil.telemetry.logging_setup import set_log_dir
+from devcouncil.telemetry.stages import log_stage, log_step
+from devcouncil.utils.json_persist import dump_json
+
+logger = logging.getLogger(__name__)
+
+
+def write(
+    task_id: str = typer.Argument(..., help="Task ID."),
+    lease_token: str = typer.Option(..., "--lease-token", help="Lease token from checkout."),
+    path: str = typer.Option(..., "--path", help="Repository-relative file path."),
+    content: str | None = typer.Option(None, "--content", help="File content (or read from stdin when omitted)."),
+    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/."),
+) -> None:
+    """Write a file for a leased task through DevCouncil's policy gate."""
+    root = project_root.expanduser().resolve()
+    set_log_dir(root)
+    body = content if content is not None else sys.stdin.read()
+    logger.info("dev write: task=%s path=%s", task_id, path)
+
+    with log_stage("write", project_root=root, task_id=task_id):
+        payload = write_file_payload(root, task_id=task_id, lease_token=lease_token, rel_path=path, content=body)
+        if json_format:
+            typer.echo(dump_json(payload, indent=2))
+            log_step("write/complete", project_root=root, task_id=task_id, trace=True)
+            if not payload.get("ok"):
+                raise typer.Exit(code=1)
+            return
+        if not payload.get("ok"):
+            typer.echo(payload.get("error") or payload.get("rejected_files"))
+            raise typer.Exit(code=1)
+        typer.echo(f"Wrote {path}")
+        log_step("write/complete", project_root=root, task_id=task_id, trace=True)
+
+
+def apply_patch(
+    task_id: str = typer.Argument(..., help="Task ID."),
+    lease_token: str = typer.Option(..., "--lease-token", help="Lease token from checkout."),
+    unified_diff: str | None = typer.Option(None, "--unified-diff", help="Unified diff (or read from stdin)."),
+    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/."),
+) -> None:
+    """Apply a unified diff for a leased task through DevCouncil's policy gate."""
+    root = project_root.expanduser().resolve()
+    set_log_dir(root)
+    diff_body = unified_diff if unified_diff is not None else sys.stdin.read()
+    if not diff_body.strip():
+        typer.echo("unified_diff must be a non-empty string")
+        raise typer.Exit(code=1)
+    logger.info("dev apply-patch: task=%s", task_id)
+
+    with log_stage("apply-patch", project_root=root, task_id=task_id):
+        payload = apply_patch_payload(root, task_id=task_id, lease_token=lease_token, unified_diff=diff_body)
+        if json_format:
+            typer.echo(dump_json(payload, indent=2))
+            log_step("apply-patch/complete", project_root=root, task_id=task_id, trace=True)
+            if not payload.get("ok"):
+                raise typer.Exit(code=1)
+            return
+        if not payload.get("ok"):
+            typer.echo(payload.get("error") or payload.get("rejected_files"))
+            raise typer.Exit(code=1)
+        typer.echo(f"Applied patch to {payload.get('applied_files')}")
+        log_step("apply-patch/complete", project_root=root, task_id=task_id, trace=True)