hanzo-mcp 0.9.0__py3-none-any.whl → 0.9.2__py3-none-any.whl

hanzo_mcp/tools/lsp/lsp_tool.py

@@ -1,602 +1,397 @@
-"""Enhanced Language Server Protocol (LSP) implementation with full protocol support.
 
-This module provides a complete LSP client implementation with support for
-all major programming languages including C, C++, Go, JavaScript, TypeScript,
-Rust, Zig, and more.
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
+"""Language Server Protocol (LSP) tool for code intelligence.
+
+This tool provides on-demand LSP configuration and installation for various
+programming languages. It automatically installs language servers as needed
+and provides code intelligence features like go-to-definition, find references,
+rename symbol, and diagnostics.
 """
 
 import os
-import sys
 import json
+import shutil
 import asyncio
 import logging
-import subprocess
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, Optional
 from pathlib import Path
-from dataclasses import dataclass, field
-from enum import Enum
+from dataclasses import dataclass
 
 from hanzo_mcp.types import MCPResourceDocument
 from hanzo_mcp.tools.common.base import BaseTool
 
-
-class MessageType(Enum):
-    """LSP message types."""
-    REQUEST = "request"
-    RESPONSE = "response"
-    NOTIFICATION = "notification"
-
-
-@dataclass
-class LSPMessage:
-    """Represents an LSP message."""
-    type: MessageType
-    id: Optional[int] = None
-    method: Optional[str] = None
-    params: Optional[Dict[str, Any]] = None
-    result: Optional[Any] = None
-    error: Optional[Dict[str, Any]] = None
-
-
-@dataclass
-class Position:
-    """LSP position in a document."""
-    line: int
-    character: int
-    
-    def to_dict(self) -> Dict[str, int]:
-        return {"line": self.line, "character": self.character}
-
-
-@dataclass
-class Range:
-    """LSP range in a document."""
-    start: Position
-    end: Position
-    
-    def to_dict(self) -> Dict[str, Any]:
-        return {"start": self.start.to_dict(), "end": self.end.to_dict()}
-
-
-@dataclass
-class Location:
-    """LSP location."""
-    uri: str
-    range: Range
-    
-    def to_dict(self) -> Dict[str, Any]:
-        return {"uri": self.uri, "range": self.range.to_dict()}
-
-
-# Enhanced LSP server configurations with compilation support
-ENHANCED_LSP_SERVERS = {
-    "c": {
-        "name": "clangd",
-        "install_cmd": {
-            "darwin": ["brew", "install", "llvm"],
-            "linux": ["sudo", "apt-get", "install", "-y", "clangd"],
-        },
-        "check_cmd": ["clangd", "--version"],
-        "start_cmd": ["clangd", "--background-index"],
-        "root_markers": ["compile_commands.json", "CMakeLists.txt", ".clangd"],
-        "file_extensions": [".c", ".h"],
-        "compile_cmd": ["clang", "-o", "{output}", "{input}"],
-        "run_cmd": ["./{output}"],
-        "capabilities": [
-            "definition", "references", "rename", "diagnostics",
-            "hover", "completion", "formatting", "code_actions"
-        ],
-    },
-    "cpp": {
-        "name": "clangd",
-        "install_cmd": {
-            "darwin": ["brew", "install", "llvm"],
-            "linux": ["sudo", "apt-get", "install", "-y", "clangd"],
-        },
-        "check_cmd": ["clangd", "--version"],
-        "start_cmd": ["clangd", "--background-index"],
-        "root_markers": ["compile_commands.json", "CMakeLists.txt", ".clangd"],
-        "file_extensions": [".cpp", ".cc", ".cxx", ".hpp", ".hxx"],
-        "compile_cmd": ["clang++", "-std=c++17", "-o", "{output}", "{input}"],
-        "run_cmd": ["./{output}"],
-        "capabilities": [
-            "definition", "references", "rename", "diagnostics",
-            "hover", "completion", "formatting", "code_actions"
-        ],
-    },
+# LSP server configurations
+LSP_SERVERS = {
     "go": {
         "name": "gopls",
-        "install_cmd": {
-            "all": ["go", "install", "golang.org/x/tools/gopls@latest"],
-        },
+        "install_cmd": ["go", "install", "golang.org/x/tools/gopls@latest"],
         "check_cmd": ["gopls", "version"],
         "start_cmd": ["gopls", "serve"],
         "root_markers": ["go.mod", "go.sum"],
         "file_extensions": [".go"],
-        "compile_cmd": ["go", "build", "-o", "{output}", "{input}"],
-        "run_cmd": ["./{output}"],
         "capabilities": [
-            "definition", "references", "rename", "diagnostics",
-            "hover", "completion", "formatting", "code_actions",
-            "implementation", "type_definition"
+            "definition",
+            "references",
+            "rename",
+            "diagnostics",
+            "hover",
+            "completion",
         ],
     },
-    "javascript": {
-        "name": "typescript-language-server",
-        "install_cmd": {
-            "all": ["npm", "install", "-g", "typescript", "typescript-language-server"],
-        },
-        "check_cmd": ["typescript-language-server", "--version"],
-        "start_cmd": ["typescript-language-server", "--stdio"],
-        "root_markers": ["package.json", "tsconfig.json", "jsconfig.json"],
-        "file_extensions": [".js", ".jsx", ".mjs"],
-        "run_cmd": ["node", "{input}"],
+    "python": {
+        "name": "pylsp",
+        "install_cmd": ["pip", "install", "python-lsp-server[all]"],
+        "check_cmd": ["pylsp", "--version"],
+        "start_cmd": ["pylsp"],
+        "root_markers": ["pyproject.toml", "setup.py", "requirements.txt"],
+        "file_extensions": [".py"],
         "capabilities": [
-            "definition", "references", "rename", "diagnostics",
-            "hover", "completion", "formatting", "code_actions"
+            "definition",
+            "references",
+            "rename",
+            "diagnostics",
+            "hover",
+            "completion",
         ],
     },
     "typescript": {
         "name": "typescript-language-server",
-        "install_cmd": {
-            "all": ["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"],
-        "compile_cmd": ["tsc", "{input}", "--outFile", "{output}.js"],
-        "run_cmd": ["node", "{output}.js"],
+        "file_extensions": [".ts", ".tsx", ".js", ".jsx"],
         "capabilities": [
-            "definition", "references", "rename", "diagnostics",
-            "hover", "completion", "formatting", "code_actions",
-            "implementation", "type_definition"
+            "definition",
+            "references",
+            "rename",
+            "diagnostics",
+            "hover",
+            "completion",
         ],
     },
     "rust": {
         "name": "rust-analyzer",
-        "install_cmd": {
-            "all": ["rustup", "component", "add", "rust-analyzer"],
-        },
+        "install_cmd": ["rustup", "component", "add", "rust-analyzer"],
         "check_cmd": ["rust-analyzer", "--version"],
         "start_cmd": ["rust-analyzer"],
         "root_markers": ["Cargo.toml"],
         "file_extensions": [".rs"],
-        "compile_cmd": ["rustc", "-o", "{output}", "{input}"],
-        "run_cmd": ["./{output}"],
         "capabilities": [
-            "definition", "references", "rename", "diagnostics",
-            "hover", "completion", "formatting", "code_actions",
-            "inlay_hints", "implementation", "type_definition"
+            "definition",
+            "references",
+            "rename",
+            "diagnostics",
+            "hover",
+            "completion",
+            "inlay_hints",
         ],
     },
-    "zig": {
-        "name": "zls",
-        "install_cmd": {
-            "darwin": ["brew", "install", "zls"],
-            "linux": ["wget", "-O", "/tmp/zls.tar.gz", 
-                     "https://github.com/zigtools/zls/releases/latest/download/zls-linux-x86_64.tar.gz",
-                     "&&", "tar", "-xvf", "/tmp/zls.tar.gz", "-C", "/usr/local/bin"],
-        },
-        "check_cmd": ["zls", "--version"],
-        "start_cmd": ["zls"],
-        "root_markers": ["build.zig", "build.zig.zon"],
-        "file_extensions": [".zig"],
-        "compile_cmd": ["zig", "build-exe", "{input}", "-femit-bin={output}"],
-        "run_cmd": ["./{output}"],
+    "java": {
+        "name": "jdtls",
+        "install_cmd": ["brew", "install", "jdtls"],  # Or manual download
+        "check_cmd": ["jdtls", "--version"],
+        "start_cmd": ["jdtls"],
+        "root_markers": ["pom.xml", "build.gradle", "build.gradle.kts"],
+        "file_extensions": [".java"],
         "capabilities": [
-            "definition", "references", "rename", "diagnostics",
-            "hover", "completion", "formatting", "code_actions",
-            "semantic_tokens"
+            "definition",
+            "references",
+            "rename",
+            "diagnostics",
+            "hover",
+            "completion",
         ],
     },
-    "python": {
-        "name": "pylsp",
-        "install_cmd": {
-            "all": ["pip", "install", "python-lsp-server[all]"],
-        },
-        "check_cmd": ["pylsp", "--version"],
-        "start_cmd": ["pylsp"],
-        "root_markers": ["pyproject.toml", "setup.py", "requirements.txt"],
-        "file_extensions": [".py"],
-        "run_cmd": ["python", "{input}"],
+    "cpp": {
+        "name": "clangd",
+        "install_cmd": ["brew", "install", "llvm"],  # Or apt-get install clangd
+        "check_cmd": ["clangd", "--version"],
+        "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",
+        ],
+    },
+    "ruby": {
+        "name": "solargraph",
+        "install_cmd": ["gem", "install", "solargraph"],
+        "check_cmd": ["solargraph", "--version"],
+        "start_cmd": ["solargraph", "stdio"],
+        "root_markers": ["Gemfile", ".solargraph.yml"],
+        "file_extensions": [".rb"],
         "capabilities": [
-            "definition", "references", "rename", "diagnostics",
-            "hover", "completion", "formatting", "code_actions"
+            "definition",
+            "references",
+            "diagnostics",
+            "hover",
+            "completion",
+        ],
+    },
+    "lua": {
+        "name": "lua-language-server",
+        "install_cmd": ["brew", "install", "lua-language-server"],
+        "check_cmd": ["lua-language-server", "--version"],
+        "start_cmd": ["lua-language-server"],
+        "root_markers": [".luarc.json"],
+        "file_extensions": [".lua"],
+        "capabilities": [
+            "definition",
+            "references",
+            "rename",
+            "diagnostics",
+            "hover",
+            "completion",
         ],
     },
 }
 
 
-class LSPClient:
-    """Full LSP client implementation."""
-    
-    def __init__(self, language: str, root_uri: str):
-        self.language = language
-        self.root_uri = root_uri
-        self.config = ENHANCED_LSP_SERVERS[language]
-        self.process: Optional[asyncio.subprocess.Process] = None
-        self.request_id = 0
-        self.pending_requests: Dict[int, asyncio.Future] = {}
-        self.initialized = False
-        self.logger = logging.getLogger(f"LSP.{language}")
-        
-    async def start(self) -> bool:
-        """Start the LSP server process."""
-        try:
-            self.process = await asyncio.create_subprocess_exec(
-                *self.config["start_cmd"],
-                stdin=asyncio.subprocess.PIPE,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE,
-                cwd=self.root_uri,
-            )
-            
-            # Start message reader
-            asyncio.create_task(self._read_messages())
-            
-            # Initialize
-            await self.initialize()
-            
-            return True
-            
-        except Exception as e:
-            self.logger.error(f"Failed to start LSP: {e}")
-            return False
-    
-    async def initialize(self):
-        """Send initialize request."""
-        params = {
-            "processId": os.getpid(),
-            "clientInfo": {
-                "name": "hanzo-mcp",
-                "version": "0.8.11"
-            },
-            "locale": "en",
-            "rootPath": self.root_uri,
-            "rootUri": f"file://{self.root_uri}",
-            "capabilities": {
-                "workspace": {
-                    "applyEdit": True,
-                    "workspaceEdit": {
-                        "documentChanges": True,
-                        "resourceOperations": ["create", "rename", "delete"],
-                    },
-                    "didChangeConfiguration": {"dynamicRegistration": True},
-                    "symbol": {"dynamicRegistration": True},
-                },
-                "textDocument": {
-                    "synchronization": {
-                        "dynamicRegistration": True,
-                        "willSave": True,
-                        "willSaveWaitUntil": True,
-                        "didSave": True,
-                    },
-                    "completion": {
-                        "dynamicRegistration": True,
-                        "contextSupport": True,
-                        "completionItem": {
-                            "snippetSupport": True,
-                            "commitCharactersSupport": True,
-                            "documentationFormat": ["markdown", "plaintext"],
-                        },
-                    },
-                    "hover": {
-                        "dynamicRegistration": True,
-                        "contentFormat": ["markdown", "plaintext"],
-                    },
-                    "signatureHelp": {"dynamicRegistration": True},
-                    "definition": {"dynamicRegistration": True},
-                    "references": {"dynamicRegistration": True},
-                    "documentHighlight": {"dynamicRegistration": True},
-                    "documentSymbol": {"dynamicRegistration": True},
-                    "codeAction": {"dynamicRegistration": True},
-                    "codeLens": {"dynamicRegistration": True},
-                    "formatting": {"dynamicRegistration": True},
-                    "rangeFormatting": {"dynamicRegistration": True},
-                    "onTypeFormatting": {"dynamicRegistration": True},
-                    "rename": {"dynamicRegistration": True, "prepareSupport": True},
-                    "documentLink": {"dynamicRegistration": True},
-                },
-            },
-        }
-        
-        result = await self.send_request("initialize", params)
-        
-        if result:
-            # Send initialized notification
-            await self.send_notification("initialized", {})
-            self.initialized = True
-            
-        return result
-    
-    async def send_request(self, method: str, params: Optional[Dict[str, Any]] = None) -> Optional[Any]:
-        """Send request and wait for response."""
-        self.request_id += 1
-        request_id = self.request_id
-        
-        request = {
-            "jsonrpc": "2.0",
-            "id": request_id,
-            "method": method,
-            "params": params or {},
-        }
-        
-        # Create future for response
-        future = asyncio.get_event_loop().create_future()
-        self.pending_requests[request_id] = future
-        
-        # Send request
-        await self._send_message(request)
-        
-        # Wait for response
-        try:
-            result = await asyncio.wait_for(future, timeout=10.0)
-            return result
-        except asyncio.TimeoutError:
-            self.logger.error(f"Request {method} timed out")
-            del self.pending_requests[request_id]
-            return None
-    
-    async def send_notification(self, method: str, params: Optional[Dict[str, Any]] = None):
-        """Send notification (no response expected)."""
-        notification = {
-            "jsonrpc": "2.0",
-            "method": method,
-            "params": params or {},
-        }
-        
-        await self._send_message(notification)
-    
-    async def _send_message(self, message: Dict[str, Any]):
-        """Send message to LSP server."""
-        if not self.process or self.process.returncode is not None:
-            return
-        
-        content = json.dumps(message)
-        content_bytes = content.encode("utf-8")
-        
-        header = f"Content-Length: {len(content_bytes)}\r\n\r\n"
-        full_message = header.encode("utf-8") + content_bytes
-        
-        self.process.stdin.write(full_message)
-        await self.process.stdin.drain()
-    
-    async def _read_messages(self):
-        """Read messages from LSP server."""
-        buffer = b""
-        
-        while self.process and self.process.returncode is None:
-            try:
-                chunk = await self.process.stdout.read(1024)
-                if not chunk:
-                    break
-                    
-                buffer += chunk
-                
-                # Parse messages
-                while True:
-                    message, remaining = self._parse_message(buffer)
-                    if not message:
-                        break
-                        
-                    buffer = remaining
-                    await self._handle_message(message)
-                    
-            except Exception as e:
-                self.logger.error(f"Error reading messages: {e}")
-                break
-    
-    def _parse_message(self, buffer: bytes) -> Tuple[Optional[Dict[str, Any]], bytes]:
-        """Parse LSP message from buffer."""
-        # Look for Content-Length header
-        header_end = buffer.find(b"\r\n\r\n")
-        if header_end == -1:
-            return None, buffer
-        
-        header = buffer[:header_end].decode("utf-8")
-        
-        # Parse content length
-        content_length = None
-        for line in header.split("\r\n"):
-            if line.startswith("Content-Length:"):
-                content_length = int(line.split(":")[1].strip())
-                break
-        
-        if not content_length:
-            return None, buffer
-        
-        # Check if we have full message
-        message_start = header_end + 4
-        message_end = message_start + content_length
-        
-        if len(buffer) < message_end:
-            return None, buffer
-        
-        # Parse message
-        message_bytes = buffer[message_start:message_end]
-        try:
-            message = json.loads(message_bytes.decode("utf-8"))
-            return message, buffer[message_end:]
-        except json.JSONDecodeError:
-            return None, buffer[message_end:]
-    
-    async def _handle_message(self, message: Dict[str, Any]):
-        """Handle incoming LSP message."""
-        if "id" in message and "result" in message:
-            # Response to our request
-            request_id = message["id"]
-            if request_id in self.pending_requests:
-                future = self.pending_requests.pop(request_id)
-                future.set_result(message.get("result"))
-                
-        elif "id" in message and "error" in message:
-            # Error response
-            request_id = message["id"]
-            if request_id in self.pending_requests:
-                future = self.pending_requests.pop(request_id)
-                future.set_exception(Exception(message["error"]))
-                
-        elif "method" in message:
-            # Server request or notification
-            # Handle server-initiated requests here if needed
-            pass
-    
-    async def shutdown(self):
-        """Shutdown the LSP server."""
-        if self.initialized:
-            await self.send_request("shutdown")
-            await self.send_notification("exit")
-            
-        if self.process and self.process.returncode is None:
-            self.process.terminate()
-            await self.process.wait()
+@dataclass
+class LSPServer:
+    """Represents an LSP server instance."""
+
+    language: str
+    process: Optional[asyncio.subprocess.Process]
+    config: Dict[str, Any]
+    root_uri: str
+    initialized: bool = False
 
 
 class LSPTool(BaseTool):
-    """Enhanced LSP tool with full protocol support and compilation capabilities."""
-    
+    """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
+    - Find references
+    - Rename symbol
+    - 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 = """Enhanced Language Server Protocol tool with compilation support.
+    description = """Language Server Protocol tool for code intelligence.
     
     Actions:
-    - definition: Go to definition of symbol
-    - references: Find all references
+    - definition: Go to definition of symbol at position
+    - references: Find all references to symbol
     - rename: Rename symbol across codebase
-    - diagnostics: Get errors and warnings
-    - hover: Get hover information
-    - completion: Get code completions
-    - compile: Compile source code
-    - run: Compile and run code
+    - diagnostics: Get errors and warnings for file
+    - hover: Get hover information at position
+    - completion: Get code completions at position
     - status: Check LSP server status
     
-    Supported languages: C, C++, Go, JavaScript, TypeScript, Rust, Zig, Python
+    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.clients: Dict[str, LSPClient] = {}
+        self.servers: Dict[str, LSPServer] = {}
         self.logger = logging.getLogger(__name__)
-        
-    def _detect_language(self, file_path: str) -> Optional[str]:
+
+    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 ENHANCED_LSP_SERVERS.items():
+
+        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 markers."""
-        markers = ENHANCED_LSP_SERVERS[language]["root_markers"]
+        """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 _get_client(self, language: str, root_uri: str) -> Optional[LSPClient]:
-        """Get or create LSP client."""
-        key = f"{language}:{root_uri}"
-        
-        if key not in self.clients:
-            client = LSPClient(language, root_uri)
-            if await client.start():
-                self.clients[key] = client
-            else:
-                return None
-                
-        return self.clients[key]
-    
-    async def _compile_code(self, file_path: str, language: str) -> Dict[str, Any]:
-        """Compile source code."""
-        config = ENHANCED_LSP_SERVERS[language]
-        
-        if "compile_cmd" not in config:
-            return {"error": f"Compilation not supported for {language}"}
-        
-        # Prepare compile command
-        input_file = Path(file_path)
-        output_file = input_file.stem
-        
-        compile_cmd = [
-            part.replace("{input}", str(input_file)).replace("{output}", output_file)
-            for part in config["compile_cmd"]
-        ]
-        
+
+    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:
-            # Run compilation
             result = await asyncio.create_subprocess_exec(
-                *compile_cmd,
+                *config["check_cmd"],
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
-                cwd=input_file.parent,
             )
