devcouncil 0.1.1 → 0.2.1

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

@@ -1,117 +0,0 @@
-from rich.console import Console
-from rich.table import Table
-from rich.panel import Panel
-from pathlib import Path
-import json
-import typer
-from devcouncil.cli.commands.init import initialize_project
-from devcouncil.app.project_status import compute_phase
-from devcouncil.storage.db import get_db
-from devcouncil.storage.repositories import ArtifactGraphRepository, StateRepository
-from devcouncil.telemetry.cost import CostEstimator
-from devcouncil.live.summary import live_review_summary
-
-console = Console()
-
-def _status_payload(project_root: Path) -> dict:
-    initialize_project(project_root, quiet=True)
-    db = get_db(project_root)
-    if not db:
-        return {"initialized": False, "phase": "UNINITIALIZED"}
-
-    with db.get_session() as session:
-        graph_repo = ArtifactGraphRepository(session)
-        graph = graph_repo.load_graph()
-        summary = graph.coverage_summary()
-
-        blocking_gaps = graph.blocking_gaps()
-        state = StateRepository(session).get_state()
-        phase = compute_phase(graph, state.current_phase if state else None)
-
-        total_cost = 0.0
-        log_file = project_root / ".devcouncil" / "logs" / "model_calls.jsonl"
-        if log_file.exists():
-            with open(log_file, "r", encoding="utf-8") as f:
-                for line in f:
-                    try:
-                        entry = json.loads(line)
-                        total_cost += CostEstimator.estimate_cost(
-                            entry.get("response", {}).get("model", ""),
-                            entry.get("usage", {}),
-                        )
-                    except Exception:
-                        continue
-
-        status_counts: dict[str, int] = {}
-        for task in graph.tasks.values():
-            status_counts[task.status] = status_counts.get(task.status, 0) + 1
-
-        return {
-            "initialized": True,
-            "phase": phase,
-            "coverage_summary": summary,
-            "total_cost": total_cost,
-            "task_status_counts": status_counts,
-            "blocking_gaps": [gap.model_dump() for gap in blocking_gaps],
-            "live_review": live_review_summary(project_root),
-        }
-
-
-def status(
-    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/."),
-):
-    """
-    Show the current status of the DevCouncil project.
-    """
-    root = project_root.expanduser().resolve()
-    payload = _status_payload(root)
-    if json_format:
-        typer.echo(json.dumps(payload, indent=2))
-        return
-
-    if not payload["initialized"]:
-        console.print("[yellow]DevCouncil state is not available in this directory.[/yellow]")
-        return
-
-    summary = payload["coverage_summary"]
-    phase = payload["phase"]
-    phase_colors = {
-        "NEW": "yellow",
-        "REQUIREMENTS_DRAFTED": "cyan",
-        "PLAN_APPROVED": "green",
-        "TASK_EXECUTING": "blue",
-        "TASK_BLOCKED": "red",
-        "PROJECT_DONE": "green bold",
-    }
-    phase_color = phase_colors.get(phase, "white")
-
-    console.print(Panel(
-        f"[bold]Phase:[/bold] [{phase_color}]{phase}[/{phase_color}]\n"
-        f"[bold]Requirements:[/bold] {summary['total_requirements']} ({summary['requirements_without_tasks']} unmapped)\n"
-        f"[bold]Tasks:[/bold] {summary['total_tasks']} ({summary['tasks_without_requirements']} orphaned)\n"
-        f"[bold]Acceptance Criteria:[/bold] {summary['total_ac']} ({summary['ac_without_evidence']} unverified)\n"
-        f"[bold]Gaps:[/bold] {summary['total_gaps']} ({summary['blocking_gaps']} blocking)\n"
-        f"[bold]Live Review:[/bold] {payload['live_review']['cards']['critical_open']} open critical, "
-        f"{len(payload['live_review']['blocking_cards'])} blocking in scope, "
-        f"{payload['live_review']['pending_signals']} pending signal(s)\n"
-        f"[bold]Total Cost:[/bold] ${payload['total_cost']:.4f}",
-        title="DevCouncil Status",
-        expand=False,
-    ))
-
-    if payload["task_status_counts"]:
-        table = Table(title="Task Summary")
-        table.add_column("Status", style="magenta")
-        table.add_column("Count", justify="right")
-        for state, count in sorted(payload["task_status_counts"].items()):
-            table.add_row(state, str(count))
-        console.print(table)
-
-    blocking_gaps = payload["blocking_gaps"]
-    if blocking_gaps:
-        console.print(f"\n[red bold]WARNING: {len(blocking_gaps)} blocking gap(s) must be resolved:[/red bold]")
-        for gap in blocking_gaps[:5]:
-            console.print(f"  - [red]{gap['id']}[/red]: {gap['description'][:80]}")
-        if len(blocking_gaps) > 5:
-            console.print(f"  ... and {len(blocking_gaps) - 5} more. Run [bold]dev report[/bold] for details.")

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

