devcouncil 0.1.1 → 0.2.1

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

@@ -1,31 +0,0 @@
-import typer
-from rich.console import Console
-from sqlmodel import delete
-from pathlib import Path
-
-from devcouncil.storage.db import get_db
-from devcouncil.storage.models import EvidenceModel, GapModel, RequirementModel, TaskModel
-from devcouncil.cli.commands.init import initialize_project
-
-console = Console()
-
-
-def reset_demo_state(
-    yes: bool = typer.Option(False, "--yes", help="Confirm clearing planning/demo artifacts."),
-):
-    """Clear demo planning artifacts from the local DevCouncil state database."""
-    if not yes:
-        console.print("[red]Refusing to clear state without --yes.[/red]")
-        raise typer.Exit(code=1)
-
-    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)
-
-    with db.get_session() as session:
-        for model in (EvidenceModel, GapModel, TaskModel, RequirementModel):
-            session.exec(delete(model))
-
-    console.print("[green]Cleared requirements, tasks, gaps, and evidence from local state.[/green]")

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

@@ -1,60 +0,0 @@
-import typer
-import subprocess
-from pathlib import Path
-from rich.console import Console
-
-app = typer.Typer()
-console = Console()
-
-@app.callback(invoke_without_command=True)
-def rollback(
-    ctx: typer.Context,
-    task_id: str = typer.Argument(..., help="ID of the task to rollback"),
-    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
-):
-    """
-    Revert changes using a task's git checkpoint.
-    """
-    if ctx.invoked_subcommand is not None:
-        return
-
-    root = project_root.expanduser().resolve()
-    checkpoint_file = root / ".devcouncil" / "checkpoints" / f"{task_id}-before.patch"
-    after_patch = root / ".devcouncil" / "checkpoints" / f"{task_id}-after.patch"
-
-    if not checkpoint_file.exists() and not after_patch.exists():
-        console.print(
-            f"[red]No checkpoint found for task {task_id}. Expected {after_patch} "
-            f"or {checkpoint_file}.[/red]"
-        )
-        raise typer.Exit(code=1)
-
-    console.print(f"Rolling back task [bold]{task_id}[/bold]...")
-    
-    try:
-        if after_patch.exists():
-            # Reverse-apply the task's changes only
-            console.print(f"Applying reverse patch from [bold]{after_patch}[/bold]...")
-            subprocess.check_call(
-                ["git", "apply", "-R", str(after_patch)],
-                cwd=root,
-            )
-            console.print(f"[green]Successfully rolled back task {task_id} changes.[/green]")
-        else:
-            # No after-patch, but we have the before-patch — warn and offer manual reset
-            console.print(
-                f"[yellow]No after-patch found at {after_patch}.[/yellow]\n"
-                f"The before-patch at {checkpoint_file} captured the state before the task ran.\n"
-                f"To manually reset:\n"
-                f"  1. [bold]git stash[/bold] (if you want to keep current changes)\n"
-                f"  2. [bold]git checkout -- .[/bold] (discard working tree changes)\n"
-                f"  3. [bold]git apply {checkpoint_file}[/bold] (restore pre-task state)"
-            )
-    except subprocess.CalledProcessError as e:
-        console.print(f"[red]Failed to apply reverse patch: {e}[/red]")
-        console.print("[yellow]The patch may conflict with current changes. Try resolving manually:[/yellow]")
-        console.print(f"  git apply -R --3way {after_patch}")
-        raise typer.Exit(code=1)
-    except Exception as e:
-        console.print(f"[red]Failed to rollback: {e}[/red]")
-        raise typer.Exit(code=1)

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