-            
-            stdout, stderr = await result.communicate()
-            
-            if result.returncode == 0:
-                return {
-                    "success": True,
-                    "output_file": output_file,
-                    "stdout": stdout.decode(),
-                    "stderr": stderr.decode(),
-                }
-            else:
-                return {
-                    "success": False,
-                    "error": stderr.decode(),
-                    "stdout": stdout.decode(),
-                }
-                
-        except Exception as e:
-            return {"success": False, "error": str(e)}
-    
-    async def _run_code(self, file_path: str, language: str) -> Dict[str, Any]:
-        """Compile and run code."""
-        config = ENHANCED_LSP_SERVERS[language]
-        
-        # Compile if needed
-        if "compile_cmd" in config:
-            compile_result = await self._compile_code(file_path, language)
-            if not compile_result.get("success"):
-                return compile_result
-                
-            run_file = compile_result["output_file"]
-        else:
-            run_file = file_path
-        
-        # Run the code
-        run_cmd = [
-            part.replace("{input}", run_file).replace("{output}", run_file)
-            for part in config["run_cmd"]
-        ]
-        
+            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(
-                *run_cmd,
+                *config["install_cmd"],
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
-                cwd=Path(file_path).parent,
             )
-            
+
             stdout, stderr = await result.communicate()
