hanzo-mcp 0.7.6__py3-none-any.whl → 0.8.0__py3-none-any.whl

hanzo_mcp/tools/lsp/lsp_tool.py

@@ -7,18 +7,16 @@ rename symbol, and diagnostics.
 """
 
 import os
-import subprocess
 import json
-import asyncio
 import shutil
-from typing import Dict, List, Any, Optional, Tuple
+import asyncio
+import logging
+from typing import Any, Dict, Optional
 from pathlib import Path
 from dataclasses import dataclass
-import logging
 
-from hanzo_mcp.tools.common.base import BaseTool
-from hanzo_mcp.tools.common.decorators import with_context_normalization
 from hanzo_mcp.types import MCPResourceDocument
+from hanzo_mcp.tools.common.base import BaseTool
 
 # LSP server configurations
 LSP_SERVERS = {
@@ -29,7 +27,14 @@ LSP_SERVERS = {
         "start_cmd": ["gopls", "serve"],
         "root_markers": ["go.mod", "go.sum"],
         "file_extensions": [".go"],
-        "capabilities": ["definition", "references", "rename", "diagnostics", "hover", "completion"]
+        "capabilities": [
+            "definition",
+            "references",
+            "rename",
+            "diagnostics",
+            "hover",
+            "completion",
+        ],
     },
     "python": {
         "name": "pylsp",
@@ -38,16 +43,36 @@ LSP_SERVERS = {
         "start_cmd": ["pylsp"],
         "root_markers": ["pyproject.toml", "setup.py", "requirements.txt"],
         "file_extensions": [".py"],
-        "capabilities": ["definition", "references", "rename", "diagnostics", "hover", "completion"]
+        "capabilities": [
+            "definition",
+            "references",
+            "rename",
+            "diagnostics",
+            "hover",
+            "completion",
+        ],
     },
     "typescript": {
         "name": "typescript-language-server",
-        "install_cmd": ["npm", "install", "-g", "typescript", "typescript-language-server"],
+        "install_cmd": [
+            "npm",
+            "install",
+            "-g",
+            "typescript",
+            "typescript-language-server",
+        ],
         "check_cmd": ["typescript-language-server", "--version"],
         "start_cmd": ["typescript-language-server", "--stdio"],
         "root_markers": ["tsconfig.json", "package.json"],
         "file_extensions": [".ts", ".tsx", ".js", ".jsx"],
-        "capabilities": ["definition", "references", "rename", "diagnostics", "hover", "completion"]
+        "capabilities": [
+            "definition",
+            "references",
+            "rename",
+            "diagnostics",
+            "hover",
+            "completion",
+        ],
     },
     "rust": {
         "name": "rust-analyzer",
@@ -56,7 +81,15 @@ LSP_SERVERS = {
         "start_cmd": ["rust-analyzer"],
         "root_markers": ["Cargo.toml"],
         "file_extensions": [".rs"],
-        "capabilities": ["definition", "references", "rename", "diagnostics", "hover", "completion", "inlay_hints"]
+        "capabilities": [
+            "definition",
+            "references",
+            "rename",
+            "diagnostics",
+            "hover",
+            "completion",
+            "inlay_hints",
+        ],
     },
     "java": {
         "name": "jdtls",
@@ -65,7 +98,14 @@ LSP_SERVERS = {
         "start_cmd": ["jdtls"],
         "root_markers": ["pom.xml", "build.gradle", "build.gradle.kts"],
         "file_extensions": [".java"],
-        "capabilities": ["definition", "references", "rename", "diagnostics", "hover", "completion"]
+        "capabilities": [
+            "definition",
+            "references",
+            "rename",
+            "diagnostics",
+            "hover",
+            "completion",
+        ],
     },
     "cpp": {
         "name": "clangd",
@@ -74,7 +114,14 @@ LSP_SERVERS = {
         "start_cmd": ["clangd"],
         "root_markers": ["compile_commands.json", "CMakeLists.txt"],
         "file_extensions": [".cpp", ".cc", ".cxx", ".c", ".h", ".hpp"],
-        "capabilities": ["definition", "references", "rename", "diagnostics", "hover", "completion"]
+        "capabilities": [
+            "definition",
+            "references",
+            "rename",
+            "diagnostics",
+            "hover",
+            "completion",
+        ],
     },
     "ruby": {
         "name": "solargraph",
@@ -83,7 +130,13 @@ LSP_SERVERS = {
         "start_cmd": ["solargraph", "stdio"],
         "root_markers": ["Gemfile", ".solargraph.yml"],
         "file_extensions": [".rb"],
-        "capabilities": ["definition", "references", "diagnostics", "hover", "completion"]
+        "capabilities": [
+            "definition",
+            "references",
+            "diagnostics",
+            "hover",
+            "completion",
+        ],
     },
     "lua": {
         "name": "lua-language-server",
@@ -92,14 +145,22 @@ LSP_SERVERS = {
         "start_cmd": ["lua-language-server"],
         "root_markers": [".luarc.json"],
         "file_extensions": [".lua"],
-        "capabilities": ["definition", "references", "rename", "diagnostics", "hover", "completion"]
-    }
+        "capabilities": [
+            "definition",
+            "references",
+            "rename",
+            "diagnostics",
+            "hover",
+            "completion",
+        ],
+    },
 }
 
 
 @dataclass
 class LSPServer:
     """Represents an LSP server instance."""
+
     language: str
     process: Optional[asyncio.subprocess.Process]
     config: Dict[str, Any]
@@ -109,11 +170,11 @@ class LSPServer:
 
 class LSPTool(BaseTool):
     """Language Server Protocol tool for code intelligence.