@@ -1,269 +0,0 @@
-import typer
-import json
-from rich.console import Console
-from pathlib import Path
-from devcouncil.storage.db import get_db
-from devcouncil.storage.repositories import TaskRepository, RequirementRepository
-from devcouncil.executors.mini_swe import MiniSWEExecutor
-from devcouncil.executors.openhands import OpenHandsExecutor
-from devcouncil.executors.coding_cli import CodingCliExecutor
-from devcouncil.executors.native.agent import NativeAgent
-from devcouncil.llm.provider import create_provider, validate_model_provider
-from devcouncil.llm.router import ModelRouter
-from devcouncil.app.config import load_config, get_api_key
-from devcouncil.domain.evidence import CommandResult, DiffEvidence, TestEvidence
-from devcouncil.storage.repositories import GapRepository, EvidenceRepository, StateRepository
-from devcouncil.verification.verifier import Verifier
-from devcouncil.app.state_machine import ProjectPhase
-from devcouncil.cli.commands.init import initialize_project
-
-console = Console()
-CODING_EXECUTOR_ALIASES = {
-    "codex": "codex",
-    "codex-cli": "codex",
-    "gemini": "gemini",
-    "gemini-cli": "gemini",
-    "claude": "claude",
-    "claude-code": "claude",
-    "claude-cli": "claude",
-}
-
-CODING_EXECUTORS = set(CODING_EXECUTOR_ALIASES.keys())
-
-def _current_changed_files(project_root: Path = Path(".")) -> list[str]:
-    from devcouncil.verification.verifier import Verifier
-
-    return Verifier(project_root).get_changed_files()
-
-def _capture_after_patch(task_id: str, project_root: Path = Path(".")):
-    """Capture the diff after task execution for use by rollback."""
-    try:
-        from devcouncil.verification.verifier import Verifier
-
-        checkpoint_dir = project_root / ".devcouncil" / "checkpoints"
-        checkpoint_dir.mkdir(exist_ok=True)
-        diff = Verifier(project_root).get_diff()
-        if diff:
-            with open(checkpoint_dir / f"{task_id}-after.patch", "w", encoding="utf-8") as f:
-                f.write(diff)
-    except Exception:
-        pass  # Non-critical — don't block execution
-
-def _capture_before_snapshot(task_id: str, project_root: Path = Path(".")):
-    checkpoint_dir = project_root / ".devcouncil" / "checkpoints"
-    checkpoint_dir.mkdir(exist_ok=True)
-    snapshot = {
-        "task_id": task_id,
-        "changed_files": _current_changed_files(project_root),
-    }
-    (checkpoint_dir / f"{task_id}-before.json").write_text(
-        json.dumps(snapshot, indent=2),
-        encoding="utf-8",
-    )
-
-def _record_project_phase(session, phase: ProjectPhase):
-    StateRepository(session).record_phase(phase.value)
-
-def _verify_after_execution(session, task, reqs, router=None, project_root: Path = Path(".")) -> bool:
-    """Run deterministic verification after an automated executor finishes."""
-    import asyncio
-
-    verifier = Verifier(project_root, router=router)
-    gaps, evidence = asyncio.run(verifier.verify_task(task, reqs))
-
-    gap_repo = GapRepository(session)
-    evidence_repo = EvidenceRepository(session)
-    gap_repo.delete_for_task(task.id)
-    evidence_repo.delete_for_task(task.id)
-
-    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)
-
-    task.status = "blocked" if any(g.blocking for g in gaps) else "verified"
-    return task.status == "verified"
-
-def run(
-    task_id: str = typer.Argument(..., help="ID of the task to run"),
-    executor: str = typer.Option(
-        "manual",
-        "--executor",
-        "-e",
-        help="Executor to use (manual, mini, openhands, native, codex, codex-cli, gemini, gemini-cli, claude, claude-code, claude-cli)",
-    ),
-    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
-):
-    """
-    Execute a specific task.
-    """
-    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]")
-        return
-
-    with db.get_session() as session:
-        task_repo = TaskRepository(session)
-        task = task_repo.get_by_id(task_id)
-        if not task:
-            console.print(f"[red]Task {task_id} not found.[/red]")
-            return
-
-        from devcouncil.gating.policy import GatePolicy
-        policy = GatePolicy()
-        gate_result = policy.check_task_ready(task, root)
-        if not gate_result.passed:
-            console.print(f"[red]Task {task_id} is not ready for execution.[/red]")
-            for gap in gate_result.gaps:
-                if gap.blocking:
-                    console.print(f" - [red][BLOCKING][/red] {gap.description} (Fix: {gap.recommended_fix})")
-            return
-
-        console.print(f"Running task [bold]{task_id}[/bold] using [bold]{executor}[/bold] executor...")
-
-        # 1. Create Git checkpoint
-        try:
-            from devcouncil.verification.verifier import Verifier
-
-            checkpoint_dir = root / ".devcouncil" / "checkpoints"
-            checkpoint_dir.mkdir(exist_ok=True)
-            _capture_before_snapshot(task_id, root)
-            diff = Verifier(root).get_diff()
-            if diff:
-                with open(checkpoint_dir / f"{task_id}-before.patch", "w", encoding="utf-8") as f:
-                    f.write(diff)
-                console.print(f"Created git checkpoint at {checkpoint_dir}/{task_id}-before.patch")
-        except Exception as e:
-            console.print(f"[yellow]Warning: Failed to create git checkpoint: {e}[/yellow]")
-
-        executor = executor.strip().lower().replace("_", "-")
-        if executor == "manual":
-            _record_project_phase(session, ProjectPhase.TASK_EXECUTING)
-            task.status = "running"
-            task_repo.save(task)
-            console.print(f"\n[green]Task {task_id} is now marked as RUNNING.[/green]")
-            console.print("Use 'dev prompt TASK-ID' to get the prompt for this task.")
-            console.print("When finished, use 'dev verify TASK-ID' to check the results.")
-        elif executor in CODING_EXECUTORS:
-            _record_project_phase(session, ProjectPhase.TASK_EXECUTING)
-            req_repo = RequirementRepository(session)
-            reqs = req_repo.get_all()
-            cli_client = CODING_EXECUTOR_ALIASES[executor]
-            cli_executor = CodingCliExecutor(root, cli_client)
-            exec_result = cli_executor.run_task(task, reqs)
-            _capture_after_patch(task_id, root)
-            if exec_result.success:
-                _record_project_phase(session, ProjectPhase.TASK_VERIFYING)
-                verified = _verify_after_execution(session, task, reqs, project_root=root)
-                _record_project_phase(
-                    session,
-                    ProjectPhase.TASK_VERIFIED if verified else ProjectPhase.TASK_BLOCKED,
-                )
-                task_repo.save(task)
-                if verified:
-                    console.print(f"\n[green]{executor.upper()} finished and task {task_id} verified.[/green]")
-                else:
-                    console.print(f"\n[yellow]{executor.upper()} finished, but task {task_id} is blocked by verification gaps.[/yellow]")
-            else:
-                console.print(f"\n[red]{executor.upper()} failed to start or execute: {exec_result.message}[/red]")
-        elif executor == "mini":
-            _record_project_phase(session, ProjectPhase.TASK_EXECUTING)
-            req_repo = RequirementRepository(session)
-            reqs = req_repo.get_all()
-            mini_executor = MiniSWEExecutor(root)
-            exec_result = mini_executor.run_task(task, reqs)
-            _capture_after_patch(task_id, root)
-            if exec_result.success:
-                _record_project_phase(session, ProjectPhase.TASK_VERIFYING)
-                verified = _verify_after_execution(session, task, reqs, project_root=root)
-                _record_project_phase(
-                    session,
-                    ProjectPhase.TASK_VERIFIED if verified else ProjectPhase.TASK_BLOCKED,
-                )
-                task_repo.save(task)
-                if verified:
-                    console.print(f"\n[green]mini-SWE-agent finished and task {task_id} verified.[/green]")
-                else:
-                    console.print(f"\n[yellow]mini-SWE-agent finished, but task {task_id} is blocked by verification gaps.[/yellow]")
-            else:
-                console.print("\n[red]mini-SWE-agent failed to start or execute.[/red]")
-        elif executor == "openhands":
-            _record_project_phase(session, ProjectPhase.TASK_EXECUTING)
-            req_repo = RequirementRepository(session)
-            reqs = req_repo.get_all()
-            oh_executor = OpenHandsExecutor(root)
-            exec_result = oh_executor.run_task(task, reqs)
-            _capture_after_patch(task_id, root)
-            if exec_result.success:
-                _record_project_phase(session, ProjectPhase.TASK_VERIFYING)
-                verified = _verify_after_execution(session, task, reqs, project_root=root)
-                _record_project_phase(
-                    session,
-                    ProjectPhase.TASK_VERIFIED if verified else ProjectPhase.TASK_BLOCKED,
-                )
-                task_repo.save(task)
-                if verified:
-                    console.print(f"\n[green]OpenHands finished and task {task_id} verified.[/green]")
-                else:
-                    console.print(f"\n[yellow]OpenHands finished, but task {task_id} is blocked by verification gaps.[/yellow]")
-            else:
-                console.print("\n[red]OpenHands failed to start or execute.[/red]")
-        elif executor == "native":
-            # Load config for model routing and permissions
-            try:
-                config = load_config(root)
-                validate_model_provider(config.models.provider)
-                api_key = get_api_key(config.models.provider, root)
-            except (FileNotFoundError, ValueError) as e:
-                console.print(f"[red]{e}[/red]")
-                return
-            
-            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)
-            
-            # Setup Permission System
-            from devcouncil.execution.permissions import PermissionPolicy, PermissionManager
-            from devcouncil.execution.task_runner import TaskRunner
-            
-            # Populate policy from config commands
-            allowed_cmds = config.commands.test + config.commands.lint + config.commands.typecheck
-            policy = PermissionPolicy(
-                allowed_shell_commands=allowed_cmds,
-            )
-            perm_manager = PermissionManager(policy, root)
-            task_runner = TaskRunner(root, perm_manager)
-            
-            req_repo = RequirementRepository(session)
-            reqs = req_repo.get_all()
-            
-            import asyncio
-            _record_project_phase(session, ProjectPhase.TASK_EXECUTING)
-            agent = NativeAgent(router, task_runner)
-            exec_result = asyncio.run(agent.run_task(task, reqs))
-            _capture_after_patch(task_id, root)
-            
-            if exec_result.success:
-                _record_project_phase(session, ProjectPhase.TASK_VERIFYING)
-                verified = _verify_after_execution(session, task, reqs, router=router, project_root=root)
-                _record_project_phase(
-                    session,
-                    ProjectPhase.TASK_VERIFIED if verified else ProjectPhase.TASK_BLOCKED,
-                )
-                task_repo.save(task)
-                if verified:
-                    console.print(f"\n[green]Native agent finished and task {task_id} verified.[/green]")
-                else:
-                    console.print(f"\n[yellow]Native agent finished, but task {task_id} is blocked by verification gaps.[/yellow]")
-            else:
-                console.print("\n[red]Native agent failed during execution.[/red]")
-        else:
-            console.print(f"[red]Executor {executor} not yet implemented.[/red]")

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

