devcouncil 0.1.1 → 0.2.1

package/src/devcouncil/artifacts/graph.py

@@ -1,143 +0,0 @@
-"""Artifact graph: the persistent, directed graph that links requirements to evidence.
-
-This is DevCouncil's core data structure:
-  Requirement -> AcceptanceCriterion -> Task -> PlannedFile -> ChangedFile
-              -> CommandResult -> TestEvidence -> Gap
-
-The graph enables coverage queries like:
-  - Which requirements have no tasks?
-  - Which tasks produced no changed files?
-  - Which acceptance criteria have no evidence?
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Set, Tuple
-
-from devcouncil.domain.requirement import Requirement, AcceptanceCriterion
-from devcouncil.domain.task import Task
-from devcouncil.domain.assumption import Assumption
-from devcouncil.domain.evidence import CommandResult, DiffEvidence, TestEvidence
-from devcouncil.domain.gap import Gap
-from devcouncil.domain.critique import CritiqueFinding
-
-
-@dataclass
-class ArtifactGraph:
-    """Directed graph of all planning and execution artifacts."""
-
-    requirements: Dict[str, Requirement] = field(default_factory=dict)
-    tasks: Dict[str, Task] = field(default_factory=dict)
-    assumptions: Dict[str, Assumption] = field(default_factory=dict)
-    findings: Dict[str, CritiqueFinding] = field(default_factory=dict)
-    gaps: Dict[str, Gap] = field(default_factory=dict)
-    test_evidence: List[TestEvidence] = field(default_factory=list)
-    diff_evidence: List[DiffEvidence] = field(default_factory=list)
-    command_results: List[CommandResult] = field(default_factory=list)
-
-    # --- Mutation ---
-
-    def add_requirement(self, req: Requirement) -> None:
-        self.requirements[req.id] = req
-
-    def add_task(self, task: Task) -> None:
-        self.tasks[task.id] = task
-
-    def add_assumption(self, asm: Assumption) -> None:
-        self.assumptions[asm.id] = asm
-
-    def add_finding(self, finding: CritiqueFinding) -> None:
-        self.findings[finding.id] = finding
-
-    def add_gap(self, gap: Gap) -> None:
-        self.gaps[gap.id] = gap
-
-    def add_test_evidence(self, ev: TestEvidence) -> None:
-        self.test_evidence.append(ev)
-
-    def add_diff_evidence(self, ev: DiffEvidence) -> None:
-        self.diff_evidence.append(ev)
-
-    def add_command_result(self, cr: CommandResult) -> None:
-        self.command_results.append(cr)
-
-    # --- Coverage Queries ---
-
-    def requirements_without_tasks(self) -> List[Requirement]:
-        """Requirements that are not mapped to any task."""
-        task_req_ids: Set[str] = set()
-        for task in self.tasks.values():
-            task_req_ids.update(task.requirement_ids)
-        return [r for r in self.requirements.values() if r.id not in task_req_ids]
-
-    def tasks_without_requirements(self) -> List[Task]:
-        """Tasks that don't map back to any requirement."""
-        return [t for t in self.tasks.values() if not t.requirement_ids]
-
-    def requirements_without_acceptance_criteria(self) -> List[Requirement]:
-        """Requirements with no acceptance criteria defined."""
-        return [r for r in self.requirements.values() if not r.acceptance_criteria]
-
-    def acceptance_criteria_without_evidence(self) -> List[Tuple[str, AcceptanceCriterion]]:
-        """AC IDs that have no test evidence mapped to them."""
-        evidenced_ac_ids: Set[str] = set()
-        for ev in self.test_evidence:
-            evidenced_ac_ids.add(ev.acceptance_criterion_id)
-
-        results: List[Tuple[str, AcceptanceCriterion]] = []
-        for req in self.requirements.values():
-            for ac in req.acceptance_criteria:
-                if ac.id not in evidenced_ac_ids:
-                    results.append((req.id, ac))
-        return results
-
-    def tasks_without_changed_files(self) -> List[Task]:
-        """Tasks that have not produced any diff evidence."""
-        tasks_with_diffs: Set[str] = set()
-        for de in self.diff_evidence:
-            tasks_with_diffs.add(de.task_id)
-        return [
-            t for t in self.tasks.values()
-            if t.id not in tasks_with_diffs and t.status not in ("planned", "ready")
-        ]
-
-    def open_findings(self, min_severity: str = "low") -> List[CritiqueFinding]:
-        """Critique findings that are still open."""
-        severity_order = {"low": 0, "medium": 1, "high": 2, "critical": 3}
-        min_rank = severity_order.get(min_severity, 0)
-        return [
-            f for f in self.findings.values()
-            if f.status == "open" and severity_order.get(f.severity, 0) >= min_rank
-        ]
-
-    def blocking_gaps(self) -> List[Gap]:
-        """Gaps that are blocking progress."""
-        return [g for g in self.gaps.values() if g.blocking]
-
-    def unconfirmed_high_impact_assumptions(self) -> List[Assumption]:
-        """Assumptions with high impact that are still open."""
-        return [
-            a for a in self.assumptions.values()
-            if a.status == "open" and a.impact == "high"
-        ]
-
-    # --- Aggregate ---
-
-    def coverage_summary(self) -> Dict[str, Any]:
-        """Produce a coverage summary for reporting."""
-        return {
-            "total_requirements": len(self.requirements),
-            "requirements_without_tasks": len(self.requirements_without_tasks()),
-            "requirements_without_ac": len(self.requirements_without_acceptance_criteria()),
-            "total_tasks": len(self.tasks),
-            "tasks_without_requirements": len(self.tasks_without_requirements()),
-            "tasks_without_diffs": len(self.tasks_without_changed_files()),
-            "total_ac": sum(len(r.acceptance_criteria) for r in self.requirements.values()),
-            "ac_without_evidence": len(self.acceptance_criteria_without_evidence()),
-            "total_gaps": len(self.gaps),
-            "blocking_gaps": len(self.blocking_gaps()),
-            "open_findings": len(self.open_findings()),
-            "high_critical_open_findings": len(self.open_findings("high")),
-            "unconfirmed_high_assumptions": len(self.unconfirmed_high_impact_assumptions()),
-        }

