devcouncil 0.1.0 → 0.1.1

package/src/devcouncil/artifacts/validators.py

@@ -1,27 +1,27 @@
-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.")
+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,48 +1,51 @@
-import typer
-from rich.console import Console
-from rich.table import Table
-
-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
-
-app = typer.Typer()
-console = Console()
-
-
-@app.command(name="validate")
-def validate():
-    """Validate requirements and tasks stored in the artifact graph."""
-    db = get_db()
-    if not db:
-        console.print("[red]DevCouncil not initialized. Run 'dev init' first.[/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)
+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

@@ -0,0 +1,22 @@
+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,32 +1,35 @@
-import json
-from pathlib import Path
-
-import typer
-from rich.console import Console
-
-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."),
-):
-    """Capture the current repo state as DevCouncil's verification baseline."""
-    if not get_db():
-        console.print("[red]DevCouncil not initialized. Run 'dev init' first.[/red]")
-        raise typer.Exit(code=1)
-
-    baseline_path = Path(".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(Path(".")).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]")
+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,54 +1,76 @@
-import typer
-import yaml
-from pathlib import Path
-from rich.console import Console
-from devcouncil.app.config import load_config
-
-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")
-):
-    """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 not role:
-        console.print("[bold]Model Configuration[/bold]")
-        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]")
+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

@@ -0,0 +1,26 @@
+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,15 +1,18 @@
-import typer
+import typer
 import subprocess
 import os
 import shutil
 from pathlib import Path
-from rich.console import Console
-from rich.table import Table
-
+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():
+def render_doctor_check(project_root: Path = Path(".")):
     def _command_version(command: list[str]) -> str | None:
         executable = shutil.which(command[0])
         if not executable:
@@ -30,32 +33,32 @@ def render_doctor_check():
             ).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 .'.")
-
+
+    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:
@@ -66,31 +69,72 @@ def render_doctor_check():
     # 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")
+        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'.")
+        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")
+        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'.")
+        table.add_row(
+            "Gemini CLI",
+            "[yellow]Missing[/yellow]",
+            "Optional. Install Gemini CLI, then run 'dev integrate gemini --apply' (or 'dev setup --integrate --apply').",
+        )
 
-    # Check OpenRouter API Key
-    if os.environ.get("OPENROUTER_API_KEY"):
-        table.add_row("OPENROUTER_API_KEY", "[green]OK[/green]", "Found in environment.")
-    else:
-        table.add_row("OPENROUTER_API_KEY", "[yellow]Missing[/yellow]", "Required if using OpenRouter provider.")
+    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):
+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()
+    render_doctor_check(project_root.expanduser().resolve())