@@ -1,223 +0,0 @@
-from pathlib import Path
-import os
-import shutil
-import sys
-
-import typer
-import yaml
-from rich.console import Console
-from rich.panel import Panel
-
-from devcouncil.app.config import load_config, load_local_secrets, provider_api_key_env_var
-from devcouncil.cli.commands.doctor import render_doctor_check
-from devcouncil.cli.commands.init import initialize_project
-from devcouncil.cli.commands.integrate import (
-    _claude_command,
-    _codex_command,
-    _configure_native_hooks,
-    _configure,
-    _cursor_command,
-    _gemini_command,
-)
-from devcouncil.llm.provider import validate_model_provider
-
-app = typer.Typer()
-console = Console()
-
-
-def _set_model_provider(project_root: Path, provider: str) -> None:
-    normalized = validate_model_provider(provider)
-    config_path = project_root / ".devcouncil" / "config.yaml"
-    raw_config = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
-    raw_config.setdefault("models", {})
-    previous = raw_config["models"].get("provider", "openrouter")
-    raw_config["models"]["provider"] = normalized
-    config_path.write_text(yaml.dump(raw_config, default_flow_style=False), encoding="utf-8")
-    if previous != normalized:
-        console.print(f"[green]Updated model provider from {previous} to {normalized}.[/green]")
-
-
-def _write_local_secret(project_root: Path, env_var: str, value: str) -> Path:
-    if "\n" in value or "\r" in value:
-        raise ValueError("API keys cannot contain newlines.")
-    secrets = load_local_secrets(project_root)
-    secrets[env_var] = value
-    path = project_root / ".devcouncil" / "secrets.env"
-    path.parent.mkdir(parents=True, exist_ok=True)
-    lines = [
-        "# Local DevCouncil secrets. This file is ignored by git.",
-        "# Process environment variables with the same name take precedence.",
-        *[f"{key}={val}" for key, val in sorted(secrets.items())],
-        "",
-    ]
-    path.write_text("\n".join(lines), encoding="utf-8")
-    return path
-
-
-def _configure_api_key(project_root: Path, api_key: str | None, skip_api_key: bool) -> None:
-    config = load_config(project_root)
-    provider = config.models.provider
-    env_var = provider_api_key_env_var(provider)
-    local_secrets = load_local_secrets(project_root)
-
-    if os.environ.get(env_var):
-        console.print(f"[green]{env_var} is already set in the environment.[/green]")
-        return
-    if local_secrets.get(env_var):
-        console.print(f"[green]{env_var} is already set in .devcouncil/secrets.env.[/green]")
-        return
-    if api_key:
-        _write_local_secret(project_root, env_var, api_key)
-        console.print(f"[green]Saved {env_var} to .devcouncil/secrets.env.[/green]")
-        return
-    if skip_api_key:
-        console.print(f"[yellow]Skipped {env_var} setup. Model-backed commands will ask again if it is missing.[/yellow]")
-        return
-    if not sys.stdin.isatty():
-        console.print(
-            f"[yellow]{env_var} is not set.[/yellow] "
-            f"Run [bold]dev setup --api-key YOUR_KEY[/bold] or set it in your shell before model-backed commands."
-        )
-        return
-
-    console.print()
-    console.print(Panel.fit(
-        "\n".join([
-            f"Provider: {provider}",
-            f"Required key: {env_var}",
-            "Press Enter without a value to skip for now.",
-        ]),
-        title="Model API Key",
-        border_style="cyan",
-    ))
-    entered = typer.prompt(f"{env_var}", default="", hide_input=True, show_default=False)
-    if not entered:
-        console.print(f"[yellow]Skipped {env_var} setup.[/yellow]")
-        return
-    _write_local_secret(project_root, env_var, entered)
-    console.print(f"[green]Saved {env_var} to .devcouncil/secrets.env.[/green]")
-
-
-def _is_interactive_terminal() -> bool:
-    return sys.stdin.isatty()
-
-
-def _configure_coding_cli_integrations(project_root: Path, apply: bool, gemini_scope: str) -> None:
-    console.print()
-    console.print("[bold]Coding CLI integration[/bold]")
-    commands = [
-        ("Codex CLI", _codex_command(project_root)),
-        ("Gemini CLI", _gemini_command(project_root, gemini_scope)),
-        ("Claude Code", _claude_command(project_root, "local")),
-        ("Cursor", _cursor_command(project_root)),
-    ]
-    results = []
-    for tool, command in commands:
-        if apply and not shutil.which(command[0]):
-            console.print(f"[yellow]{tool} CLI not found on PATH. Skipping optional integration.[/yellow]")
-            continue
-        results.append(_configure(tool, command, apply))
-    _configure_native_hooks(project_root, "all", apply)
-    if apply and any(not ok for ok in results):
-        raise typer.Exit(code=1)
-
-
-def _prompt_for_first_run_integrations(project_root: Path, apply: bool, gemini_scope: str) -> bool:
-    if not _is_interactive_terminal():
-        return False
-
-    console.print()
-    console.print(Panel.fit(
-        "\n".join([
-            "DevCouncil can configure supported coding CLIs now.",
-            "This adds MCP setup and native hook config for detected clients.",
-            "Missing optional clients are skipped.",
-        ]),
-        title="Coding CLI Setup",
-        border_style="cyan",
-    ))
-    if not typer.confirm("Set up coding CLI integrations now?", default=True):
-        console.print("[yellow]Skipped coding CLI integration setup.[/yellow]")
-        return False
-
-    _configure_coding_cli_integrations(project_root, apply=apply, gemini_scope=gemini_scope)
-    return True
-
-
-@app.callback(invoke_without_command=True)
-def setup(
-    ctx: typer.Context,
-    project_root: Path = typer.Option(
-        Path("."),
-        "--project-root",
-        help="Target project repository root. Defaults to the terminal's current directory.",
-    ),
-    name: str | None = typer.Option(None, "--name", "-n", help="Project name for .devcouncil/config.yaml."),
-    integrate: bool = typer.Option(False, "--integrate", help="Configure supported coding CLI MCP integrations and native hooks."),
-    apply: bool = typer.Option(False, "--apply", help="Apply integration config instead of previewing commands."),
-    gemini_scope: str = typer.Option("project", "--gemini-scope", help="Gemini MCP config scope: project or user."),
-    provider: str | None = typer.Option(None, "--provider", help="Set models.provider before configuring the API key."),
-    api_key: str | None = typer.Option(None, "--api-key", help="Store the configured provider API key in local .devcouncil/secrets.env."),
-    skip_api_key: bool = typer.Option(False, "--skip-api-key", help="Skip the first-run model API key prompt."),
-    skip_integrations: bool = typer.Option(False, "--skip-integrations", help="Skip the first-run coding CLI integration prompt."),
-):
-    """
-    Initialize DevCouncil from a normal terminal in the target repository root.
-
-    Use the coding CLI later only for the generated dev prompt output.
-    """
-    if ctx.invoked_subcommand is not None:
-        return
-
-    if gemini_scope not in {"project", "user"}:
-        console.print("[red]--gemini-scope must be 'project' or 'user'.[/red]")
-        raise typer.Exit(code=2)
-
-    root = project_root.expanduser().resolve()
-    created = initialize_project(root, project_name=name)
-    if not created:
-        console.print(f"[yellow]DevCouncil is already initialized at {root / '.devcouncil'}.[/yellow]")
-
-    if provider:
-        try:
-            _set_model_provider(root, provider)
-        except ValueError as e:
-            console.print(f"[red]{e}[/red]")
-            raise typer.Exit(code=2) from e
-
-    _configure_api_key(root, api_key, skip_api_key)
-
-    console.print()
-    render_doctor_check(root)
-
-    if integrate:
-        _configure_coding_cli_integrations(root, apply=apply, gemini_scope=gemini_scope)
-    elif created and not skip_integrations:
-        _prompt_for_first_run_integrations(root, apply=True, gemini_scope=gemini_scope)
-
-    console.print()
-    console.print(Panel.fit(
-        "\n".join([
-            "[bold]Next commands[/bold]",
-            f"Keep running DevCouncil commands in this terminal at: {root}",
-            "One-command agent path:",
-            "dev e2e \"Describe the implementation goal\"",
-            "",
-            "Manual sidecar path:",
-            "dev plan \"Describe the implementation goal\"",
-            "dev tasks",
-            "dev run TASK-001 --executor manual",
-            "dev prompt TASK-001",
-            "Paste only the dev prompt output into your coding CLI.",
-            "Paste only the dev prompt output into your coding CLI, or run directly:",
-            "dev run TASK-001 --executor codex",
-            "dev run TASK-001 --executor gemini",
-            "dev run TASK-001 --executor claude",
-            "dev verify TASK-001",
-            "",
-            "Use [bold]dev setup --integrate[/bold] to preview coding CLI MCP and native hook setup.",
-            "Use [bold]dev setup --integrate --apply[/bold] to configure detected clients.",
-        ]),
-        title="DevCouncil is ready",
-        border_style="green",
-    ))

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

