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

hanzo_mcp/tools/lsp/lsp_tool.py

@@ -1,401 +1,602 @@
-"""Language Server Protocol (LSP) tool for code intelligence.
+"""Enhanced Language Server Protocol (LSP) implementation with full protocol support.
 
-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.
+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.
 """
 
 import os
+import sys
 import json
-import shutil
 import asyncio
 import logging
-from typing import Any, Dict, Optional
+import subprocess
+from typing import Any, Dict, List, Optional, Tuple
 from pathlib import Path
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from enum import Enum
 
 from hanzo_mcp.types import MCPResourceDocument
 from hanzo_mcp.tools.common.base import BaseTool
 
-# LSP server configurations
-LSP_SERVERS = {
+
+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"
+        ],
+    },
     "go": {
         "name": "gopls",
-        "install_cmd": ["go", "install", "golang.org/x/tools/gopls@latest"],
+        "install_cmd": {
+            "all": ["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",
+            "definition", "references", "rename", "diagnostics",
+            "hover", "completion", "formatting", "code_actions",
+            "implementation", "type_definition"
         ],
     },
-    "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"],
+    "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}"],
         "capabilities": [
-            "definition",
-            "references",
-            "rename",
-            "diagnostics",
-            "hover",
-            "completion",
+            "definition", "references", "rename", "diagnostics",
+            "hover", "completion", "formatting", "code_actions"
         ],
     },
     "typescript": {
         "name": "typescript-language-server",
-        "install_cmd": [
-            "npm",
-            "install",
-            "-g",
-            "typescript",
-            "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": ["tsconfig.json", "package.json"],
-        "file_extensions": [".ts", ".tsx", ".js", ".jsx"],
+        "file_extensions": [".ts", ".tsx"],
+        "compile_cmd": ["tsc", "{input}", "--outFile", "{output}.js"],
+        "run_cmd": ["node", "{output}.js"],
         "capabilities": [
-            "definition",
-            "references",
-            "rename",
-            "diagnostics",
-            "hover",
-            "completion",
+            "definition", "references", "rename", "diagnostics",
+            "hover", "completion", "formatting", "code_actions",
+            "implementation", "type_definition"
         ],
     },
     "rust": {
         "name": "rust-analyzer",
-        "install_cmd": ["rustup", "component", "add", "rust-analyzer"],
+        "install_cmd": {
+            "all": ["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",
-            "inlay_hints",
-        ],
-    },
-    "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",
-        ],
-    },
-    "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",
+            "definition", "references", "rename", "diagnostics",
+            "hover", "completion", "formatting", "code_actions",
+            "inlay_hints", "implementation", "type_definition"
         ],
     },
-    "ruby": {
-        "name": "solargraph",
-        "install_cmd": ["gem", "install", "solargraph"],
-        "check_cmd": ["solargraph", "--version"],
-        "start_cmd": ["solargraph", "stdio"],
-        "root_markers": ["Gemfile", ".solargraph.yml"],
-        "file_extensions": [".rb"],
+    "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}"],
         "capabilities": [
-            "definition",
-            "references",
-            "diagnostics",
-            "hover",
-            "completion",
+            "definition", "references", "rename", "diagnostics",
+            "hover", "completion", "formatting", "code_actions",
+            "semantic_tokens"
         ],
     },
-    "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"],
+    "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}"],
         "capabilities": [
-            "definition",
-            "references",
-            "rename",
-            "diagnostics",
-            "hover",
-            "completion",
+            "definition", "references", "rename", "diagnostics",
+            "hover", "completion", "formatting", "code_actions"
         ],
     },
 }
 
 
-@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 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()
 
 
 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
-    - 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.
-    """
-
+    """Enhanced LSP tool with full protocol support and compilation capabilities."""
+    
     name = "lsp"
-    description = """Language Server Protocol tool for code intelligence.
+    description = """Enhanced Language Server Protocol tool with compilation support.
     
     Actions:
-    - definition: Go to definition of symbol at position
-    - references: Find all references to symbol
+    - definition: Go to definition of symbol
+    - references: Find all references
     - rename: Rename symbol across codebase
-    - diagnostics: Get errors and warnings for file
-    - hover: Get hover information at position
-    - completion: Get code completions at position
+    - diagnostics: Get errors and warnings
+    - hover: Get hover information
+    - completion: Get code completions
+    - compile: Compile source code
+    - run: Compile and run code
     - status: Check LSP server status
     