package/src/devcouncil/artifacts/migrations.py

@@ -1,20 +0,0 @@
-from typing import Any, Dict
-
-class ArtifactMigrator:
-    """Migrates artifact schemas across DevCouncil versions."""
-    
-    @staticmethod
-    def migrate_requirement(data: Dict[str, Any]) -> Dict[str, Any]:
-        """Upgrade requirement payload to current schema."""
-        if "priority" not in data:
-            data["priority"] = "medium"
-        return data
-
-    @staticmethod
-    def migrate_task(data: Dict[str, Any]) -> Dict[str, Any]:
-        """Upgrade task payload to current schema."""
-        if "forbidden_changes" not in data:
-            data["forbidden_changes"] = []
-        if "expected_tests" not in data:
-            data["expected_tests"] = []
-        return data

package/src/devcouncil/artifacts/schemas.py

@@ -1,23 +0,0 @@
-from typing import List
-from pydantic import BaseModel, Field
-
-# Common schemas that might be shared across artifacts
-class FileModification(BaseModel):
-    path: str
-    diff: str
-
-class CoverageMatrix(BaseModel):
-    """Represents a requirement to task/test mapping coverage."""
-    requirement_id: str
-    task_ids: List[str] = Field(default_factory=list)
-    test_evidence_ids: List[str] = Field(default_factory=list)
-    is_covered: bool = False
-    missing_tasks: bool = False
-    missing_tests: bool = False
-
-class ReportSchema(BaseModel):
-    project_id: str
-    tasks_completed: int
-    tasks_blocked: int
-    open_gaps: int
-    coverage_matrix: List[CoverageMatrix]

