core-runtime 0.1.1__py3-none-any.whl

cli/commands/coverage/generation_commands.py

@@ -0,0 +1,155 @@
+# src/cli/commands/coverage/generation_commands.py
+"""Test generation commands — V2 adaptive architecture.
+
+Thin clients over POST /v1/coverage/generate and /v1/coverage/generate:batch
+(ADR-057 D1). The async resource lifecycle (pending → executing →
+completed/failed) is polled via CoreApiClient.poll_coverage_run; the
+server owns the file iteration and the adaptive generator instance.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import typer
+from rich.console import Console
+
+from api.cli import CoreApiClient
+from cli.utils import core_command
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+# ID: b27c8ef7-9e92-4995-ae21-3a2f7d42b73d
+def register_generation_commands(app: typer.Typer) -> None:
+    """Register V2 test generation commands."""
+    app.command("generate-adaptive")(generate_adaptive_command)
+    app.command("generate-adaptive-batch")(generate_adaptive_batch_command)
+
+
+@core_command(dangerous=True, confirmation=True, requires_context=False)
+# ID: 35d81f3f-de8f-4984-b9ab-0b311669268d
+async def generate_adaptive_command(
+    ctx: typer.Context,
+    file_path: str = typer.Argument(..., help="Source file to generate tests for"),
+    write: bool = typer.Option(
+        False,
+        "--write",
+        help="Promote sandbox-passing tests to /tests (mirror src/). Route failures to var/artifacts/.",
+    ),
+    max_failures: int = typer.Option(
+        3, "--max-failures", help="Switch strategy after N failures with same pattern"
+    ),
+) -> None:
+    """Generate tests using adaptive learning (V2 - Component Architecture)."""
+    _ = ctx
+    _ = max_failures  # The API owns the adaptive failure threshold.
+    console.print("[bold cyan]🧪 Adaptive Test Generation (V2)[/bold cyan]\n")
+
+    client = CoreApiClient()
+    initial = await client.coverage_generate(target_file=file_path, write=write)
+    run_id = initial.get("run_id")
+    if not run_id:
+        console.print(f"[red]❌ coverage_generate failed to dispatch: {initial}[/red]")
+        raise typer.Exit(code=1)
+
+    console.print(f"[dim]Dispatched run {run_id} — polling…[/dim]")
+    final = await client.poll_coverage_run(run_id)
+    if final.get("status") != "completed":
+        console.print(f"[red]❌ Generation failed: {final.get('error') or final}[/red]")
+        raise typer.Exit(code=1)
+
+    payload = final.get("result") or {}
+    console.print("\n[bold]📊 Generation Results:[/bold]")
+    for key, label in (
+        ("file_path", "File"),
+        ("total_symbols", "Total symbols"),
+        ("tests_generated", "Validated tests"),
+        ("sandbox_passed", "Sandbox passed"),
+        ("tests_failed", "Sandbox failed"),
+        ("tests_skipped", "Skipped"),
+        ("success_rate", "Validation rate"),
+        ("strategy_switches", "Strategy switches"),
+        ("total_duration", "Duration (s)"),
+    ):
+        if key in payload:
+            console.print(f"  {label}: {payload[key]}")
+
+    patterns = payload.get("patterns_learned") or {}
+    if patterns:
+        console.print("\n[bold]🧠 Patterns Learned:[/bold]")
+        for pattern, count in sorted(
+            patterns.items(), key=lambda x: x[1], reverse=True
+        ):
+            console.print(f"  • {pattern}: {count}x")
+
+    if write:
+        console.print("\n[dim]Write mode:[/dim]")
+        console.print("  • Passing tests -> tests/... (mirrored)")
+        console.print("  • Failing tests  -> var/artifacts/test_gen/failures/...")
+
+    if payload.get("tests_generated", 0):
+        console.print("\n[bold green]✅ Completed generation cycle.[/bold green]")
+    else:
+        console.print(
+            "\n[bold yellow]⚠️  No tests validated successfully.[/bold yellow]"
+        )
+
+
+@core_command(dangerous=True, confirmation=True, requires_context=False)
+# ID: 4158a9ca-f87e-4311-8a02-ea8d5e696f40
+async def generate_adaptive_batch_command(
+    ctx: typer.Context,
+    priority: str = typer.Option(
+        "all", "--priority", help="Batch priority: 'high' or 'all'."
+    ),
+    write: bool = typer.Option(False, "--write", help="Save passing tests"),
+) -> None:
+    """Generate tests for multiple files via the API batch endpoint."""
+    _ = ctx
+    if priority not in {"high", "all"}:
+        console.print(
+            f"[red]Unknown priority '{priority}'. Allowed: 'high', 'all'.[/red]"
+        )
+        raise typer.Exit(code=1)
+
+    console.print(
+        "[bold cyan]🧪 Adaptive Test Generation - Batch Mode (V2)[/bold cyan]\n"
+    )
+    console.print(f"[cyan]Priority: {priority}[/cyan]")
+    console.print(f"[dim]Write mode: {'on' if write else 'dry-run'}[/dim]\n")
+
+    client = CoreApiClient()
+    initial = await client.coverage_generate_batch(priority=priority, write=write)
+    run_id = initial.get("run_id")
+    if not run_id:
+        console.print(
+            f"[red]❌ coverage_generate_batch failed to dispatch: {initial}[/red]"
+        )
+        raise typer.Exit(code=1)
+
+    console.print(f"[dim]Dispatched run {run_id} — polling…[/dim]")
+    final = await client.poll_coverage_run(run_id, timeout_seconds=1800.0)
+    if final.get("status") != "completed":
+        console.print(
+            f"[red]❌ Batch generation failed: {final.get('error') or final}[/red]"
+        )
+        raise typer.Exit(code=1)
+
+    payload = final.get("result") or {}
+    console.print("\n" + "=" * 80)
+    console.print("[bold]📊 Batch Generation Summary[/bold]\n")
+    for key, label in (
+        ("files_processed", "Files processed"),
+        ("files_failed", "Files failed"),
+        ("total_symbols", "Total symbols"),
+        ("tests_validated", "Tests validated"),
+        ("tests_sandbox_passed", "Tests sandbox-passed"),
+        ("tests_saved", "Tests saved"),
+        ("total_duration", "Duration (s)"),
+    ):
+        if key in payload:
+            console.print(f"  {label}: {payload[key]}")
+    console.print("=" * 80)

cli/commands/coverage/services/__init__.py

@@ -0,0 +1,15 @@
+# src/cli/commands/coverage/services/__init__.py
+"""Coverage service layer for reusable logic."""
+
+from __future__ import annotations
+
+from .coverage_checker import CoverageChecker
+from .coverage_reporter import CoverageReporter
+from .gaps_analyzer import GapsAnalyzer
+
+
+__all__ = [
+    "CoverageChecker",
+    "CoverageReporter",
+    "GapsAnalyzer",
+]

cli/commands/coverage/services/coverage_checker.py

@@ -0,0 +1,50 @@
+# src/cli/commands/coverage/services/coverage_checker.py
+"""Service for checking coverage against constitutional requirements.
+
+Thin client over GET /v1/coverage/check (ADR-057 D1). All data fetching
+crosses the HTTP boundary via CoreApiClient — no direct calls to
+mind.governance.filtered_audit (which is the API's backend, not a CLI
+dependency).
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from api.cli import CoreApiClient
+
+
+logger = logging.getLogger(__name__)
+
+
+# ID: 1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d
+class CoverageChecker:
+    """Checks coverage compliance via the API."""
+
+    def __init__(self, auditor_context: Any = None):
+        # auditor_context retained for call-site compatibility; the API
+        # owns the auditor context server-side now.
+        _ = auditor_context
+
+    # ID: c2727c81-f41c-4023-8d5b-94d90d71b1dd
+    async def check_compliance(self) -> dict[str, Any]:
+        """Check coverage against constitutional requirements.
+
+        Returns:
+            dict with keys:
+                - compliant: bool
+                - findings: list of violations
+                - blocking_violations: list of error-level violations
+        """
+        client = CoreApiClient()
+        payload = await client.coverage_check()
+        findings = payload.get("findings", [])
+        blocking_violations = [
+            f for f in findings if str(f.get("severity", "")).lower() == "error"
+        ]
+        return {
+            "compliant": payload.get("passed", len(findings) == 0),
+            "findings": findings,
+            "blocking_violations": blocking_violations,
+        }