-    The tool automatically installs language servers as needed.
-    Supported languages: Go, Python, TypeScript/JavaScript, Rust, Java, C/C++, Ruby, Lua
+    Supported languages: C, C++, Go, JavaScript, TypeScript, Rust, Zig, Python
     """
-
+    
     def __init__(self):
         super().__init__()
-        self.servers: Dict[str, LSPServer] = {}
+        self.clients: Dict[str, LSPClient] = {}
         self.logger = logging.getLogger(__name__)
-
-    def _get_language_from_file(self, file_path: str) -> Optional[str]:
+        
+    def _detect_language(self, file_path: str) -> Optional[str]:
         """Detect language from file extension."""
         ext = Path(file_path).suffix.lower()
-
-        for lang, config in LSP_SERVERS.items():
+        
+        for lang, config in ENHANCED_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"]
+        """Find project root based on markers."""
+        markers = ENHANCED_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,
-            )
-            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}")
-
+    
+    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"]
+        ]
+        
         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
+            # Run compilation
             result = await asyncio.create_subprocess_exec(
-                *config["install_cmd"],
+                *compile_cmd,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
+                cwd=input_file.parent,
             )
-
+            
             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
-
+            
+            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:
-            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]
-
+            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"]
+        ]
+        
         try:
-            process = await asyncio.create_subprocess_exec(
-                *config["start_cmd"],
-                stdin=asyncio.subprocess.PIPE,
+            result = await asyncio.create_subprocess_exec(
+                *run_cmd,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
-                cwd=root_uri,
-            )
-
-            server = LSPServer(
-                language=language, process=process, config=config, root_uri=root_uri
+                cwd=Path(file_path).parent,
             )
-
-            # 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"))
-
+            
+            stdout, stderr = await result.communicate()
+            
+            return {
+                "success": result.returncode == 0,
+                "stdout": stdout.decode(),
+                "stderr": stderr.decode(),
+                "exit_code": result.returncode,
+            }
+            
         except Exception as e:
-            self.logger.error(f"LSP communication error: {e}")
-
-        return None
-
+            return {"success": False, "error": str(e)}
+    
     async def run(
         self,
         action: str,
@@ -405,193 +606,132 @@ class LSPTool(BaseTool):
         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
-            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)
+        """Execute LSP action."""
+        
+        # Detect language
+        language = self._detect_language(file)
         if not language:
             return MCPResourceDocument(
                 data={
                     "error": f"Unsupported file type: {file}",
-                    "supported_languages": list(LSP_SERVERS.keys()),
+                    "supported_languages": list(ENHANCED_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,
-                }
-            )
-
-        # 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,
-                }
-            )
-
-        # Find project root
+        
+        # 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)
-
-        # Ensure LSP is running
-        server = await self._ensure_lsp_running(language, root_uri)
-        if not server:
+        client = await self._get_client(language, root_uri)
+        
+        if not client:
             return MCPResourceDocument(
-                data={
-                    "error": f"Failed to start LSP server for {language}",
-                    "install_command": " ".join(LSP_SERVERS[language]["install_cmd"]),
-                }
+                data={"error": f"Failed to start LSP server for {language}"}
             )
-
-        # Execute action
-        result = await self._execute_lsp_action(
-            server, action, file, line, character, new_name
+        
+        # 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,
+                }
+            },
         )
-
-        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."""
-
-        @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
-
+        
+        # Execute LSP action
         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",
-            }
-
+            result = await client.send_request(
+                "textDocument/definition",
+                {
+                    "textDocument": {"uri": file_uri},
+                    "position": {"line": line - 1, "character": character},
+                },
+            )
+            
         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",
-            }
-
+            result = await client.send_request(
+                "textDocument/references",
+                {
+                    "textDocument": {"uri": file_uri},
+                    "position": {"line": line - 1, "character": character},
+                    "context": {"includeDeclaration": True},
+                },
+            )
+            
         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",
-            }
-
+            result = await client.send_request(
+                "textDocument/rename",
+                {
+                    "textDocument": {"uri": file_uri},
+                    "position": {"line": line - 1, "character": character},
+                    "newName": new_name,
+                },
+            )
+            
         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",
-            }
-
+            result = await client.send_request(
+                "textDocument/diagnostic",
+                {
+                    "textDocument": {"uri": file_uri},
+                },
+            )
+            
         elif action == "hover":
-            # textDocument/hover request
-            return {
-                "action": "hover",
-                "file": file,
-                "position": {"line": line, "character": character},
-                "note": "LSP integration pending full implementation",
-            }
-
+            result = await client.send_request(
+                "textDocument/hover",
+                {
+                    "textDocument": {"uri": file_uri},
+                    "position": {"line": line - 1, "character": character},
+                },
+            )
+            
         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"}
-
+            result = await client.send_request(
+                "textDocument/completion",
+                {
+                    "textDocument": {"uri": file_uri},
+                    "position": {"line": line - 1, "character": character},
+                },
+            )
+            
+        else:
+            result = {"error": f"Unknown action: {action}"}
+        
+        # Close the file
+        await client.send_notification(
+            "textDocument/didClose",
+            {"textDocument": {"uri": file_uri}},
+        )
+        
+        return MCPResourceDocument(data=result)
+    
+    async def call(self, **kwargs) -> str:
+        """Tool interface for MCP."""
+        result = await self.run(**kwargs)
+        return result.to_json_string()
+    
     async def cleanup(self):
-        """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()
+        """Clean up all LSP clients."""
+        for client in self.clients.values():
+            await client.shutdown()
 
 
-# Tool registration
+# Factory function
 def create_lsp_tool():
-    """Factory function to create LSP tool."""
-    return LSPTool()
+    """Create enhanced LSP tool."""
+    return LSPTool()