crackerjack 0.32.0__py3-none-any.whl → 0.33.1__py3-none-any.whl

crackerjack/mcp/websocket/server.py

@@ -4,6 +4,7 @@ import signal
 import subprocess
 import tempfile
 import time
+import typing as t
 from pathlib import Path
 
 import uvicorn
@@ -23,9 +24,9 @@ class WebSocketServer:
         self.progress_dir = Path(tempfile.gettempdir()) / "crackerjack-mcp-progress"
         self.is_running = True
         self.job_manager: JobManager | None = None
-        self.app = None
+        self.app: t.Any = None
         self.timeout_manager = get_timeout_manager()
-        self.server_task: asyncio.Task | None = None
+        self.server_task: asyncio.Task[t.Any] | None = None
 
     def setup(self) -> None:
         self.progress_dir.mkdir(exist_ok=True)
@@ -37,29 +38,22 @@ class WebSocketServer:
         signal.signal(signal.SIGINT, self._signal_handler)
         signal.signal(signal.SIGTERM, self._signal_handler)
 
-    def _signal_handler(self, _signum: int, _frame) -> None:
+    def _signal_handler(self, _signum: int, _frame: t.Any) -> None:
         console.print("\n[yellow]Shutting down WebSocket server...[/yellow]")
         self.is_running = False
 
-        # Cancel server task if running
         if self.server_task and not self.server_task.done():
             self.server_task.cancel()
 
-        # Clean up job manager connections
         if self.job_manager:
             with contextlib.suppress(Exception):
-                # Give existing connections 5 seconds to close
                 asyncio.create_task(self._graceful_shutdown())
 
     async def _graceful_shutdown(self) -> None:
-        """Gracefully shutdown WebSocket connections."""
         if self.job_manager:
             try:
-                # Wait briefly for connections to close naturally
                 await asyncio.sleep(2.0)
 
-                # Force close any remaining connections
-                # Note: Implementation depends on JobManager API
                 console.print(
                     "[yellow]Forcing remaining WebSocket connections to close[/yellow]"
                 )
@@ -80,14 +74,12 @@ class WebSocketServer:
                 port=self.port,
                 host="127.0.0.1",
                 log_level="info",
-                # Add timeout configurations
-                timeout_keep_alive=30,  # Keep-alive timeout
-                timeout_graceful_shutdown=30,  # Graceful shutdown timeout
+                timeout_keep_alive=30,
+                timeout_graceful_shutdown=30,
             )
 
             server = uvicorn.Server(config)
 
-            # Use asyncio event loop for better control
             try:
                 asyncio.run(self._run_with_timeout(server))
             except KeyboardInterrupt:
@@ -101,22 +93,13 @@ class WebSocketServer:
             console.print("[green]WebSocket server shutdown complete[/green]")
 
     async def _run_with_timeout(self, server: uvicorn.Server) -> None:
-        """Run the server with timeout protection."""
         try:
-            # Start server as a background task
             self.server_task = asyncio.create_task(server.serve())
 
-            # Monitor server health while running
             while self.is_running and not self.server_task.done():
                 try:
-                    # Check server health periodically
                     await asyncio.sleep(5.0)
 
-                    # Optional: Add health checks here
-                    # if not await self._server_health_check():
-                    #     console.print("[yellow]Server health check failed[/yellow]")
-                    #     break
-
                 except asyncio.CancelledError:
                     console.print("[yellow]Server monitoring cancelled[/yellow]")
                     break
@@ -124,7 +107,6 @@ class WebSocketServer:
                     console.print(f"[red]Server monitoring error: {e}[/red]")
                     break
 
-            # Wait for server task to complete
             if self.server_task and not self.server_task.done():
                 try:
                     await asyncio.wait_for(self.server_task, timeout=30.0)