@@ -1,55 +0,0 @@
-import json
-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 TaskRepository
-
-app = typer.Typer()
-console = Console()
-
-@app.callback(invoke_without_command=True)
-def tasks(
-    ctx: typer.Context,
-    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/."),
-):
-    """
-    List task graph and task gate status.
-    """
-    if ctx.invoked_subcommand is not None:
-        return
-
-    root = project_root.expanduser().resolve()
-    initialize_project(root, quiet=True)
-    db = get_db(root)
-    if not db:
-        console.print("[red]DevCouncil state is unavailable in this directory.[/red]")
-        raise typer.Exit(code=1)
-
-    with db.get_session() as session:
-        task_repo = TaskRepository(session)
-        tasks_list = task_repo.get_all()
-
-        if json_format:
-            typer.echo(json.dumps({"tasks": [task.model_dump() for task in tasks_list]}, indent=2))
-            return
-        
-        if not tasks_list:
-            console.print("No tasks found. Run 'dev plan' to generate tasks.")
-            return
-
-        table = Table(title="DevCouncil Tasks")
-        table.add_column("Task ID", style="cyan", no_wrap=True)
-        table.add_column("Title", style="white")
-        table.add_column("Status", style="magenta")
-        table.add_column("Linked Reqs", style="green")
-
-        for t in tasks_list:
-            reqs = ", ".join(t.requirement_ids)
-            table.add_row(t.id, t.title, t.status, reqs)
-
-        console.print(table)

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

@@ -1,44 +0,0 @@
-import json
-import time
-from pathlib import Path
-
-import typer
-from rich.console import Console
-
-from devcouncil.telemetry.traces import read_trace_events
-
-app = typer.Typer(help="Inspect DevCouncil trace events.")
-console = Console()
-
-
-@app.command("tail")
-def tail(
-    follow: bool = typer.Option(False, "--follow", "-f", help="Continue polling for new events."),
-    limit: int = typer.Option(50, "--limit", "-n", help="Maximum events to print before following."),
-    jsonl: bool = typer.Option(True, "--jsonl/--pretty", help="Print JSONL or compact text rows."),
-    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
-):
-    """Print the DevCouncil trace JSONL stream for replay or debugging."""
-    project_root = project_root.expanduser().resolve()
-    printed = 0
-
-    def emit_new(start_index: int) -> int:
-        events = list(read_trace_events(project_root))
-        selected = events[start_index:]
-        for event in selected:
-            if jsonl:
-                typer.echo(event.model_dump_json())
-            else:
-                console.print(
-                    f"{event.timestamp} {event.type} "
-                    f"{event.task_id or '-'} {event.summary or json.dumps(event.details)}"
-                )
-        return len(events)
-
-    events = list(read_trace_events(project_root))
-    start = max(0, len(events) - limit)
-    printed = emit_new(start)
-
-    while follow:
-        time.sleep(1)
-        printed = emit_new(printed)

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

