forgex-cli 0.1.0__py3-none-any.whl

forgex/cli/commands/context.py

@@ -0,0 +1,94 @@
+"""`forgex context` — inspect the context index and retrieval (spec section 17)."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from rich.table import Table
+
+from forgex.cli.ui import JsonFlag, Output, PlainFlag, ui_from
+from forgex.context.manager import ContextManager
+from forgex.schemas.error import ProjectError
+from forgex.utils.paths import find_project_root
+
+app = typer.Typer(no_args_is_help=True, help="Inspect the project context index.")
+
+
+@app.command("stats")
+def stats_command(
+    ctx: typer.Context,
+    refresh: Annotated[bool, typer.Option("--refresh", help="Force a full re-index.")] = False,
+    json_out: JsonFlag = False,
+    plain: PlainFlag = False,
+) -> None:
+    """Index summary: files, languages, symbols, cache stats."""
+    ui = ui_from(ctx, json_out=json_out, plain=plain)
+    root = find_project_root()
+    if root is None:
+        raise ProjectError("Not inside a FORGEX project — run `forgex init` first.")
+
+    manager = ContextManager(root)
+    index = manager.ensure_index(refresh=refresh)
+    languages: dict[str, int] = {}
+    symbols = 0
+    imports = 0
+    for entry in index.files.values():
+        languages[entry.language] = languages.get(entry.language, 0) + 1
+        symbols += len(entry.symbols)
+        imports += len(entry.imports)
+
+    payload = {
+        "files": len(index.files),
+        "languages": languages,
+        "symbols": symbols,
+        "imports": imports,
+        "stats": index.stats,
+    }
+    ui.data(payload)
+
+    if ui.mode is Output.RICH:
+        table = Table(show_header=True, header_style="bold")
+        table.add_column("Metric")
+        table.add_column("Value")
+        table.add_row("Total Files", str(len(index.files)))
+        table.add_row("Languages", ", ".join(f"{k}: {v}" for k, v in languages.items()))
+        table.add_row("Symbols", str(symbols))
+        table.add_row("Imports", str(imports))
+        table.add_row("Cache Stats", str(index.stats))
+        ui.console.print(table)
+    elif ui.mode is Output.PLAIN:
+        ui.text(f"Files: {len(index.files)} | Symbols: {symbols} | Imports: {imports} | Stats: {index.stats}")
+
+
+@app.command("search")
+def search_command(
+    ctx: typer.Context,
+    query: Annotated[str, typer.Option("--query", "-q", help="Search query")] = "",
+    seeds: Annotated[list[str] | None, typer.Option("--seeds", "-s", help="Seed file paths")] = None,
+    limit: Annotated[int, typer.Option("--limit", "-n", help="Max results")] = 10,
+    json_out: JsonFlag = False,
+    plain: PlainFlag = False,
+) -> None:
+    """Relevance search across project files."""
+    ui = ui_from(ctx, json_out=json_out, plain=plain)
+    root = find_project_root()
+    if root is None:
+        raise ProjectError("Not inside a FORGEX project — run `forgex init` first.")
+
+    manager = ContextManager(root)
+    ranked = manager.relevant_files(query=query, seeds=seeds or [], limit=limit)
+    payload = [{"path": r.path, "score": r.score, "reasons": r.reasons} for r in ranked]
+    ui.data({"results": payload})
+
+    if ui.mode is Output.RICH:
+        table = Table(show_header=True, header_style="bold")
+        table.add_column("Score", style="cyan")
+        table.add_column("Path")
+        table.add_column("Reasons", overflow="fold")
+        for r in ranked:
+            table.add_row(str(r.score), r.path, "; ".join(r.reasons))
+        ui.console.print(table)
+    elif ui.mode is Output.PLAIN:
+        for r in ranked:
+            ui.text(f"[{r.score}] {r.path}: {'; '.join(r.reasons)}")

forgex/cli/commands/diff.py

@@ -0,0 +1,32 @@
+"""`forgex diff` — show the current Git diff (spec section 21)."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from forgex.cli.ui import JsonFlag, PlainFlag, ui_from
+from forgex.schemas.error import ProjectError
+from forgex.tools.git import git_diff, has_git_repo
+from forgex.utils.paths import find_project_root
+
+
+def diff_command(
+    ctx: typer.Context,
+    staged: Annotated[bool, typer.Option("--staged", help="Show staged changes.")] = False,
+    json_out: JsonFlag = False,
+    plain: PlainFlag = False,
+) -> None:
+    """Show the current Git diff."""
+    ui = ui_from(ctx, json_out=json_out, plain=plain)
+    root = find_project_root()
+    if root is None:
+        raise ProjectError("Not inside a FORGEX project — run `forgex init` first.")
+    if not has_git_repo(root):
+        ui.text("not a git repository")
+        raise typer.Exit(code=0)
+
+    diff = git_diff(root, staged=staged)
+    ui.data({"staged": staged, "diff": diff})
+    ui.text(diff or "(no changes)")