-            
-            return {
-                "success": result.returncode == 0,
-                "stdout": stdout.decode(),
-                "stderr": stderr.decode(),
-                "exit_code": result.returncode,
-            }
-            
+
+            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:
-            return {"success": False, "error": str(e)}
-    
+            self.logger.error(f"Installation error: {e}")
+            return False
+
+    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}"
+        if server_key in self.servers:
+            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,
+            )
+
+            server = LSPServer(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
+        # In a real implementation, you'd use the full LSP protocol
+        init_params = {
+            "processId": os.getpid(),
+            "rootUri": f"file://{server.root_uri}",
+            "capabilities": {
+                "textDocument": {
+                    "definition": {"dynamicRegistration": True},
+                    "references": {"dynamicRegistration": True},
+                    "rename": {"dynamicRegistration": True},
+                }
+            },
+        }
+
+        # Send initialize request
+        request = {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "initialize",
+            "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]]:
+        """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"))
+
+            # Send LSP message
+            message = f"Content-Length: {content_length}\r\n\r\n{request_str}"
+            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"))
+
+        except Exception as e:
+            self.logger.error(f"LSP communication error: {e}")
+
+        return None
+
     async def run(
         self,
         action: str,
@@ -606,132 +401,190 @@ class LSPTool(BaseTool):
         new_name: Optional[str] = None,
         **kwargs,
     ) -> MCPResourceDocument:
-        """Execute LSP action."""
-        
-        # Detect language
-        language = self._detect_language(file)
+        """Execute LSP action.
+
+        Args:
+            action: LSP action (definition, references, rename, diagnostics, hover, completion, status)
+            file: File path to analyze
+            line: Line number (1-indexed)
+            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",
+        ]
+        if action not in 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(ENHANCED_LSP_SERVERS.keys()),
+                    "supported_languages": list(LSP_SERVERS.keys()),
                 }
             )