package/src/devcouncil/artifacts/serializer.py

@@ -1,21 +0,0 @@
-import json
-from typing import Any, Dict, TypeVar, Type
-from pydantic import BaseModel
-
-T = TypeVar("T", bound=BaseModel)
-
-class ArtifactSerializer:
-    """Handles serialization and deserialization of DevCouncil artifacts."""
-    
-    @staticmethod
-    def to_json(artifact: BaseModel) -> str:
-        return artifact.model_dump_json(indent=2)
-
-    @staticmethod
-    def from_json(json_str: str, model_class: Type[T]) -> T:
-        data = json.loads(json_str)
-        return model_class.model_validate(data)
-
-    @staticmethod
-    def to_dict(artifact: BaseModel) -> Dict[str, Any]:
-        return artifact.model_dump()

package/src/devcouncil/artifacts/validators.py

@@ -1,27 +0,0 @@
-from devcouncil.domain.requirement import Requirement
-from devcouncil.domain.task import Task
-from devcouncil.app.errors import GatingError
-
-class ArtifactValidator:
-    """Validates DevCouncil artifacts (tasks, requirements, etc.)."""
-    
-    @staticmethod
-    def validate_requirement(req: Requirement) -> None:
-        if not req.title:
-            raise GatingError(f"Requirement {req.id} missing title.")
-        if not req.acceptance_criteria:
-            raise GatingError(f"Requirement {req.id} must have at least one acceptance criterion.")
-        for ac in req.acceptance_criteria:
-            if not ac.verification_method:
-                raise GatingError(f"Acceptance criterion {ac.id} in {req.id} missing verification method.")
-
-    @staticmethod
-    def validate_task(task: Task) -> None:
-        if not task.requirement_ids:
-            raise GatingError(f"Task {task.id} must map to at least one requirement.")
-        if not task.planned_files:
-            raise GatingError(f"Task {task.id} must have at least one planned file.")
-        if not task.acceptance_criterion_ids:
-            raise GatingError(f"Task {task.id} must map to at least one acceptance criterion.")
-        if not task.allowed_commands and not task.expected_tests:
-            raise GatingError(f"Task {task.id} must define allowed commands or expected tests.")

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

@@ -1,51 +0,0 @@
-import typer
-from rich.console import Console
-from rich.table import Table
-from pathlib import Path
-
-from devcouncil.app.errors import GatingError
-from devcouncil.artifacts.validators import ArtifactValidator
-from devcouncil.storage.db import get_db
-from devcouncil.storage.repositories import RequirementRepository, TaskRepository
-from devcouncil.cli.commands.init import initialize_project
-
-app = typer.Typer()
-console = Console()
-
-
-@app.command(name="validate")
-def validate():
-    """Validate requirements and tasks stored in the artifact graph."""
-    initialize_project(Path("."), quiet=True)
-    db = get_db()
-    if not db:
-        console.print("[red]DevCouncil state is unavailable in this directory.[/red]")
-        raise typer.Exit(code=1)
-
-    errors: list[str] = []
-    with db.get_session() as session:
-        req_repo = RequirementRepository(session)
-        task_repo = TaskRepository(session)
-
-        for req in req_repo.get_all():
-            try:
-                ArtifactValidator.validate_requirement(req)
-            except GatingError as exc:
-                errors.append(str(exc))
-
-        for task in task_repo.get_all():
-            try:
-                ArtifactValidator.validate_task(task)
-            except GatingError as exc:
-                errors.append(str(exc))
-
-    if not errors:
-        console.print("[green]Artifacts are valid.[/green]")
-        return
-
-    table = Table(title="Artifact Validation Errors")
-    table.add_column("Error", style="red")
-    for error in errors:
-        table.add_row(error)
-    console.print(table)
-    raise typer.Exit(code=1)

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