forgex/cli/commands/do_cmd.py

@@ -0,0 +1,50 @@
+"""`forgex do` — end-to-end autonomous execution pipeline."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Annotated
+
+import typer
+
+from forgex.cli.progress import render_pipeline_header, render_runtime_summary
+from forgex.cli.runtime import AutonomousRuntime
+from forgex.cli.ui import JsonFlag, Output, PlainFlag, ui_from
+
+
+def do_command(
+    ctx: typer.Context,
+    request: Annotated[list[str], typer.Argument(help="What to build or modify")],
+    resume: Annotated[bool, typer.Option("--resume", "-r", help="Resume interrupted build.")] = False,
+    dry_run: Annotated[bool, typer.Option("--dry-run", help="Show execution preview without making changes.")] = False,
+    json_out: JsonFlag = False,
+    plain: PlainFlag = False,
+) -> None:
+    """Run full autonomous pipeline: auto-init → plan → build → verify → repair → checkpoint."""
+    req_text = " ".join(request).strip()
+    if not req_text:
+        typer.echo("Error: Please describe what to build or modify.")
+        raise typer.Exit(code=2)
+
+    ui = ui_from(ctx, json_out=json_out, plain=plain)
+    if ui.mode is Output.RICH and not dry_run:
+        render_pipeline_header(req_text, console=ui.console)
+
+    runtime = AutonomousRuntime(ui=ui)
+    result = asyncio.run(runtime.execute(request=req_text, dry_run=dry_run, resume=resume))
+
+    if json_out or (ctx.obj and ctx.obj.get("json")):
+        ui.data({
+            "status": result.status,
+            "request": result.request,
+            "tasks_total": result.tasks_total,
+            "tasks_completed": result.tasks_completed,
+            "changed_files": result.changed_files,
+            "checkpoint": result.checkpoint_id,
+            "phases": result.phases_completed,
+            "duration": result.duration_seconds,
+        })
+    else:
+        render_runtime_summary(result, console=ui.console)
+
+    raise typer.Exit(code=0 if result.is_success else 1)

forgex/cli/commands/doctor.py

@@ -0,0 +1,175 @@
+"""`forgex doctor` — environment, tools, and configuration health checks (spec section 37)."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import sqlite3
+import subprocess
+import sys
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.table import Table
+
+from forgex import __version__
+from forgex.cli.ui import JsonFlag, Output, PlainFlag, ui_from
+from forgex.config import global_config_path, load_config
+from forgex.models.router import collect_health
+from forgex.schemas.error import ConfigError
+from forgex.utils.paths import find_project_root
+
+
+@dataclass
+class Check:
+    name: str
+    ok: bool
+    required: bool
+    detail: str
+
+
+def _check_python() -> Check:
+    v = sys.version_info
+    ok = (v.major, v.minor) >= (3, 12)
+    return Check(
+        "Python",
+        ok,
+        required=True,
+        detail=f"{v.major}.{v.minor}.{v.micro} (>= 3.12 required)",
+    )
+
+
+def _check_binary(name: str, *, required: bool, purpose: str) -> Check:
+    found = shutil.which(name) is not None
+    detail = f"found — {purpose}" if found else f"not found — {purpose}"
+    return Check(name, found, required=required, detail=detail)
+
+
+def _check_docker(config) -> list[Check]:
+    found = shutil.which("docker") is not None
+    sandbox_on = config is not None and config.sandbox.enabled
+    purpose = "sandboxed execution" + (" (ENABLED)" if sandbox_on else " (disabled)")
+    checks = [Check("Docker", found, required=sandbox_on, detail=f"found — {purpose}" if found else f"not found — {purpose}")]
+    if sandbox_on and found:
+        image = config.sandbox.image
+        try:
+            proc = subprocess.run(
+                ["docker", "image", "inspect", image],
+                capture_output=True,
+                timeout=15,
+                check=False,
+            )
+            ok = proc.returncode == 0
+            detail = f"image {image} present" if ok else f"image missing — run: docker pull {image}"
+        except (OSError, subprocess.TimeoutExpired):
+            ok, detail = False, "docker daemon unreachable"
+        checks.append(Check("Sandbox image", ok, required=False, detail=detail))
+    return checks
+
+
+def _check_credentials(config) -> list[Check]:
+    checks = []
+    for name, p_cfg in sorted(config.providers.items()):
+        env_var = p_cfg.api_key_env
+        if not env_var:
+            continue
+        val = os.environ.get(env_var)
+        checks.append(
+            Check(
+                f"Credential: {env_var}",
+                bool(val),
+                required=False,
+                detail=f"configured for provider '{name}'" if val else f"not set in environment (used by {name})",
+            )
+        )
+    return checks
+
+
+def _check_workspace(root: Path) -> Check:
+    return Check("Workspace", root.is_dir(), required=True, detail=str(root))
+
+
+def _check_sqlite() -> Check:
+    try:
+        conn = sqlite3.connect(":memory:")
+        conn.execute("CREATE TABLE t (x INT);")
+        conn.close()
+    except Exception as exc:  # noqa: BLE001
+        return Check("SQLite", False, required=True, detail=str(exc))
+    return Check("SQLite", True, required=True, detail="available (metadata storage)")
+
+
+def doctor_command(
+    ctx: typer.Context,
+    json_out: JsonFlag = False,
+    plain: PlainFlag = False,
+    ping: Annotated[bool, typer.Option("--ping", help="Also ping configured providers (network).")] = False,
+) -> None:
+    """Check environment, tools and configuration."""
+    ui = ui_from(ctx, json_out=json_out, plain=plain)
+    root = find_project_root() or Path.cwd()
+
+    try:
+        config = load_config(root)
+        config_error = None
+    except ConfigError as exc:
+        config, config_error = None, str(exc)
+
+    checks = [
+        _check_python(),
+        _check_binary("git", required=False, purpose="checkpoints and diffs"),
+        _check_binary("rg", required=False, purpose="fast code search (falls back to Python)"),
+    ]
+    checks.extend(_check_docker(config))
+
+    if config is not None:
+        gpath = global_config_path()
+        ppath = root / ".forgex" / "config.toml" if find_project_root() else None
+        sources = []
+        if gpath.is_file():
+            sources.append("global")
+        if ppath and ppath.is_file():
+            sources.append("project")
+        detail = "valid — " + (", ".join(sources) if sources else "defaults")
+        checks.append(Check("Configuration", True, required=True, detail=detail))
+        checks.extend(_check_credentials(config))
+    else:
+        checks.append(Check("Configuration", False, required=True, detail=config_error or "invalid"))
+
+    checks.append(_check_workspace(root))
+    checks.append(_check_sqlite())
+
+    if ping and config is not None:
+        for name, health in sorted(collect_health(config).items()):
+            checks.append(Check(f"Provider: {name}", health.ok, required=False, detail=health.detail))
+
+    all_required_ok = all(c.ok for c in checks if c.required)
+    ui.data({
+        "forgex": __version__,
+        "root": str(root),
+        "ok": all_required_ok,
+        "checks": [asdict(c) for c in checks],
+    })
+
+    if ui.mode is Output.RICH:
+        table = Table(show_header=True, header_style="bold", expand=False)
+        table.add_column("Check", style="bold")
+        table.add_column("Status")
+        table.add_column("Detail", overflow="fold")
+        for c in checks:
+            if c.ok:
+                status = "[green]✓[/green]"
+            elif c.required:
+                status = "[red]✗[/red]"
+            else:
+                status = "[yellow]○[/yellow] optional"
+            table.add_row(c.name, status, c.detail)
+        ui.console.print(table)
+    elif ui.mode is Output.PLAIN:
+        for c in checks:
+            label = "OK" if c.ok else ("FAIL" if c.required else "WARN")
+            ui.console.print(f"{label}: {c.name} — {c.detail}")
+
+    raise typer.Exit(code=0 if all_required_ok else 1)

