core-runtime 0.1.1__py3-none-any.whl

cli/commands/check/diagnostics_commands.py

@@ -0,0 +1,70 @@
+# src/cli/commands/check/diagnostics_commands.py
+"""
+Diagnostic and contract verification commands.
+
+Thin clients over /v1/quality/* (ADR-055 D6 Batch C3). Policy coverage
+and Body UI contract checks both execute server-side; this module
+renders the responses.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.console import Console
+
+from api.cli import CoreApiClient
+from cli.logic.diagnostics_policy import policy_coverage
+from cli.utils import core_command
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@core_command(dangerous=False)
+# ID: 2d3aad66-4285-48c7-b65d-f32ab7f86a01
+async def diagnostics_cmd(ctx: typer.Context) -> None:
+    """
+    Audit the constitution for policy coverage and structural integrity.
+    """
+    _ = ctx
+    await policy_coverage()
+
+
+@core_command(dangerous=False)
+# ID: a2eeec63-e811-4430-8e97-7d317bd0c384
+async def check_body_ui_cmd(ctx: typer.Context) -> None:
+    """
+    Check for Body layer UI contract violations (print, rich usage, os.environ).
+
+    Body modules must be HEADLESS.
+    """
+    _ = ctx
+    console.print("[bold cyan]🔍 Checking Body UI Contracts...[/bold cyan]")
+    client = CoreApiClient()
+    result = await client.quality_body_ui()
+    if result.get("status") == "ok":
+        console.print("[green]✅ Body contracts compliant.[/green]")
+        return
+
+    violations = result.get("violations", [])
+    console.print(f"\n[red]❌ Found {len(violations)} contract violations:[/red]\n")
+    by_file: dict[str, list[dict]] = {}
+    for v in violations:
+        path = v.get("file", "unknown")
+        by_file.setdefault(path, []).append(v)
+    for path, file_violations in by_file.items():
+        console.print(f"[bold]{path}[/bold]:")
+        for v in file_violations:
+            rule = v.get("rule_id", "unknown")
+            msg = v.get("message", "")
+            line = v.get("line")
+            loc = f"line {line}" if line else "general"
+            console.print(f"  - [{rule}] {msg} ({loc})")
+        console.print()
+    console.print(
+        "[yellow]💡 Run 'core-admin fix body-ui --write' to auto-fix.[/yellow]"
+    )
+    raise typer.Exit(1)

cli/commands/check/formatters.py

@@ -0,0 +1,310 @@
+# src/cli/commands/check/formatters.py
+"""
+Output formatters for audit results.
+
+Handles Rich UI presentation of findings, summaries, and statistics.
+All formatting logic lives here - keeps command code clean.
+"""
+
+from __future__ import annotations
+
+import re
+from collections import defaultdict
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from shared.logger import getLogger
+from shared.models import AuditFinding, AuditSeverity
+
+
+logger = getLogger(__name__)
+console = Console()
+
+
+# ID: b0dc9c82-dd40-4970-94e8-911fd3354930
+def print_verbose_findings(findings: list[AuditFinding]) -> None:
+    """Prints every single finding in a detailed table for verbose output."""
+    table = Table(
+        title="[bold]Verbose Audit Findings[/bold]",
+        show_header=True,
+        header_style="bold magenta",
+    )
+    table.add_column("Severity", style="cyan")
+    table.add_column("Check ID", style="magenta")
+    table.add_column("Message", style="white", overflow="fold")
+    table.add_column("File:Line", style="yellow")
+    severity_styles = {
+        AuditSeverity.BLOCK: "[bold red]ERROR[/bold red]",
+        AuditSeverity.HIGH: "[bold yellow]WARNING[/bold yellow]",
+        AuditSeverity.INFO: "[dim]INFO[/dim]",
+    }
+    for finding in findings:
+        location = str(finding.file_path or "")
+        if finding.line_number:
+            location += f":{finding.line_number}"
+        table.add_row(
+            severity_styles.get(finding.severity, str(finding.severity)),
+            finding.check_id,
+            finding.message,
+            location,
+        )
+    console.print(table)
+
+
+# ID: cac19f77-d41c-4493-aeaa-7eb5af07cd90
+def print_summary_findings(findings: list[AuditFinding]) -> None:
+    """Groups findings by check ID only and prints a summary table."""
+    grouped_findings: dict[tuple[str, AuditSeverity], list[AuditFinding]] = defaultdict(
+        list
+    )
+    for f in findings:
+        key = (f.check_id, f.severity)
+        grouped_findings[key].append(f)
+    table = Table(
+        title="[bold]Audit Findings Summary[/bold]",
+        show_header=True,
+        header_style="bold magenta",
+    )
+    table.add_column("Severity", style="cyan")
+    table.add_column("Check ID", style="magenta")
+    table.add_column("Message", style="white", overflow="fold")
+    table.add_column("Occurrences", style="yellow", justify="right")
+    severity_styles = {
+        AuditSeverity.BLOCK: "[bold red]ERROR[/bold red]",
+        AuditSeverity.HIGH: "[bold yellow]WARNING[/bold yellow]",
+        AuditSeverity.INFO: "[dim]INFO[/dim]",
+    }
+    sorted_items = sorted(
+        grouped_findings.items(),
+        key=lambda item: (item[0][1], item[0][0]),
+        reverse=True,
+    )
+    for (check_id, severity), finding_list in sorted_items:
+        representative_message = finding_list[0].message
+        table.add_row(
+            severity_styles.get(severity, str(severity)),
+            check_id,
+            representative_message,
+            str(len(finding_list)),
+        )
+    console.print(table)
+    console.print("\n[dim]Run with '--verbose' to see all individual locations.[/dim]")
+
+
+# ID: 5127f2bc-b6fc-4452-9b6d-1c0d7f828043
+def print_audit_summary(
+    *,
+    passed: bool,
+    errors: list[AuditFinding],
+    warnings: list[AuditFinding],
+    unassigned_count: int | None = None,
+    title_prefix: str = "",
+) -> None:
+    """Print audit summary panel with pass/fail status."""
+    summary_table = Table.grid(expand=True, padding=(0, 1))
+    summary_table.add_column(justify="left")
+    summary_table.add_column(justify="right", style="bold")
+    summary_table.add_row("Errors:", f"[red]{len(errors)}[/red]")
+    summary_table.add_row("Warnings:", f"[yellow]{len(warnings)}[/yellow]")
+    if unassigned_count is not None:
+        summary_table.add_row("Unassigned Symbols:", f"[cyan]{unassigned_count}[/cyan]")
+    title = (
+        f"✅ {title_prefix}AUDIT PASSED" if passed else f"❌ {title_prefix}AUDIT FAILED"
+    )
+    style = "bold green" if passed else "bold red"
+    console.print(Panel(summary_table, title=title, style=style, expand=False))
+
+
+# ID: e76eccad-7bfe-4134-ae63-2e7be93f5536
+def print_filtered_audit_summary(
+    *,
+    passed: bool,
+    stats: dict,
+    errors: list[AuditFinding],
+    warnings: list[AuditFinding],
+) -> None:
+    """Print summary for filtered/focused audit runs."""
+    summary_table = Table.grid(expand=True, padding=(0, 1))
+    summary_table.add_column(justify="left")
+    summary_table.add_column(justify="right", style="bold")
+    summary_table.add_row("Total Rules:", str(stats["total_rules"]))
+    summary_table.add_row("Filtered Rules:", str(stats["filtered_rules"]))
+    summary_table.add_row("Executed Rules:", str(stats["executed_rules"]))
+    summary_table.add_row("Failed Rules:", f"[red]{stats.get('failed_rules', 0)}[/red]")
+    summary_table.add_row("", "")
+    summary_table.add_row("Total Findings:", str(stats["total_findings"]))
+    summary_table.add_row("Errors:", f"[red]{len(errors)}[/red]")
+    summary_table.add_row("Warnings:", f"[yellow]{len(warnings)}[/yellow]")
+    title = "✅ FILTERED AUDIT PASSED" if passed else "❌ FILTERED AUDIT FAILED"
+    style = "bold green" if passed else "bold red"
+    console.print(Panel(summary_table, title=title, style=style, expand=False))
+
+
+# ID: a6337eb6-9780-46a0-817c-0e02acd2d206
+def print_executed_rules(executed_rules: set[str]) -> None:
+    """Print list of executed rules."""
+    if not executed_rules:
+        return
+    console.print("\n[dim]Executed rules:[/dim]")
+    for rule_id in sorted(executed_rules):
+        console.print(f"  [dim]• {rule_id}[/dim]")
+
+
+# ID: ea2aff39-6dec-4462-9dd0-c4b116125e0a
+def print_migration_delta(*, legacy_executed: set[str], v2_rule_ids: set[str]) -> None:
+    """Print migration delta showing legacy vs v2 coverage."""
+    legacy_only = sorted(legacy_executed - v2_rule_ids)
+    v2_only = sorted(v2_rule_ids - legacy_executed)
+    overlap = sorted(legacy_executed & v2_rule_ids)
+    table = Table(
+        title="[bold]Migration Delta (Legacy vs Engine-Based)[/bold]",
+        show_header=True,
+        header_style="bold magenta",
+    )
+    table.add_column("Metric", style="cyan")
+    table.add_column("Count", style="yellow", justify="right")
+    table.add_row("Legacy executed ids (evidence)", str(len(legacy_executed)))
+    table.add_row("V2 rule ids (from findings)", str(len(v2_rule_ids)))
+    table.add_row("Overlap", str(len(overlap)))
+    table.add_row("Legacy-only", str(len(legacy_only)))
+    table.add_row("V2-only", str(len(v2_only)))
+    console.print(table)
+
+    def _sample(values: list[str], n: int = 15) -> str:
+        if not values:
+            return "-"
+        shown = values[:n]
+        more = len(values) - len(shown)
+        suffix = f" (+{more} more)" if more > 0 else ""
+        return ", ".join(shown) + suffix
+
+    details = Table(
+        title="[bold]Migration Candidates (Samples)[/bold]",
+        show_header=True,
+        header_style="bold magenta",
+    )
+    details.add_column("Category", style="cyan")
+    details.add_column("Sample ids", style="white", overflow="fold")
+    details.add_row("Legacy-only (candidate to migrate)", _sample(legacy_only))
+    details.add_row("V2-only (new coverage not in legacy evidence)", _sample(v2_only))
+    console.print(details)
+
+
+_CHECK_TO_TASK: dict[str, str] = {
+    "test": "test_generation",
+    "coverage": "test_generation",
+    "docstring": "code_modification",
+    "linkage": "code_modification",
+    "architecture": "code_modification",
+    "agent": "code_modification",
+    "safety": "code_modification",
+    "ai": "code_modification",
+    "purity": "code_modification",
+    "modularity": "code_modification",
+    "logic": "code_modification",
+    "workflow": "code_modification",
+}
+_SKIP_FILE_PREFIXES = ("DB", "none", "None", "System", "/")
+_CALL_PATTERNS = {"make_request_async", "make_request", "invoke", "print", "logger"}
+
+
+def _is_real_file_path(file_path: str) -> bool:
+    """Return True only for real source file paths."""
+    if not file_path:
+        return False
+    if any(file_path.startswith(p) for p in _SKIP_FILE_PREFIXES):
+        return False
+    if not file_path.endswith(".py"):
+        return False
+    return True
+
+
+def _infer_task_type(check_id: str) -> str:
+    """Map check_id prefix to the most appropriate context build task type."""
+    check_lower = check_id.lower()
+    for prefix, task in _CHECK_TO_TASK.items():
+        if check_lower.startswith(prefix):
+            return task
+    return "code_modification"
+
+
+def _extract_symbol(finding: AuditFinding) -> str | None:
+    """
+    Try to extract a symbol name from a finding.
+
+    Priority:
+    1. context["symbol_key"] / context["symbol_path"]
+    2. context["name"] / context["symbol_name"]
+    3. Parse message — only class/function names, not call patterns
+    """
+    ctx = finding.context or {}
+    symbol_key = ctx.get("symbol_key") or ctx.get("symbol_path")
+    if symbol_key:
+        name = str(symbol_key).split("::")[-1].strip()
+        if name and name not in _CALL_PATTERNS:
+            return name
+    name = ctx.get("name") or ctx.get("symbol_name")
+    if name and str(name).strip() not in _CALL_PATTERNS:
+        return str(name).strip()
+    match = re.search("'([A-Za-z_][A-Za-z0-9_]*)'", finding.message or "")
+    if match:
+        candidate = match.group(1)
+        if candidate not in _CALL_PATTERNS:
+            return candidate
+    return None
+
+
+# ID: 91657aab-4dc3-478b-9563-ce344e823e15
+def print_context_build_hints(findings: list[AuditFinding]) -> None:
+    """
+    Print exact context build commands for actionable findings.
+
+    Bridges audit output directly to the AI workflow with zero manual translation.
+    Only emits hints for ERROR/WARNING findings with real .py file paths,
+    deduplicated by (file, symbol) pair.
+    """
+    actionable = [
+        f
+        for f in findings
+        if _is_real_file_path(str(f.file_path or ""))
+        and f.severity >= AuditSeverity.HIGH
+    ]
+    if not actionable:
+        return
+    seen: set[tuple[str, str | None]] = set()
+    hints: list[tuple[AuditFinding, str | None]] = []
+    for f in actionable:
+        symbol = _extract_symbol(f)
+        key = (str(f.file_path), symbol)
+        if key not in seen:
+            seen.add(key)
+            hints.append((f, symbol))
+    console.print()
+    console.print(
+        Panel(
+            f"[dim]{len(hints)} actionable location(s). Run the command below for each, then paste the output to Claude.[/dim]",
+            title="[bold cyan]💡 AI Workflow — Next Steps[/bold cyan]",
+            expand=False,
+        )
+    )
+    severity_icon = {
+        AuditSeverity.BLOCK: "[bold red]❌ ERROR[/bold red]",
+        AuditSeverity.HIGH: "[bold yellow]⚠️  WARN [/bold yellow]",
+    }
+    for finding, symbol in hints:
+        file_path = str(finding.file_path)
+        task = _infer_task_type(finding.check_id)
+        icon = severity_icon.get(finding.severity, "")
+        console.print(f"\n  {icon} [magenta]{finding.check_id}[/magenta]")
+        console.print(f"  [dim]{finding.message[:100]}[/dim]")
+        if symbol:
+            console.print(
+                f"\n  [green]core-admin context build \\\n      --file {file_path} \\\n      --symbol {symbol} \\\n      --task {task} \\\n      --output var/context_for_claude.md[/green]"
+            )
+        else:
+            console.print(
+                f"\n  [green]core-admin context build \\\n      --file {file_path} \\\n      --task {task} \\\n      --output var/context_for_claude.md[/green]"
+            )
+    console.print()

cli/commands/check/imports.py

@@ -0,0 +1,73 @@
+# src/cli/commands/check/imports.py
+"""
+Import integrity check command — thin client over POST /v1/quality/imports.
+
+Enforces: code.imports.must_resolve, code.imports.no_stale_namespace.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@core_command(dangerous=False, requires_context=False)
+# ID: 90ad21a4-b24a-4247-aeb5-3abf13cb45ae
+async def imports_cmd(ctx: typer.Context) -> None:
+    """
+    Verify all import statements resolve to existing modules.
+
+    Checks for:
+    - F821: References to undefined names (moved/deleted modules)
+    - F401: Stale imports left after refactoring
+
+    Enforces constitutional rules:
+    - code.imports.must_resolve
+    - code.imports.no_stale_namespace
+    """
+    _ = ctx
+    console.rule("[bold cyan]Import Integrity Check[/bold cyan]")
+    console.print("[dim]Scanning src/ for unresolvable imports (F821, F401)...[/dim]\n")
+    client = CoreApiClient()
+    result = await client.quality_imports()
+    if result.get("status") == "ok":
+        console.print("[bold green]✅ All imports resolve cleanly.[/bold green]")
+        return
+    violations = result.get("violations", [])
+    violation_count = len(violations)
+    console.print(
+        f"[bold red]❌ {violation_count} unresolvable import(s) found.[/bold red]\n"
+    )
+    if violations:
+        table = Table(
+            title="Import Violations", show_header=True, header_style="bold red"
+        )
+        table.add_column("File", style="cyan", overflow="fold")
+        table.add_column("Line", style="yellow", justify="right", width=6)
+        table.add_column("Rule", style="magenta", width=6)
+        table.add_column("Message", style="white", overflow="fold")
+        for v in violations:
+            table.add_row(
+                v.get("file", ""),
+                str(v.get("line", "")),
+                v.get("rule", ""),
+                v.get("message", ""),
+            )
+        console.print(table)
+    console.print(
+        "\n[dim]Fix: Update stale import paths or remove unused imports.[/dim]"
+    )
+    console.print(
+        "[dim]Rule violated: code.imports.must_resolve (.intent/rules/code/imports.json)[/dim]"
+    )
+    raise typer.Exit(code=1)