-        
-        # Handle compile and run actions
-        if action == "compile":
-            result = await self._compile_code(file, language)
-            return MCPResourceDocument(data=result)
-            
-        elif action == "run":
-            result = await self._run_code(file, language)
-            return MCPResourceDocument(data=result)
-        
-        # Get LSP client
-        root_uri = self._find_project_root(file, language)
-        client = await self._get_client(language, root_uri)
-        
-        if not client:
+
+        # Check LSP capabilities
+        capabilities = LSP_SERVERS[language]["capabilities"]
+        if action not in capabilities and action != "status":
             return MCPResourceDocument(
-                data={"error": f"Failed to start LSP server for {language}"}
-            )
-        
-        # Open the file
-        file_uri = f"file://{Path(file).resolve()}"
-        with open(file, "r") as f:
-            content = f.read()
-            
-        await client.send_notification(
-            "textDocument/didOpen",
-            {
-                "textDocument": {
-                    "uri": file_uri,
-                    "languageId": language,
-                    "version": 1,
-                    "text": content,
+                data={
+                    "error": f"Action '{action}' not supported for {language}",
+                    "supported_actions": capabilities,
                 }
-            },
-        )
-        
-        # Execute LSP action
-        if action == "definition":
-            result = await client.send_request(
-                "textDocument/definition",
-                {
-                    "textDocument": {"uri": file_uri},
-                    "position": {"line": line - 1, "character": character},
-                },
-            )
-            
-        elif action == "references":
-            result = await client.send_request(
-                "textDocument/references",
-                {
-                    "textDocument": {"uri": file_uri},
-                    "position": {"line": line - 1, "character": character},
-                    "context": {"includeDeclaration": True},
-                },
-            )
-            
-        elif action == "rename":
-            result = await client.send_request(
-                "textDocument/rename",
-                {
-                    "textDocument": {"uri": file_uri},
-                    "position": {"line": line - 1, "character": character},
-                    "newName": new_name,
-                },
             )
-            
-        elif action == "diagnostics":
-            result = await client.send_request(
-                "textDocument/diagnostic",
-                {
-                    "textDocument": {"uri": file_uri},
-                },
-            )
-            
-        elif action == "hover":
-            result = await client.send_request(
-                "textDocument/hover",
-                {
-                    "textDocument": {"uri": file_uri},
-                    "position": {"line": line - 1, "character": character},
-                },
+
+        # 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,
+                }
             )