forgex/cli/commands/fix.py

@@ -0,0 +1,46 @@
+"""`forgex fix` — verify → supervise → repair until green (spec sections 12, 22)."""
+
+from __future__ import annotations
+
+import asyncio
+
+import typer
+
+from forgex.cli.build_views import _render_failure, _render_success, format_progress
+from forgex.cli.ui import JsonFlag, Output, PlainFlag, make_approval, ui_from
+from forgex.config import load_config
+from forgex.orchestration.engine import BuildEngine
+from forgex.orchestration.stores import open_stores
+from forgex.schemas.error import ProjectError
+from forgex.utils.paths import find_project_root
+
+
+def fix_command(
+    ctx: typer.Context,
+    json_out: JsonFlag = False,
+    plain: PlainFlag = False,
+) -> None:
+    """Run verification + supervision + the repair loop. No rebuild."""
+    ui = ui_from(ctx, json_out=json_out, plain=plain)
+    root = find_project_root()
+    if root is None:
+        raise ProjectError("Not inside a FORGEX project — run `forgex init` first.")
+
+    config = load_config(root)
+    with open_stores(root) as stores:
+        engine = BuildEngine(
+            stores=stores,
+            config=config,
+            approval=make_approval(ui),
+            progress=lambda line: ui.text(format_progress(line, rich_mode=(ui.mode is Output.RICH))),
+        )
+        result = asyncio.run(engine.fix())
+
+    ui.data(result.model_dump(mode="json"))
+    if ui.mode in (Output.RICH, Output.PLAIN):
+        if result.status == "completed":
+            _render_success(ui, result)
+        else:
+            _render_failure(ui, result)
+
+    raise typer.Exit(code=0 if result.status == "completed" else 1)