cli/commands/check/quality.py

@@ -0,0 +1,71 @@
+# src/cli/commands/check/quality.py
+"""
+Code quality and system health commands.
+
+Thin clients over the /v1/quality namespace (ADR-055 D3). lint and
+tests are async (subprocess-backed); system bundles lint+tests+audit.
+"""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+
+console = Console()
+
+
+async def _poll_quality(client: CoreApiClient, label: str, initial: dict) -> dict:
+    """Poll an async /quality dispatch to terminal status, raising on failure."""
+    run_id = initial.get("run_id")
+    if not run_id:
+        console.print(f"[red]{label} failed to dispatch: {initial}[/red]")
+        raise typer.Exit(1)
+    final = await client._poll_run(run_id)
+    if final.get("status") != "completed":
+        console.print(f"[red]{label} failed: {final.get('error') or final}[/red]")
+        raise typer.Exit(1)
+    return final
+
+
+@core_command(dangerous=False)
+# ID: 23a0948a-570d-442d-b19a-ebd3af4f1c2d
+async def lint_cmd(ctx: typer.Context) -> None:
+    """
+    Check code formatting and quality using Black and Ruff.
+    """
+    _ = ctx
+    client = CoreApiClient()
+    initial = await client.quality_lint()
+    await _poll_quality(client, "quality.lint", initial)
+    console.print("[green]✓ lint completed.[/green]")
+
+
+@core_command(dangerous=False)
+# ID: 3e9af575-9c8b-483d-b63a-477e5c6b0a02
+async def tests_cmd(ctx: typer.Context) -> None:
+    """
+    Run the project test suite via pytest.
+    """
+    _ = ctx
+    client = CoreApiClient()
+    initial = await client.quality_tests()
+    await _poll_quality(client, "quality.tests", initial)
+    console.print("[green]✓ tests completed.[/green]")
+
+
+@core_command(dangerous=False)
+# ID: fdb8e693-c147-469a-a17a-1ee59227985b
+async def system_cmd(ctx: typer.Context) -> None:
+    """
+    Run all system health checks: Lint, Tests, and Constitutional Audit.
+    """
+    _ = ctx
+    client = CoreApiClient()
+    console.rule("[bold cyan]System Health Bundle (lint + tests + audit)[/bold cyan]")
+    initial = await client.quality_system()
+    await _poll_quality(client, "quality.system", initial)
+    console.print("[green]✓ system health bundle completed.[/green]")