-    
+
     This tool automatically configures and manages LSP servers for various
     programming languages. It installs language servers on-demand and provides
     code intelligence features.
-    
+
     Features:
     - Auto-installation of language servers
     - Go-to-definition
@@ -122,25 +183,25 @@ class LSPTool(BaseTool):
     - Get diagnostics
     - Hover information
     - Code completion
-    
+
     Example usage:
-    
+
     1. Find definition of a Go function:
        lsp("definition", file="main.go", line=10, character=15)
-    
+
     2. Find all references to a Python class:
        lsp("references", file="models.py", line=25, character=10)
-    
+
     3. Rename a TypeScript variable:
        lsp("rename", file="app.ts", line=30, character=20, new_name="newVarName")
-    
+
     4. Get diagnostics for a Rust file:
        lsp("diagnostics", file="lib.rs")
-    
+
     The tool automatically detects the language based on file extension and
     installs the appropriate language server if not already available.
     """
-    
+
     name = "lsp"
     description = """Language Server Protocol tool for code intelligence.
     
@@ -156,87 +217,89 @@ class LSPTool(BaseTool):
     The tool automatically installs language servers as needed.
     Supported languages: Go, Python, TypeScript/JavaScript, Rust, Java, C/C++, Ruby, Lua
     """
-    
+
     def __init__(self):
         super().__init__()
         self.servers: Dict[str, LSPServer] = {}
         self.logger = logging.getLogger(__name__)
-        
+
     def _get_language_from_file(self, file_path: str) -> Optional[str]:
         """Detect language from file extension."""
         ext = Path(file_path).suffix.lower()
-        
+
         for lang, config in LSP_SERVERS.items():
             if ext in config["file_extensions"]:
                 return lang
-        
+
         return None
-    
+
     def _find_project_root(self, file_path: str, language: str) -> str:
         """Find project root based on language markers."""
         markers = LSP_SERVERS[language]["root_markers"]
         path = Path(file_path).resolve()
-        
+
         for parent in path.parents:
             for marker in markers:
                 if (parent / marker).exists():
                     return str(parent)
-        
+
         return str(path.parent)
-    
+
     async def _check_lsp_installed(self, language: str) -> bool:
         """Check if LSP server is installed."""
         config = LSP_SERVERS.get(language)
         if not config:
             return False
-        
+
         try:
             result = await asyncio.create_subprocess_exec(
                 *config["check_cmd"],
                 stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE
+                stderr=asyncio.subprocess.PIPE,
             )
             await result.communicate()
             return result.returncode == 0
         except (FileNotFoundError, OSError):
             return False
-    
+
     async def _install_lsp(self, language: str) -> bool:
         """Install LSP server for language."""
         config = LSP_SERVERS.get(language)
         if not config:
             return False
-        
+
         self.logger.info(f"Installing {config['name']} for {language}")
-        
+
         try:
             # Check if installer is available
             installer = config["install_cmd"][0]
             if not shutil.which(installer):
                 self.logger.error(f"Installer {installer} not found")
                 return False
-            
+
             # Run installation command
             result = await asyncio.create_subprocess_exec(
                 *config["install_cmd"],
                 stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE
+                stderr=asyncio.subprocess.PIPE,
             )
-            
+
             stdout, stderr = await result.communicate()
-            
+
             if result.returncode != 0:
                 self.logger.error(f"Installation failed: {stderr.decode()}")
                 return False
-            
+
             self.logger.info(f"Successfully installed {config['name']}")
             return True
-            
+
         except Exception as e:
             self.logger.error(f"Installation error: {e}")
             return False
-    
-    async def _ensure_lsp_running(self, language: str, root_uri: str) -> Optional[LSPServer]:
+
+    async def _ensure_lsp_running(
+        self, language: str, root_uri: str
+    ) -> Optional[LSPServer]:
         """Ensure LSP server is running for language."""
         # Check if already running
         server_key = f"{language}:{root_uri}"
@@ -244,42 +307,39 @@ class LSPTool(BaseTool):
             server = self.servers[server_key]
             if server.process and server.process.returncode is None:
                 return server
-        
+
         # Check if installed
         if not await self._check_lsp_installed(language):
             # Try to install
             if not await self._install_lsp(language):
                 return None
-        
+
         # Start LSP server
         config = LSP_SERVERS[language]
-        
+
         try:
             process = await asyncio.create_subprocess_exec(
                 *config["start_cmd"],
                 stdin=asyncio.subprocess.PIPE,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
-                cwd=root_uri
+                cwd=root_uri,
             )
-            
+
             server = LSPServer(
-                language=language,
-                process=process,
-                config=config,
-                root_uri=root_uri
+                language=language, process=process, config=config, root_uri=root_uri
             )
-            
+
             # Initialize LSP
             await self._initialize_lsp(server)
-            
+
             self.servers[server_key] = server
             return server
-            
+
         except Exception as e:
             self.logger.error(f"Failed to start LSP: {e}")
             return None
-    
+
     async def _initialize_lsp(self, server: LSPServer):
         """Send initialize request to LSP server."""
         # This is a simplified initialization
@@ -291,58 +351,62 @@ class LSPTool(BaseTool):
                 "textDocument": {
                     "definition": {"dynamicRegistration": True},
                     "references": {"dynamicRegistration": True},
-                    "rename": {"dynamicRegistration": True}
+                    "rename": {"dynamicRegistration": True},
                 }
-            }
+            },
         }
-        
+
         # Send initialize request
         request = {
             "jsonrpc": "2.0",
             "id": 1,
             "method": "initialize",
-            "params": init_params
+            "params": init_params,
         }
-        
+
         await self._send_request(server, request)
         server.initialized = True
-    
-    async def _send_request(self, server: LSPServer, request: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+
+    async def _send_request(
+        self, server: LSPServer, request: Dict[str, Any]
+    ) -> Optional[Dict[str, Any]]:
         """Send JSON-RPC request to LSP server."""
         if not server.process or server.process.returncode is not None:
             return None
-        
+
         try:
             # Serialize request
             request_str = json.dumps(request)
-            content_length = len(request_str.encode('utf-8'))
-            
+            content_length = len(request_str.encode("utf-8"))
+
             # Send LSP message
             message = f"Content-Length: {content_length}\r\n\r\n{request_str}"
-            server.process.stdin.write(message.encode('utf-8'))
+            server.process.stdin.write(message.encode("utf-8"))
             await server.process.stdin.drain()
-            
+
             # Read response (simplified - real implementation needs proper parsing)
             # This is a placeholder - actual LSP requires parsing Content-Length headers
             response_data = await server.process.stdout.readline()
-            
+
             if response_data:
-                return json.loads(response_data.decode('utf-8'))
-            
+                return json.loads(response_data.decode("utf-8"))
+
         except Exception as e:
             self.logger.error(f"LSP communication error: {e}")
-        
+
         return None
-    
-    async def run(self,
-                  action: str,
-                  file: str,
-                  line: Optional[int] = None,
-                  character: Optional[int] = None,
-                  new_name: Optional[str] = None,
-                  **kwargs) -> MCPResourceDocument:
+
+    async def run(
+        self,
+        action: str,
+        file: str,
+        line: Optional[int] = None,
+        character: Optional[int] = None,
+        new_name: Optional[str] = None,
+        **kwargs,
+    ) -> MCPResourceDocument:
         """Execute LSP action.
