stravinsky 0.4.18__py3-none-any.whl → 0.4.66__py3-none-any.whl

mcp_bridge/tools/lsp/__init__.py

@@ -4,20 +4,20 @@ LSP Tools Package
 Provides Language Server Protocol functionality for code intelligence.
 """
 
+from .manager import LSPManager, get_lsp_manager
 from .tools import (
-    lsp_hover,
-    lsp_goto_definition,
-    lsp_find_references,
+    lsp_code_action_resolve,
+    lsp_code_actions,
     lsp_document_symbols,
-    lsp_workspace_symbols,
+    lsp_extract_refactor,
+    lsp_find_references,
+    lsp_goto_definition,
+    lsp_hover,
     lsp_prepare_rename,
     lsp_rename,
-    lsp_code_actions,
-    lsp_code_action_resolve,
-    lsp_extract_refactor,
     lsp_servers,
+    lsp_workspace_symbols,
 )
-from .manager import LSPManager, get_lsp_manager
 
 __all__ = [
     "lsp_hover",

mcp_bridge/tools/lsp/manager.py

@@ -13,24 +13,19 @@ Architecture:
 """
 
 import asyncio
-import json
 import logging
 import os
-import shlex
-import signal
 import threading
 import time
 from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any, Optional
+from typing import Optional
 
-from pygls.client import JsonRPCClient
 from lsprotocol.types import (
-    InitializeParams,
-    InitializedParams,
     ClientCapabilities,
-    WorkspaceFolder,
+    InitializedParams,
+    InitializeParams,
 )
+from pygls.client import JsonRPCClient
 
 logger = logging.getLogger(__name__)
 
@@ -48,10 +43,11 @@ class LSPServer:
 
     name: str
     command: list[str]
-    client: Optional[JsonRPCClient] = None
+    client: JsonRPCClient | None = None
     initialized: bool = False
-    process: Optional[asyncio.subprocess.Process] = None
-    pid: Optional[int] = None  # Track subprocess PID for explicit cleanup
+    process: asyncio.subprocess.Process | None = None
+    pid: int | None = None  # Track subprocess PID for explicit cleanup
+    root_path: str | None = None  # Track root path server was started with
     last_used: float = field(default_factory=time.time)  # Timestamp of last usage
     created_at: float = field(default_factory=time.time)  # Timestamp of server creation
 
@@ -82,24 +78,31 @@ class LSPManager:
         self._servers: dict[str, LSPServer] = {}
         self._lock = asyncio.Lock()
         self._restart_attempts: dict[str, int] = {}
-        self._health_monitor_task: Optional[asyncio.Task] = None
+        self._health_monitor_task: asyncio.Task | None = None
 
         # Register available LSP servers
         self._register_servers()
 
     def _register_servers(self):
         """Register available LSP server configurations."""
-        self._servers["python"] = LSPServer(name="python", command=["jedi-language-server"])
-        self._servers["typescript"] = LSPServer(
-            name="typescript", command=["typescript-language-server", "--stdio"]
-        )
-
-    async def get_server(self, language: str) -> Optional[JsonRPCClient]:
+        # Allow overriding commands via environment variables
+        python_cmd = os.environ.get("LSP_CMD_PYTHON", "jedi-language-server").split()
+        ts_cmd = os.environ.get(
+            "LSP_CMD_TYPESCRIPT", "typescript-language-server --stdio"
+        ).split()
+
+        self._servers["python"] = LSPServer(name="python", command=python_cmd)
+        self._servers["typescript"] = LSPServer(name="typescript", command=ts_cmd)
+
+    async def get_server(
+        self, language: str, root_path: str | None = None
+    ) -> JsonRPCClient | None:
         """
         Get or start a persistent LSP server for the given language.
 
         Args:
             language: Language identifier (e.g., "python", "typescript")
+            root_path: Project root path (optional, but recommended)
 
         Returns:
             JsonRPCClient instance or None if server unavailable
@@ -110,6 +113,20 @@ class LSPManager:
 
         server = self._servers[language]
 
+        # Check if we need to restart due to root path change
+        # (Simple implementation: if root_path differs, restart)
+        # In multi-root workspaces, this might be too aggressive, but safe for now.
+        restart_needed = False
+        if root_path and server.root_path and root_path != server.root_path:
+            logger.info(
+                f"Restarting {language} LSP server: root path changed ({server.root_path} -> {root_path})"
+            )
+            restart_needed = True
+
+        if restart_needed:
+            async with self._lock:
+                await self._shutdown_single_server(language, server)
+
         # Return existing initialized server
         if server.initialized and server.client:
             # Update last_used timestamp
@@ -129,7 +146,7 @@ class LSPManager:
                 return server.client
 
             try:
-                await self._start_server(server)
+                await self._start_server(server, root_path)
                 # Start health monitor on first server creation
                 if self._health_monitor_task is None or self._health_monitor_task.done():
                     self._health_monitor_task = asyncio.create_task(self._background_health_monitor())
@@ -138,7 +155,7 @@ class LSPManager:
                 logger.error(f"Failed to start {language} LSP server: {e}")
                 return None
 
-    async def _start_server(self, server: LSPServer):
+    async def _start_server(self, server: LSPServer, root_path: str | None = None):
         """
         Start a persistent LSP server process.
 
