devcouncil 0.2.0 → 0.2.2

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/assets/__init__.py

@@ -1 +0,0 @@
-"""Packaged visual assets for DevCouncil."""

package/src/devcouncil/assets/devcouncil-logo.svg

@@ -1,60 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 500 500" width="100%" height="100%">
-  <defs>
-    <linearGradient id="bgGrad" x1="0%" y1="0%" x2="100%" y2="100%">
-      <stop offset="0%" stop-color="#1a0000" />
-      <stop offset="100%" stop-color="#000000" />
-    </linearGradient>
-    <linearGradient id="redGlow" x1="0%" y1="0%" x2="100%" y2="100%">
-      <stop offset="0%" stop-color="#ff3333" />
-      <stop offset="100%" stop-color="#990000" />
-    </linearGradient>
-    <filter id="glow" x="-20%" y="-20%" width="140%" height="140%">
-      <feGaussianBlur stdDeviation="10" result="blur" />
-      <feComposite in="SourceGraphic" in2="blur" operator="over" />
-    </filter>
-  </defs>
-  
-  <rect width="500" height="500" fill="transparent" />
-  
-  <g transform="translate(250, 250)">
-    <!-- Outer wireframe hexagon representing the bounds of the orchestrator -->
-    <polygon points="0,-180 155.88,-90 155.88,90 0,180 -155.88,90 -155.88,-90" 
-             fill="none" stroke="#330000" stroke-width="8" stroke-linejoin="round" />
-             
-    <!-- Inner geometric structure - Top Face -->
-    <polygon points="0,-180 155.88,-90 0,0 -155.88,-90" fill="#0d0000" stroke="#ff0000" stroke-width="2" />
-    
-    <!-- Inner geometric structure - Right Face -->
-    <polygon points="0,0 155.88,-90 155.88,90 0,180" fill="#000000" stroke="#cc0000" stroke-width="2" />
-    
-    <!-- Inner geometric structure - Left Face -->
-    <polygon points="0,0 0,180 -155.88,90 -155.88,-90" fill="#1a0000" stroke="#ff3333" stroke-width="2" />
-    
-    <!-- The glowing core node (3D Isometric) -->
-    <!-- Top core face -->
-    <polygon points="0,-80 69.28,-40 0,0 -69.28,-40" fill="#ff4d4d" />
-    
-    <!-- Right core face -->
-    <polygon points="0,0 69.28,-40 69.28,40 0,80" fill="#b30000" />
-    
-    <!-- Left core face -->
-    <polygon points="0,0 0,80 -69.28,40 -69.28,-40" fill="#800000" />
-    
-    <!-- Power lines radiating from the core -->
-    <line x1="0" y1="-80" x2="0" y2="-180" stroke="#ff0000" stroke-width="4" filter="url(#glow)" />
-    <line x1="69.28" y1="40" x2="155.88" y2="90" stroke="#ff0000" stroke-width="4" filter="url(#glow)" />
-    <line x1="-69.28" y1="40" x2="-155.88" y2="90" stroke="#ff0000" stroke-width="4" filter="url(#glow)" />
-    
-    <line x1="0" y1="80" x2="0" y2="180" stroke="#ff0000" stroke-width="2" stroke-dasharray="5,5" />
-    <line x1="-69.28" y1="-40" x2="-155.88" y2="-90" stroke="#ff0000" stroke-width="2" stroke-dasharray="5,5" />
-    <line x1="69.28" y1="-40" x2="155.88" y2="-90" stroke="#ff0000" stroke-width="2" stroke-dasharray="5,5" />
-    
-    <!-- Terminal connection dots -->
-    <circle cx="0" cy="-180" r="8" fill="#ff3333" filter="url(#glow)" />
-    <circle cx="155.88" cy="90" r="8" fill="#ff3333" filter="url(#glow)" />
-    <circle cx="-155.88" cy="90" r="8" fill="#ff3333" filter="url(#glow)" />
-    <circle cx="0" cy="180" r="5" fill="#800000" />
-    <circle cx="-155.88" cy="-90" r="5" fill="#800000" />
-    <circle cx="155.88" cy="-90" r="5" fill="#800000" />
-  </g>
-</svg>

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