cli/commands/coverage/services/coverage_reporter.py

@@ -0,0 +1,81 @@
+# src/cli/commands/coverage/services/coverage_reporter.py
+"""Service for generating coverage reports.
+
+Thin client over GET /v1/coverage/report (ADR-057 D1). The API runs
+coverage.py server-side and returns the report shape; CLI no longer
+shells out to subprocess directly.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from api.cli import CoreApiClient
+
+
+logger = logging.getLogger(__name__)
+
+
+# ID: 2b3c4d5e-6f7a-8b9c-0d1e-2f3a4b5c6d7e
+class CoverageReporter:
+    """Generates coverage reports via the API."""
+
+    def __init__(self, repo_path: Path):
+        # repo_path retained for call-site compatibility; the API resolves
+        # the repo root server-side now.
+        self.repo_path = repo_path
+        self.coverage_file = repo_path / ".coverage"
+
+    # ID: 45deb3d8-4955-4912-b017-659a6ee885b4
+    def has_coverage_data(self) -> bool:
+        """Check if coverage data exists locally.
+
+        Filesystem check — kept client-side to short-circuit calls when
+        the user hasn't run pytest yet.
+        """
+        return self.coverage_file.exists()
+
+    # ID: 052d759d-022b-4094-a850-c8afbb11f2a7
+    async def generate_text_report(self, show_missing: bool = True) -> str:
+        """Generate text coverage report via the API.
+
+        Args:
+            show_missing: Include line numbers of missing coverage
+
+        Returns:
+            Report output as string
+
+        Raises:
+            RuntimeError: If the API call fails
+        """
+        client = CoreApiClient()
+        payload = await client.coverage_report(show_missing=show_missing)
+        if not payload.get("ok", False):
+            error_msg = payload.get("summary") or "Coverage report failed"
+            raise RuntimeError(f"Coverage report failed: {error_msg}")
+        return "\n".join(payload.get("stdout_tail", []))
+
+    # ID: 2abbdff3-b661-4736-abea-69e89e7e383e
+    async def generate_html_report(self) -> Path:
+        """Generate HTML coverage report via the API.
+
+        Calls `GET /v1/coverage/report?format=html`, which runs pytest
+        with `--cov-report=html` server-side and returns the path to
+        the generated `htmlcov/` directory.
+
+        Returns:
+            Absolute path to the generated htmlcov/ directory.
+
+        Raises:
+            RuntimeError: If the API call fails or no html_path returned.
+        """
+        client = CoreApiClient()
+        payload = await client.coverage_report(output_format="html")
+        if not payload.get("ok", False):
+            error_msg = payload.get("summary") or "HTML coverage generation failed"
+            raise RuntimeError(f"Coverage HTML report failed: {error_msg}")
+        rel_path = payload.get("html_path")
+        if not rel_path:
+            raise RuntimeError("Coverage HTML report: server returned no html_path")
+        return self.repo_path / rel_path

cli/commands/coverage/services/gaps_analyzer.py

@@ -0,0 +1,114 @@
+# src/cli/commands/coverage/services/gaps_analyzer.py
+"""Service for analyzing coverage gaps and identifying low-coverage modules.
+
+Thin client over GET /v1/coverage/gaps (ADR-057 D1). The API owns the
+CoverageAnalyzer instance server-side; this CLI service just shapes the
+response for callers expecting the legacy below_threshold / sorted_lowest
+/ stats layout.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+from api.cli import CoreApiClient
+
+
+logger = logging.getLogger(__name__)
+
+
+_DEFAULT_GAP_THRESHOLD_PCT = 75.0
+_DEFAULT_LOW_BUCKET_PCT = 50.0
+_SORTED_LOWEST_LIMIT = 20
+
+
+# ID: 3c4d5e6f-7a8b-9c0d-1e2f-3a4b5c6d7e8f
+class GapsAnalyzer:
+    """Analyzes coverage data to identify gaps and priorities."""
+
+    def __init__(self, repo_root: Path):
+        # repo_root retained for call-site compatibility.
+        self.repo_root = repo_root
+
+    # ID: c902f595-d5bb-491e-94ea-cff937370d27
+    async def get_coverage_map(self) -> dict[str, float]:
+        """Get coverage percentage for all modules.
+
+        Fetches a generous gap list (threshold=100 returns all modules)
+        and projects to file→coverage. The /coverage/gaps endpoint is
+        the only one that exposes per-module coverage; a dedicated
+        /coverage/map endpoint would be cleaner but isn't in scope.
+        """
+        client = CoreApiClient()
+        payload = await client.coverage_gaps(threshold=100.0, limit=10_000)
+        gaps = payload.get("gaps", [])
+        return {g["file"]: float(g["coverage"]) for g in gaps}
+
+    # ID: 9ac607c3-502e-4cd1-9349-26fe7044d996
+    async def find_gaps(
+        self, threshold: float = _DEFAULT_GAP_THRESHOLD_PCT
+    ) -> dict[str, Any]:
+        """Find modules below coverage threshold.
+
+        Args:
+            threshold: Coverage percentage threshold (0-100)
+
+        Returns:
+            dict with keys:
+                - below_threshold: list of (module, coverage) tuples
+                - sorted_lowest: list of lowest 20 modules
+                - stats: summary statistics
+        """
+        coverage_map = await self.get_coverage_map()
+
+        if not coverage_map:
+            return {
+                "below_threshold": [],
+                "sorted_lowest": [],
+                "stats": {"total": 0, "below_threshold": 0, "below_50": 0},
+            }
+
+        sorted_modules = sorted(coverage_map.items(), key=lambda x: x[1])
+        below_threshold = [
+            (mod, cov) for mod, cov in coverage_map.items() if cov < threshold
+        ]
+
+        total_modules = len(coverage_map)
+        below_threshold_count = len(below_threshold)
+        below_50 = sum(
+            1 for cov in coverage_map.values() if cov < _DEFAULT_LOW_BUCKET_PCT
+        )
+
+        return {
+            "below_threshold": below_threshold,
+            "sorted_lowest": sorted_modules[:_SORTED_LOWEST_LIMIT],
+            "stats": {
+                "total": total_modules,
+                "below_threshold": below_threshold_count,
+                "below_50": below_50,
+                "threshold": threshold,
+            },
+        }
+
+    # ID: 9c458310-c4b0-41ad-ad9a-10ec65d23b53
+    async def prioritize_files(
+        self, pattern: str, max_coverage: float = 100.0, limit: int = 10
+    ) -> list[tuple[str, float]]:
+        """Get prioritized file list for test generation.
+
+        Args:
+            pattern: File glob pattern (not used, kept for interface compatibility)
+            max_coverage: Only include files at or below this coverage
+            limit: Maximum number of files to return
+
+        Returns:
+            List of (module_path, coverage) tuples, sorted by lowest coverage first
+        """
+        _ = pattern
+        coverage_map = await self.get_coverage_map()
+        eligible = [
+            (mod, cov) for mod, cov in coverage_map.items() if cov <= max_coverage
+        ]
+        return sorted(eligible, key=lambda x: x[1])[:limit]