@@ -150,6 +167,7 @@ class LSPManager:
 
         Args:
             server: LSPServer metadata object
+            root_path: Project root path
         """
         try:
             # Create pygls client
@@ -158,7 +176,9 @@ class LSPManager:
             logger.info(f"Starting {server.name} LSP server: {' '.join(server.command)}")
 
             # Start server process (start_io expects cmd as first arg, then *args)
-            await client.start_io(server.command[0], *server.command[1:])
+            # Use cwd=root_path if available to help server find config
+            cwd = root_path if root_path and os.path.isdir(root_path) else None
+            await client.start_io(server.command[0], *server.command[1:], cwd=cwd)
 
             # Brief delay for process startup
             await asyncio.sleep(0.2)
@@ -180,8 +200,9 @@ class LSPManager:
                 )
 
             # Perform LSP initialization handshake
+            root_uri = f"file://{root_path}" if root_path else None
             init_params = InitializeParams(
-                process_id=None, root_uri=None, capabilities=ClientCapabilities()
+                process_id=None, root_uri=root_uri, capabilities=ClientCapabilities()
             )
 
             try:
@@ -195,12 +216,13 @@ class LSPManager:
 
                 logger.info(f"{server.name} LSP server initialized: {response}")
 
-            except asyncio.TimeoutError:
+            except TimeoutError:
                 raise ConnectionError(f"{server.name} LSP server initialization timed out")
 
             # Store client reference (GC protection)
             server.client = client
             server.initialized = True
+            server.root_path = root_path
             server.created_at = time.time()
             server.last_used = time.time()
 
@@ -221,6 +243,7 @@ class LSPManager:
             server.initialized = False
             server.process = None
             server.pid = None
+            server.root_path = None
             raise
 
     async def _restart_with_backoff(self, server: LSPServer):
@@ -281,7 +304,7 @@ class LSPManager:
             )
             logger.debug(f"{server.name} LSP server health check passed")
             return True
-        except asyncio.TimeoutError:
+        except TimeoutError:
             logger.warning(f"{server.name} LSP server health check timed out")
             return False
         except Exception as e:
@@ -307,7 +330,7 @@ class LSPManager:
                 await asyncio.wait_for(
                     server.client.protocol.send_request_async("shutdown", None), timeout=5.0
                 )
-            except asyncio.TimeoutError:
+            except TimeoutError:
                 logger.warning(f"{name} LSP server shutdown request timed out")
 
             # Send exit notification
@@ -325,7 +348,7 @@ class LSPManager:
                         server.process.terminate()
                         try:
                             await asyncio.wait_for(server.process.wait(), timeout=2.0)
-                        except asyncio.TimeoutError:
+                        except TimeoutError:
                             server.process.kill()
                             await asyncio.wait_for(server.process.wait(), timeout=1.0)
                 except Exception as e:
@@ -433,7 +456,7 @@ class LSPManager:
 
 
 # Singleton accessor
-_manager_instance: Optional[LSPManager] = None
+_manager_instance: LSPManager | None = None
 _manager_lock = threading.Lock()
 
 

mcp_bridge/tools/lsp/tools.py

@@ -8,11 +8,12 @@ Supplements Claude Code's native LSP support with advanced operations.
 import asyncio
 import json
 import logging
-import subprocess
+import os
 import sys
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any
 from urllib.parse import unquote, urlparse
+from mcp_bridge.utils.process import async_execute
 
 # Use lsprotocol for types
 try:
@@ -26,6 +27,7 @@ try:
         HoverParams,
         Location,
         Position,
+        PrepareRenameParams,
         Range,
         ReferenceContext,
         ReferenceParams,
@@ -34,7 +36,6 @@ try:
         TextDocumentItem,
         TextDocumentPositionParams,
         WorkspaceSymbolParams,
-        PrepareRenameParams,
     )
 except ImportError:
     # Fallback/Mock for environment without lsprotocol
@@ -66,9 +67,44 @@ def _get_language_for_file(file_path: str) -> str:
     return mapping.get(suffix, "unknown")
 
 
+def _find_project_root(file_path: str) -> str | None:
+    """
+    Find project root by looking for marker files.
+
+    Markers:
+    - Python: pyproject.toml, setup.py, requirements.txt, .git
+    - JS/TS: package.json, tsconfig.json, .git
+    - General: .git
+    """
+    path = Path(file_path).resolve()
+    if path.is_file():
+        path = path.parent
+
+    markers = {
+        "pyproject.toml",
+        "setup.py",
+        "requirements.txt",
+        "package.json",
+        "tsconfig.json",
+        ".git",
+    }
+
+    # Walk up the tree
+    current = path
+    for _ in range(20):  # Limit depth
+        for marker in markers:
+            if (current / marker).exists():
+                return str(current)
+        if current.parent == current:  # Root reached
+            break
+        current = current.parent
+
+    return None
+
+
 async def _get_client_and_params(
     file_path: str, needs_open: bool = True
-) -> Tuple[Optional[Any], Optional[str], str]:
+) -> tuple[Any | None, str | None, str]:
     """
     Get LSP client and prepare file for operations.
 