@@ -1,22 +0,0 @@
-import json
-from pathlib import Path
-
-import typer
-
-from devcouncil.indexing.ast_matcher import AstMatcher
-
-app = typer.Typer(help="Run structural AST searches.")
-
-
-@app.command("match")
-def match(
-    query: str = typer.Argument("", help="Name or source text to match."),
-    language: str | None = typer.Option(None, "--language", "-l", help="Language filter."),
-    kind: str | None = typer.Option(None, "--kind", "-k", help="Symbol kind filter."),
-    limit: int = typer.Option(100, "--limit", help="Maximum matches."),
-    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root."),
-):
-    """Find function/class/type symbols using tree-sitter when available and fallbacks otherwise."""
-    root = project_root.expanduser().resolve()
-    matches = AstMatcher(root).match(query=query, language=language, kind=kind, limit=max(1, limit))
-    typer.echo(json.dumps({"matches": [item.model_dump() for item in matches]}, indent=2))

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

@@ -1,35 +0,0 @@
-import json
-from pathlib import Path
-
-import typer
-from rich.console import Console
-
-from devcouncil.cli.commands.init import initialize_project
-from devcouncil.storage.db import get_db
-from devcouncil.verification.verifier import Verifier
-
-console = Console()
-
-
-def baseline(
-    force: bool = typer.Option(False, "--force", help="Overwrite an existing baseline snapshot."),
-    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
-):
-    """Capture the current repo state as DevCouncil's verification baseline."""
-    root = project_root.expanduser().resolve()
-    initialize_project(root, quiet=True)
-    if not get_db(root):
-        raise typer.Exit(code=1)
-
-    baseline_path = root / ".devcouncil" / "baseline.json"
-    if baseline_path.exists() and not force:
-        console.print("[yellow]Baseline already exists. Use --force to replace it.[/yellow]")
-        raise typer.Exit(code=1)
-
-    changed_files = Verifier(root).get_changed_files()
-    payload = {
-        "changed_files": changed_files,
-        "note": "Files present in this snapshot are excluded from future task-scoped verification diffs.",
-    }
-    baseline_path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
-    console.print(f"[green]Captured baseline with {len(changed_files)} changed file(s).[/green]")

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

@@ -1,76 +0,0 @@
-import typer
-import yaml
-from pathlib import Path
-from rich.console import Console
-from devcouncil.app.config import load_config
-from devcouncil.llm.provider import SUPPORTED_MODEL_PROVIDERS, validate_model_provider
-
-app = typer.Typer(help="Manage DevCouncil configuration")
-console = Console()
-
-@app.command("models")
-def models(
-    role: str = typer.Option(None, "--role", "-r", help="Specific role to show/edit"),
-    model: str = typer.Option(None, "--model", "-m", help="New model string to set for the role"),
-    provider: str = typer.Option(None, "--provider", help="Set the model provider."),
-):
-    """View or edit model role configuration."""
-    try:
-        load_config(Path("."))
-    except FileNotFoundError as e:
-        console.print(f"[red]{e}[/red]")
-        return
-
-    config_path = Path(".devcouncil/config.yaml")
-    
-    with open(config_path) as f:
-        raw_config = yaml.safe_load(f) or {}
-
-    if provider:
-        try:
-            normalized_provider = validate_model_provider(provider)
-        except ValueError as e:
-            console.print(f"[red]{e}[/red]")
-            raise typer.Exit(code=2) from e
-        raw_config.setdefault("models", {})
-        previous = raw_config["models"].get("provider", "openrouter")
-        raw_config["models"]["provider"] = normalized_provider
-        with open(config_path, "w") as f:
-            yaml.dump(raw_config, f, default_flow_style=False)
-        if previous == normalized_provider:
-            console.print(f"[green]Model provider remains '{normalized_provider}'.[/green]")
-        else:
-            console.print(f"[green]Updated model provider from '{previous}' to '{normalized_provider}'.[/green]")
-        return
-
-    if not role:
-        console.print("[bold]Model Configuration[/bold]")
-        configured_provider = raw_config.get("models", {}).get("provider", "openrouter")
-        supported = ", ".join(SUPPORTED_MODEL_PROVIDERS)
-        console.print(f"  [cyan]provider[/cyan]: {configured_provider} (supported: {supported})")
-        for r, m in raw_config.get("models", {}).get("roles", {}).items():
-            console.print(f"  [cyan]{r}[/cyan]: {m.get('model')}")
-        return
-
-    if not model:
-        m = raw_config.get("models", {}).get("roles", {}).get(role)
-        if m:
-            console.print(f"[cyan]{role}[/cyan]: {m.get('model')}")
-        else:
-            console.print(f"[red]Role '{role}' not found.[/red]")
-        return
-
-    if "models" not in raw_config:
-        raw_config["models"] = {"roles": {}}
-    if "roles" not in raw_config["models"]:
-        raw_config["models"]["roles"] = {}
-        
-    if role not in raw_config["models"]["roles"]:
-        raw_config["models"]["roles"][role] = {}
-        
-    raw_config["models"]["roles"][role]["model"] = model
-    
-    with open(config_path, "w") as f:
-        yaml.dump(raw_config, f, default_flow_style=False)
-        
-    console.print(f"[green]Updated '{role}' to use model '{model}'[/green]")

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