forgex/cli/commands/init.py

@@ -0,0 +1,41 @@
+"""`forgex init` — scaffold the .forgex directory and detect the project."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from forgex.cli.ui import JsonFlag, PlainFlag, ui_from
+from forgex.orchestration.state import StateStore
+from forgex.project import detect_project, initialize_project
+
+
+def init_command(
+    ctx: typer.Context,
+    name: Annotated[str | None, typer.Argument(help="Target directory (defaults to current).")] = None,
+    json_out: JsonFlag = False,
+    plain: PlainFlag = False,
+) -> None:
+    """Initialize FORGEX in a project directory."""
+    ui = ui_from(ctx, json_out=json_out, plain=plain)
+    target = Path(name).resolve() if name else Path.cwd()
+
+    root = initialize_project(target)
+    detection = detect_project(root)
+    state = StateStore(root).load()
+
+    ui.data({
+        "root": str(root),
+        "project_id": state.project_id if state else None,
+        "detection": detection.as_dict(),
+    })
+    ui.ok(f"Initialized FORGEX project at {root}")
+    if state:
+        ui.text(f"Project ID: {state.project_id[:8]}")
+    ui.text(f"Detected: {detection.summary()}")
+    if detection.has_git:
+        ui.text("Git repository detected — checkpoints will be available.")
+    else:
+        ui.warn("No Git repository detected. Run 'git init' to enable checkpoints.")

forgex/cli/commands/logs.py

@@ -0,0 +1,102 @@
+"""`forgex logs` — inspect the project event stream (spec section 24)."""
+
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.markup import escape
+
+from forgex.cli.ui import JsonFlag, Output, PlainFlag, ui_from
+from forgex.orchestration.events import read_events
+from forgex.schemas.error import ConfigError, ProjectError
+from forgex.schemas.event import Event, EventType
+from forgex.utils.paths import find_project_root
+
+
+def _pairs(event: Event, width: int = 60) -> str:
+    parts = []
+    for key, value in event.data.items():
+        text = str(value).replace("\n", " ")
+        if len(text) > width:
+            text = text[: width - 1] + "…"
+        parts.append(f"{key}={text}")
+    return " ".join(parts)
+
+
+def _render(event: Event, *, rich: bool) -> str:
+    ts = event.ts.strftime("%H:%M:%S")
+    run = f" run={event.run_id[:8]}" if event.run_id else ""
+    pairs = _pairs(event)
+    if rich:
+        return (
+            f"[dim]{ts}[/dim] [bold cyan]{event.type.value}[/bold cyan]"
+            f"[dim]{escape(run)} {escape(pairs)}[/dim]"
+        ).rstrip()
+    return f"{ts} {event.type.value}{run} {pairs}".rstrip()
+
+
+def _follow(events_path: Path, event_type: EventType | None, ui) -> None:
+    """Poll JSONL and print appended events until interrupted."""
+    with events_path.open("r", encoding="utf-8") as fh:
+        fh.seek(0, os.SEEK_END)
+        while True:
+            line = fh.readline()
+            if not line:
+                time.sleep(0.5)
+                continue
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                event = Event.from_jsonl(line)
+            except Exception:  # noqa: BLE001
+                continue
+            if event_type is not None and event.type is not event_type:
+                continue
+            if ui.mode is Output.JSON:
+                ui.console.print(event.model_dump_json(), soft_wrap=True, highlight=False)
+            else:
+                ui.console.print(_render(event, rich=(ui.mode is Output.RICH)))
+
+
+def logs_command(
+    ctx: typer.Context,
+    event_type: Annotated[str | None, typer.Option("--type", "-t", help="Filter by EventType name.")] = None,
+    limit: Annotated[int | None, typer.Option("--limit", "-n", help="Limit event count (default: all).")] = None,
+    follow: Annotated[bool, typer.Option("--follow", "-f", help="Follow event stream in real-time.")] = False,
+    json_out: JsonFlag = False,
+    plain: PlainFlag = False,
+) -> None:
+    """Show recorded FORGEX events."""
+    ui = ui_from(ctx, json_out=json_out, plain=plain)
+    root = find_project_root()
+    if root is None:
+        raise ProjectError("Not inside a FORGEX project — run `forgex init` first.")
+
+    etype = None
+    if event_type:
+        try:
+            etype = EventType(event_type)
+        except ValueError:
+            valid = ", ".join(e.value for e in EventType)
+            raise ConfigError(f"Unknown event type '{event_type}'. Valid: {valid}") from None
+
+    events_path = root / ".forgex" / "events.jsonl"
+    if not events_path.is_file():
+        return
+
+    if follow:
+        _follow(events_path, etype, ui)
+        return
+
+    events = read_events(events_path, limit=limit, event_type=etype)
+    if ui.mode is Output.JSON:
+        for e in events:
+            ui.console.print(e.model_dump_json(), soft_wrap=True, highlight=False)
+    else:
+        for e in events:
+            ui.console.print(_render(e, rich=(ui.mode is Output.RICH)))

forgex/cli/commands/models.py

@@ -0,0 +1,144 @@
+"""`forgex models` — inspect agent bindings, catalog, and provider health."""
+
+from __future__ import annotations
+
+import os
+
+import typer
+from rich.table import Table
+
+from forgex.cli.ui import JsonFlag, Output, PlainFlag, ui_from
+from forgex.config import load_config
+from forgex.models.registry import ModelRegistry
+from forgex.models.router import collect_health
+from forgex.schemas.agent import AgentRole
+from forgex.utils.paths import find_project_root
+
+app = typer.Typer(help="Inspect model bindings, catalog, and provider health.")
+
+
+def _binding_rows(config) -> list[dict]:
+    rows = []
+    models_cfg = config.models
+    for role in AgentRole:
+        binding = getattr(models_cfg, role.value, None)
+        if not binding:
+            continue
+        prov_cfg = config.providers.get(binding.provider)
+        model = binding.model or (prov_cfg.default_model if prov_cfg else None) or "—"
+        env_var = prov_cfg.api_key_env if prov_cfg else None
+        cred = "set" if (env_var and os.environ.get(env_var)) else ("keyless" if not env_var else "missing")
+        rows.append({
+            "agent": role.value,
+            "provider": binding.provider,
+            "model": model,
+            "credential": cred,
+        })
+    return rows
+
+
+@app.callback(invoke_without_command=True)
+def models_default(
+    ctx: typer.Context,
+    json_out: JsonFlag = False,
+    plain: PlainFlag = False,
+) -> None:
+    if ctx.invoked_subcommand is not None:
+        return
+    ui = ui_from(ctx, json_out=json_out, plain=plain)
+    root = find_project_root()
+    config = load_config(root)
+    rows = _binding_rows(config)
+
+    ensemble_reviewers = None
+    if config.ensemble.enabled:
+        from forgex.agents.ensemble import resolve_reviewer_bindings
+        ensemble_reviewers = [f"{b.provider}/{b.model}" for b in resolve_reviewer_bindings(config)]
+
+    ui.data({"bindings": rows, "ensemble": ensemble_reviewers})
+    if ui.mode is Output.RICH:
+        table = Table(show_header=True, header_style="bold")
+        table.add_column("Agent")
+        table.add_column("Provider")
+        table.add_column("Model")
+        table.add_column("Credential")
+        for r in rows:
+            table.add_row(r["agent"], r["provider"], r["model"], r["credential"])
+        ui.console.print(table)
+        if ensemble_reviewers:
+            ui.text(f"Ensemble reviewers: {', '.join(ensemble_reviewers)}")
+    elif ui.mode is Output.PLAIN:
+        for r in rows:
+            ui.text(f"{r['agent']}: {r['provider']}/{r['model']} ({r['credential']})")
+        if ensemble_reviewers:
+            ui.text(f"Ensemble reviewers: {', '.join(ensemble_reviewers)}")
+
+
+@app.command("catalog")
+def catalog_command(
+    ctx: typer.Context,
+    json_out: JsonFlag = False,
+    plain: PlainFlag = False,
+) -> None:
+    """Show the advisory model capability catalog."""
+    ui = ui_from(ctx, json_out=json_out, plain=plain)
+    root = find_project_root()
+    config = load_config(root)
+    reg = ModelRegistry(config.models.capabilities)
+    catalog = reg.catalog()
+    payload = [c.model_dump() for c in catalog]
+    ui.data({"catalog": payload})
+
+    if ui.mode is Output.RICH:
+        table = Table(show_header=True, header_style="bold")
+        table.add_column("Model")
+        table.add_column("Context")
+        table.add_column("Tools")
+        table.add_column("JSON")
+        table.add_column("Stream")
+        for c in catalog:
+            table.add_row(
+                c.model,
+                str(c.context_window or "—"),
+                "✓" if c.supports_tools else "—",
+                "✓" if c.supports_json else "—",
+                "✓" if c.supports_streaming else "—",
+            )
+        ui.console.print(table)
+    elif ui.mode is Output.PLAIN:
+        for c in catalog:
+            ui.text(f"{c.model}: ctx={c.context_window} tools={c.supports_tools} json={c.supports_json}")
+
+
+@app.command("health")
+def health_command(
+    ctx: typer.Context,
+    json_out: JsonFlag = False,
+    plain: PlainFlag = False,
+) -> None:
+    """Live ping of all configured providers."""
+    ui = ui_from(ctx, json_out=json_out, plain=plain)
+    root = find_project_root()
+    config = load_config(root)
+    health_results = collect_health(config)
+
+    all_ok = all(h.ok for h in health_results.values())
+    payload = {name: h.model_dump() for name, h in health_results.items()}
+    ui.data({"ok": all_ok, "providers": payload})
+
+    if ui.mode is Output.RICH:
+        table = Table(show_header=True, header_style="bold")
+        table.add_column("Provider")
+        table.add_column("Status")
+        table.add_column("Detail")
+        table.add_column("Latency")
+        for name, h in sorted(health_results.items()):
+            status = "[green]✓[/green]" if h.ok else "[red]✗[/red]"
+            lat = f"{h.latency_ms:.0f}ms" if h.latency_ms is not None else "—"
+            table.add_row(name, status, h.detail, lat)
+        ui.console.print(table)
+    elif ui.mode is Output.PLAIN:
+        for name, h in sorted(health_results.items()):
+            ui.text(f"{name}: {'OK' if h.ok else 'FAIL'} ({h.detail})")
+
+    raise typer.Exit(code=0 if all_ok else 1)