crackerjack 0.37.9__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/managers/test_manager.py

@@ -1,49 +1,65 @@
+import re
 import subprocess
 import time
 import typing as t
 from pathlib import Path
 
-from rich.console import Console
-
-from crackerjack.models.protocols import CoverageRatchetProtocol, OptionsProtocol
+from acb.config import root_path
+from acb.console import Console
+from acb.depends import Inject, depends
+from rich import box
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from crackerjack.config import get_console_width
+from crackerjack.models.protocols import (
+    CoverageBadgeServiceProtocol,
+    CoverageRatchetProtocol,
+    OptionsProtocol,
+)
+from crackerjack.models.test_models import TestFailure
+from crackerjack.services.lsp_client import LSPClient
 
 from .test_command_builder import TestCommandBuilder
 from .test_executor import TestExecutor
 
+ANSI_ESCAPE_RE = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+
 
 class TestManager:
+    @depends.inject
     def __init__(
         self,
-        console: Console,
-        pkg_path: Path,
-        coverage_ratchet: CoverageRatchetProtocol | None = None,
+        console: Inject[Console],
+        coverage_ratchet: Inject[CoverageRatchetProtocol],
+        coverage_badge: Inject[CoverageBadgeServiceProtocol],
+        command_builder: Inject[TestCommandBuilder],
+        lsp_client: Inject[LSPClient] | None = None,
     ) -> None:
         self.console = console
-        self.pkg_path = pkg_path
-
-        self.executor = TestExecutor(console, pkg_path)
-        self.command_builder = TestCommandBuilder(pkg_path)
+        # Ensure a concrete pathlib.Path instance to avoid async Path behaviors
+        # and to guarantee sync filesystem operations in this manager.
+        try:
+            self.pkg_path = Path(str(root_path))
+        except Exception:
+            # Fallback in the unlikely event root_path lacks __str__
+            self.pkg_path = Path(root_path)
 
-        if coverage_ratchet is None:
-            from crackerjack.services.coverage_ratchet import CoverageRatchetService
+        # Ensure downstream components receive a concrete pathlib.Path
+        self.executor = TestExecutor(console, self.pkg_path)
+        self.command_builder = command_builder
 
-            coverage_ratchet_obj = CoverageRatchetService(pkg_path, console)
-            self.coverage_ratchet: CoverageRatchetProtocol | None = t.cast(
-                CoverageRatchetProtocol, coverage_ratchet_obj
-            )
-        else:
-            self.coverage_ratchet = coverage_ratchet
+        # Services injected via ACB DI
+        self.coverage_ratchet = coverage_ratchet
+        self._coverage_badge_service = coverage_badge
+        self._lsp_client = lsp_client
 
         self._last_test_failures: list[str] = []
         self._progress_callback: t.Callable[[dict[str, t.Any]], None] | None = None
         self.coverage_ratchet_enabled = True
         self.use_lsp_diagnostics = True
 