-            
-        elif action == "completion":
-            result = await client.send_request(
-                "textDocument/completion",
-                {
-                    "textDocument": {"uri": file_uri},
-                    "position": {"line": line - 1, "character": character},
-                },
+
+        # 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"]),
+                }
             )
-            
-        else:
-            result = {"error": f"Unknown action: {action}"}
-        
-        # Close the file
-        await client.send_notification(
-            "textDocument/didClose",
-            {"textDocument": {"uri": file_uri}},
-        )
-        
+
+        # Execute action
+        result = await self._execute_lsp_action(server, action, file, line, character, new_name)
+
         return MCPResourceDocument(data=result)
-    
+
+    @auto_timeout("lsp")
+
+
     async def call(self, **kwargs) -> str:
-        """Tool interface for MCP."""
+        """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."""
+
+        @mcp_server.tool(name=self.name, description=self.description)
+        async def lsp_handler(
+            action: str,
+            file: str,
+            line: Optional[int] = None,
+            character: Optional[int] = None,
+            new_name: Optional[str] = None,
+        ) -> str:
+            """Execute LSP action."""
+            return await self.call(
+                action=action,
+                file=file,
+                line=line,
+                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]:
+        """Execute specific LSP action."""
+
+        # This is a simplified implementation
+        # Real implementation would use proper LSP protocol
+
+        if action == "definition":
+            # textDocument/definition request
+            return {
+                "action": "definition",
+                "file": file,
+                "position": {"line": line, "character": character},
+                "note": "LSP integration pending full implementation",
+                "fallback": "Use mcp__lsp__find_definition tool for now",
+            }
+
+        elif action == "references":
+            # textDocument/references request
+            return {
+                "action": "references",
+                "file": file,
+                "position": {"line": line, "character": character},
+                "note": "LSP integration pending full implementation",
+                "fallback": "Use mcp__lsp__find_references tool for now",
+            }
+
+        elif action == "rename":
+            # textDocument/rename request
+            return {
+                "action": "rename",
+                "file": file,
+                "position": {"line": line, "character": character},
+                "new_name": new_name,
+                "note": "LSP integration pending full implementation",
+                "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",
+            }
+
+        elif action == "hover":
+            # textDocument/hover request
+            return {
+                "action": "hover",
+                "file": file,
+                "position": {"line": line, "character": character},
+                "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",
+            }
+
+        return {"error": "Unknown action"}
+
     async def cleanup(self):
-        """Clean up all LSP clients."""
-        for client in self.clients.values():
-            await client.shutdown()
+        """Clean up LSP servers."""
+        for server in self.servers.values():
+            if server.process and server.process.returncode is None:
+                server.process.terminate()
+                await server.process.wait()
 
 
-# Factory function
+# Tool registration
 def create_lsp_tool():
-    """Create enhanced LSP tool."""
-    return LSPTool()
+    """Factory function to create LSP tool."""
+    return LSPTool()