codeframe-ai 0.9.0__py3-none-any.whl

codeframe/cli/commands/__init__.py

@@ -0,0 +1,5 @@
+"""CLI command modules for CodeFRAME v2.
+
+Each module provides a Typer sub-application for a specific domain.
+Commands follow the pattern: codeframe <domain> <verb> [args] [--options]
+"""

codeframe/cli/config_commands.py

@@ -0,0 +1,79 @@
+"""`cf config` — machine-wide CodeFRAME configuration (issue #616)."""
+
+import os
+
+import typer
+from rich.console import Console
+
+from codeframe.core import telemetry as telemetry_core
+
+config_app = typer.Typer(
+    name="config",
+    help="Manage machine-wide CodeFRAME configuration",
+    no_args_is_help=True,
+)
+
+console = Console()
+
+
+@config_app.command()
+def telemetry(
+    action: str = typer.Argument(..., help="on | off | status"),
+) -> None:
+    """Enable, disable, or inspect anonymous telemetry (default: off).
+
+    See PRIVACY.md for exactly what is collected. Env overrides:
+    CODEFRAME_TELEMETRY=on|off always wins; DO_NOT_TRACK disables.
+    """
+    action = action.strip().lower()
+    if action not in ("on", "off", "status"):
+        console.print(f"[red]Error:[/red] unknown action '{action}' (expected on|off|status)")
+        raise typer.Exit(1)
+
+    if action == "status":
+        _print_status()
+        return
+
+    config = telemetry_core.load_config()
+    config.enabled = action == "on"
+    config.prompted = True
+    telemetry_core.save_config(config)
+
+    if config.enabled:
+        console.print(
+            "[green]Telemetry enabled.[/green] Anonymous usage events and crash "
+            "reports will be sent — see PRIVACY.md for exactly what is collected."
+        )
+        console.print(f"Anonymous id: [dim]{config.anonymous_id}[/dim]")
+    else:
+        console.print("[yellow]Telemetry disabled.[/yellow] Nothing will be sent.")
+
+
+def _print_status() -> None:
+    # Resolve the effective state from this single config read (rather than
+    # is_enabled(), which re-reads) so the displayed state and anonymous id
+    # can't disagree if the file changes between two loads.
+    config = telemetry_core.load_config()
+    override = telemetry_core.env_override()
+    dnt_active = os.environ.get("DO_NOT_TRACK", "").strip().lower() not in ("", "0", "false")
+    if override is not None:
+        effective = override
+    elif dnt_active:
+        effective = False
+    else:
+        effective = config.enabled
+    state = "[green]enabled[/green]" if effective else "[yellow]disabled[/yellow]"
+    console.print(f"Telemetry: {state}")
+
+    if override is not None:
+        console.print(
+            f"  (overridden by CODEFRAME_TELEMETRY={os.environ['CODEFRAME_TELEMETRY']})"
+        )
+    elif dnt_active:
+        console.print("  (disabled by DO_NOT_TRACK)")
+
+    console.print(f"  Config file: {telemetry_core.config_path()}")
+    console.print(f"  Endpoint: {telemetry_core.resolve_endpoint()}")
+    if telemetry_core.config_path().exists():
+        console.print(f"  Anonymous id: {config.anonymous_id}")
+    console.print("  Details: PRIVACY.md  |  Change: cf config telemetry on|off")

codeframe/cli/dashboard_commands.py

