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

crackerjack/adapters/lsp/_client.py

@@ -0,0 +1,358 @@
+"""LSP client wrapper for Zuban communication."""
+
+import asyncio
+import json
+import logging
+import socket
+import typing as t
+from pathlib import Path
+
+logger = logging.getLogger("crackerjack.lsp_client")
+
+
+class ZubanLSPClient:
+    """Minimal LSP client for zuban communication."""
+
+    def __init__(self, host: str = "127.0.0.1", port: int = 8677) -> None:
+        """Initialize LSP client.
+
+        Args:
+            host: LSP server host
+            port: LSP server port
+        """
+        self.host = host
+        self.port = port
+        self._socket: socket.socket | None = None
+        self._reader: asyncio.StreamReader | None = None
+        self._writer: asyncio.StreamWriter | None = None
+        self._request_id = 0
+        self._initialized = False
+
+    def _next_request_id(self) -> int:
+        """Generate next request ID."""
+        self._request_id += 1
+        return self._request_id
+
+    async def connect(self, timeout: float = 5.0) -> bool:
+        """Connect to zuban LSP server.
+
+        Args:
+            timeout: Connection timeout in seconds
+
+        Returns:
+            True if connected successfully
+        """
+        try:
+            # Attempt TCP connection
+            self._reader, self._writer = await asyncio.wait_for(
+                asyncio.open_connection(self.host, self.port), timeout=timeout
+            )
+
+            logger.info(f"Connected to Zuban LSP server at {self.host}:{self.port}")
+            return True
+
+        except (TimeoutError, OSError) as e:
+            logger.warning(f"Failed to connect to LSP server: {e}")
+            return False
+
+    async def disconnect(self) -> None:
+        """Disconnect from LSP server."""
+        if self._writer:
+            try:
+                # Send shutdown request
+                if self._initialized:
+                    await self._send_request("shutdown")
+                    await self._send_notification("exit")
+
+                self._writer.close()
+                await self._writer.wait_closed()
+
+            except Exception as e:
+                logger.warning(f"Error during disconnect: {e}")
+            finally:
+                self._writer = None
+                self._reader = None
+                self._initialized = False
+
+    async def initialize(self, root_path: Path) -> dict[str, t.Any] | None:
+        """Send initialize request.
+
+        Args:
+            root_path: Workspace root path
+
+        Returns:
+            Initialize response from server
+        """
+        if self._initialized:
+            return {"status": "already_initialized"}
+
+        params = {
+            "processId": None,
+            "rootPath": str(root_path),
+            "rootUri": f"file://{root_path}",
+            "capabilities": {
+                "textDocument": {
+                    "publishDiagnostics": {
+                        "versionSupport": True,
+                        "tagSupport": {"valueSet": [1, 2]},
+                        "relatedInformation": True,
+                    }
+                },
+                "workspace": {
+                    "workspaceFolders": True,
+                    "configuration": True,
+                },
+            },
+            "workspaceFolders": [
+                {"uri": f"file://{root_path}", "name": root_path.name}
+            ],
+        }
+
+        response = await self._send_request("initialize", params)
+        if response and not response.get("error"):
+            # Send initialized notification
+            await self._send_notification("initialized")
+            self._initialized = True
+            logger.info("LSP client initialized successfully")
+
+        return response
+
+    async def text_document_did_open(self, file_path: Path) -> None:
+        """Notify server of opened document.
+
+        Args:
+            file_path: Path to opened file
+        """
+        if not file_path.exists():
+            logger.warning(f"File does not exist: {file_path}")
+            return
+
+        try:
+            content = file_path.read_text(encoding="utf-8")
+        except UnicodeDecodeError:
+            logger.warning(f"Could not read file as UTF-8: {file_path}")
+            return
+
+        params = {
+            "textDocument": {
+                "uri": f"file://{file_path}",
+                "languageId": "python",
+                "version": 1,
+                "text": content,
+            }
+        }
+
+        await self._send_notification("textDocument/didOpen", params)
+
+    async def text_document_did_change(
+        self, file_path: Path, content: str, version: int = 2
+    ) -> None:
+        """Notify server of document changes.
+
+        Args:
+            file_path: Path to changed file
+            content: New file content
+            version: Document version number
+        """
+        params = {
+            "textDocument": {
+                "uri": f"file://{file_path}",
+                "version": version,
+            },
+            "contentChanges": [{"text": content}],
+        }
+
+        await self._send_notification("textDocument/didChange", params)
+
+    async def text_document_did_close(self, file_path: Path) -> None:
+        """Notify server of closed document.
+
+        Args:
+            file_path: Path to closed file
+        """
+        params = {
+            "textDocument": {
+                "uri": f"file://{file_path}",
+            }
+        }
+
+        await self._send_notification("textDocument/didClose", params)
+
+    async def get_diagnostics(self, timeout: float = 2.0) -> list[dict[str, t.Any]]:
+        """Retrieve current diagnostics from server.
+
+        Args:
+            timeout: Timeout for waiting for diagnostics
+
+        Returns:
+            List of diagnostic messages
+        """
+        # For now, return empty list[t.Any] as diagnostics are typically pushed via notifications
+        # In a full implementation, we'd maintain a diagnostics store updated by notifications
+        return []
+
+    async def _send_request(
+        self, method: str, params: dict[str, t.Any] | None = None, timeout: float = 10.0
+    ) -> dict[str, t.Any] | None:
+        """Send LSP request and wait for response.
+
+        Args:
+            method: LSP method name
+            params: Request parameters
+            timeout: Response timeout
+
+        Returns:
+            Response from server
+        """
+        if not self._writer or not self._reader:
+            return None
+
+        request_id = self._next_request_id()
+        request = {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "method": method,
+        }
+
+        if params is not None:
+            request["params"] = params
+
+        try:
+            # Send request
+            await self._send_message(request)
+
+            # Wait for response
+            response = await asyncio.wait_for(
+                self._read_response(request_id), timeout=timeout
+            )
+
+            return response
+
+        except TimeoutError:
+            logger.warning(f"LSP request {method} timed out")
+            return {"error": "timeout", "id": request_id}
+        except Exception as e:
+            logger.error(f"LSP request {method} failed: {e}")
+            return {"error": str(e), "id": request_id}
+
+    async def _send_notification(
+        self, method: str, params: dict[str, t.Any] | None = None
+    ) -> None:
+        """Send LSP notification (no response expected).
+
+        Args:
+            method: LSP method name
+            params: Notification parameters
+        """
+        if not self._writer:
+            return
+
+        notification: dict[str, t.Any] = {
+            "jsonrpc": "2.0",
+            "method": method,
+        }
+
+        if params is not None:
+            notification["params"] = params
+
+        try:
+            await self._send_message(notification)
+        except Exception as e:
+            logger.error(f"LSP notification {method} failed: {e}")
+
+    async def _send_message(self, message: dict[str, t.Any]) -> None:
+        """Send LSP message with proper formatting.
+
+        Args:
+            message: Message to send
+        """
+        if not self._writer:
+            return
+
+        content_bytes = json.dumps(message).encode("utf-8")
+        content_length = len(content_bytes)
+
+        # LSP protocol: Content-Length header + \r\n\r\n + JSON
+        header = f"Content-Length: {content_length}\r\n\r\n"
+        full_message = header.encode("ascii") + content_bytes
+
+        self._writer.write(full_message)
+        await self._writer.drain()
+
+    async def _read_response(self, expected_id: int) -> dict[str, t.Any] | None:
+        """Read LSP response for specific request ID.
+
+        Args:
+            expected_id: Expected request ID
+
+        Returns:
+            Response message
+        """
+        while True:
+            message = await self._read_message()
+            if not message:
+                return None
+
+            # Check if this is the response we're waiting for
+            if message.get("id") == expected_id:
+                return message
+
+            # If it's a different response or notification, log and continue
+            if "id" in message:
+                logger.debug(
+                    f"Received response for ID {message['id']}, expected {expected_id}"
+                )
+            else:
+                logger.debug(
+                    f"Received notification: {message.get('method', 'unknown')}"
+                )
+
+    async def _read_message(self) -> dict[str, t.Any] | None:
+        """Read complete LSP message.
+
+        Returns:
+            Parsed message dictionary
+        """
+        if not self._reader:
+            return None
+
+        try:
+            # Read Content-Length header
+            header_line = await self._reader.readline()
+            header_str = header_line.decode("ascii").strip()
+
+            if not header_str.startswith("Content-Length:"):
+                logger.warning(f"Invalid LSP header: {header_str}")
+                return None
+
+            content_length = int(header_str.split(":", 1)[1].strip())
+
+            # Read separator line
+            separator = await self._reader.readline()
+            if separator.strip():
+                logger.warning("Expected empty separator line")
+
+            # Read JSON content
+            content_bytes = await self._reader.readexactly(content_length)
+            content = content_bytes.decode()
+
+            json_result = json.loads(content)
+            return t.cast(dict[str, t.Any] | None, json_result)
+
+        except Exception as e:
+            logger.error(f"Failed to read LSP message: {e}")
+            return None
+
+    async def __aenter__(self) -> "ZubanLSPClient":
+        """Async context manager entry."""
+        await self.connect()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: t.Any,
+    ) -> None:
+        """Async context manager exit."""
+        await self.disconnect()