@@ -80,8 +116,14 @@ async def _get_client_and_params(
         return None, None, "unknown"
 
     lang = _get_language_for_file(file_path)
+    root_path = _find_project_root(file_path)
+
+    # Use found root or fallback to file's parent directory
+    # Passing root_path allows the manager to initialize/restart server with correct context
+    server_root = root_path if root_path else str(path.parent)
+
     manager = get_lsp_manager()
-    client = await manager.get_server(lang)
+    client = await manager.get_server(lang, root_path=server_root)
 
     if not client:
         return None, None, lang
@@ -148,7 +190,7 @@ async def lsp_hover(file_path: str, line: int, character: int) -> str:
     try:
         if lang == "python":
             # Use jedi for Python hover info
-            result = subprocess.run(
+            result = await async_execute(
                 [
                     "python",
                     "-c",
@@ -157,14 +199,12 @@ import jedi
 script = jedi.Script(path='{file_path}')
 completions = script.infer({line}, {character})
 for c in completions[:1]:
-    logger.info(f"Type: {{c.type}}")
-    logger.info(f"Name: {{c.full_name}}")
+    print(f"Type: {{c.type}}")
+    print(f"Name: {{c.full_name}}")
     if c.docstring():
-        logger.info(f"\\nDocstring:\\n{{c.docstring()[:500]}}")
+        print(f"\\nDocstring:\\n{{c.docstring()[:500]}}")
 """,
                 ],
-                capture_output=True,
-                text=True,
                 timeout=10,
             )
             output = result.stdout.strip()
@@ -173,14 +213,14 @@ for c in completions[:1]:
             return f"No hover info at line {line}, character {character}"
 
         elif lang in ("typescript", "javascript", "typescriptreact", "javascriptreact"):
-            return f"TypeScript hover requires running language server. Use Claude Code's native hover."
+            return "TypeScript hover requires running language server. Use Claude Code's native hover."
 
         else:
             return f"Hover not available for language: {lang}"
 
     except FileNotFoundError as e:
         return f"Tool not found: {e.filename}. Install jedi: pip install jedi"
-    except subprocess.TimeoutExpired:
+    except asyncio.TimeoutError:
         return "Hover lookup timed out"
     except Exception as e:
         return f"Error: {str(e)}"
@@ -240,7 +280,7 @@ async def lsp_goto_definition(file_path: str, line: int, character: int) -> str:
 
     try:
         if lang == "python":
-            result = subprocess.run(
+            result = await async_execute(
                 [
                     "python",
                     "-c",
@@ -249,11 +289,9 @@ import jedi
 script = jedi.Script(path='{file_path}')
 definitions = script.goto({line}, {character})
 for d in definitions:
-    logger.info(f"{{d.module_path}}:{{d.line}}:{{d.column}} - {{d.full_name}}")
+    print(f"{{d.module_path}}:{{d.line}}:{{d.column}} - {{d.full_name}}")
 """,
                 ],
-                capture_output=True,
-                text=True,
                 timeout=10,
             )
             output = result.stdout.strip()
@@ -267,9 +305,9 @@ for d in definitions:
         else:
             return f"Goto definition not available for language: {lang}"
 
-    except FileNotFoundError as e:
-        return f"Tool not found: Install jedi: pip install jedi"
-    except subprocess.TimeoutExpired:
+    except FileNotFoundError:
+        return "Tool not found: Install jedi: pip install jedi"
+    except asyncio.TimeoutError:
         return "Definition lookup timed out"
     except Exception as e:
         return f"Error: {str(e)}"
@@ -328,7 +366,7 @@ async def lsp_find_references(
 
     try:
         if lang == "python":
-            result = subprocess.run(
+            result = await async_execute(
                 [
                     "python",
                     "-c",
@@ -337,13 +375,11 @@ import jedi
 script = jedi.Script(path='{file_path}')
 references = script.get_references({line}, {character}, include_builtins=False)
 for r in references[:30]:
-    logger.info(f"{{r.module_path}}:{{r.line}}:{{r.column}}")
+    print(f"{{r.module_path}}:{{r.line}}:{{r.column}}")
 if len(references) > 30:
-    logger.info(f"... and {{len(references) - 30}} more")
+    print(f"... and {{len(references) - 30}} more")
 """,
                 ],
-                capture_output=True,
-                text=True,
                 timeout=15,
             )
             output = result.stdout.strip()
@@ -354,7 +390,7 @@ if len(references) > 30:
         else:
             return f"Find references not available for language: {lang}"
 
-    except subprocess.TimeoutExpired:
+    except asyncio.TimeoutError:
         return "Reference search timed out"
     except Exception as e:
         return f"Error: {str(e)}"
@@ -425,7 +461,7 @@ async def lsp_document_symbols(file_path: str) -> str:
 
     try:
         if lang == "python":
-            result = subprocess.run(
+            result = await async_execute(
                 [
                     "python",
                     "-c",
@@ -435,11 +471,9 @@ script = jedi.Script(path='{file_path}')
 names = script.get_names(all_scopes=True, definitions=True)
 for n in names:
     indent = "  " * (n.get_line_code().count("    ") if n.get_line_code() else 0)
-    logger.info(f"{{n.line:4d}} | {{indent}}{{n.type:10}} {{n.name}}")
+    print(f"{{n.line:4d}} | {{indent}}{{n.type:10}} {{n.name}}")
 """,
                 ],
-                capture_output=True,
-                text=True,
                 timeout=10,
             )
             output = result.stdout.strip()
@@ -449,10 +483,8 @@ for n in names:
 
         else:
             # Fallback: use ctags
-            result = subprocess.run(
+            result = await async_execute(
                 ["ctags", "-x", "--sort=no", str(path)],
-                capture_output=True,
-                text=True,
                 timeout=10,
             )
             output = result.stdout.strip()
@@ -462,7 +494,7 @@ for n in names:
 
     except FileNotFoundError:
         return "Install jedi (pip install jedi) or ctags for symbol lookup"
-    except subprocess.TimeoutExpired:
+    except asyncio.TimeoutError:
         return "Symbol lookup timed out"
     except Exception as e:
         return f"Error: {str(e)}"
@@ -507,10 +539,8 @@ async def lsp_workspace_symbols(query: str, directory: str = ".") -> str:
     # Fallback to legacy grep/ctags
     try:
         # Use ctags to index and grep for symbols
-        result = subprocess.run(
+        result = await async_execute(
             ["rg", "-l", query, directory, "--type", "py", "--type", "ts", "--type", "js"],
-            capture_output=True,
-            text=True,
             timeout=15,
         )
 
@@ -524,10 +554,8 @@ async def lsp_workspace_symbols(query: str, directory: str = ".") -> str:
             if not f:
                 continue
             # Get symbols from each file
-            ctags_result = subprocess.run(
+            ctags_result = await async_execute(
                 ["ctags", "-x", "--sort=no", f],
-                capture_output=True,
-                text=True,
                 timeout=5,
             )
             for line in ctags_result.stdout.split("\n"):
@@ -540,7 +568,7 @@ async def lsp_workspace_symbols(query: str, directory: str = ".") -> str:
 
     except FileNotFoundError:
         return "Install ctags and ripgrep for workspace symbol search"
-    except subprocess.TimeoutExpired:
+    except asyncio.TimeoutError:
         return "Search timed out"
     except Exception as e:
         return f"Error: {str(e)}"
@@ -587,7 +615,7 @@ async def lsp_prepare_rename(file_path: str, line: int, character: int) -> str:
 
     try:
         if lang == "python":
-            result = subprocess.run(
+            result = await async_execute(
                 [
                     "python",
                     "-c",
@@ -596,16 +624,14 @@ import jedi
 script = jedi.Script(path='{file_path}')
 refs = script.get_references({line}, {character})
 if refs:
-    logger.info(f"Symbol: {{refs[0].name}}")
-    logger.info(f"Type: {{refs[0].type}}")
-    logger.info(f"References: {{len(refs)}}")
-    logger.info("✅ Rename is valid")
+    print(f"Symbol: {{refs[0].name}}")
+    print(f"Type: {{refs[0].type}}")
+    print(f"References: {{len(refs)}}")
+    print("✅ Rename is valid")
 else:
-    logger.info("❌ No symbol found at position")
+    print("❌ No symbol found at position")
 """,
                 ],
-                capture_output=True,
-                text=True,
                 timeout=10,
             )
             return result.stdout.strip() or "No symbol found at position"
@@ -689,7 +715,7 @@ async def lsp_rename(
 
     try:
         if lang == "python":
-            result = subprocess.run(
+            result = await async_execute(
                 [
                     "python",
                     "-c",
@@ -698,13 +724,11 @@ import jedi
 script = jedi.Script(path='{file_path}')
 refactoring = script.rename({line}, {character}, new_name='{new_name}')
 for path, changed in refactoring.get_changed_files().items():
-    logger.info(f"File: {{path}}")
-    logger.info(changed[:500])
-    logger.info("---")
+    print(f"File: {{path}}")
+    print(changed[:500])
+    print("---")
 """,
                 ],
-                capture_output=True,
-                text=True,
                 timeout=15,
             )
             output = result.stdout.strip()
@@ -722,7 +746,7 @@ for path, changed in refactoring.get_changed_files().items():
         return f"Error: {str(e)}"
 
 
-def _apply_workspace_edit(changes: Dict[str, List[Any]]):
+def _apply_workspace_edit(changes: dict[str, list[Any]]):
     """Apply LSP changes to files."""
     for file_uri, edits in changes.items():
         parsed = urlparse(file_uri)
@@ -809,10 +833,8 @@ async def lsp_code_actions(file_path: str, line: int, character: int) -> str:
     try:
         if lang == "python":
             # Use ruff to suggest fixes
-            result = subprocess.run(
+            result = await async_execute(
                 ["ruff", "check", str(path), "--output-format=json", "--show-fixes"],
-                capture_output=True,
-                text=True,
                 timeout=10,
             )
 
@@ -868,10 +890,8 @@ async def lsp_code_action_resolve(file_path: str, action_code: str, line: int =
 
     if lang == "python":
         try:
-            result = subprocess.run(
+            result = await async_execute(
                 ["ruff", "check", str(path), "--fix", "--select", action_code],
-                capture_output=True,
-                text=True,
                 timeout=15,
             )
 
@@ -885,7 +905,7 @@ async def lsp_code_action_resolve(file_path: str, action_code: str, line: int =
 
         except FileNotFoundError:
             return "Install ruff: pip install ruff"
-        except subprocess.TimeoutExpired:
+        except asyncio.TimeoutError:
             return "Timeout applying fix"
         except Exception as e:
             return f"Error: {str(e)}"
@@ -956,6 +976,10 @@ async def lsp_servers() -> str:
     # USER-VISIBLE NOTIFICATION
     print("🖥️ LSP-SERVERS: listing installed servers", file=sys.stderr)
 
+    # Check env var overrides
+    py_cmd = os.environ.get("LSP_CMD_PYTHON", "jedi-language-server")
+    ts_cmd = os.environ.get("LSP_CMD_TYPESCRIPT", "typescript-language-server")
+
     servers = [
         ("python", "jedi", "pip install jedi"),
         ("python", "jedi-language-server", "pip install jedi-language-server"),
@@ -965,12 +989,21 @@ async def lsp_servers() -> str:
         ("rust", "rust-analyzer", "rustup component add rust-analyzer"),
     ]
 
-    lines = ["| Language | Server | Status | Install |", "|----------|--------|--------|---------|"]
+    lines = [
+        "**LSP Configuration (Env Vars):**",
+        f"- `LSP_CMD_PYTHON`: `{py_cmd}`",
+        f"- `LSP_CMD_TYPESCRIPT`: `{ts_cmd}`",
+        "",
+        "**Installation Status:**",
+        "| Language | Server | Status | Install |",
+        "|----------|--------|--------|---------|",
+    ]
 
     for lang, server, install in servers:
         # Check if installed
         try:
-            subprocess.run([server, "--version"], capture_output=True, timeout=2)
+            cmd = server.split()[0]  # simple check for command
+            await async_execute([cmd, "--version"], timeout=2)
             status = "✅ Installed"
         except FileNotFoundError:
             status = "❌ Not installed"