@@ -0,0 +1,67 @@
+"""CLI command for launching the TUI dashboard.
+
+Provides `cf dashboard` to launch the Textual-based terminal dashboard.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+console = Console()
+
+dashboard_app = typer.Typer(
+    name="dashboard",
+    help="Terminal dashboard for monitoring workspace state",
+    invoke_without_command=True,
+)
+
+
+@dashboard_app.callback(invoke_without_command=True)
+def dashboard(
+    repo_path: Optional[Path] = typer.Option(
+        None,
+        "--workspace", "-w",
+        help="Workspace path (defaults to current directory)",
+    ),
+    refresh_interval: int = typer.Option(
+        2,
+        "--refresh-interval",
+        min=1,
+        max=60,
+        help="Seconds between data refreshes (default: 2)",
+    ),
+) -> None:
+    """Launch the TUI dashboard.
+
+    Shows a live terminal dashboard with task board, event log,
+    and blocker notifications. Updates automatically.
+
+    Keyboard shortcuts:
+      q         Quit
+      r         Force refresh
+      Tab       Switch panels
+      Up/Down   Navigate rows
+
+    Example:
+        codeframe dashboard
+        codeframe dashboard --refresh-interval 5
+    """
+    from codeframe.core.workspace import get_workspace
+    from codeframe.tui.app import DashboardApp
+
+    workspace_path = repo_path or Path.cwd()
+
+    try:
+        workspace = get_workspace(workspace_path)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        console.print("[dim]Run 'codeframe init' to create a workspace first.[/dim]")
+        raise typer.Exit(1)
+
+    app = DashboardApp(
+        workspace=workspace,
+        refresh_interval=refresh_interval,
+    )
+    app.run()

codeframe/cli/engines_commands.py

@@ -0,0 +1,205 @@
+"""CLI engine management commands.
+
+Usage:
+    codeframe engines list           # Show available engines
+    codeframe engines check <name>   # Check engine requirements
+    codeframe engines stats          # Show engine performance stats
+    codeframe engines compare        # Compare engine performance
+"""
+
+import json as _json
+import logging
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from codeframe.core import engine_stats
+from codeframe.core.workspace import get_workspace
+
+logger = logging.getLogger(__name__)
+
+console = Console()
+
+engines_app = typer.Typer(
+    name="engines",
+    help="Engine management commands",
+    no_args_is_help=True,
+)
+
+
+@engines_app.command("list")
+def engines_list() -> None:
+    """List all available execution engines and their requirement status."""
+    from codeframe.core.engine_registry import VALID_ENGINES, EXTERNAL_ENGINES, check_requirements
+
+    table = Table(title="Available Engines")
+    table.add_column("Engine", style="cyan")
+    table.add_column("Type", style="dim")
+    table.add_column("Requirements", style="green")
+
+    for engine in sorted(VALID_ENGINES):
+        engine_type = "external" if engine in EXTERNAL_ENGINES else "builtin"
+        if engine == "built-in":
+            engine_type = "alias → react"
+
+        try:
+            reqs = check_requirements(engine)
+        except ValueError:
+            reqs = {}
+
+        if not reqs:
+            req_display = "[green]Ready[/green]"
+        else:
+            parts = []
+            for key, satisfied in reqs.items():
+                mark = "[green]✓[/green]" if satisfied else "[red]✗[/red]"
+                parts.append(f"{mark} {key}")
+            req_display = ", ".join(parts)
+
+        table.add_row(engine, engine_type, req_display)
+
+    console.print(table)
+
+
+@engines_app.command("check")
+def engines_check(
+    name: str = typer.Argument(..., help="Engine name to check"),
+) -> None:
+    """Check if an engine's requirements are satisfied."""
+    from codeframe.core.engine_registry import check_requirements
+
+    try:
+        reqs = check_requirements(name)
+    except ValueError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+    if not reqs:
+        console.print(f"[green]Engine '{name}' has no additional requirements.[/green]")
+        return
+
+    all_satisfied = True
+    for key, satisfied in reqs.items():
+        if satisfied:
+            console.print(f"  [green]✓[/green] {key}")
+        else:
+            console.print(f"  [red]✗[/red] {key} — not set")
+            all_satisfied = False
+
+    if all_satisfied:
+        console.print(f"\n[green]Engine '{name}' is ready.[/green]")
+    else:
+        console.print(f"\n[red]Engine '{name}' has unmet requirements.[/red]")
+        raise typer.Exit(1)
+
+
+def _get_current_workspace():
+    """Get workspace from current working directory.
+
+    Returns:
+        Workspace object.
+
+    Raises:
+        typer.Exit: If no workspace is found.
+    """
+    try:
+        return get_workspace(Path.cwd())
+    except (FileNotFoundError, ValueError):
+        console.print("[red]Error:[/red] No workspace found. Run 'cf init' first.")
+        raise typer.Exit(1)
+
+
+def _compute_success_rate(metrics: dict[str, float]) -> float:
+    """Compute success rate from engine metrics."""
+    attempted = metrics.get("tasks_attempted", 0)
+    completed = metrics.get("tasks_completed", 0)
+    if attempted == 0:
+        return 0.0
+    return round(100.0 * completed / attempted, 1)
+
+
+def _format_duration(ms: float) -> str:
+    """Format duration in human-readable form."""
+    if ms < 1000:
+        return f"{ms:.0f}ms"
+    return f"{ms / 1000:.1f}s"
+
+
+def _build_stats_table(stats: dict[str, dict[str, float]], title: str = "Engine Stats") -> Table:
+    """Build a Rich table from engine stats."""
+    table = Table(title=title)
+    table.add_column("Engine", style="cyan")
+    table.add_column("Tasks", justify="right")
+    table.add_column("Success %", justify="right", style="green")
+    table.add_column("Gate Pass %", justify="right")
+    table.add_column("Avg Duration", justify="right")
+    table.add_column("Total Tokens", justify="right")
+    table.add_column("Avg Tokens/Task", justify="right")
+
+    # Sort by success rate descending
+    sorted_engines = sorted(
+        stats.items(),
+        key=lambda item: _compute_success_rate(item[1]),
+        reverse=True,
+    )
+
+    for eng, metrics in sorted_engines:
+        success_rate = _compute_success_rate(metrics)
+        gate_rate = metrics.get("gate_pass_rate", 0.0)
+        avg_dur = metrics.get("avg_duration_ms", 0.0)
+        total_tok = metrics.get("total_tokens", 0.0)
+        avg_tok = metrics.get("avg_tokens_per_task", 0.0)
+        attempted = int(metrics.get("tasks_attempted", 0))
+
+        table.add_row(
+            eng,
+            str(attempted),
+            f"{success_rate}%",
+            f"{gate_rate}%",
+            _format_duration(avg_dur),
+            f"{int(total_tok):,}",
+            f"{int(avg_tok):,}",
+        )
+
+    return table
+
+
+@engines_app.command("stats")
+def stats(
+    engine: Optional[str] = typer.Option(None, "--engine", "-e", help="Filter by engine name"),
+    output_format: str = typer.Option("text", "--format", "-f", help="Output format: text or json"),
+) -> None:
+    """Show engine performance statistics."""
+    workspace = _get_current_workspace()
+    data = engine_stats.get_engine_stats(workspace, engine=engine)
+
+    if not data:
+        console.print("[yellow]No engine stats recorded yet.[/yellow]")
+        return
+
+    if output_format == "json":
+        console.print(_json.dumps(data, indent=2))
+        return
+
+    table = _build_stats_table(data, title="Engine Performance Stats")
+    console.print(table)
+
+
+@engines_app.command("compare")
+def compare() -> None:
+    """Compare performance across all engines."""
+    workspace = _get_current_workspace()
+    data = engine_stats.get_engine_stats(workspace)
+
+    if not data:
+        console.print(
+            "[yellow]No engine stats recorded yet. "
+            "Run tasks with different engines to see comparison.[/yellow]"
+        )
+        return
+
+    table = _build_stats_table(data, title="Engine Comparison (sorted by success rate)")
+    console.print(table)