cli/commands/check/quality_gates.py

@@ -0,0 +1,107 @@
+# src/cli/commands/check/quality_gates.py
+"""
+Quality Gates Command — thin client over POST /v1/quality/gates.
+
+Dispatches the six industry-standard checks (ruff/mypy/pytest/pip-audit/
+radon/vulture) server-side via fix_runs (kind='quality_check'). The CLI
+polls and renders the per-check summary.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@core_command(dangerous=False, requires_context=False)
+# ID: 41993614-7f98-425d-bfab-5c5d65c26d2f
+async def quality_gates_cmd(
+    ctx: typer.Context,
+    fix: bool = typer.Option(False, "--fix", help="Attempt to auto-fix violations"),
+    strict: bool = typer.Option(False, "--strict", help="Fail on warnings"),
+) -> None:
+    """
+    Run all quality gates (ruff, mypy, coverage, security, complexity, dead code).
+
+    Dispatches to POST /v1/quality/gates; the server runs the bundle and
+    persists per-check results in fix_runs.result. --fix and --strict are
+    forwarded as params.
+    """
+    _ = ctx
+    console.print("\n[bold blue]🔍 Running Quality Gates[/bold blue]\n")
+    client = CoreApiClient()
+    initial = await client.quality_gates()
+    run_id = initial.get("run_id")
+    if not run_id:
+        console.print(f"[red]quality.gates failed to dispatch: {initial}[/red]")
+        raise typer.Exit(1)
+    final = await client._poll_run(run_id)
+    if final.get("status") not in {"completed", "failed"}:
+        console.print(f"[red]quality.gates unexpected status: {final}[/red]")
+        raise typer.Exit(1)
+
+    payload = final.get("result") or {}
+    results = payload.get("checks", payload.get("results", []))
+    _display_summary(results, strict=strict, fix=fix)
+
+    critical_failures = [
+        r for r in results if not r.get("passed") and not r.get("is_warning")
+    ]
+    warning_failures = [
+        r for r in results if not r.get("passed") and r.get("is_warning")
+    ]
+    if critical_failures or (strict and warning_failures):
+        raise typer.Exit(code=1)
+
+
+def _display_summary(results: list[dict], *, strict: bool, fix: bool) -> None:
+    """Render the server's per-check results as a table."""
+    console.print("\n[bold]Quality Gates Summary[/bold]\n")
+    table = Table(show_header=True, header_style="bold cyan")
+    table.add_column("Check", style="cyan")
+    table.add_column("Status", justify="center")
+    table.add_column("Type", justify="center")
+    table.add_column("Summary", style="dim")
+    for result in results:
+        check_type = "WARNING" if result.get("is_warning") else "ERROR"
+        if result.get("passed"):
+            status = "[green]✓ PASS[/green]"
+        elif result.get("is_warning"):
+            status = "[yellow]⚠ WARN[/yellow]"
+        else:
+            status = "[red]✗ FAIL[/red]"
+        summary = result.get("summary", "")
+        if len(summary) > 60:
+            summary = summary[:60] + "..."
+        table.add_row(result.get("name", ""), status, check_type, summary)
+    console.print(table)
+    critical_fails = sum(
+        1 for r in results if not r.get("passed") and not r.get("is_warning")
+    )
+    warning_fails = sum(
+        1 for r in results if not r.get("passed") and r.get("is_warning")
+    )
+    if critical_fails == 0 and warning_fails == 0:
+        console.print("\n[bold green]✅ All quality gates passed![/bold green]\n")
+    elif critical_fails == 0:
+        console.print(
+            f"\n[bold yellow]⚠️  {warning_fails} warning(s) - review recommended[/bold yellow]\n"
+        )
+    else:
+        console.print(
+            f"\n[bold red]❌ {critical_fails} critical failure(s) - must fix before merge[/bold red]\n"
+        )
+    if fix:
+        logger.info("--fix forwarded to server (per-check auto-fix where supported).")
+    if strict:
+        logger.info("--strict in effect: warnings will fail this run.")