@@ -1,26 +0,0 @@
-from pathlib import Path
-
-import typer
-from rich.console import Console
-
-from devcouncil.cli.commands.init import initialize_project
-from devcouncil.ui.dashboard import run_dashboard
-
-app = typer.Typer(help="Serve the live DevCouncil dashboard.")
-console = Console()
-
-
-@app.callback(invoke_without_command=True)
-def dashboard(
-    ctx: typer.Context,
-    host: str = typer.Option("127.0.0.1", "--host", help="Dashboard bind host."),
-    port: int = typer.Option(8765, "--port", help="Dashboard bind port."),
-    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
-):
-    """Serve a local live dashboard with project status, tasks, coverage, and traces."""
-    if ctx.invoked_subcommand is not None:
-        return
-    root = project_root.expanduser().resolve()
-    initialize_project(root, quiet=True)
-    console.print(f"Serving DevCouncil dashboard at http://{host}:{port}")
-    run_dashboard(root, host=host, port=port)

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

@@ -1,140 +0,0 @@
-import typer
-import subprocess
-import os
-import shutil
-from pathlib import Path
-from rich.console import Console
-from rich.table import Table
-
-from devcouncil.app.config import load_config, load_local_secrets, provider_api_key_env_var
-from devcouncil.llm.provider import SUPPORTED_MODEL_PROVIDERS, validate_model_provider
-
-app = typer.Typer()
-console = Console()
-
-def render_doctor_check(project_root: Path = Path(".")):
-    def _command_version(command: list[str]) -> str | None:
-        executable = shutil.which(command[0])
-        if not executable:
-            return None
-
-        resolved_command = [executable, *command[1:]]
-        use_shell = os.name == "nt" and Path(executable).suffix.lower() in {".bat", ".cmd", ".ps1"}
-        invocation = subprocess.list2cmdline(resolved_command) if use_shell else resolved_command
-        try:
-            return subprocess.check_output(
-                invocation,
-                stderr=subprocess.STDOUT,
-                text=True,
-                encoding="utf-8",
-                errors="replace",
-                shell=use_shell,
-                timeout=10,
-            ).splitlines()[0].strip()
-        except Exception:
-            return None
-
-    table = Table(title="DevCouncil Doctor Check")
-    table.add_column("Component", style="cyan")
-    table.add_column("Status", style="magenta")
-    table.add_column("Notes", style="green")
-
-    # Check Git
-    git_ver = _command_version(["git", "--version"])
-    if git_ver:
-        table.add_row("Git", "[green]OK[/green]", git_ver)
-    else:
-        table.add_row("Git", "[red]Missing[/red]", "Git is required for repo mapping and checkpoints.")
-
-    # Check uv
-    uv_ver = _command_version(["uv", "--version"])
-    if uv_ver:
-        table.add_row("uv", "[green]OK[/green]", uv_ver)
-    else:
-        table.add_row("uv", "[red]Missing[/red]", "Install uv to run or install DevCouncil.")
-
-    # Check CLI shims
-    if shutil.which("devcouncil"):
-        table.add_row("devcouncil CLI", "[green]OK[/green]", "Found on PATH.")
-    else:
-        table.add_row("devcouncil CLI", "[yellow]Missing[/yellow]", "Run via 'uv run devcouncil' or install with 'uv tool install --force .'.")
-
-    # Check ripgrep
-    rg_ver = _command_version(["rg", "--version"])
-    if rg_ver:
-        table.add_row("ripgrep (rg)", "[green]OK[/green]", rg_ver)
-    else:
-        table.add_row("ripgrep (rg)", "[yellow]Missing[/yellow]", "ripgrep is highly recommended for fast repo mapping.")
-
-    # Check supported coding CLIs
-    codex_ver = _command_version(["codex", "--version"])
-    if codex_ver:
-        table.add_row(
-            "Codex CLI",
-            "[green]OK[/green]",
-            f"{codex_ver}. Setup: dev integrate codex --apply (or dev setup --integrate --apply).",
-        )
-    else:
-        table.add_row(
-            "Codex CLI",
-            "[yellow]Missing[/yellow]",
-            "Optional. Install Codex, then run 'dev integrate codex --apply' (or 'dev setup --integrate --apply').",
-        )
-
-    gemini_ver = _command_version(["gemini", "--version"])
-    if gemini_ver:
-        table.add_row(
-            "Gemini CLI",
-            "[green]OK[/green]",
-            f"{gemini_ver}. Setup: dev integrate gemini --apply (or dev setup --integrate --apply).",
-        )
-    else:
-        table.add_row(
-            "Gemini CLI",
-            "[yellow]Missing[/yellow]",
-            "Optional. Install Gemini CLI, then run 'dev integrate gemini --apply' (or 'dev setup --integrate --apply').",
-        )
-
-    try:
-        provider = load_config(project_root).models.provider
-    except Exception:
-        provider = "openrouter"
-    try:
-        provider = validate_model_provider(provider)
-    except ValueError:
-        supported = ", ".join(SUPPORTED_MODEL_PROVIDERS)
-        table.add_row(
-            "models.provider",
-            "[red]Unsupported[/red]",
-            f"{provider} is configured, but this runtime supports: {supported}.",
-        )
-        console.print(table)
-        return
-    env_var = provider_api_key_env_var(provider)
-    local_secrets = load_local_secrets(project_root)
-    if os.environ.get(env_var):
-        table.add_row(env_var, "[green]OK[/green]", f"Found in environment for {provider}.")
-    elif local_secrets.get(env_var):
-        table.add_row(env_var, "[green]OK[/green]", f"Found in .devcouncil/secrets.env for {provider}.")
-    else:
-        table.add_row(env_var, "[yellow]Missing[/yellow]", f"Required if using {provider} provider. Run 'dev setup'.")
-
-    console.print(table)
-
-
-@app.callback(invoke_without_command=True)
-def doctor(
-    ctx: typer.Context,
-    project_root: Path = typer.Option(
-        Path("."),
-        "--project-root",
-        help="Repository root containing .devcouncil/config.yaml.",
-    ),
-):
-    """
-    Check the environment for DevCouncil prerequisites.
-    """
-    if ctx.invoked_subcommand is not None:
-        return
-
-    render_doctor_check(project_root.expanduser().resolve())