crackerjack/adapters/lsp/_manager.py

@@ -0,0 +1,193 @@
+"""Rust tool manager for unified execution and coordination."""
+
+import asyncio
+import time
+import typing as t
+from pathlib import Path
+
+from ._base import BaseRustToolAdapter, ToolResult
+from .skylos import SkylosAdapter
+from .zuban import ZubanAdapter
+
+if t.TYPE_CHECKING:
+    from crackerjack.orchestration.execution_strategies import ExecutionContext
+
+
+class RustToolHookManager:
+    """Manager for coordinating Rust-based analysis tools."""
+
+    def __init__(self, context: "ExecutionContext") -> None:
+        """Initialize manager with execution context."""
+        self.context = context
+        self.adapters: dict[str, BaseRustToolAdapter] = {}
+        self._initialize_adapters()
+
+    def _initialize_adapters(self) -> None:
+        """Initialize available Rust tool adapters."""
+        # Dead code detection with Skylos
+        self.adapters["skylos"] = SkylosAdapter(context=self.context)
+
+        # Type checking with Zuban
+        self.adapters["zuban"] = ZubanAdapter(context=self.context)
+
+    async def run_all_tools(
+        self, target_files: list[Path] | None = None
+    ) -> dict[str, ToolResult]:
+        """Run all available Rust tools in parallel."""
+        target_files = target_files or []
+
+        # Filter to available tools only
+        available_adapters = {
+            name: adapter
+            for name, adapter in self.adapters.items()
+            if adapter.validate_tool_available()
+        }
+
+        if not available_adapters:
+            return {
+                "error": ToolResult(
+                    success=False,
+                    error=(
+                        "No Rust tools are available. "
+                        "Install skylos and zuban with: uv add skylos zuban"
+                    ),
+                )
+            }
+
+        # Run tools in parallel
+        tasks = [
+            self._run_single_tool(name, adapter, target_files)
+            for name, adapter in available_adapters.items()
+        ]
+
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        # Process results
+        tool_results = {}
+        for i, (name, _) in enumerate(available_adapters.items()):
+            result = results[i]
+            if isinstance(result, Exception):
+                tool_results[name] = ToolResult(
+                    success=False,
+                    error=f"Tool execution failed: {result}",
+                )
+            elif isinstance(result, ToolResult):  # Explicit check for mypy
+                tool_results[name] = result
+
+        return tool_results
+
+    async def run_single_tool(
+        self, tool_name: str, target_files: list[Path] | None = None
+    ) -> ToolResult:
+        """Run a single Rust tool by name."""
+        if tool_name not in self.adapters:
+            return ToolResult(
+                success=False,
+                error=(
+                    f"Unknown tool: {tool_name}. "
+                    f"Available: {list[t.Any](self.adapters.keys())}"
+                ),
+            )
+
+        adapter = self.adapters[tool_name]
+        if not adapter.validate_tool_available():
+            return ToolResult(
+                success=False,
+                error=(
+                    f"Tool {tool_name} is not available. "
+                    f"Install with: uv add {tool_name}"
+                ),
+            )
+
+        return await self._run_single_tool(tool_name, adapter, target_files or [])
+
+    async def _run_single_tool(
+        self, name: str, adapter: BaseRustToolAdapter, target_files: list[Path]
+    ) -> ToolResult:
+        """Execute a single tool adapter."""
+        start_time = time.time()
+
+        try:
+            # Get command arguments
+            cmd_args = adapter.get_command_args(target_files)
+
+            # Execute command
+            process = await asyncio.create_subprocess_exec(
+                *cmd_args,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.STDOUT,
+                cwd=self.context.working_directory,
+            )
+
+            stdout, _ = await process.communicate()
+            output = stdout.decode() if stdout else ""
+
+            # Parse output
+            result = adapter.parse_output(output)
+            result.execution_time = time.time() - start_time
+
+            return result
+
+        except Exception as e:
+            return ToolResult(
+                success=False,
+                error=f"Failed to execute {name}: {e}",
+                execution_time=time.time() - start_time,
+                tool_version=adapter.get_tool_version(),
+            )
+
+    def get_available_tools(self) -> list[str]:
+        """Get list[t.Any] of available Rust tools."""
+        return [
+            name
+            for name, adapter in self.adapters.items()
+            if adapter.validate_tool_available()
+        ]
+
+    def get_tool_info(self) -> dict[str, dict[str, t.Any]]:
+        """Get information about all configured tools."""
+        info: dict[str, dict[str, t.Any]] = {}
+        for name, adapter in self.adapters.items():
+            info[name] = {
+                "available": adapter.validate_tool_available(),
+                "supports_json": adapter.supports_json_output(),
+                "version": adapter.get_tool_version(),
+                "tool_name": adapter.get_tool_name(),
+            }
+        return info
+
+    def create_consolidated_report(
+        self, results: dict[str, ToolResult]
+    ) -> dict[str, t.Any]:
+        """Create a consolidated report from multiple tool results."""
+        total_issues = 0
+        total_errors = 0
+        total_warnings = 0
+        all_success = True
+        execution_times = {}
+
+        for tool_name, result in results.items():
+            if tool_name == "error":
+                all_success = False
+                continue
+
+            total_issues += len(result.issues)
+            total_errors += result.error_count
+            total_warnings += result.warning_count
+            execution_times[tool_name] = result.execution_time
+
+            if not result.success:
+                all_success = False
+
+        return {
+            "overall_success": all_success,
+            "total_issues": total_issues,
+            "total_errors": total_errors,
+            "total_warnings": total_warnings,
+            "tools_run": list[t.Any](results.keys()),
+            "execution_times": execution_times,
+            "total_time": sum(execution_times.values()),
+            "results_by_tool": {
+                name: result.to_dict() for name, result in results.items()
+            },
+        }