@@ -1,292 +0,0 @@
-from __future__ import annotations
-
-import subprocess
-import sys
-from pathlib import Path
-
-import typer
-from rich.console import Console
-from rich.table import Table
-
-from devcouncil.cli.commands import run as run_command
-from devcouncil.cli.commands.integrate import _load_raw_config, _project_root, _save_raw_config
-from devcouncil.executors.agent_registry import (
-    VALID_INPUT_MODES,
-    agent_config_entry,
-    detect_available_coding_cli,
-    is_reserved_agent_name,
-    load_agent_profiles,
-    load_cli_agent_specs,
-    normalize_agent_name,
-    resolve_automated_executor,
-    resolve_cursor_agent_executable,
-)
-from devcouncil.optimization.gepa_agent import GepaUnavailableError, optimize_agent_profile
-
-app = typer.Typer(help="Manage DevCouncil CLI agents.")
-console = Console()
-
-
-@app.callback(invoke_without_command=True)
-def list_agents(
-    ctx: typer.Context,
-    project_root: Path | None = typer.Option(None, "--project-root", help="Repository root containing .devcouncil/."),
-):
-    """List built-in and configured CLI agents."""
-    if ctx.invoked_subcommand is not None:
-        return
-
-    root = _project_root(project_root)
-    table = Table(title="DevCouncil Agents")
-    table.add_column("Agent", style="cyan")
-    table.add_column("Type")
-    table.add_column("Command")
-    table.add_column("Profile")
-    table.add_column("MCP")
-    table.add_column("Diff Review")
-
-    for name, spec in sorted(load_cli_agent_specs(root).items()):
-        table.add_row(
-            name,
-            "built-in" if spec.built_in else spec.kind,
-            " ".join(spec.base_command()),
-            spec.default_profile,
-            "yes" if spec.supports_mcp else "no",
-            "yes" if spec.supports_diff_review else "no",
-        )
-    console.print(table)
-
-
-@app.command("add")
-def add_agent(
-    name: str = typer.Argument(..., help="Agent name, for example opencode or aider."),
-    command: str = typer.Option(..., "--command", help="Executable to launch."),
-    arg: list[str] | None = typer.Option(None, "--arg", help="Argument to pass to the CLI. Repeat for multiple args."),
-    input_mode: str = typer.Option("stdin", "--input-mode", help="Prompt input mode: stdin, argument, or prompt-file."),
-    prompt_arg: str | None = typer.Option(None, "--prompt-arg", help="Flag used before the prompt or prompt file."),
-    timeout_seconds: int | None = typer.Option(None, "--timeout-seconds", help="Agent-specific timeout override."),
-    display_name: str | None = typer.Option(None, "--display-name", help="Human-readable agent name."),
-    kind: str = typer.Option("custom", "--kind", help="Agent kind, for example coding-cli or review-cli."),
-    supports_mcp: bool = typer.Option(False, "--supports-mcp", help="Mark this agent as MCP-capable."),
-    supports_diff_review: bool = typer.Option(False, "--supports-diff-review", help="Mark this agent as able to review diffs."),
-    default_profile: str = typer.Option("default", "--default-profile", help="Default execution profile for this agent."),
-    help_arg: list[str] | None = typer.Option(None, "--help-arg", help="Argument for the agent help command. Repeat for multiple args."),
-    project_root: Path | None = typer.Option(None, "--project-root", help="Repository root containing .devcouncil/."),
-):
-    """Register an arbitrary prompt-taking CLI as a DevCouncil agent."""
-    if input_mode not in VALID_INPUT_MODES:
-        console.print("[red]--input-mode must be one of: stdin, argument, prompt-file.[/red]")
-        raise typer.Exit(code=2)
-    if not name.strip():
-        console.print("[red]Agent name cannot be empty.[/red]")
-        raise typer.Exit(code=2)
-    if not command.strip():
-        console.print("[red]--command cannot be empty.[/red]")
-        raise typer.Exit(code=2)
-
-    root = _project_root(project_root)
-    if is_reserved_agent_name(name):
-        console.print(f"[red]'{name}' is reserved for a built-in DevCouncil agent.[/red]")
-        raise typer.Exit(code=2)
-    if default_profile not in load_agent_profiles(root):
-        console.print(f"[red]Unknown --default-profile '{default_profile}'.[/red]")
-        raise typer.Exit(code=2)
-
-    normalized = normalize_agent_name(name)
-    entry = agent_config_entry(
-        command=command,
-        args=arg or [],
-        input_mode=input_mode,
-        prompt_arg=prompt_arg,
-        timeout_seconds=timeout_seconds,
-        display_name=display_name,
-        kind=kind,
-        supports_mcp=supports_mcp,
-        supports_diff_review=supports_diff_review,
-        default_profile=default_profile,
-        help_command=[command, *(help_arg or [])] if help_arg else [],
-    )
-    config = _load_raw_config(root)
-    agents = config.setdefault("integrations", {}).setdefault("cli_agents", {}).setdefault("agents", {})
-    agents[normalized] = entry
-    _save_raw_config(root, config)
-    console.print(f"[green]Registered CLI agent '{normalized}' in .devcouncil/config.yaml.[/green]")
-
-
-@app.command("doctor")
-def doctor(
-    project_root: Path | None = typer.Option(None, "--project-root", help="Repository root containing .devcouncil/."),
-):
-    """Check configured CLI agents and execution profiles."""
-    root = _project_root(project_root)
-    profiles = load_agent_profiles(root)
-    table = Table(title="DevCouncil Agent Doctor")
-    table.add_column("Agent", style="cyan")
-    table.add_column("Status")
-    table.add_column("Details", no_wrap=True)
-
-    for name, spec in sorted(load_cli_agent_specs(root).items()):
-        if spec.name == "cursor":
-            executable = resolve_cursor_agent_executable()
-        else:
-            executable = _which(spec.executable)
-        mode_ok = spec.input_mode in VALID_INPUT_MODES
-        profile_ok = spec.default_profile in profiles
-        help_ok, help_detail = _check_help(spec.help_command or [spec.executable, "--help"])
-
-        if executable and mode_ok and profile_ok:
-            status = "[green]OK[/green]"
-        elif executable:
-            status = "[red]Invalid[/red]"
-        else:
-            status = "[yellow]Missing[/yellow]"
-
-        details = []
-        details.append(executable or f"{spec.executable} not found on PATH")
-        if not mode_ok:
-            details.append(f"invalid input_mode={spec.input_mode}")
-        if not profile_ok:
-            details.append(f"missing profile={spec.default_profile}")
-        if help_ok:
-            details.append("help command OK")
-        elif not spec.built_in:
-            details.append(help_detail)
-        table.add_row(name, status, "; ".join(details))
-
-    console.print(table)
-    detected = detect_available_coding_cli(root)
-    if detected:
-        resolved = resolve_automated_executor(root, None)
-        console.print(
-            f"\n[dim]Auto-pick for dev go / dev run:[/dim] [cyan]{resolved}[/cyan] "
-            f"(first built-in CLI on PATH in probe order)"
-        )
-    else:
-        console.print("\n[dim]No built-in coding CLI on PATH for auto-pick.[/dim]")
-
-
-@app.command("run")
-def run_agent(
-    task_id: str = typer.Argument(..., help="ID of the task to run."),
-    agent: str = typer.Option(..., "--agent", "-a", help="Agent name to execute."),
-    profile: str | None = typer.Option(None, "--profile", help="Execution profile: default, yolo, prod, or configured."),
-    stream: bool = typer.Option(
-        False,
-        "--stream",
-        help="Stream coding CLI stdout/stderr live (also enabled by execution.stream_cli_output).",
-    ),
-    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
-):
-    """Run a DevCouncil task with a named CLI agent and profile."""
-    run_command.run(task_id, executor=agent, profile=profile, stream=stream, project_root=project_root)
-
-
-def _which(command: str) -> str | None:
-    from shutil import which
-
-    return which(command)
-
-
-@app.command("help")
-def agent_help(
-    name: str = typer.Argument(..., help="Agent name, for example codex or opencode."),
-    project_root: Path | None = typer.Option(None, "--project-root", help="Repository root containing .devcouncil/."),
-):
-    """Show the underlying CLI agent's own help output."""
-    root = _project_root(project_root)
-    spec = load_cli_agent_specs(root).get(normalize_agent_name(name))
-    if spec is None:
-        console.print(f"[red]Unknown agent '{name}'. Use 'dev agents' to list available agents.[/red]")
-        raise typer.Exit(code=1)
-    command = list(spec.help_command) or [spec.executable, "--help"]
-    executable = _which(command[0])
-    if not executable:
-        console.print(f"[red]{command[0]} is not installed or not on PATH.[/red]")
-        raise typer.Exit(code=1)
-    resolved = [executable, *command[1:]]
-    use_shell = sys.platform == "win32" and Path(executable).suffix.lower() in {".bat", ".cmd", ".ps1"}
-    try:
-        result = subprocess.run(
-            subprocess.list2cmdline(resolved) if use_shell else resolved,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-            timeout=15,
-            shell=use_shell,
-        )
-    except (subprocess.TimeoutExpired, FileNotFoundError, OSError) as exc:
-        console.print(f"[red]Failed to run {' '.join(command)}: {exc}[/red]")
-        raise typer.Exit(code=1)
-    output = (result.stdout or "") + (result.stderr or "")
-    typer.echo(output.strip())
-    raise typer.Exit(code=result.returncode)
-
-
-def _check_help(command: list[str]) -> tuple[bool, str]:
-    executable = _which(command[0]) if command else None
-    if not command or not executable:
-        return False, "help command unavailable"
-    resolved = [executable, *command[1:]]
-    use_shell = sys.platform == "win32" and Path(executable).suffix.lower() in {".bat", ".cmd", ".ps1"}
-    try:
-        result = subprocess.run(
-            subprocess.list2cmdline(resolved) if use_shell else resolved,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-            timeout=5,
-            shell=use_shell,
-        )
-    except subprocess.TimeoutExpired:
-        return False, "help command timed out"
-    return result.returncode == 0, f"help command exited {result.returncode}"
-
-
-@app.command("optimize")
-def optimize_agent(
-    agent: str = typer.Option(..., "--agent", "-a", help="Agent name to optimize, for example codex or opencode."),
-    profile_name: str = typer.Option("default", "--profile", help="Profile name to optimize: default, yolo, prod, or configured."),
-    evals_path: Path = typer.Option(..., "--evals", help="JSON or JSONL GEPA evaluation dataset."),
-    max_metric_calls: int = typer.Option(40, "--max-metric-calls", min=1, help="Maximum GEPA metric calls."),
-    objective: str | None = typer.Option(None, "--objective", help="Override the default optimization objective."),
-    apply: bool = typer.Option(
-        False,
-        "--apply/--dry-run",
-        help="Write the optimized preamble into .devcouncil/config.yaml. Defaults to dry-run.",
-    ),
-    output_path: Path | None = typer.Option(None, "--output", help="Write the optimization artifact to this path."),
-    project_root: Path | None = typer.Option(None, "--project-root", help="Repository root containing .devcouncil/."),
-):
-    """
-    Optimize a CLI-agent profile prompt preamble with GEPA.
-    """
-    root = _project_root(project_root)
-    try:
-        result = optimize_agent_profile(
-            project_root=root,
-            agent=agent,
-            profile_name=profile_name,
-            evals_path=evals_path,
-            max_metric_calls=max_metric_calls,
-            objective=objective,
-            apply=apply,
-            output_path=output_path,
-        )
-    except GepaUnavailableError as exc:
-        console.print(f"[red]{exc}[/red]")
-        raise typer.Exit(code=1) from exc
-    except ValueError as exc:
-        console.print(f"[red]{exc}[/red]")
-        raise typer.Exit(code=2) from exc
-
-    mode = "applied" if result.applied else "dry-run"
-    score = "unknown" if result.best_score is None else f"{result.best_score:.3f}"
-    console.print(
-        f"[green]GEPA optimization complete ({mode}) for {result.agent}:{result.profile_name}.[/green]"
-    )
-    console.print(f"Score: [bold]{score}[/bold]")
-    console.print(f"Artifact: [dim]{result.artifact_path}[/dim]")
-    console.print("\n[bold]Optimized preamble[/bold]")
-    console.print(result.best_preamble or "[dim](empty)[/dim]")

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

@@ -1,54 +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(
-    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
-):
-    """Validate requirements and tasks stored in the artifact graph."""
-    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)
-
-    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]")