-        
+
         Args:
             action: LSP action (definition, references, rename, diagnostics, hover, completion, status)
             file: File path to analyze
@@ -350,65 +414,84 @@ class LSPTool(BaseTool):
             character: Character position in line (0-indexed)
             new_name: New name for rename action
         """
-        
+
         # Validate action
-        valid_actions = ["definition", "references", "rename", "diagnostics", "hover", "completion", "status"]
+        valid_actions = [
+            "definition",
+            "references",
+            "rename",
+            "diagnostics",
+            "hover",
+            "completion",
+            "status",
+        ]
         if action not in valid_actions:
-            return MCPResourceDocument(data={
-                "error": f"Invalid action. Must be one of: {', '.join(valid_actions)}"
-            })
-        
+            return MCPResourceDocument(
+                data={
+                    "error": f"Invalid action. Must be one of: {', '.join(valid_actions)}"
+                }
+            )
+
         # Get language from file
         language = self._get_language_from_file(file)
         if not language:
-            return MCPResourceDocument(data={
-                "error": f"Unsupported file type: {file}",
-                "supported_languages": list(LSP_SERVERS.keys())
-            })
-        
+            return MCPResourceDocument(
+                data={
+                    "error": f"Unsupported file type: {file}",
+                    "supported_languages": list(LSP_SERVERS.keys()),
+                }
+            )
+
         # Check LSP capabilities
         capabilities = LSP_SERVERS[language]["capabilities"]
         if action not in capabilities and action != "status":
-            return MCPResourceDocument(data={
-                "error": f"Action '{action}' not supported for {language}",
-                "supported_actions": capabilities
-            })
-        
+            return MCPResourceDocument(
+                data={
+                    "error": f"Action '{action}' not supported for {language}",
+                    "supported_actions": capabilities,
+                }
+            )
+
         # Status check
         if action == "status":
             installed = await self._check_lsp_installed(language)
-            return MCPResourceDocument(data={
-                "language": language,
-                "lsp_server": LSP_SERVERS[language]["name"],
-                "installed": installed,
-                "capabilities": capabilities
-            })
-        
+            return MCPResourceDocument(
+                data={
+                    "language": language,
+                    "lsp_server": LSP_SERVERS[language]["name"],
+                    "installed": installed,
+                    "capabilities": capabilities,
+                }
+            )
+
         # Find project root
         root_uri = self._find_project_root(file, language)
-        
+
         # Ensure LSP is running
         server = await self._ensure_lsp_running(language, root_uri)
         if not server:
-            return MCPResourceDocument(data={
-                "error": f"Failed to start LSP server for {language}",
-                "install_command": " ".join(LSP_SERVERS[language]["install_cmd"])
-            })
-        
+            return MCPResourceDocument(
+                data={
+                    "error": f"Failed to start LSP server for {language}",
+                    "install_command": " ".join(LSP_SERVERS[language]["install_cmd"]),
+                }
+            )
+
         # Execute action
-        result = await self._execute_lsp_action(server, action, file, line, character, new_name)
-        
+        result = await self._execute_lsp_action(
+            server, action, file, line, character, new_name
+        )
+
         return MCPResourceDocument(data=result)
-    
+
     async def call(self, **kwargs) -> str:
         """Tool interface for MCP - converts result to JSON string."""
         result = await self.run(**kwargs)
         return result.to_json_string()
-    
+
     def register(self, mcp_server) -> None:
         """Register tool with MCP server."""
-        from mcp.server import FastMCP
-        
+
         @mcp_server.tool(name=self.name, description=self.description)
         async def lsp_handler(
             action: str,
@@ -425,19 +508,21 @@ class LSPTool(BaseTool):
                 character=character,
                 new_name=new_name,
             )
-    
-    async def _execute_lsp_action(self,
-                                 server: LSPServer,
-                                 action: str,
-                                 file: str,
-                                 line: Optional[int],
-                                 character: Optional[int],
-                                 new_name: Optional[str]) -> Dict[str, Any]:
+
+    async def _execute_lsp_action(
+        self,
+        server: LSPServer,
+        action: str,
+        file: str,
+        line: Optional[int],
+        character: Optional[int],
+        new_name: Optional[str],
+    ) -> Dict[str, Any]:
         """Execute specific LSP action."""
-        
+
         # This is a simplified implementation
         # Real implementation would use proper LSP protocol
-        
+
         if action == "definition":
             # textDocument/definition request
             return {
@@ -445,9 +530,9 @@ class LSPTool(BaseTool):
                 "file": file,
                 "position": {"line": line, "character": character},
                 "note": "LSP integration pending full implementation",
-                "fallback": "Use mcp__lsp__find_definition tool for now"
+                "fallback": "Use mcp__lsp__find_definition tool for now",
             }
-        
+
         elif action == "references":
             # textDocument/references request
             return {
@@ -455,9 +540,9 @@ class LSPTool(BaseTool):
                 "file": file,
                 "position": {"line": line, "character": character},
                 "note": "LSP integration pending full implementation",
-                "fallback": "Use mcp__lsp__find_references tool for now"
+                "fallback": "Use mcp__lsp__find_references tool for now",
             }
-        
+
         elif action == "rename":
             # textDocument/rename request
             return {
@@ -466,38 +551,38 @@ class LSPTool(BaseTool):
                 "position": {"line": line, "character": character},
                 "new_name": new_name,
                 "note": "LSP integration pending full implementation",
-                "fallback": "Use mcp__lsp__rename_symbol tool for now"
+                "fallback": "Use mcp__lsp__rename_symbol tool for now",
             }
-        
+
         elif action == "diagnostics":
             # textDocument/diagnostic request
             return {
                 "action": "diagnostics",
                 "file": file,
                 "note": "LSP integration pending full implementation",
-                "fallback": "Use mcp__lsp__get_diagnostics tool for now"
+                "fallback": "Use mcp__lsp__get_diagnostics tool for now",
             }
-        
+
         elif action == "hover":
             # textDocument/hover request
             return {
                 "action": "hover",
                 "file": file,
                 "position": {"line": line, "character": character},
-                "note": "LSP integration pending full implementation"
+                "note": "LSP integration pending full implementation",
             }
-        
+
         elif action == "completion":
             # textDocument/completion request
             return {
                 "action": "completion",
                 "file": file,
                 "position": {"line": line, "character": character},
-                "note": "LSP integration pending full implementation"
+                "note": "LSP integration pending full implementation",
             }
-        
+
         return {"error": "Unknown action"}
-    
+
     async def cleanup(self):
         """Clean up LSP servers."""
         for server in self.servers.values():
@@ -509,4 +594,4 @@ class LSPTool(BaseTool):
 # Tool registration
 def create_lsp_tool():
     """Factory function to create LSP tool."""
-    return LSPTool()
+    return LSPTool()