-        # Initialize coverage badge service
-        from crackerjack.services.coverage_badge_service import CoverageBadgeService
-
-        self._coverage_badge_service = CoverageBadgeService(console, pkg_path)
-
     def set_progress_callback(
         self,
         callback: t.Callable[[dict[str, t.Any]], None] | None,
@@ -54,56 +70,79 @@ class TestManager:
         self.coverage_ratchet_enabled = enabled
         if enabled:
             self.console.print(
-                "[cyan]📊[/ cyan] Coverage ratchet enabled-targeting 100 % coverage"
+                "[cyan]📊[/cyan] Coverage ratchet enabled-targeting 100 % coverage"
             )
         else:
-            self.console.print("[yellow]⚠️[/ yellow] Coverage ratchet disabled")
+            self.console.print("[yellow]⚠️[/yellow] Coverage ratchet disabled")
 
     def run_tests(self, options: OptionsProtocol) -> bool:
+        # Early return if tests are disabled
+        if hasattr(options, "test") and not options.test:
+            return True
+
         start_time = time.time()
 
         try:
             result = self._execute_test_workflow(options)
             duration = time.time() - start_time
 
-            if result:
-                return self._handle_test_success(result.stdout, duration)
+            # Get worker count for statistics panel (don't print info messages)
+            workers = self.command_builder.get_optimal_workers(
+                options, print_info=False
+            )
+
+            if result.returncode == 0:
+                return self._handle_test_success(
+                    result.stdout, duration, options, workers
+                )
             else:
                 return self._handle_test_failure(
-                    result.stderr if result else "", duration
+                    result.stderr if result else "",
+                    result.stdout if result else "",
+                    duration,
+                    options,
+                    workers,
                 )
 
         except Exception as e:
             return self._handle_test_error(start_time, e)
 
     def run_specific_tests(self, test_pattern: str) -> bool:
-        self.console.print(f"[cyan]🧪[/ cyan] Running tests matching: {test_pattern}")
+        self.console.print(f"[cyan]🧪[/cyan] Running tests matching: {test_pattern}")
 
         cmd = self.command_builder.build_specific_test_command(test_pattern)
         result = self.executor.execute_with_progress(cmd)
 
         success = result.returncode == 0
         if success:
-            self.console.print("[green]✅[/ green] Specific tests passed")
+            self.console.print("[green]✅[/green] Specific tests passed")
         else:
-            self.console.print("[red]❌[/ red] Some specific tests failed")
+            self.console.print("[red]❌[/red] Some specific tests failed")
 
         return success
 
     def validate_test_environment(self) -> bool:
         if not self.has_tests():
-            self.console.print("[yellow]⚠️[/ yellow] No tests found")
+            self.console.print("[yellow]⚠️[/yellow] No tests found")
             return False
 
+        from rich.live import Live
+        from rich.spinner import Spinner
+
         cmd = self.command_builder.build_validation_command()
-        result = subprocess.run(cmd, cwd=self.pkg_path, capture_output=True, text=True)
+
+        spinner = Spinner("dots", text="[cyan]Validating test environment...[/cyan]")
+        with Live(spinner, console=self.console, transient=True):
+            result = subprocess.run(
+                cmd, cwd=self.pkg_path, capture_output=True, text=True
+            )
 
         if result.returncode != 0:
-            self.console.print("[red]❌[/ red] Test environment validation failed")
+            self.console.print("[red]❌[/red] Test environment validation failed")
             self.console.print(result.stderr)
             return False
 
-        self.console.print("[green]✅[/ green] Test environment validated")
+        self.console.print("[green]✅[/green] Test environment validated")
         return True
 
     def get_coverage_ratchet_status(self) -> dict[str, t.Any]:
@@ -128,25 +167,101 @@ class TestManager:
         except Exception:
             return None
 
+    def _get_coverage_from_file(self) -> float | None:
+        """Extract coverage from coverage.json file."""
+        import json
+
+        coverage_json_path = self.pkg_path / "coverage.json"
+        if not coverage_json_path.exists():
+            return None
+
+        try:
+            with coverage_json_path.open() as f:
+                coverage_data = json.load(f)
+
+            # Extract coverage percentage from totals
+            totals = coverage_data.get("totals", {})
+            percent_covered = totals.get("percent_covered", None)
+
+            if percent_covered is not None:
+                return float(percent_covered)
+
+            # Alternative extraction methods for different coverage formats
+            if "percent_covered" in coverage_data:
+                return float(coverage_data["percent_covered"])
+
+            # Check for coverage in files section
+            files = coverage_data.get("files", {})
+            if files:
+                total_lines = 0
+                covered_lines = 0
+                for file_data in files.values():
+                    summary = file_data.get("summary", {})
+                    total_lines += summary.get("num_statements", 0)
+                    covered_lines += summary.get("covered_lines", 0)
+
+                if total_lines > 0:
+                    return (covered_lines / total_lines) * 100
+
+            return None
+
+        except (json.JSONDecodeError, ValueError, KeyError, TypeError):
+            return None
+
+    def _handle_no_ratchet_status(
+        self, direct_coverage: float | None
+    ) -> dict[str, t.Any]:
+        """Handle case when ratchet is not initialized."""
+        if direct_coverage is not None:
+            return {
+                "status": "coverage_available",
+                "coverage_percent": direct_coverage,
+                "message": "Coverage data available from coverage.json",
+                "source": "coverage.json",
+            }
+
+        return {
+            "status": "not_initialized",
+            "coverage_percent": 0.0,
+            "message": "Coverage ratchet not initialized",
+        }
+
+    def _get_final_coverage(
+        self, ratchet_coverage: float, direct_coverage: float | None
+    ) -> float:
+        """Determine final coverage value."""
+        return direct_coverage if direct_coverage is not None else ratchet_coverage
+
     def get_coverage(self) -> dict[str, t.Any]:
         try:
             status = self.coverage_ratchet.get_status_report()
 
-            if status.get("status") == "not_initialized":
-                return {
-                    "status": "not_initialized",
-                    "coverage_percent": 0.0,
-                    "message": "Coverage ratchet not initialized",
-                }
+            # Check if we have actual coverage data from coverage.json even if ratchet is not initialized
+            direct_coverage = self._get_coverage_from_file()
+
+            # If ratchet is not initialized but we have direct coverage data, use it
+            if (
+                not status or status.get("status") == "not_initialized"
+            ) and direct_coverage is not None:
+                return self._handle_no_ratchet_status(direct_coverage)
+
+            # If ratchet is not initialized and no direct coverage, return not initialized
+            if not status or status.get("status") == "not_initialized":
+                return self._handle_no_ratchet_status(None)
+
+            # Use ratchet data, but prefer direct coverage if available and different
+            ratchet_coverage = status.get("current_coverage", 0.0)
+            final_coverage = self._get_final_coverage(ratchet_coverage, direct_coverage)
 
             return {
                 "status": "active",
-                "coverage_percent": status.get("current_coverage", 0.0),
+                "coverage_percent": final_coverage,
                 "target_coverage": status.get("target_coverage", 100.0),
                 "next_milestone": status.get("next_milestone"),
                 "progress_percent": status.get("progress_percent", 0.0),
                 "last_updated": status.get("last_updated"),
                 "milestones_achieved": status.get("milestones_achieved", []),
+                "source": "coverage.json" if direct_coverage is not None else "ratchet",
             }
         except Exception as e:
             return {
@@ -164,11 +279,11 @@ class TestManager:
             test_path = self.pkg_path / test_dir
             if test_path.exists() and test_path.is_dir():
                 for test_file_pattern in test_files:
-                    if list[t.Any](test_path.glob(f"**/{test_file_pattern}")):
+                    if list(test_path.glob(f"**/{test_file_pattern}")):
                         return True
 
         for test_file_pattern in test_files:
-            if list[t.Any](self.pkg_path.glob(test_file_pattern)):
+            if list(self.pkg_path.glob(test_file_pattern)):
                 return True
 
         return False
@@ -187,34 +302,389 @@ class TestManager:
         return self.executor.execute_with_progress(cmd, self._get_timeout(options))
 
     def _print_test_start_message(self, options: OptionsProtocol) -> None:
-        workers = self.command_builder.get_optimal_workers(options)
+        workers = self.command_builder.get_optimal_workers(options, print_info=False)
         timeout = self.command_builder.get_test_timeout(options)
 
         self.console.print(
-            f"[cyan]🧪[/ cyan] Running tests (workers: {workers}, timeout: {timeout}s)"
+            f"[cyan]🧪[/cyan] Running tests (workers: {workers}, timeout: {timeout}s)"
         )
 
-    def _handle_test_success(self, output: str, duration: float) -> bool:
-        self.console.print(f"[green]✅[/ green] Tests passed in {duration: .1f}s")
+    def _handle_test_success(
+        self,
+        output: str,
+        duration: float,
+        options: OptionsProtocol,
+        workers: int | str,
+    ) -> bool:
+        self.console.print(f"[green]✅[/green] Tests passed in {duration: .1f}s")
+
+        # Parse and display test statistics panel
+        stats = self._parse_test_statistics(output)
+        if self._should_render_test_panel(stats):
+            self._render_test_results_panel(stats, workers, success=True)
 
         if self.coverage_ratchet_enabled:
             return self._process_coverage_ratchet()
 
         return True
 
-    def _handle_test_failure(self, output: str, duration: float) -> bool:
-        self.console.print(f"[red]❌[/ red] Tests failed in {duration: .1f}s")
+    def _handle_test_failure(
+        self,
+        stderr: str,
+        stdout: str,
+        duration: float,
+        options: OptionsProtocol,
+        workers: int | str,
+    ) -> bool:
+        self.console.print(f"[red]❌[/red] Tests failed in {duration:.1f}s")
+
+        # Parse and display test statistics panel (use stdout for stats)
+        combined_output = stdout + "\n" + stderr
+        clean_output = self._strip_ansi_codes(combined_output)
+        stats = self._parse_test_statistics(clean_output, already_clean=True)
+        if self._should_render_test_panel(stats):
+            self._render_test_results_panel(stats, workers, success=False)
+
+        # Always show key failure information, not just in verbose mode
+        if clean_output.strip():
+            # Extract and show essential failure details even in non-verbose mode
+            failure_lines = self._extract_failure_lines(clean_output)
+            if failure_lines:
+                self._last_test_failures = failure_lines
+                self._render_banner("Key Test Failures", line_style="red")
+
+                for failure in failure_lines:
+                    self.console.print(f"[red]• {failure}[/red]")
+            else:
+                self._last_test_failures = []
+
+            # Enhanced error reporting in verbose mode
+            if options.verbose or getattr(options, "ai_debug", False):
+                self._render_banner(
+                    "Full Test Output (Enhanced)",
+                    line_style="red",
+                )
+                # Use Rich-formatted output instead of raw dump
+                self._render_formatted_output(clean_output, options, already_clean=True)
+        else:
+            # Show some information even when there's no output
+            border_line = "-" * getattr(options, "column_width", 70)
+            self.console.print("\n🧪 TESTS Failed test execution")
+            self.console.print(border_line)
+
+            self.console.print(
+                "    [yellow]This may indicate a timeout or critical error[/yellow]"
+            )
+            self.console.print(
+                f"    [yellow]Duration: {duration:.1f}s, Workers: {workers}[/yellow]"
+            )
+            if duration > 290:  # Approaching 300s timeout
+                self.console.print(
+                    "    [yellow]⚠️  Execution time was very close to timeout, may have timed out[/yellow]"
+                )
+            self.console.print(
+                "    [red]Workflow failed: Test workflow execution failed[/red]"
+            )
+            self.console.print(border_line)
+            self._last_test_failures = []
 
-        self._last_test_failures = self._extract_failure_lines(output)
         return False
 
     def _handle_test_error(self, start_time: float, error: Exception) -> bool:
         duration = time.time() - start_time
         self.console.print(
-            f"[red]💥[/ red] Test execution error after {duration: .1f}s: {error}"
+            f"[red]💥[/red] Test execution error after {duration: .1f}s: {error}"
         )
         return False
 
+    def _parse_test_statistics(
+        self, output: str, *, already_clean: bool = False
+    ) -> dict[str, t.Any]:
+        """Parse test statistics from pytest output.
+
+        Extracts metrics like passed, failed, skipped, errors, and duration
+        from pytest's summary line.
+
+        Args:
+            output: Raw pytest output text
+
+        Returns:
+            Dictionary containing test statistics
+        """
+        clean_output = output if already_clean else self._strip_ansi_codes(output)
+        stats = {
+            "total": 0,
+            "passed": 0,
+            "failed": 0,
+            "skipped": 0,
+            "errors": 0,
+            "xfailed": 0,
+            "xpassed": 0,
+            "duration": 0.0,
+            "coverage": None,
+        }
+
+        try:
+            # Extract summary and duration
+            summary_match = self._extract_pytest_summary(clean_output)
+            if summary_match:
+                summary_text, duration = self._parse_summary_match(
+                    summary_match, clean_output
+                )
+                stats["duration"] = duration
+
+                # Extract metrics from summary
+                self._extract_test_metrics(summary_text, stats)
+
+            # Calculate totals and fallback if summary missing
+            self._calculate_total_tests(stats, clean_output)
+
+            # Extract coverage if present
+            stats["coverage"] = self._extract_coverage_from_output(clean_output)
+
+        except (ValueError, AttributeError) as e:
+            self.console.print(f"[dim]⚠️ Failed to parse test statistics: {e}[/dim]")
+
+        return stats
+
+    def _extract_pytest_summary(self, output: str) -> re.Match[str] | None:
+        """Extract pytest summary line match from output."""
+        summary_patterns = [
+            r"=+\s+(.+?)\s+in\s+([\d.]+)s?\s*=+",  # "======= 5 passed in 1.23s ======="
+            r"(\d+\s+\w+)+\s+in\s+([\d.]+)s?",  # "5 passed, 2 failed in 1.23s"
+            r"(\d+.*)in\s+([\d.]+)s?",  # More flexible format
+        ]
+
+        for pattern in summary_patterns:
+            match = re.search(pattern, output)
+            if match:
+                return match
+        return None
+
+    def _parse_summary_match(
+        self, match: re.Match[str], output: str
+    ) -> tuple[str, float]:
+        """Parse summary text and duration from regex match."""
+        if len(match.groups()) >= 2:
+            summary_text = match.group(1)
+            duration = float(match.group(2))
+        else:
+            # Pattern only captured duration
+            duration = (
+                float(match.group(1))
+                if match.group(1).replace(".", "").isdigit()
+                else 0.0
+            )
+            summary_text = output
+
+        return summary_text, duration
+
+    def _extract_test_metrics(self, summary_text: str, stats: dict[str, t.Any]) -> None:
+        """Extract individual test metrics from summary text."""
+        for metric in ("passed", "failed", "skipped", "error", "xfailed", "xpassed"):
+            metric_pattern = rf"(\d+)\s+{metric}"
+            metric_match = re.search(metric_pattern, summary_text, re.IGNORECASE)
+            if metric_match:
+                count = int(metric_match.group(1))
+                key = "errors" if metric == "error" else metric
+                stats[key] = count
+
+    def _calculate_total_tests(self, stats: dict[str, t.Any], output: str) -> None:
+        """Calculate total tests and apply fallback counting if needed."""
+        stats["total"] = sum(
+            [
+                stats["passed"],
+                stats["failed"],
+                stats["skipped"],
+                stats["errors"],
+                stats["xfailed"],
+                stats["xpassed"],
+            ]
+        )
+
+        # Fallback: manually count from output if total is still 0
+        if stats["total"] == 0:
+            self._fallback_count_tests(output, stats)
+
+    def _fallback_count_tests(self, output: str, stats: dict[str, t.Any]) -> None:
+        """Manually count test results from output when parsing fails."""
+        status_tokens = [
+            ("passed", "PASSED"),
+            ("failed", "FAILED"),
+            ("skipped", "SKIPPED"),
+            ("errors", "ERROR"),
+            ("xfailed", "XFAIL"),
+            ("xpassed", "XPASS"),
+        ]
+
+        for raw_line in output.splitlines():
+            line = raw_line.strip()
+            if "::" not in line:
+                continue
+
+            line_upper = line.upper()
+            if line_upper.startswith(
+                ("FAILED", "ERROR", "XPASS", "XFAIL", "SKIPPED", "PASSED")
+            ):
+                continue
+
+            for key, token in status_tokens:
+                if token in line_upper:
+                    stats[key] += 1
+                    break
+
+        stats["total"] = sum(
+            [
+                stats["passed"],
+                stats["failed"],
+                stats["skipped"],
+                stats["errors"],
+                stats.get("xfailed", 0),
+                stats.get("xpassed", 0),
+            ]
+        )
+
+        if stats["total"] == 0:
+            legacy_patterns = {
+                "passed": r"(?:\.|✓)\s*(?:PASSED|pass)",
+                "failed": r"(?:F|X|❌)\s*(?:FAILED|fail)",
+                "skipped": r"(?:s|S|.SKIPPED|skip)",
+                "errors": r"ERROR|E\s+",
+            }
+            for key, pattern in legacy_patterns.items():
+                stats[key] = len(re.findall(pattern, output, re.IGNORECASE))
+
+            stats["total"] = (
+                stats["passed"] + stats["failed"] + stats["skipped"] + stats["errors"]
+            )
+
+    def _extract_coverage_from_output(self, output: str) -> float | None:
+        """Extract coverage percentage from pytest output."""
+        coverage_pattern = r"TOTAL\s+\d+\s+\d+\s+(\d+)%"
+        coverage_match = re.search(coverage_pattern, output)
+        if coverage_match:
+            return float(coverage_match.group(1))
+        return None
+
+    def _should_render_test_panel(self, stats: dict[str, t.Any]) -> bool:
+        """Determine if the test results panel should be rendered."""
+        return any(
+            [
+                stats.get("total", 0) > 0,
+                stats.get("passed", 0) > 0,
+                stats.get("failed", 0) > 0,
+                stats.get("errors", 0) > 0,
+                stats.get("skipped", 0) > 0,
+                stats.get("xfailed", 0) > 0,
+                stats.get("xpassed", 0) > 0,
+                stats.get("duration", 0.0) > 0.0,
+                stats.get("coverage") is not None,
+            ]
+        )
+
+    def _render_test_results_panel(
+        self,
+        stats: dict[str, t.Any],
+        workers: int | str,
+        success: bool,
+    ) -> None:
+        """Render test results panel with statistics similar to hook results.
+
+        Args:
+            stats: Dictionary of test statistics from _parse_test_statistics
+            workers: Number of workers used (or "auto")
+            success: Whether tests passed overall
+        """
+        table = Table(box=box.SIMPLE, header_style="bold bright_white")
+        table.add_column("Metric", style="cyan", overflow="fold")
+        table.add_column("Count", justify="right", style="bright_white")
+        table.add_column("Percentage", justify="right", style="magenta")
+
+        total = stats["total"]
+
+        # Add rows for each metric
+        metrics = [
+            ("✅ Passed", stats["passed"], "green"),
+            ("❌ Failed", stats["failed"], "red"),
+            ("⏭ Skipped", stats["skipped"], "yellow"),
+            ("💥 Errors", stats["errors"], "red"),
+        ]
+
+        # Only show xfailed/xpassed if they exist
+        if stats.get("xfailed", 0) > 0:
+            metrics.append(("⚠️ Expected Failures", stats["xfailed"], "yellow"))
+        if stats.get("xpassed", 0) > 0:
+            metrics.append(("✨ Unexpected Passes", stats["xpassed"], "green"))
+
+        for label, count, _ in metrics:
+            percentage = f"{(count / total * 100):.1f}%" if total > 0 else "0.0%"
+            table.add_row(label, str(count), percentage)
+
+        # Add separator and summary rows
+        table.add_row("─" * 20, "─" * 10, "─" * 15, style="dim")
+        table.add_row("📊 Total Tests", str(total), "100.0%", style="bold")
+        table.add_row(
+            "⏱ Duration",
+            f"{stats['duration']:.2f}s",
+            "",
+            style="bold magenta",
+        )
+        table.add_row(
+            "👥 Workers",
+            str(workers),
+            "",
+            style="bold cyan",
+        )
+
+        # Add coverage if available
+        if stats.get("coverage") is not None:
+            table.add_row(
+                "📈 Coverage",
+                f"{stats['coverage']:.1f}%",
+                "",
+                style="bold green",
+            )
+
+        # Create panel with appropriate styling
+        border_style = "green" if success else "red"
+        title_icon = "✅" if success else "❌"
+        title_text = "Test Results" if success else "Test Results (Failed)"
+
+        panel = Panel(
+            table,
+            title=f"[bold]{title_icon} {title_text}[/bold]",
+            border_style=border_style,
+            padding=(0, 1),
+            width=get_console_width(),
+        )
+
+        self.console.print(panel)
+
+    def _render_banner(
+        self,
+        title: str,
+        *,
+        line_style: str = "red",
+        title_style: str | None = None,
+        char: str = "━",
+        padding: bool = True,
+    ) -> None:
+        """Render a horizontal banner that respects configured console width."""
+        width = max(20, get_console_width())
+        line_text = Text(char * width, style=line_style)
+        resolved_title_style = title_style or ("bold " + line_style).strip()
+        title_text = Text(title, style=resolved_title_style)
+
+        if padding:
+            self.console.print()
+
+        self.console.print(line_text)
+        self.console.print(title_text)
+        self.console.print(line_text)
+
+        if padding:
+            self.console.print()
+
     def _process_coverage_ratchet(self) -> bool:
         if not self.coverage_ratchet_enabled:
             return True
@@ -226,34 +696,116 @@ class TestManager:
 
         return self._handle_ratchet_result(ratchet_result)
 
+    def _attempt_coverage_extraction(self) -> float | None:
+        """Attempt to extract coverage from various sources."""
+        # Primary: Try to extract from coverage.json
+        current_coverage = self._get_coverage_from_file()
+        if current_coverage is not None:
+            return current_coverage
+
+        return None
+
+    def _handle_coverage_extraction_result(
+        self, current_coverage: float | None
+    ) -> float | None:
+        """Handle the result of coverage extraction attempts."""
+        if current_coverage is not None:
+            self.console.print(
+                f"[dim]📊 Coverage extracted from coverage.json: {current_coverage:.2f}%[/dim]"
+            )
+        return current_coverage
+
+    def _try_service_coverage(self) -> float | None:
+        """Try coverage service fallback.
+
+        Returns:
+            Coverage value if available, None otherwise
+        """
+        try:
+            current_coverage = self.coverage_ratchet.get_baseline_coverage()
+            if current_coverage is not None and current_coverage > 0:
+                self.console.print(
+                    f"[dim]📊 Coverage from service fallback: {current_coverage:.2f}%[/dim]"
+                )
+                return current_coverage
+            return None
+        except (AttributeError, Exception):
+            # Service method doesn't exist or failed, skip
+            return None
+
+    def _handle_zero_coverage_fallback(self, current_coverage: float | None) -> None:
+        """Handle 0.0% fallback case when coverage.json exists."""
+        coverage_json_path = self.pkg_path / "coverage.json"
+        if current_coverage is None and coverage_json_path.exists():
+            self.console.print(
+                "[yellow]⚠️[/yellow] Skipping 0.0% fallback when coverage.json exists"
+            )
+
+    def _get_fallback_coverage(
+        self, ratchet_result: dict[str, t.Any], current_coverage: float | None
+    ) -> float | None:
+        """Get coverage from fallback sources."""
+        # Secondary: Try ratchet result if coverage.json failed
+        if current_coverage is None and ratchet_result:
+            # Try to extract from ratchet result
+            if "current_coverage" in ratchet_result:
+                current_coverage = ratchet_result["current_coverage"]
+                if current_coverage is not None and current_coverage > 0:
+                    self.console.print(
+                        f"[dim]📊 Coverage from ratchet result: {current_coverage:.2f}%[/dim]"
+                    )
+
+        # Tertiary: Try coverage service, but only accept non-zero values
+        if current_coverage is None:
+            current_coverage = self._try_service_coverage()
+            if current_coverage is None:
+                self._handle_zero_coverage_fallback(current_coverage)
+
+        return current_coverage
+
     def _update_coverage_badge(self, ratchet_result: dict[str, t.Any]) -> None:
         """Update coverage badge in README.md if coverage changed."""
         try:
-            # Get current coverage directly from coverage.json to ensure freshest data
-            import json
-
-            current_coverage = None
+            # Check if coverage files exist and inform user
             coverage_json_path = self.pkg_path / "coverage.json"
+            ratchet_path = self.pkg_path / ".coverage-ratchet.json"
 
-            if coverage_json_path.exists():
-                with coverage_json_path.open() as f:
-                    data = json.load(f)
-                    current_coverage = data.get("totals", {}).get("percent_covered")
+            if not coverage_json_path.exists():
+                self.console.print(
+                    "[yellow]ℹ️[/yellow] Coverage file doesn't exist yet, will be created after test run"
+                )
+            if not ratchet_path.exists():
+                self.console.print(
+                    "[yellow]ℹ️[/yellow] Coverage ratchet file doesn't exist yet, initializing..."
+                )
 
-            # Fallback to ratchet result if coverage.json not available
-            if current_coverage is None:
-                current_coverage = ratchet_result.get("current_coverage")
+            # Get current coverage directly from coverage.json to ensure freshest data
+            current_coverage = self._attempt_coverage_extraction()
+            current_coverage = self._handle_coverage_extraction_result(current_coverage)
 
-            # Final fallback to coverage service
-            if current_coverage is None:
-                coverage_info = self.get_coverage()
-                current_coverage = coverage_info.get("coverage_percent")
+            # Get fallback coverage if needed
+            current_coverage = self._get_fallback_coverage(
+                ratchet_result, current_coverage
+            )
 
-            if current_coverage is not None:
+            # Only update badge if we have valid coverage data
+            if current_coverage is not None and current_coverage >= 0:
                 if self._coverage_badge_service.should_update_badge(current_coverage):
                     self._coverage_badge_service.update_readme_coverage_badge(
                         current_coverage
                     )
+                    self.console.print(
+                        f"[green]✅[/green] Badge updated to {current_coverage:.2f}%"
+                    )
+                else:
+                    self.console.print(
+                        f"[dim]📊 Badge unchanged (current: {current_coverage:.2f}%)[/dim]"
+                    )
+            else:
+                self.console.print(
+                    "[yellow]⚠️[/yellow] No valid coverage data found for badge update"
+                )
+
         except Exception as e:
             # Don't fail the test process if badge update fails
             self.console.print(f"[yellow]⚠️[/yellow] Badge update failed: {e}")
@@ -265,12 +817,12 @@ class TestManager:
             return True
         else:
             if "message" in ratchet_result:
-                self.console.print(f"[red]📉[/ red] {ratchet_result['message']}")
+                self.console.print(f"[red]📉[/red] {ratchet_result['message']}")
             else:
                 current = ratchet_result.get("current_coverage", 0)
                 previous = ratchet_result.get("previous_coverage", 0)
                 self.console.print(
-                    f"[red]📉[/ red] Coverage regression: "
+                    f"[red]📉[/red] Coverage regression: "
                     f"{current: .2f}% < {previous: .2f}%"
                 )
             return False
@@ -280,7 +832,7 @@ class TestManager:
         current = ratchet_result.get("current_coverage", 0)
 
         self.console.print(
-            f"[green]📈[/ green] Coverage improved by {improvement: .2f}% "
+            f"[green]📈[/green] Coverage improved by {improvement: .2f}% "
             f"to {current: .2f}%"
         )
 
@@ -296,18 +848,473 @@ class TestManager:
 
         return failures[:10]
 
+    @staticmethod
+    def _strip_ansi_codes(text: str) -> str:
+        """Remove ANSI escape sequences from a string."""
+        return ANSI_ESCAPE_RE.sub("", text)
+
+    def _split_output_sections(self, output: str) -> list[tuple[str, str]]:
+        """Split pytest output into logical sections for rendering.
+
+        Sections:
+        - header: Session start, test collection
+        - failure: Individual test failures with tracebacks
+        - summary: Short test summary info
+        - footer: Coverage, timing, final stats
+
+        Returns:
+            List of (section_type, section_content) tuples
+        """
+        sections = []
+        lines = output.split("\n")
+
+        current_section: list[str] = []
+        current_type = "header"
+
+        for line in lines:
+            # Detect section boundaries
+            if "short test summary" in line.lower():
+                # Save previous section
+                if current_section:
+                    sections.append((current_type, "\n".join(current_section)))
+                current_section = [line]
+                current_type = "summary"
+
+            elif " FAILED " in line or " ERROR " in line:
+                # Save previous section
+                if current_section and current_type != "failure":
+                    sections.append((current_type, "\n".join(current_section)))
+                    current_section = []
+                current_type = "failure"
+                current_section.append(line)
+
+            elif line.startswith("=") and ("passed" in line or "failed" in line):
+                # Footer section
+                if current_section:
+                    sections.append((current_type, "\n".join(current_section)))
+                current_section = [line]
+                current_type = "footer"
+
+            else:
+                current_section.append(line)
+
+        # Add final section
+        if current_section:
+            sections.append((current_type, "\n".join(current_section)))
+
+        return sections
+
+    def _render_formatted_output(
+        self,
+        output: str,
+        options: OptionsProtocol,
+        *,
+        already_clean: bool = False,
+    ) -> None:
+        """Render test output with Rich formatting and sections.
+
+        Phase 2: Uses structured failure parser when available.
+
+        Args:
+            output: Raw pytest output text
+            options: Test options (for verbosity level)
+        """
+        from rich.panel import Panel
+
+        clean_output = output if already_clean else self._strip_ansi_codes(output)
+
+        # Try structured parsing first (Phase 2)
+        try:
+            failures = self._extract_structured_failures(clean_output)
+            if failures:
+                self._render_banner(
+                    "Detailed Failure Analysis",
+                    line_style="red",
+                    char="═",
+                )
+
+                self._render_structured_failure_panels(failures)
+
+                # Still show summary section
+                sections = self._split_output_sections(clean_output)
+                for section_type, section_content in sections:
+                    if section_type == "summary":
+                        panel = Panel(
+                            section_content.strip(),
+                            title="[bold yellow]📋 Test Summary[/bold yellow]",
+                            border_style="yellow",
+                            width=get_console_width(),
+                        )
+                        self.console.print(panel)
+                    elif section_type == "footer":
+                        self.console.print(
+                            f"\n[cyan]{section_content.strip()}[/cyan]\n"
+                        )
+
+                return
+
+        except Exception as e:
+            # Fallback to Phase 1 rendering if parsing fails
+            self.console.print(
+                f"[dim yellow]⚠️  Structured parsing failed: {e}[/dim yellow]"
+            )
+            self.console.print(
+                "[dim yellow]Falling back to standard formatting...[/dim yellow]\n"
+            )
+
+        # Fallback: Phase 1 section-based rendering
+        sections = self._split_output_sections(clean_output)
+
+        for section_type, section_content in sections:
+            if not section_content.strip():
+                continue
+
+            if section_type == "failure":
+                self._render_failure_section(section_content)
+            elif section_type == "summary":
+                panel = Panel(
+                    section_content.strip(),
+                    title="[bold yellow]📋 Test Summary[/bold yellow]",
+                    border_style="yellow",
+                    width=get_console_width(),
+                )
+                self.console.print(panel)
+            elif section_type == "footer":
+                self.console.print(f"\n[cyan]{section_content.strip()}[/cyan]\n")
+            else:
+                # Header and other sections (dimmed)
+                if options.verbose or getattr(options, "ai_debug", False):
+                    self.console.print(f"[dim]{section_content}[/dim]")
+
+    def _render_failure_section(self, section_content: str) -> None:
+        """Render a failure section with syntax highlighting.
+
+        Args:
+            section_content: Failure output text
+        """
+        from rich.panel import Panel
+        from rich.syntax import Syntax
+
+        # Apply Python syntax highlighting to tracebacks
+        syntax = Syntax(
+            section_content,
+            "python",
+            theme="monokai",
+            line_numbers=False,
+            word_wrap=True,
+            background_color="default",
+        )
+
+        panel = Panel(
+            syntax,
+            title="[bold red]❌ Test Failure[/bold red]",
+            border_style="red",
+            width=get_console_width(),
+        )
+        self.console.print(panel)
+
+    def _parse_failure_header(
+        self, line: str, current_failure: "TestFailure | None"
+    ) -> tuple["TestFailure | None", bool]:
+        """Parse failure header line."""
+        import re
+
+        from crackerjack.models.test_models import TestFailure
+
+        failure_match = re.match(r"^(.+?)\s+(FAILED|ERROR)\s*(?:\[(.+?)\])?", line)
+        if failure_match:
+            test_path, status, params = failure_match.groups()
+            new_failure = TestFailure(
+                test_name=test_path + (f"[{params}]" if params else ""),
+                status=status,
+                location=test_path,
+            )
+            return new_failure, True
+        return current_failure, False
+
+    def _parse_location_and_assertion(
+        self, line: str, current_failure: "TestFailure", in_traceback: bool
+    ) -> bool:
+        """Parse location and assertion lines."""
+        import re
+
+        # Detect location: "tests/test_foo.py:42: AssertionError"
+        location_match = re.match(r"^(.+?\.py):(\d+):\s*(.*)$", line)
+        if location_match and in_traceback:
+            file_path, line_num, error_type = location_match.groups()
+            current_failure.location = f"{file_path}:{line_num}"
+            if error_type:
+                current_failure.short_summary = error_type
+            return True
+
+        # Detect assertion errors
+        if "AssertionError:" in line or line.strip().startswith("E       assert "):
+            assertion_text = line.strip().lstrip("E").strip()
+            if current_failure.assertion:
+                current_failure.assertion += "\n" + assertion_text
+            else:
+                current_failure.assertion = assertion_text
+            return True
+
+        return False
+
+    def _parse_captured_section_header(self, line: str) -> tuple[bool, str | None]:
+        """Parse captured output section headers."""
+        if "captured stdout" in line.lower():
+            return True, "stdout"
+        elif "captured stderr" in line.lower():
+            return True, "stderr"
+        return False, None
+
+    def _parse_traceback_line(
+        self, line: str, lines: list[str], i: int, current_failure: "TestFailure"
+    ) -> bool:
+        """Parse traceback lines."""
+        if line.startswith("    ") or line.startswith("\t") or line.startswith("E   "):
+            current_failure.traceback.append(line)
+            return True
+        elif line.strip().startswith("=") or (
+            i < len(lines) - 1 and "FAILED" in lines[i + 1]
+        ):
+            return False
+        return True
+
+    def _parse_captured_output(
+        self, line: str, capture_type: str | None, current_failure: "TestFailure"
+    ) -> bool:
+        """Parse captured output lines."""
+        if line.strip().startswith("=") or line.strip().startswith("_"):
+            return False
+
+        if capture_type == "stdout":
+            if current_failure.captured_stdout:
+                current_failure.captured_stdout += "\n" + line
+            else:
+                current_failure.captured_stdout = line
+        elif capture_type == "stderr":
+            if current_failure.captured_stderr:
+                current_failure.captured_stderr += "\n" + line
+            else:
+                current_failure.captured_stderr = line
+        return True
+
+    def _extract_structured_failures(self, output: str) -> list["TestFailure"]:
+        """Extract structured failure information from pytest output.
+
+        This parser handles pytest's standard output format and extracts:
+        - Test names and locations
+        - Full tracebacks
+        - Assertion errors
+        - Captured output (stdout/stderr)
+        - Duration (if available)
+
+        Args:
+            output: Raw pytest output text
+
+        Returns:
+            List of TestFailure objects
+        """
+        failures = []
+        lines = output.split("\n")
+
+        current_failure = None
+        in_traceback = False
+        in_captured = False
+        capture_type = None
+
+        for i, line in enumerate(lines):
+            # Parse failure header
+            new_failure, header_found = self._parse_failure_header(
+                line, current_failure
+            )
+            if header_found:
+                if current_failure:
+                    failures.append(current_failure)
+                current_failure = new_failure
+                in_traceback = True
+                in_captured = False
+                continue
+
+            if not current_failure:
+                continue
+
+            # Parse location and assertion
+            if self._parse_location_and_assertion(line, current_failure, in_traceback):
+                continue
+
+            # Parse captured section headers
+            is_captured, new_capture_type = self._parse_captured_section_header(line)
+            if is_captured:
+                in_captured = True
+                capture_type = new_capture_type
+                in_traceback = False
+                continue
+
+            # Parse traceback lines
+            if in_traceback:
+                in_traceback = self._parse_traceback_line(
+                    line, lines, i, current_failure
+                )
+
+            # Parse captured output
+            if in_captured and capture_type:
+                in_captured = self._parse_captured_output(
+                    line, capture_type, current_failure
+                )
+                if not in_captured:
+                    capture_type = None
+
+        # Save final failure
+        if current_failure:
+            failures.append(current_failure)
+
+        return failures
+
+    def _render_structured_failure_panels(self, failures: list["TestFailure"]) -> None:
+        """Render failures as Rich panels with tables and syntax highlighting.
+
+        Each failure is rendered in a panel containing:
+        - Summary table (test name, location, status)
+        - Assertion details (if present)
+        - Syntax-highlighted traceback
+        - Captured output (if any)
+
+        Args:
+            failures: List of TestFailure objects
+        """
+        from rich import box
+        from rich.console import Group
+        from rich.panel import Panel
+        from rich.syntax import Syntax
+        from rich.table import Table
+
+        if not failures:
+            return
+
+        # Group failures by file for better organization
+        failures_by_file: dict[str, list[TestFailure]] = {}
+        for failure in failures:
+            file_path = failure.get_file_path()
+            if file_path not in failures_by_file:
+                failures_by_file[file_path] = []
+            failures_by_file[file_path].append(failure)
+
+        # Render each file group
+        for file_path, file_failures in failures_by_file.items():
+            self.console.print(
+                f"\n[bold red]📁 {file_path}[/bold red] ({len(file_failures)} failure(s))\n"
+            )
+
+            for i, failure in enumerate(file_failures, 1):
+                # Create details table
+                table = Table(
+                    show_header=False,
+                    box=box.SIMPLE,
+                    padding=(0, 1),
+                    border_style="red",
+                )
+                table.add_column("Key", style="cyan bold", width=12)
+                table.add_column("Value", overflow="fold")
+
+                # Add rows
+                table.add_row("Test", f"[yellow]{failure.test_name}[/yellow]")
+                table.add_row(
+                    "Location", f"[blue underline]{failure.location}[/blue underline]"
+                )
+                table.add_row("Status", f"[red bold]{failure.status}[/red bold]")
+
+                if failure.duration:
+                    table.add_row("Duration", f"{failure.duration:.3f}s")
+
+                # Add summary timing insight if available
+                duration_note = self._get_duration_note(failure)
+                if duration_note:
+                    table.add_row("Timing", duration_note)
+
+                # Components for panel (mixed list of renderables for Rich Group)
+                components: list[t.Any] = [table]
+
+                # Add assertion details
+                if failure.assertion:
+                    components.append("")  # Spacer
+                    components.append("[bold red]Assertion Error:[/bold red]")
+
+                    # Syntax highlight the assertion
+                    assertion_syntax = Syntax(
+                        failure.assertion,
+                        "python",
+                        theme="monokai",
+                        line_numbers=False,
+                        background_color="default",
+                    )
+                    components.append(assertion_syntax)
+
+                # Add relevant traceback (last 15 lines)
+                relevant_traceback = failure.get_relevant_traceback(max_lines=15)
+                if relevant_traceback:
+                    components.append("")  # Spacer
+                    components.append("[bold red]Traceback:[/bold red]")
+
+                    traceback_text = "\n".join(relevant_traceback)
+                    traceback_syntax = Syntax(
+                        traceback_text,
+                        "python",
+                        theme="monokai",
+                        line_numbers=False,
+                        word_wrap=True,
+                        background_color="default",
+                    )
+                    components.append(traceback_syntax)
+
+                # Add captured output if present
+                if failure.captured_stdout:
+                    components.append("")  # Spacer
+                    components.append("[bold yellow]Captured stdout:[/bold yellow]")
+                    components.append(f"[dim]{failure.captured_stdout}[/dim]")
+
+                if failure.captured_stderr:
+                    components.append("")  # Spacer
+                    components.append("[bold yellow]Captured stderr:[/bold yellow]")
+                    components.append(f"[dim]{failure.captured_stderr}[/dim]")
+
+                # Create grouped content
+                group = Group(*components)
+
+                # Render panel
+                panel = Panel(
+                    group,
+                    title=f"[bold red]❌ Failure {i}/{len(file_failures)}[/bold red]",
+                    border_style="red",
+                    width=get_console_width(),
+                    padding=(1, 2),
+                )
+
+            self.console.print(panel)
+
+    def _get_duration_note(self, failure: "TestFailure") -> str | None:
+        """Return a duration note highlighting long-running failures."""
+        if not failure.duration:
+            return None
+
+        if failure.duration > 5:
+            return (
+                f"[bold red]{failure.duration:.2f}s – investigate slow test[/bold red]"
+            )
+        if failure.duration > 2:
+            return f"[yellow]{failure.duration:.2f}s – moderately slow[/yellow]"
+        return None
+
     def _get_timeout(self, options: OptionsProtocol) -> int:
         return self.command_builder.get_test_timeout(options)
 
     async def run_pre_test_lsp_diagnostics(self) -> bool:
         """Run LSP diagnostics before tests to catch type errors early."""
-        if not self.use_lsp_diagnostics:
+        if not self.use_lsp_diagnostics or self._lsp_client is None:
             return True
 
         try:
-            from crackerjack.services.lsp_client import LSPClient
-
-            lsp_client = LSPClient(self.console)
+            # Use injected LSP client (already instantiated)
+            lsp_client = self._lsp_client
 
             # Check if LSP server is available
             if not lsp_client.is_server_running():