raise-cli 2.2.1__py3-none-any.whl

raise_cli/cli/commands/doctor.py

@@ -0,0 +1,177 @@
+"""rai doctor — self-diagnostic and bug reporting.
+
+Architecture: ADR-045 (DoctorCheck protocol, E352).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from raise_cli.doctor.models import CheckStatus, DoctorContext
+from raise_cli.doctor.registry import CheckRegistry
+from raise_cli.doctor.runner import PIPELINE_ORDER, run_checks, summarize
+
+doctor_app = typer.Typer(
+    name="doctor",
+    help="Diagnose RaiSE setup, report problems, and auto-fix common issues.",
+    invoke_without_command=True,
+)
+
+console = Console(stderr=True)
+
+_STATUS_STYLE: dict[CheckStatus, tuple[str, str]] = {
+    CheckStatus.PASS: ("[green]OK[/green]", "  "),
+    CheckStatus.WARN: ("[yellow]!![/yellow]", "[yellow]!![/yellow]"),
+    CheckStatus.ERROR: ("[red]XX[/red]", "[red]XX[/red]"),
+}
+
+
+def _format_result_line(category: str, message: str, status: CheckStatus) -> str:
+    """Format a single result line for human output."""
+    _, prefix = _STATUS_STYLE[status]
+    return f"  {prefix} {category:14s} {message}"
+
+
+@doctor_app.callback()
+def doctor(
+    ctx: typer.Context,
+    verbose: Annotated[
+        bool,
+        typer.Option("--verbose", "-v", help="Show all checks including passing"),
+    ] = False,
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="JSON output for CI"),
+    ] = False,
+    fix: Annotated[
+        bool,
+        typer.Option("--fix", help="Auto-fix common issues (with backup)"),
+    ] = False,
+    online: Annotated[
+        bool,
+        typer.Option("--online", help="Include online checks (MCP, adapter connectivity)"),
+    ] = False,
+    category: Annotated[
+        str | None,
+        typer.Option("--category", "-c", help="Run only this check category"),
+    ] = None,
+) -> None:
+    """Run diagnostic checks on your RaiSE setup."""
+    if ctx.invoked_subcommand is not None:
+        return
+
+    registry = CheckRegistry()
+    registry.discover()
+
+    categories = [category] if category else None
+    if category and category not in PIPELINE_ORDER:
+        available = ", ".join(PIPELINE_ORDER)
+        console.print(f"Unknown category '{category}'. Available: {available}")
+        raise typer.Exit(1)
+
+    context = DoctorContext(
+        working_dir=Path.cwd(),
+        online=online,
+        verbose=verbose,
+    )
+
+    results = run_checks(registry, context, categories)
+    passes, warns, errors = summarize(results)
+
+    if json_output:
+        import json
+
+        out = Console()
+        data = {
+            "results": [
+                {
+                    "check_id": r.check_id,
+                    "category": r.category,
+                    "status": r.status.value,
+                    "message": r.message,
+                    "fix_hint": r.fix_hint,
+                    "details": list(r.details),
+                }
+                for r in results
+            ],
+            "summary": {"pass": passes, "warn": warns, "error": errors},
+        }
+        out.print_json(json.dumps(data))
+    else:
+        out = Console()
+        if not results:
+            out.print("No checks registered. Install raise-cli with extras for diagnostics.")
+            return
+
+        for r in results:
+            if not verbose and r.status == CheckStatus.PASS:
+                continue
+            out.print(_format_result_line(r.category, r.message, r.status))
+            if r.fix_hint:
+                from rich.markup import escape
+
+                out.print(f"       hint: {escape(r.fix_hint)}")
+
+        if warns == 0 and errors == 0:
+            out.print("\n[green]All checks passed.[/green]")
+        else:
+            parts: list[str] = []
+            if warns:
+                parts.append(f"{warns} warning{'s' if warns > 1 else ''}")
+            if errors:
+                parts.append(f"{errors} error{'s' if errors > 1 else ''}")
+            out.print(f"\n{', '.join(parts)}.")
+
+    if fix:
+        fixable = [r for r in results if r.fix_id and r.status != CheckStatus.PASS]
+        if fixable:
+            from raise_cli.doctor.fix import run_fixes
+
+            out = Console()
+            outcomes = run_fixes(fixable, Path.cwd())
+            for fix_id, success in outcomes:
+                status_label = "[green]fixed[/green]" if success else "[red]failed[/red]"
+                out.print(f"  fix: {fix_id} -- {status_label}")
+
+    if errors > 0:
+        raise typer.Exit(1)
+
+
+@doctor_app.command()
+def report(
+    send: Annotated[
+        bool, typer.Option("--send", help="Open email client with report"),
+    ] = False,
+) -> None:
+    """Generate diagnostic report, optionally send via email."""
+    from raise_cli.doctor.report import (
+        SUPPORT_EMAIL,
+        generate_report,
+        open_mailto,
+        save_report,
+    )
+
+    registry = CheckRegistry()
+    registry.discover()
+    context = DoctorContext(working_dir=Path.cwd())
+    results = run_checks(registry, context)
+
+    report_data = generate_report(results, Path.cwd())
+    saved = save_report(report_data, Path.cwd())
+    out = Console()
+    out.print(f"Report saved to {saved}")
+
+    if send:
+        opened = open_mailto(report_data)
+        if opened:
+            out.print("Email client opened. Review and send.")
+        else:
+            out.print("Could not open email client.")
+            out.print(f"Email to: {SUPPORT_EMAIL}")
+            out.print(f"Attach or paste the report from: {saved}")
+    else:
+        out.print("To send: rai doctor report --send")

raise_cli/cli/commands/gate.py

@@ -0,0 +1,223 @@
+"""CLI commands for workflow gate discovery and execution.
+
+Provides ``rai gate check`` and ``rai gate list`` for discovering
+and invoking registered WorkflowGate implementations.
+
+Architecture: ADR-039 §1 (WorkflowGate Protocol), §5 (Standalone gates)
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from raise_cli.gates.models import GateContext, GateResult
+from raise_cli.gates.protocol import WorkflowGate
+from raise_cli.gates.registry import GateRegistry
+
+logger = logging.getLogger(__name__)
+
+gate_app = typer.Typer(
+    name="gate",
+    help="Discover and run workflow gates",
+    no_args_is_help=True,
+)
+
+console = Console()
+
+
+def _get_registry() -> GateRegistry:
+    """Create and populate a gate registry from entry points."""
+    reg = GateRegistry()
+    reg.discover()
+    return reg
+
+
+def _run_gate(gate: WorkflowGate, context: GateContext) -> GateResult:
+    """Run a single gate with error isolation.
+
+    Gate exceptions are caught and converted to a failed GateResult.
+    Gates never crash the CLI.
+    """
+    try:
+        return gate.evaluate(context)
+    except Exception as exc:  # noqa: BLE001
+        msg = f"{type(exc).__name__}: {exc}"
+        logger.warning("Gate '%s' raised: %s", context.gate_id, msg)
+        return GateResult(
+            passed=False,
+            gate_id=context.gate_id,
+            message=msg,
+        )
+
+
+def _print_result(result: GateResult) -> None:
+    """Print a single gate result in human format."""
+    marker = "[green]✓[/green]" if result.passed else "[red]✗[/red]"
+    console.print(f"  {marker} {result.gate_id}: {result.message}")
+    for detail in result.details:
+        console.print(f"    {detail}")
+
+
+@gate_app.command("list")
+def list_command(
+    format: Annotated[
+        str,
+        typer.Option("--format", "-f", help="Output format: human or json"),
+    ] = "human",
+) -> None:
+    """List all discovered workflow gates.
+
+    Shows each gate's ID, description, and workflow point.
+
+    Examples:
+        $ rai gate list
+        $ rai gate list --format json
+    """
+    registry = _get_registry()
+    gates = registry.gates
+
+    if not gates:
+        if format == "json":
+            typer.echo(json.dumps({"gates": []}, indent=2))
+        else:
+            console.print("No gates discovered.")
+        return
+
+    if format == "json":
+        data = [
+            {
+                "gate_id": g.gate_id,
+                "description": g.description,
+                "workflow_point": g.workflow_point,
+            }
+            for g in gates
+        ]
+        typer.echo(json.dumps({"gates": data}, indent=2))
+    else:
+        console.print("[bold]Discovered gates:[/bold]\n")
+        for g in gates:
+            console.print(f"  {g.gate_id:<20s} {g.description:<30s} {g.workflow_point}")
+
+
+@gate_app.command("check")
+def check_command(
+    gate_id: Annotated[
+        str | None,
+        typer.Argument(help="Gate ID to check (omit for --all)"),
+    ] = None,
+    all_gates: Annotated[
+        bool,
+        typer.Option("--all", "-a", help="Run all discovered gates"),
+    ] = False,
+    format: Annotated[
+        str,
+        typer.Option("--format", "-f", help="Output format: human or json"),
+    ] = "human",
+) -> None:
+    """Run workflow gates and report results.
+
+    Check a specific gate by ID, or use --all to run every discovered gate.
+    Exit code 0 when all pass, 1 when any fail.
+
+    Examples:
+        $ rai gate check gate-tests
+        $ rai gate check --all
+        $ rai gate check --all --format json
+    """
+    registry = _get_registry()
+
+    if gate_id and all_gates:
+        console.print("[red]Error:[/red] Provide gate_id OR --all, not both.")
+        raise typer.Exit(1)
+
+    if not gate_id and not all_gates:
+        console.print("[red]Error:[/red] Provide a gate_id or use --all.")
+        raise typer.Exit(1)
+
+    if gate_id:
+        _check_single(registry, gate_id, format)
+    else:
+        _check_all(registry, format)
+
+
+def _check_single(registry: GateRegistry, gate_id: str, fmt: str) -> None:
+    """Check a single gate by ID."""
+    gate = registry.get_gate(gate_id)
+    if gate is None:
+        if fmt == "json":
+            typer.echo(json.dumps({"error": f"Gate '{gate_id}' not found"}))
+        else:
+            console.print(f"[red]Error:[/red] Gate '{gate_id}' not found.")
+        raise typer.Exit(1)
+
+    context = GateContext(gate_id=gate_id)
+    result = _run_gate(gate, context)
+
+    if fmt == "json":
+        typer.echo(
+            json.dumps(
+                {
+                    "gate_id": result.gate_id,
+                    "passed": result.passed,
+                    "message": result.message,
+                    "details": list(result.details),
+                },
+                indent=2,
+            )
+        )
+    else:
+        _print_result(result)
+
+    raise typer.Exit(0 if result.passed else 1)
+
+
+def _check_all(registry: GateRegistry, fmt: str) -> None:
+    """Check all discovered gates."""
+    gates = registry.gates
+    if not gates:
+        if fmt == "json":
+            typer.echo(json.dumps({"gates": [], "summary": "No gates discovered"}))
+        else:
+            console.print("No gates discovered.")
+        raise typer.Exit(0)
+
+    results: list[GateResult] = []
+    for gate in gates:
+        context = GateContext(gate_id=gate.gate_id)
+        result = _run_gate(gate, context)
+        results.append(result)
+
+    failed = [r for r in results if not r.passed]
+
+    if fmt == "json":
+        data = [
+            {
+                "gate_id": r.gate_id,
+                "passed": r.passed,
+                "message": r.message,
+                "details": list(r.details),
+            }
+            for r in results
+        ]
+        typer.echo(
+            json.dumps({"gates": data, "all_passed": len(failed) == 0}, indent=2)
+        )
+    else:
+        for r in results:
+            _print_result(r)
+        console.print()
+        if failed:
+            console.print(
+                f"[red bold]FAILED:[/red bold] {len(failed)} of {len(results)} gates failed"
+            )
+        else:
+            console.print(
+                f"[green bold]PASSED:[/green bold] {len(results)} gates passed"
+            )
+
+    raise typer.Exit(1 if failed else 0)