@@ -1,76 +0,0 @@
-import json
-from pathlib import Path
-
-import typer
-from rich.console import Console
-from rich.panel import Panel
-from devcouncil.cli.commands.init import initialize_project
-from devcouncil.storage.db import get_db
-from devcouncil.storage.repositories import TaskRepository, RequirementRepository
-
-app = typer.Typer()
-console = Console()
-
-@app.callback(invoke_without_command=True)
-def show(
-    ctx: typer.Context,
-    task_id: str = typer.Argument(..., help="ID of the task to show"),
-    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 details of a specific task.
-    """
-    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:
-        raise typer.Exit(code=1)
-
-    with db.get_session() as session:
-        task_repo = TaskRepository(session)
-        req_repo = RequirementRepository(session)
-        
-        task = task_repo.get_by_id(task_id)
-        if not task:
-            console.print(f"[red]Task {task_id} not found.[/red]")
-            raise typer.Exit(code=1)
-        
-        reqs = req_repo.get_all()
-        req_map = {r.id: r for r in reqs}
-
-        if json_format:
-            linked_requirements = [
-                req_map[req_id].model_dump()
-                for req_id in task.requirement_ids
-                if req_id in req_map
-            ]
-            typer.echo(json.dumps({
-                "task": task.model_dump(),
-                "linked_requirements": linked_requirements,
-            }, indent=2))
-            return
-
-        output = f"[bold]Status:[/bold] {task.status}\n\n"
-        output += f"[bold]Description:[/bold]\n{task.description}\n\n"
-        
-        output += "[bold]Linked Requirements:[/bold]\n"
-        for req_id in task.requirement_ids:
-            req = req_map.get(req_id)
-            if req:
-                output += f"  - [cyan]{req.id}[/cyan]: {req.title}\n"
-            else:
-                output += f"  - [cyan]{req_id}[/cyan]: (Requirement not found)\n"
-                
-        output += "\n[bold]Planned Files:[/bold]\n"
-        for pf in task.planned_files:
-            output += f"  - {pf.path} ({pf.allowed_change}): {pf.reason}\n"
-            
-        output += "\n[bold]Expected Tests:[/bold]\n"
-        for et in task.expected_tests:
-            output += f"  - {et}\n"
-
-        console.print(Panel(output, title=f"Task {task.id}: {task.title}", expand=False))