crackerjack 0.33.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

@@ -1,5 +1,3 @@
-"""Common mixins for crackerjack components."""
-
 from .error_handling import ErrorHandlingMixin
 
 __all__ = ["ErrorHandlingMixin"]

crackerjack/mixins/error_handling.py

@@ -1,5 +1,3 @@
-"""Common error handling patterns for crackerjack components."""
-
 import subprocess
 import typing as t
 from pathlib import Path
@@ -8,12 +6,9 @@ from rich.console import Console
 
 
 class ErrorHandlingMixin:
-    """Mixin providing common error handling patterns for crackerjack components."""
-
     def __init__(self) -> None:
-        # These attributes should be provided by the class using the mixin
         self.console: Console
-        self.logger: t.Any  # Logger instance
+        self.logger: t.Any
 
     def handle_subprocess_error(
         self,
@@ -22,20 +17,8 @@ class ErrorHandlingMixin:
         operation_name: str,
         critical: bool = False,
     ) -> bool:
-        """Handle subprocess errors with consistent logging and user feedback.
-
-        Args:
-            error: The exception that occurred
-            command: The command that failed
-            operation_name: Human-readable name of the operation
-            critical: Whether this is a critical error that should stop execution
-
-        Returns:
-            False to indicate failure
-        """
         error_msg = f"{operation_name} failed: {error}"
 
-        # Log the error
         if hasattr(self, "logger") and self.logger:
             self.logger.error(
                 error_msg,
@@ -44,7 +27,6 @@ class ErrorHandlingMixin:
                 critical=critical,
             )
 
-        # Display user-friendly error message
         if critical:
             self.console.print(f"[red]🚨 CRITICAL: {error_msg}[/red]")
         else:
@@ -59,20 +41,8 @@ class ErrorHandlingMixin:
         operation: str,
         critical: bool = False,
     ) -> bool:
-        """Handle file operation errors with consistent logging and user feedback.
-
-        Args:
-            error: The exception that occurred
-            file_path: The file that caused the error
-            operation: The operation that failed (e.g., "read", "write", "delete")
-            critical: Whether this is a critical error that should stop execution
-
-        Returns:
-            False to indicate failure
-        """
         error_msg = f"Failed to {operation} {file_path}: {error}"
 
-        # Log the error
         if hasattr(self, "logger") and self.logger:
             self.logger.error(
                 error_msg,
@@ -82,7 +52,6 @@ class ErrorHandlingMixin:
                 critical=critical,
             )
 
-        # Display user-friendly error message
         if critical:
             self.console.print(f"[red]🚨 CRITICAL: {error_msg}[/red]")
         else:
@@ -96,19 +65,8 @@ class ErrorHandlingMixin:
         timeout_seconds: float,
         command: list[str] | None = None,
     ) -> bool:
-        """Handle timeout errors with consistent logging and user feedback.
-
-        Args:
-            operation_name: Human-readable name of the operation
-            timeout_seconds: The timeout that was exceeded
-            command: Optional command that timed out
-
-        Returns:
-            False to indicate failure
-        """
         error_msg = f"{operation_name} timed out after {timeout_seconds}s"
 
-        # Log the error
         if hasattr(self, "logger") and self.logger:
             self.logger.warning(
                 error_msg,
@@ -116,7 +74,6 @@ class ErrorHandlingMixin:
                 command=" ".join(command) if command else None,
             )
 
-        # Display user-friendly error message
         self.console.print(f"[yellow]⏰ {error_msg}[/yellow]")
 
         return False
@@ -126,12 +83,6 @@ class ErrorHandlingMixin:
         operation_name: str,
         details: dict[str, t.Any] | None = None,
     ) -> None:
-        """Log successful operations with consistent formatting.
-
-        Args:
-            operation_name: Human-readable name of the operation
-            details: Optional additional details to log
-        """
         if hasattr(self, "logger") and self.logger:
             self.logger.info(
                 f"{operation_name} completed successfully", **(details or {})
@@ -142,15 +93,6 @@ class ErrorHandlingMixin:
         tools: dict[str, str],
         operation_name: str,
     ) -> bool:
-        """Validate that required external tools are available.
-
-        Args:
-            tools: Dict mapping tool names to their expected commands
-            operation_name: Name of operation requiring the tools
-
-        Returns:
-            True if all tools are available, False otherwise
-        """
         missing_tools = []
 
         for tool_name, command in tools.items():
@@ -190,17 +132,6 @@ class ErrorHandlingMixin:
         default: t.Any = None,
         operation_name: str = "attribute access",
     ) -> t.Any:
-        """Safely get an attribute with error handling.
-
-        Args:
-            obj: Object to get attribute from
-            attribute: Name of attribute to get
-            default: Default value if attribute doesn't exist
-            operation_name: Name of operation for error logging
-
-        Returns:
-            The attribute value or default
-        """
         try:
             return getattr(obj, attribute, default)
         except Exception as e:

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
 
@@ -87,6 +88,15 @@ class MCPServerConfig:
     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)
@@ -100,3 +110,4 @@ class WorkflowOptions:
     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