crackerjack 0.33.0__py3-none-any.whl → 0.33.2__py3-none-any.whl

crackerjack/core/service_watchdog.py

@@ -1,10 +1,3 @@
-"""
-Service watchdog with timeout protection and automatic recovery.
-
-This module provides comprehensive monitoring of crackerjack services
-with automatic restart capabilities and hanging prevention.
-"""
-
 import asyncio
 import contextlib
 import logging
@@ -24,8 +17,6 @@ logger = logging.getLogger("crackerjack.service_watchdog")
 
 
 class ServiceState(Enum):
-    """Service states."""
-
     STOPPED = "stopped"
     STARTING = "starting"
     RUNNING = "running"
@@ -36,8 +27,6 @@ class ServiceState(Enum):
 
 @dataclass
 class ServiceConfig:
-    """Configuration for a monitored service."""
-
     name: str
     command: list[str]
     health_check_url: str | None = None
@@ -52,8 +41,6 @@ class ServiceConfig:
 
 @dataclass
 class ServiceStatus:
-    """Status of a monitored service."""
-
     config: ServiceConfig
     state: ServiceState = ServiceState.STOPPED
     process: subprocess.Popen[bytes] | None = None
@@ -66,14 +53,12 @@ class ServiceStatus:
 
     @property
     def uptime(self) -> float:
-        """Get service uptime in seconds."""
         if self.state == ServiceState.RUNNING and self.last_start_time > 0:
             return time.time() - self.last_start_time
         return 0.0
 
     @property
     def is_healthy(self) -> bool:
-        """Check if service is healthy."""
         return (
             self.state == ServiceState.RUNNING
             and self.process is not None
@@ -83,8 +68,6 @@ class ServiceStatus:
 
 
 class ServiceWatchdog:
-    """Watchdog for monitoring and managing services with timeout protection."""
-
     def __init__(self, console: Console | None = None) -> None:
         self.console = console or Console()
         self.timeout_manager = get_timeout_manager()
@@ -92,7 +75,6 @@ class ServiceWatchdog:
         self.is_running = False
         self.monitor_task: asyncio.Task[None] | None = None
 
-        # Default service configurations
         self.default_configs = {
             "mcp_server": ServiceConfig(
                 name="MCP Server",
@@ -103,53 +85,55 @@ class ServiceWatchdog:
             "websocket_server": ServiceConfig(
                 name="WebSocket Server",
                 command=["python", "-m", "crackerjack", "--start-websocket-server"],
-                health_check_url="http://localhost:8675/",
+                health_check_url="http: //localhost: 8675/",
                 health_check_timeout=3.0,
                 startup_timeout=20.0,
                 shutdown_timeout=10.0,
             ),
+            "zuban_lsp": ServiceConfig(
+                name="Zuban LSP Server",
+                command=["uv", "run", "zuban", "server"],
+                startup_timeout=15.0,
+                shutdown_timeout=10.0,
+                max_restarts=5,
+                restart_delay=5.0,
+                restart_backoff_multiplier=2.0,
+                max_restart_delay=300.0,
+            ),
         }
 
     def add_service(self, service_id: str, config: ServiceConfig) -> None:
-        """Add a service to monitor."""
         self.services[service_id] = ServiceStatus(config=config)
         logger.info(f"Added service {service_id} to watchdog")
 
     def remove_service(self, service_id: str) -> None:
-        """Remove a service from monitoring."""
         if service_id in self.services:
             asyncio.create_task(self.stop_service(service_id))
             del self.services[service_id]
             logger.info(f"Removed service {service_id} from watchdog")
 
     async def start_watchdog(self) -> None:
-        """Start the watchdog monitoring."""
         if self.is_running:
             return
 
         self.is_running = True
 
-        # Add default services
         for service_id, config in self.default_configs.items():
             self.add_service(service_id, config)
 
-        # Start monitoring task with timeout protection
         self.monitor_task = asyncio.create_task(self._monitor_services())
 
-        # Setup signal handlers for graceful shutdown
         self._setup_signal_handlers()
 
         self.console.print("[green]🐕 Service Watchdog started[/green]")
         logger.info("Service watchdog started")
 
     async def stop_watchdog(self) -> None:
-        """Stop the watchdog and all monitored services."""
         if not self.is_running:
             return
 
         self.is_running = False
 
-        # Cancel monitoring task
         if self.monitor_task and not self.monitor_task.done():
             self.monitor_task.cancel()
             try:
@@ -157,7 +141,6 @@ class ServiceWatchdog:
             except asyncio.CancelledError:
                 pass
 
-        # Stop all services
         stop_tasks = [
             self.stop_service(service_id) for service_id in self.services.keys()
         ]
@@ -168,7 +151,6 @@ class ServiceWatchdog:
         logger.info("Service watchdog stopped")
 
     async def start_service(self, service_id: str) -> bool:
-        """Start a specific service with timeout protection."""
         if not self._validate_service_start_request(service_id):
             return False
 
@@ -180,7 +162,6 @@ class ServiceWatchdog:
             return self._handle_service_start_failure(service, service_id, e)
 
     def _validate_service_start_request(self, service_id: str) -> bool:
-        """Validate if service can be started."""
         if service_id not in self.services:
             return False
 
@@ -190,7 +171,6 @@ class ServiceWatchdog:
     async def _execute_service_startup(
         self, service_id: str, service: ServiceStatus
     ) -> bool:
-        """Execute the service startup process with timeout protection."""
         async with self.timeout_manager.timeout_context(
             f"start_service_{service_id}",
             timeout=service.config.startup_timeout,
@@ -208,13 +188,10 @@ class ServiceWatchdog:
             return True
 
     def _prepare_service_startup(self, service: ServiceStatus) -> None:
-        """Prepare service for startup."""
         service.state = ServiceState.STARTING
         service.last_start_time = time.time()
 
     async def _start_service_process(self, service: ServiceStatus) -> bool:
-        """Start the service process and verify it's running."""
-        # Start the service process with security logging
         security_logger = get_security_logger()
         security_logger.log_subprocess_execution(
             command=service.config.command,
@@ -228,10 +205,8 @@ class ServiceWatchdog:
             start_new_session=True,
         )
 
-        # Wait for process to stabilize
         await asyncio.sleep(2)
 
-        # Check if process is still running
         if service.process.poll() is not None:
             service.state = ServiceState.FAILED
             service.last_error = "Process exited immediately"
@@ -240,7 +215,6 @@ class ServiceWatchdog:
         return True
 
     async def _verify_service_health(self, service: ServiceStatus) -> bool:
-        """Verify service health if health check is configured."""
         if not service.config.health_check_url:
             return True
 
@@ -256,7 +230,6 @@ class ServiceWatchdog:
     def _finalize_successful_startup(
         self, service: ServiceStatus, service_id: str
     ) -> None:
-        """Finalize successful service startup."""
         service.state = ServiceState.RUNNING
         service.consecutive_failures = 0
         service.health_check_failures = 0
@@ -267,7 +240,6 @@ class ServiceWatchdog:
     def _handle_service_start_failure(
         self, service: ServiceStatus, service_id: str, error: Exception
     ) -> bool:
-        """Handle service startup failure."""
         service.state = ServiceState.FAILED
         service.last_error = str(error)
         service.consecutive_failures += 1
@@ -282,7 +254,6 @@ class ServiceWatchdog:
         return False
 
     async def stop_service(self, service_id: str) -> bool:
-        """Stop a specific service with timeout protection."""
         if service_id not in self.services:
             return False
 
@@ -320,17 +291,15 @@ class ServiceWatchdog:
             return False
 
     async def _monitor_services(self) -> None:
-        """Main monitoring loop with timeout protection."""
         while self.is_running:
             try:
                 async with self.timeout_manager.timeout_context(
                     "monitor_services",
-                    timeout=30.0,  # Monitor cycle timeout
+                    timeout=30.0,
                     strategy=TimeoutStrategy.GRACEFUL_DEGRADATION,
                 ):
-                    # Check each service
                     for service_id, service in self.services.items():
-                        if not self.is_running:  # Check if shutdown requested
+                        if not self.is_running:
                             break
 
                         try:
@@ -338,19 +307,16 @@ class ServiceWatchdog:
                         except Exception as e:
                             logger.error(f"Error checking service {service_id}: {e}")
 
-                # Wait before next check cycle
-                await asyncio.sleep(10)  # Check every 10 seconds
+                await asyncio.sleep(10)
 
             except Exception as e:
                 logger.error(f"Monitor services error: {e}")
-                await asyncio.sleep(30)  # Longer delay on error
+                await asyncio.sleep(30)
 
     async def _check_service_health(
         self, service_id: str, service: ServiceStatus
     ) -> None:
-        """Check health of a single service."""
         if service.state == ServiceState.RUNNING:
-            # Check if process is still alive
             if service.process and service.process.poll() is not None:
                 service.state = ServiceState.FAILED
                 service.last_error = (
@@ -362,7 +328,6 @@ class ServiceWatchdog:
                 return
 
     async def _perform_health_check(self, service: ServiceStatus) -> bool:
-        """Perform HTTP health check with timeout protection."""
         if not service.config.health_check_url:
             return True
 
@@ -382,21 +347,17 @@ class ServiceWatchdog:
             return False
 
     async def _terminate_process(self, service: ServiceStatus) -> None:
-        """Terminate service process gracefully with timeout."""
         if not service.process:
             return
 
         try:
-            # Try graceful termination first
             service.process.terminate()
 
-            # Wait for graceful shutdown
             try:
                 await asyncio.wait_for(
                     self._wait_for_process_exit(service.process), timeout=5.0
                 )
             except TimeoutError:
-                # Force kill if graceful shutdown fails
                 service.process.kill()
                 await asyncio.wait_for(
                     self._wait_for_process_exit(service.process), timeout=2.0
@@ -404,21 +365,17 @@ class ServiceWatchdog:
 
         except Exception as e:
             logger.warning(f"Error terminating process: {e}")
-            # Last resort: force kill
+
             with contextlib.suppress(Exception):
                 service.process.kill()
 
     async def _wait_for_process_exit(self, process: subprocess.Popen[bytes]) -> None:
-        """Wait for process to exit."""
         while process.poll() is None:
             await asyncio.sleep(0.1)
 
     def _setup_signal_handlers(self) -> None:
-        """Setup signal handlers for graceful shutdown."""
-
-        def signal_handler(signum: int, frame: object) -> None:  # noqa: ARG001
-            """Handle termination signals."""
-            _ = frame  # Signal handler frame - required by signal API
+        def signal_handler(signum: int, frame: object) -> None:
+            _ = frame
             logger.info(f"Received signal {signum}, stopping watchdog...")
             asyncio.create_task(self.stop_watchdog())
 
@@ -426,64 +383,74 @@ class ServiceWatchdog:
         signal.signal(signal.SIGTERM, signal_handler)
 
     def get_service_status(self, service_id: str) -> ServiceStatus | None:
-        """Get status of a specific service."""
         return self.services.get(service_id)
 
     def get_all_services_status(self) -> dict[str, ServiceStatus]:
-        """Get status of all services."""
         return self.services.copy()
 
     def print_status_report(self) -> None:
-        """Print formatted status report."""
-        self.console.print("\n[bold blue]🐕 Service Watchdog Status[/bold blue]")
-        self.console.print("=" * 50)
+        """Print detailed status report for all services."""
+        self._print_report_header()
 
         if not self.services:
             self.console.print("[dim]No services configured[/dim]")
             return
 
+        table = self._create_status_table()
+        self.console.print(table)
+
+    def _print_report_header(self) -> None:
+        """Print the status report header."""
+        self.console.print("\n[bold blue]🐕 Service Watchdog Status[/bold blue]")
+        self.console.print("=" * 50)
+
+    def _create_status_table(self) -> Table:
+        """Create and populate the status table."""
         table = Table()
         table.add_column("Service")
         table.add_column("Status")
         table.add_column("Uptime")
 
         for service in self.services.values():
-            # Status emoji and color
-            if service.state == ServiceState.RUNNING and service.is_healthy:
-                status = "[green]🟢 Running[/green]"
-            elif service.state == ServiceState.STARTING:
-                status = "[yellow]🟡 Starting[/yellow]"
-            elif service.state == ServiceState.STOPPING:
-                status = "[yellow]🟡 Stopping[/yellow]"
-            elif service.state == ServiceState.FAILED:
-                status = "[red]🔴 Failed[/red]"
-            elif service.state == ServiceState.TIMEOUT:
-                status = "[red]⏰ Timeout[/red]"
-            else:
-                status = "[dim]⚫ Stopped[/dim]"
-
-            # Format uptime
-            uptime = service.uptime
-            if uptime > 3600:
-                uptime_str = f"{uptime / 3600:.1f}h"
-            elif uptime > 60:
-                uptime_str = f"{uptime / 60:.1f}m"
-            elif uptime > 0:
-                uptime_str = f"{uptime:.0f}s"
-            else:
-                uptime_str = "-"
-
-            table.add_row(service.config.name, status, uptime_str)
+            status_display = self._get_service_status_display(service)
+            uptime_display = self._format_uptime(service.uptime)
+            table.add_row(service.config.name, status_display, uptime_display)
+
+        return table
+
+    def _get_service_status_display(self, service: ServiceStatus) -> str:
+        """Get formatted status display for a service."""
+        status_map = {
+            (ServiceState.RUNNING, True): "[green]🟢 Running[/green]",
+            (ServiceState.STARTING, None): "[yellow]🟡 Starting[/yellow]",
+            (ServiceState.STOPPING, None): "[yellow]🟡 Stopping[/yellow]",
+            (ServiceState.FAILED, None): "[red]🔴 Failed[/red]",
+            (ServiceState.TIMEOUT, None): "[red]⏰ Timeout[/red]",
+        }
 
-        self.console.print(table)
+        # Check for running with healthy status first
+        if service.state == ServiceState.RUNNING and service.is_healthy:
+            return status_map[(ServiceState.RUNNING, True)]
+
+        # Check other states
+        status_key = (service.state, None)
+        return status_map.get(status_key, "[dim]⚫ Stopped[/dim]")
+
+    def _format_uptime(self, uptime: float) -> str:
+        """Format uptime duration for display."""
+        if uptime > 3600:
+            return f"{uptime / 3600: .1f}h"
+        elif uptime > 60:
+            return f"{uptime / 60: .1f}m"
+        elif uptime > 0:
+            return f"{uptime: .0f}s"
+        return "-"
 
 
-# Global service watchdog instance
 _global_watchdog: ServiceWatchdog | None = None
 
 
 def get_service_watchdog(console: Console | None = None) -> ServiceWatchdog:
-    """Get global service watchdog instance."""
     global _global_watchdog
     if _global_watchdog is None:
         _global_watchdog = ServiceWatchdog(console)

crackerjack/core/session_coordinator.py

@@ -45,6 +45,10 @@ class SessionCoordinator:
     def end_session(self, success: bool = True) -> None:
         self.success = success
         self.end_time = time.time()
+
+        # Capture quality metrics at session end
+        self._capture_quality_metrics()
+
         if success:
             self.complete_task("session", "Session completed successfully")
         else:
@@ -283,3 +287,148 @@ class SessionCoordinator:
     def update_stage(self, stage: str, status: str) -> None:
         if self.web_job_id:
             self._update_websocket_progress(status, f"{stage}: {status}")
+
+    def _capture_quality_metrics(self) -> None:
+        """Capture quality metrics at the end of the session."""
+        try:
+            quality_service = self._initialize_quality_service()
+            metrics = self._extract_session_metrics()
+
+            if metrics:
+                self._record_quality_baseline(quality_service, metrics)
+                report = quality_service.generate_comprehensive_report(metrics)
+                self._display_quality_report(report)
+        except Exception as e:
+            self._handle_quality_tracking_error(e)
+
+    def _initialize_quality_service(self) -> t.Any:
+        """Initialize the quality baseline service."""
+        from crackerjack.services.quality_baseline_enhanced import (
+            EnhancedQualityBaselineService,
+        )
+
+        return EnhancedQualityBaselineService()
+
+    def _record_quality_baseline(
+        self, quality_service: t.Any, metrics: dict[str, t.Any]
+    ) -> None:
+        """Record quality baseline with metrics."""
+        quality_service.record_baseline(
+            coverage_percent=metrics.get("coverage_percent", 0.0),
+            test_count=metrics.get("test_count", 0),
+            test_pass_rate=metrics.get("test_pass_rate", 100.0),
+            hook_failures=metrics.get("hook_failures", 0),
+            complexity_violations=metrics.get("complexity_violations", 0),
+            security_issues=metrics.get("security_issues", 0),
+            type_errors=metrics.get("type_errors", 0),
+            linting_issues=metrics.get("linting_issues", 0),
+        )
+
+    def _handle_quality_tracking_error(self, error: Exception) -> None:
+        """Handle quality tracking errors without failing the session."""
+        self.console.print(
+            f"[dim yellow]Warning: Quality tracking failed: {error}[/dim yellow]"
+        )
+
+    def _extract_session_metrics(self) -> dict[str, t.Any] | None:
+        """Extract quality metrics from the current session."""
+        with suppress(Exception):
+            metrics: dict[str, t.Any] = {}
+            self._extract_test_metrics(metrics)
+            self._extract_hook_metrics(metrics)
+            self._set_default_metrics(metrics)
+            return metrics or None
+        return None
+
+    def _extract_test_metrics(self, metrics: dict[str, t.Any]) -> None:
+        """Extract test-related metrics from tasks."""
+        if "testing" not in self.tasks:
+            return
+
+        test_task = self.tasks["testing"]
+
+        if hasattr(test_task, "coverage_percent"):
+            metrics["coverage_percent"] = getattr(test_task, "coverage_percent", 0.0)
+        if hasattr(test_task, "test_count"):
+            metrics["test_count"] = getattr(test_task, "test_count", 0)
+        if hasattr(test_task, "test_pass_rate"):
+            metrics["test_pass_rate"] = getattr(test_task, "test_pass_rate", 0.0)
+
+    def _extract_hook_metrics(self, metrics: dict[str, t.Any]) -> None:
+        """Extract hook failure metrics from tasks."""
+        hook_failures = 0
+        for task_name, task in self.tasks.items():
+            if "hooks" in task_name and hasattr(task, "status"):
+                if getattr(task, "status") == "failed":
+                    hook_failures += 1
+        metrics["hook_failures"] = hook_failures
+
+    def _set_default_metrics(self, metrics: dict[str, t.Any]) -> None:
+        """Set default values for metrics we don't have direct access to."""
+        defaults = {
+            "coverage_percent": 0.0,
+            "test_count": 0,
+            "test_pass_rate": 100.0 if self.success else 0.0,
+            "complexity_violations": 0,
+            "security_issues": 0,
+            "type_errors": 0,
+            "linting_issues": 0,
+        }
+        for key, default_value in defaults.items():
+            metrics.setdefault(key, default_value)
+
+    def _display_quality_report(self, report: t.Any) -> None:
+        """Display a summary of the quality report."""
+        with suppress(Exception):
+            if not report.current_metrics:
+                return
+
+            self._display_quality_score(report)
+            self._display_quality_trend(report)
+            self._display_critical_alerts(report)
+            self._display_top_recommendations(report)
+
+    def _display_quality_score(self, report: t.Any) -> None:
+        """Display the quality score."""
+        score = report.current_metrics.quality_score
+        self.console.print(f"\n[cyan]📊 Quality Score: {score}/100[/cyan]")
+
+    def _display_quality_trend(self, report: t.Any) -> None:
+        """Display quality trend information."""
+        if not report.trend:
+            return
+
+        trend_emoji = self._get_trend_emoji(report.trend.direction.value)
+        self.console.print(
+            f"[dim]{trend_emoji} Trend: {report.trend.direction.value} "
+            f"({report.trend.confidence:.1%} confidence)[/dim]"
+        )
+
+    def _get_trend_emoji(self, direction: str) -> str:
+        """Get emoji for trend direction."""
+        trend_emojis = {
+            "improving": "📈",
+            "declining": "📉",
+            "stable": "📊",
+            "volatile": "⚠️",
+        }
+        return trend_emojis.get(direction, "📊")
+
+    def _display_critical_alerts(self, report: t.Any) -> None:
+        """Display critical quality alerts."""
+        critical_alerts = [a for a in report.alerts if a.severity.value == "critical"]
+        if critical_alerts:
+            self.console.print(
+                f"[red]🚨 {len(critical_alerts)} critical quality issues[/red]"
+            )
+
+    def _display_top_recommendations(self, report: t.Any) -> None:
+        """Display top quality recommendations."""
+        if not report.recommendations:
+            return
+
+        self.console.print("\n[yellow]💡 Top Recommendations:[/yellow]")
+        for rec in report.recommendations[:2]:  # Show top 2
+            self.console.print(f"  {rec}")
+
+        # Silently fail for display issues using suppress above