@@ -153,7 +135,7 @@ def handle_websocket_server_command(
 
         try:
             result = subprocess.run(
-                ["pkill", "-f", f"uvicorn.*:{port}"],
+                ["pkill", "-f", f"uvicorn.*: {port}"],
                 check=False,
                 capture_output=True,
                 text=True,

crackerjack/mcp/websocket/websocket_handler.py

@@ -1,4 +1,5 @@
 import asyncio
+import typing as t
 from contextlib import suppress
 from pathlib import Path
 
@@ -24,10 +25,9 @@ class WebSocketHandler:
             return
 
         try:
-            # Add timeout to the entire connection handling
             async with self.timeout_manager.timeout_context(
                 "websocket_connection",
-                timeout=3600.0,  # 1 hour max connection time
+                timeout=3600.0,
                 strategy=TimeoutStrategy.GRACEFUL_DEGRADATION,
             ):
                 await self._establish_connection(websocket, job_id)
@@ -44,13 +44,11 @@ class WebSocketHandler:
             await self._cleanup_connection(job_id, websocket)
 
     async def _establish_connection(self, websocket: WebSocket, job_id: str) -> None:
-        """Establish WebSocket connection and add to job manager."""
         await websocket.accept()
         self.job_manager.add_connection(job_id, websocket)
         console.print(f"[green]WebSocket connected for job: {job_id}[/green]")
 
     async def _send_initial_progress(self, websocket: WebSocket, job_id: str) -> None:
-        """Send initial progress data to the connected WebSocket."""
         try:
             async with self.timeout_manager.timeout_context(
                 "websocket_broadcast",
@@ -69,8 +67,7 @@ class WebSocketHandler:
                 f"[red]Failed to send initial progress for {job_id}: {e}[/red]"
             )
 
-    def _create_initial_progress_message(self, job_id: str) -> dict:
-        """Create initial progress message for new jobs."""
+    def _create_initial_progress_message(self, job_id: str) -> dict[str, t.Any]:
         return {
             "job_id": job_id,
             "status": "waiting",
@@ -82,9 +79,8 @@ class WebSocketHandler:
         }
 
     async def _handle_message_loop(self, websocket: WebSocket, job_id: str) -> None:
-        """Handle the main message processing loop."""
         message_count = 0
-        max_messages = 10000  # Prevent infinite message loops
+        max_messages = 10000
 
         while message_count < max_messages:
             try:
@@ -105,25 +101,21 @@ class WebSocketHandler:
     async def _process_single_message(
         self, websocket: WebSocket, job_id: str, message_count: int
     ) -> bool:
-        """Process a single WebSocket message. Returns False to break the loop."""
         try:
-            # Add timeout to individual message operations
             async with self.timeout_manager.timeout_context(
                 "websocket_message",
-                timeout=30.0,  # 30 second timeout per message
+                timeout=30.0,
                 strategy=TimeoutStrategy.FAIL_FAST,
             ):
-                # Use asyncio.wait_for for additional protection
                 data = await asyncio.wait_for(
                     websocket.receive_text(),
-                    timeout=25.0,  # Slightly less than timeout context
+                    timeout=25.0,
                 )
 
                 console.print(
                     f"[blue]Received message {message_count} for {job_id}: {data[:100]}...[/blue]",
                 )
 
-                # Respond with timeout protection
                 await asyncio.wait_for(
                     websocket.send_json(
                         {
@@ -151,7 +143,6 @@ class WebSocketHandler:
             return False
 
     async def _handle_timeout_error(self, websocket: WebSocket, job_id: str) -> None:
-        """Handle timeout errors during connection."""
         console.print(
             f"[yellow]WebSocket connection timeout for job: {job_id}[/yellow]"
         )
@@ -161,13 +152,11 @@ class WebSocketHandler:
     async def _handle_connection_error(
         self, websocket: WebSocket, job_id: str, error: Exception
     ) -> None:
-        """Handle connection errors."""
         console.print(f"[red]WebSocket error for job {job_id}: {error}[/red]")
         with suppress(Exception):
             await websocket.close(code=1011, reason="Internal error")
 
     async def _cleanup_connection(self, job_id: str, websocket: WebSocket) -> None:
-        """Clean up the connection."""
         try:
             self.job_manager.remove_connection(job_id, websocket)
         except Exception as e:

crackerjack/mixins/__init__.py

@@ -0,0 +1,3 @@
+from .error_handling import ErrorHandlingMixin
+
+__all__ = ["ErrorHandlingMixin"]

crackerjack/mixins/error_handling.py

@@ -0,0 +1,145 @@
+import subprocess
+import typing as t
+from pathlib import Path
+
+from rich.console import Console
+
+
+class ErrorHandlingMixin:
+    def __init__(self) -> None:
+        self.console: Console
+        self.logger: t.Any
+
+    def handle_subprocess_error(
+        self,
+        error: Exception,
+        command: list[str],
+        operation_name: str,
+        critical: bool = False,
+    ) -> bool:
+        error_msg = f"{operation_name} failed: {error}"
+
+        if hasattr(self, "logger") and self.logger:
+            self.logger.error(
+                error_msg,
+                command=" ".join(command),
+                error_type=type(error).__name__,
+                critical=critical,
+            )
+
+        if critical:
+            self.console.print(f"[red]🚨 CRITICAL: {error_msg}[/red]")
+        else:
+            self.console.print(f"[red]❌ {error_msg}[/red]")
+
+        return False
+
+    def handle_file_operation_error(
+        self,
+        error: Exception,
+        file_path: Path,
+        operation: str,
+        critical: bool = False,
+    ) -> bool:
+        error_msg = f"Failed to {operation} {file_path}: {error}"
+
+        if hasattr(self, "logger") and self.logger:
+            self.logger.error(
+                error_msg,
+                file_path=str(file_path),
+                operation=operation,
+                error_type=type(error).__name__,
+                critical=critical,
+            )
+
+        if critical:
+            self.console.print(f"[red]🚨 CRITICAL: {error_msg}[/red]")
+        else:
+            self.console.print(f"[red]❌ {error_msg}[/red]")
+
+        return False
+
+    def handle_timeout_error(
+        self,
+        operation_name: str,
+        timeout_seconds: float,
+        command: list[str] | None = None,
+    ) -> bool:
+        error_msg = f"{operation_name} timed out after {timeout_seconds}s"
+
+        if hasattr(self, "logger") and self.logger:
+            self.logger.warning(
+                error_msg,
+                timeout=timeout_seconds,
+                command=" ".join(command) if command else None,
+            )
+
+        self.console.print(f"[yellow]⏰ {error_msg}[/yellow]")
+
+        return False
+
+    def log_operation_success(
+        self,
+        operation_name: str,
+        details: dict[str, t.Any] | None = None,
+    ) -> None:
+        if hasattr(self, "logger") and self.logger:
+            self.logger.info(
+                f"{operation_name} completed successfully", **(details or {})
+            )
+
+    def validate_required_tools(
+        self,
+        tools: dict[str, str],
+        operation_name: str,
+    ) -> bool:
+        missing_tools = []
+
+        for tool_name, command in tools.items():
+            try:
+                subprocess.run(
+                    [command, "--version"],
+                    capture_output=True,
+                    check=True,
+                    timeout=5,
+                )
+            except (
+                subprocess.CalledProcessError,
+                subprocess.TimeoutExpired,
+                FileNotFoundError,
+            ):
+                missing_tools.append(tool_name)
+
+        if missing_tools:
+            error_msg = f"Missing required tools for {operation_name}: {', '.join(missing_tools)}"
+
+            if hasattr(self, "logger") and self.logger:
+                self.logger.error(
+                    error_msg,
+                    missing_tools=missing_tools,
+                    operation=operation_name,
+                )
+
+            self.console.print(f"[red]❌ {error_msg}[/red]")
+            return False
+
+        return True
+
+    def safe_get_attribute(
+        self,
+        obj: t.Any,
+        attribute: str,
+        default: t.Any = None,
+        operation_name: str = "attribute access",
+    ) -> t.Any:
+        try:
+            return getattr(obj, attribute, default)
+        except Exception as e:
+            if hasattr(self, "logger") and self.logger:
+                self.logger.warning(
+                    f"Error accessing {attribute} during {operation_name}: {e}",
+                    attribute=attribute,
+                    operation=operation_name,
+                    error_type=type(e).__name__,
+                )
+            return default

crackerjack/models/config.py

@@ -18,6 +18,7 @@ class HookConfig:
     experimental_hooks: bool = False
     enable_pyrefly: bool = False
     enable_ty: bool = False
+    enable_lsp_optimization: bool = False
 
 
 @dataclass
@@ -47,7 +48,7 @@ class GitConfig:
 class AIConfig:
     ai_agent: bool = False
     start_mcp_server: bool = False
-    max_iterations: int = 10
+    max_iterations: int = 5
     autofix: bool = True
     ai_agent_autofix: bool = False
 
@@ -79,6 +80,23 @@ class EnterpriseConfig:
     organization: str | None = None
 
 
+@dataclass
+class MCPServerConfig:
+    http_port: int = 8676
+    http_host: str = "127.0.0.1"
+    websocket_port: int = 8675
+    http_enabled: bool = False
+
+
+@dataclass
+class ZubanLSPConfig:
+    enabled: bool = True
+    auto_start: bool = True
+    port: int = 8677
+    mode: str = "stdio"
+    timeout: int = 30
+
+
 @dataclass
 class WorkflowOptions:
     cleaning: CleaningConfig = field(default_factory=CleaningConfig)
@@ -91,3 +109,5 @@ class WorkflowOptions:
     progress: ProgressConfig = field(default_factory=ProgressConfig)
     cleanup: CleanupConfig = field(default_factory=CleanupConfig)
     enterprise: EnterpriseConfig = field(default_factory=EnterpriseConfig)
+    mcp_server: MCPServerConfig = field(default_factory=MCPServerConfig)
+    zuban_lsp: ZubanLSPConfig = field(default_factory=ZubanLSPConfig)

crackerjack/models/config_adapter.py

@@ -3,18 +3,43 @@ import typing as t
 from .config import (
     AIConfig,
     CleaningConfig,
+    CleanupConfig,
     EnterpriseConfig,
     ExecutionConfig,
     GitConfig,
     HookConfig,
+    MCPServerConfig,
     ProgressConfig,
     PublishConfig,
     TestConfig,
     WorkflowOptions,
+    ZubanLSPConfig,
 )
 from .protocols import OptionsProtocol
 
 
+def _determine_max_iterations(options: OptionsProtocol) -> int:
+    """Determine max_iterations using effective_max_iterations if available, otherwise fallback logic.
+
+    Priority:
+    1. Use effective_max_iterations property if available (handles quick/thorough flags)
+    2. Explicit max_iterations value
+    3. Default: 5 iterations
+    """
+    # Use effective_max_iterations property if available (Options class has this)
+    if hasattr(options, "effective_max_iterations"):
+        return getattr(options, "effective_max_iterations")  # type: ignore[no-any-return]
+
+    # Fallback for other OptionsProtocol implementations
+    if hasattr(options, "max_iterations") and getattr(
+        options, "max_iterations", None
+    ) not in (0, None):
+        return getattr(options, "max_iterations")  # type: ignore[no-any-return]
+
+    # Default to 5 iterations
+    return 5
+
+
 class OptionsAdapter:
     @staticmethod
     def from_options_protocol(options: OptionsProtocol) -> WorkflowOptions:
@@ -32,6 +57,7 @@ class OptionsAdapter:
                 experimental_hooks=getattr(options, "experimental_hooks", False),
                 enable_pyrefly=getattr(options, "enable_pyrefly", False),
                 enable_ty=getattr(options, "enable_ty", False),
+                enable_lsp_optimization=getattr(options, "enable_lsp_hooks", False),
             ),
             testing=TestConfig(
                 test=getattr(options, "test", False),
@@ -55,7 +81,7 @@ class OptionsAdapter:
                 autofix=getattr(options, "autofix", True),
                 ai_agent_autofix=getattr(options, "ai_agent_autofix", False),
                 start_mcp_server=getattr(options, "start_mcp_server", False),
-                max_iterations=getattr(options, "max_iterations", 10),
+                max_iterations=_determine_max_iterations(options),
             ),
             execution=ExecutionConfig(
                 interactive=getattr(options, "interactive", False),
@@ -66,11 +92,29 @@ class OptionsAdapter:
             progress=ProgressConfig(
                 enabled=getattr(options, "track_progress", False),
             ),
+            cleanup=CleanupConfig(
+                auto_cleanup=getattr(options, "auto_cleanup", True),
+                keep_debug_logs=getattr(options, "keep_debug_logs", 5),
+                keep_coverage_files=getattr(options, "keep_coverage_files", 10),
+            ),
             enterprise=EnterpriseConfig(
                 enabled=getattr(options, "enterprise_batch", None) is not None,
                 license_key=getattr(options, "license_key", None),
                 organization=getattr(options, "organization", None),
             ),
+            mcp_server=MCPServerConfig(
+                http_port=getattr(options, "http_port", 8676),
+                http_host=getattr(options, "http_host", "127.0.0.1"),
+                websocket_port=getattr(options, "websocket_port", 8675),
+                http_enabled=getattr(options, "http_enabled", False),
+            ),
+            zuban_lsp=ZubanLSPConfig(
+                enabled=not getattr(options, "no_zuban_lsp", False),
+                auto_start=True,
+                port=getattr(options, "zuban_lsp_port", 8677),
+                mode=getattr(options, "zuban_lsp_mode", "stdio"),
+                timeout=getattr(options, "zuban_lsp_timeout", 30),
+            ),
         )
 
     @staticmethod
@@ -200,6 +244,10 @@ class LegacyOptionsWrapper:
     def enable_ty(self) -> bool:
         return self._options.hooks.enable_ty
 
+    @property
+    def enable_lsp_hooks(self) -> bool:
+        return self._options.hooks.enable_lsp_optimization
+
     @property
     def no_git_tags(self) -> bool:
         return self._options.publishing.no_git_tags