@@ -1,193 +0,0 @@
-import typer
-import asyncio
-import json
-from rich.console import Console
-from rich.table import Table
-from pathlib import Path
-from typing import Optional
-from devcouncil.cli.commands.init import initialize_project
-from devcouncil.storage.db import get_db
-from devcouncil.storage.repositories import TaskRepository, RequirementRepository, GapRepository, EvidenceRepository, StateRepository
-from devcouncil.verification.verifier import Verifier
-from devcouncil.llm.provider import create_provider, validate_model_provider
-from devcouncil.llm.router import ModelRouter
-from devcouncil.domain.evidence import CommandResult, DiffEvidence, TestEvidence
-from devcouncil.app.config import load_config, get_api_key
-from devcouncil.app.state_machine import ProjectPhase
-from devcouncil.integrations.code_review_graph import CodeReviewGraphAdapter
-from devcouncil.telemetry.traces import TraceLogger
-
-console = Console()
-MAX_RENDERED_GAPS = 20
-
-def verify(
-    task_id: Optional[str] = typer.Argument(None, help="Optional ID of the task to verify"),
-    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/."),
-):
-    """
-    Verify one task, or all tasks when TASK_ID is omitted.
-    """
-    root = project_root.expanduser().resolve()
-    initialize_project(root, quiet=True)
-    db = get_db(root)
-    if not db:
-        if json_format:
-            typer.echo(json.dumps({"ok": False, "error": "DevCouncil state is unavailable in this directory."}, indent=2))
-        else:
-            console.print("[red]DevCouncil state is unavailable in this directory.[/red]")
-        return
-
-    with db.get_session() as session:
-        task_repo = TaskRepository(session)
-        req_repo = RequirementRepository(session)
-        gap_repo = GapRepository(session)
-        evidence_repo = EvidenceRepository(session)
-        
-        tasks = [task_repo.get_by_id(task_id)] if task_id else task_repo.get_all()
-        tasks = [task for task in tasks if task is not None]
-        if not tasks:
-            missing = f"Task {task_id} not found." if task_id else "No tasks found to verify."
-            if json_format:
-                typer.echo(json.dumps({"ok": False, "error": missing}, indent=2))
-            else:
-                console.print(f"[red]{missing}[/red]")
-            return
-
-        reqs = req_repo.get_all()
-        
-        # Load router for LLM review if possible
-        router = None
-        try:
-            config = load_config(root)
-            validate_model_provider(config.models.provider)
-            api_key = get_api_key(config.models.provider, root)
-            provider = create_provider(config.models.provider, api_key)
-            role_config = {name: role.model_dump() for name, role in config.models.roles.items()}
-            router = ModelRouter(provider, role_config)
-        except Exception:
-            pass
-
-        verifier = Verifier(root, router=router)
-        total_gaps = 0
-        blocked_tasks = 0
-        task_results = []
-
-        for task in tasks:
-            TraceLogger(root).log_event(
-                "task_verification_started",
-                {"task_id": task.id},
-                task_id=task.id,
-                summary=f"Verifying {task.id}",
-            )
-            graph_context = CodeReviewGraphAdapter(root).get_context(
-                [planned.path for planned in task.planned_files]
-            )
-            if graph_context.available:
-                TraceLogger(root).log_event(
-                    "graph_context_loaded",
-                    graph_context.model_dump(),
-                    task_id=task.id,
-                    summary=f"Loaded graph context for {task.id}",
-                )
-            StateRepository(session).record_phase(ProjectPhase.TASK_VERIFYING.value)
-            gap_repo.delete_for_task(task.id)
-            evidence_repo.delete_for_task(task.id)
-
-            gaps, evidence = asyncio.run(verifier.verify_task(task, reqs))
-            total_gaps += len(gaps)
-
-            for gap in gaps:
-                gap_repo.save(gap)
-
-            for ev in evidence:
-                if isinstance(ev, CommandResult):
-                    evidence_repo.save_command_result(task.id, ev)
-                elif isinstance(ev, DiffEvidence):
-                    evidence_repo.save_diff_evidence(ev)
-                elif isinstance(ev, TestEvidence):
-                    evidence_repo.save_test_evidence(ev, task.id)
-
-            if not json_format:
-                _print_task_result(task.id, gaps)
-
-            if any(gap.blocking for gap in gaps):
-                task.status = "blocked"
-                blocked_tasks += 1
-                TraceLogger(root).log_event(
-                    "gate_failed",
-                    {"task_id": task.id, "gap_count": len(gaps)},
-                    task_id=task.id,
-                    summary=f"{task.id} blocked with {len(gaps)} gap(s)",
-                )
-            else:
-                task.status = "verified"
-                TraceLogger(root).log_event(
-                    "task_verified",
-                    {"task_id": task.id, "gap_count": len(gaps)},
-                    task_id=task.id,
-                    summary=f"{task.id} verified",
-                )
-            task_repo.save(task)
-            task_results.append({
-                "task_id": task.id,
-                "status": task.status,
-                "gap_count": len(gaps),
-                "blocking_gap_count": len([gap for gap in gaps if gap.blocking]),
-                "gaps": [gap.model_dump() for gap in gaps],
-            })
-
-        StateRepository(session).record_phase(
-            ProjectPhase.TASK_BLOCKED.value if blocked_tasks else ProjectPhase.TASK_VERIFIED.value
-        )
-
-        if json_format:
-            typer.echo(json.dumps({
-                "ok": blocked_tasks == 0,
-                "verified_tasks": len(tasks),
-                "blocked_tasks": blocked_tasks,
-                "total_gaps": total_gaps,
-                "tasks": task_results,
-            }, indent=2))
-        elif len(tasks) > 1:
-            if blocked_tasks:
-                console.print(
-                    f"\n[yellow]Verified {len(tasks)} tasks: {blocked_tasks} blocked, "
-                    f"{total_gaps} total gap(s).[/yellow]"
-                )
-            else:
-                console.print(f"\n[green]Verified {len(tasks)} tasks successfully.[/green]")
-
-
-def _print_task_result(task_id: str, gaps):
-    if not gaps:
-        console.print(f"[green]Task {task_id} verified successfully! No gaps found.[/green]")
-        return
-
-    console.print(f"[yellow]Verification finished for task {task_id} with {len(gaps)} gaps:[/yellow]")
-
-    table = Table(title="Detected Gaps")
-    table.add_column("ID", style="cyan")
-    table.add_column("Severity", style="magenta")
-    table.add_column("Description", style="white")
-    table.add_column("Blocking", style="red")
-
-    for gap in gaps[:MAX_RENDERED_GAPS]:
-        table.add_row(
-            gap.id,
-            gap.severity,
-            gap.description,
-            "YES" if gap.blocking else "NO",
-        )
-
-    console.print(table)
-    if len(gaps) > MAX_RENDERED_GAPS:
-        console.print(
-            f"[yellow]Showing first {MAX_RENDERED_GAPS} of {len(gaps)} gaps. "
-            "Run [bold]dev report --json[/bold] for the full list.[/yellow]"
-        )
-
-    if any(gap.blocking for gap in gaps):
-        console.print(f"\n[red]Task {task_id} is BLOCKED due to critical gaps.[/red]")
-    else:
-        console.print(f"\n[green]Task {task_id} passed with non-blocking gaps.[/green]")

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

@@ -1,20 +0,0 @@
-import typer
-from rich.console import Console
-import importlib.metadata
-
-app = typer.Typer()
-console = Console()
-
-@app.callback(invoke_without_command=True)
-def version(ctx: typer.Context):
-    """
-    Display the current version of DevCouncil.
-    """
-    if ctx.invoked_subcommand is not None:
-        return
-        
-    try:
-        ver = importlib.metadata.version("devcouncil")
-        console.print(f"DevCouncil version: [bold cyan]{ver}[/bold cyan]")
-    except importlib.metadata.PackageNotFoundError:
-        console.print("DevCouncil version: [yellow]unknown (editable/uninstalled)[/yellow]")