stravinsky 0.2.40__py3-none-any.whl → 0.3.4__py3-none-any.whl

mcp_bridge/tools/code_search.py

@@ -15,17 +15,21 @@ from pathlib import Path
 async def lsp_diagnostics(file_path: str, severity: str = "all") -> str:
     """
     Get diagnostics (errors, warnings) for a file using language server.
-    
+
     For TypeScript/JavaScript, uses `tsc` or `biome`.
     For Python, uses `pyright` or `ruff`.
-    
+
     Args:
         file_path: Path to the file to analyze
         severity: Filter by severity (error, warning, information, hint, all)
-        
+
     Returns:
         Formatted diagnostics output.
     """
+    # USER-VISIBLE NOTIFICATION
+    import sys
+    print(f"🩺 LSP-DIAG: file={file_path} severity={severity}", file=sys.stderr)
+
     path = Path(file_path)
     if not path.exists():
         return f"Error: File not found: {file_path}"
@@ -49,7 +53,7 @@ async def lsp_diagnostics(file_path: str, severity: str = "all") -> str:
         elif suffix == ".py":
             # Use ruff for Python diagnostics
             result = subprocess.run(
-                ["ruff", "check", str(path), "--output-format=text"],
+                ["ruff", "check", str(path), "--output-format=concise"],
                 capture_output=True,
                 text=True,
                 timeout=30,
@@ -70,21 +74,88 @@ async def lsp_diagnostics(file_path: str, severity: str = "all") -> str:
         return f"Error: {str(e)}"
 
 
+async def check_ai_comment_patterns(file_path: str) -> str:
+    """
+    Detect AI-generated or placeholder comment patterns that indicate incomplete work.
+
+    Patterns detected:
+    - # TODO: implement, # FIXME, # placeholder
+    - // TODO, // FIXME, // placeholder
+    - AI-style verbose comments: "This function handles...", "This method is responsible for..."
+    - Placeholder phrases: "implement this", "add logic here", "your code here"
+
+    Args:
+        file_path: Path to the file to check
+
+    Returns:
+        List of detected AI-style patterns with line numbers, or "No AI patterns detected"
+    """
+    # USER-VISIBLE NOTIFICATION
+    import sys
+    print(f"🤖 AI-CHECK: {file_path}", file=sys.stderr)
+
+    path = Path(file_path)
+    if not path.exists():
+        return f"Error: File not found: {file_path}"
+
+    # Patterns that indicate AI-generated or placeholder code
+    ai_patterns = [
+        # Placeholder comments
+        r"#\s*(TODO|FIXME|XXX|HACK):\s*(implement|add|placeholder|your code)",
+        r"//\s*(TODO|FIXME|XXX|HACK):\s*(implement|add|placeholder|your code)",
+        # AI-style verbose descriptions
+        r"#\s*This (function|method|class) (handles|is responsible for|manages|processes)",
+        r"//\s*This (function|method|class) (handles|is responsible for|manages|processes)",
+        r'"""This (function|method|class) (handles|is responsible for|manages|processes)',
+        # Placeholder implementations
+        r"pass\s*#\s*(TODO|implement|placeholder)",
+        r"raise NotImplementedError.*implement",
+        # Common AI filler phrases
+        r"#.*\b(as needed|as required|as appropriate|if necessary)\b",
+        r"//.*\b(as needed|as required|as appropriate|if necessary)\b",
+    ]
+
+    import re
+
+    try:
+        content = path.read_text()
+        lines = content.split("\n")
+        findings = []
+
+        for i, line in enumerate(lines, 1):
+            for pattern in ai_patterns:
+                if re.search(pattern, line, re.IGNORECASE):
+                    findings.append(f"  Line {i}: {line.strip()[:80]}")
+                    break
+
+        if findings:
+            return f"AI/Placeholder patterns detected in {file_path}:\n" + "\n".join(findings)
+        return "No AI patterns detected"
+
+    except Exception as e:
+        return f"Error reading file: {str(e)}"
+
+
 async def ast_grep_search(pattern: str, directory: str = ".", language: str = "") -> str:
     """
     Search codebase using ast-grep for structural patterns.
-    
+
     ast-grep uses AST-aware pattern matching, finding code by structure
     rather than just text. More precise than regex for code search.
-    
+
     Args:
         pattern: ast-grep pattern to search for
         directory: Directory to search in
         language: Filter by language (typescript, python, rust, etc.)
-        
+
     Returns:
         Matched code locations and snippets.
     """
+    # USER-VISIBLE NOTIFICATION
+    import sys
+    lang_info = f" lang={language}" if language else ""
+    print(f"🔍 AST-GREP: pattern='{pattern[:50]}...'{lang_info}", file=sys.stderr)
+
     try:
         cmd = ["sg", "run", "-p", pattern, directory]
         if language:
@@ -129,15 +200,20 @@ async def ast_grep_search(pattern: str, directory: str = ".", language: str = ""
 async def grep_search(pattern: str, directory: str = ".", file_pattern: str = "") -> str:
     """
     Fast text search using ripgrep.
-    
+
     Args:
         pattern: Search pattern (supports regex)
         directory: Directory to search in
         file_pattern: Glob pattern to filter files (e.g., "*.py", "*.ts")
-        
+
     Returns:
         Matched lines with file paths and line numbers.
     """
+    # USER-VISIBLE NOTIFICATION
+    import sys
+    glob_info = f" glob={file_pattern}" if file_pattern else ""
+    print(f"🔎 GREP: pattern='{pattern[:50]}'{glob_info} dir={directory}", file=sys.stderr)
+
     try:
         cmd = ["rg", "--line-number", "--max-count=50", pattern, directory]
         if file_pattern:
@@ -173,14 +249,18 @@ async def grep_search(pattern: str, directory: str = ".", file_pattern: str = ""
 async def glob_files(pattern: str, directory: str = ".") -> str:
     """
     Find files matching a glob pattern.
-    
+
     Args:
         pattern: Glob pattern (e.g., "**/*.py", "src/**/*.ts")
         directory: Base directory for search
-        
+
     Returns:
         List of matching file paths.
     """
+    # USER-VISIBLE NOTIFICATION
+    import sys
+    print(f"📁 GLOB: pattern='{pattern}' dir={directory}", file=sys.stderr)
+
     try:
         cmd = ["fd", "--type", "f", "--glob", pattern, directory]
         
@@ -234,6 +314,12 @@ async def ast_grep_replace(
     Returns:
         Preview of changes or confirmation of applied changes.
     """
+    # USER-VISIBLE NOTIFICATION
+    import sys
+    mode = "dry-run" if dry_run else "APPLY"
+    lang_info = f" lang={language}" if language else ""
+    print(f"🔄 AST-REPLACE: '{pattern[:30]}' → '{replacement[:30]}'{lang_info} [{mode}]", file=sys.stderr)
+
     try:
         # Build command
         cmd = ["sg", "run", "-p", pattern, "-r", replacement, directory]

mcp_bridge/tools/lsp/__init__.py

@@ -13,8 +13,11 @@ from .tools import (
     lsp_prepare_rename,
     lsp_rename,
     lsp_code_actions,
+    lsp_code_action_resolve,
+    lsp_extract_refactor,
     lsp_servers,
 )
+from .manager import LSPManager, get_lsp_manager
 
 __all__ = [
     "lsp_hover",
@@ -25,5 +28,9 @@ __all__ = [
     "lsp_prepare_rename",
     "lsp_rename",
     "lsp_code_actions",
+    "lsp_code_action_resolve",
+    "lsp_extract_refactor",
     "lsp_servers",
+    "LSPManager",
+    "get_lsp_manager",
 ]

mcp_bridge/tools/lsp/manager.py

@@ -0,0 +1,448 @@
+"""
+Persistent LSP Server Manager
+
+Manages persistent Language Server Protocol (LSP) servers for improved performance.
+Implements lazy initialization, JSON-RPC communication, and graceful shutdown.
+
+Architecture:
+- Servers start on first use (lazy initialization)
+- JSON-RPC over stdio using pygls BaseLanguageClient
+- Supports Python (jedi-language-server) and TypeScript (typescript-language-server)
+- Graceful shutdown on MCP server exit
+- Health checks and idle timeout management
+"""
+
+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 pygls.client import JsonRPCClient
+from lsprotocol.types import (
+    InitializeParams,
+    InitializedParams,
+    ClientCapabilities,
+    WorkspaceFolder,
+)
+
+logger = logging.getLogger(__name__)
+
+# Configuration for LSP server lifecycle management
+LSP_CONFIG = {
+    "idle_timeout": 1800,  # 30 minutes
+    "health_check_interval": 300,  # 5 minutes
+    "health_check_timeout": 5.0,
+}
+
+
+@dataclass
+class LSPServer:
+    """Metadata for a persistent LSP server."""
+
+    name: str
+    command: list[str]
+    client: Optional[JsonRPCClient] = None
+    initialized: bool = False
+    process: Optional[asyncio.subprocess.Process] = None
+    pid: Optional[int] = None  # Track subprocess PID for explicit cleanup
+    last_used: float = field(default_factory=time.time)  # Timestamp of last usage
+    created_at: float = field(default_factory=time.time)  # Timestamp of server creation
+
+
+class LSPManager:
+    """
+    Singleton manager for persistent LSP servers.
+
+    Implements:
+    - Lazy server initialization (start on first use)
+    - Process lifecycle management with GC protection
+    - Exponential backoff for crash recovery
+    - Graceful shutdown with signal handling
+    - Health checks and idle server shutdown
+    """
+
+    _instance: Optional["LSPManager"] = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if hasattr(self, "_initialized"):
+            return
+        self._initialized = True
+        self._servers: dict[str, LSPServer] = {}
+        self._lock = asyncio.Lock()
+        self._restart_attempts: dict[str, int] = {}
+        self._health_monitor_task: Optional[asyncio.Task] = 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]:
+        """
+        Get or start a persistent LSP server for the given language.
+
+        Args:
+            language: Language identifier (e.g., "python", "typescript")
+
+        Returns:
+            JsonRPCClient instance or None if server unavailable
+        """
+        if language not in self._servers:
+            logger.warning(f"No LSP server configured for language: {language}")
+            return None
+
+        server = self._servers[language]
+
+        # Return existing initialized server
+        if server.initialized and server.client:
+            # Update last_used timestamp
+            server.last_used = time.time()
+            # Start health monitor on first use
+            if self._health_monitor_task is None or self._health_monitor_task.done():
+                self._health_monitor_task = asyncio.create_task(self._background_health_monitor())
+            return server.client
+
+        # Start server with lock to prevent race conditions
+        async with self._lock:
+            # Double-check after acquiring lock
+            if server.initialized and server.client:
+                server.last_used = time.time()
+                if self._health_monitor_task is None or self._health_monitor_task.done():
+                    self._health_monitor_task = asyncio.create_task(self._background_health_monitor())
+                return server.client
+
+            try:
+                await self._start_server(server)
+                # 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())
+                return server.client
+            except Exception as e:
+                logger.error(f"Failed to start {language} LSP server: {e}")
+                return None
+
+    async def _start_server(self, server: LSPServer):
+        """
+        Start a persistent LSP server process.
+
+        Implements:
+        - Process health validation after start
+        - LSP initialization handshake
+        - GC protection via persistent reference
+        - Timestamp tracking for idle detection
+
+        Args:
+            server: LSPServer metadata object
+        """
+        try:
+            # Create pygls client
+            client = JsonRPCClient()
+
+            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:])
+
+            # Brief delay for process startup
+            await asyncio.sleep(0.2)
+
+            # Capture subprocess from client
+            if not hasattr(client, "_server") or client._server is None:
+                raise ConnectionError(
+                    f"{server.name} LSP server process not accessible after start_io()"
+                )
+
+            server.process = client._server
+            server.pid = server.process.pid
+            logger.debug(f"{server.name} LSP server started with PID: {server.pid}")
+
+            # Validate process is still running
+            if server.process.returncode is not None:
+                raise ConnectionError(
+                    f"{server.name} LSP server exited immediately (code {server.process.returncode})"
+                )
+
+            # Perform LSP initialization handshake
+            init_params = InitializeParams(
+                process_id=None, root_uri=None, capabilities=ClientCapabilities()
+            )
+
+            try:
+                # Send initialize request via protocol
+                response = await asyncio.wait_for(
+                    client.protocol.send_request_async("initialize", init_params), timeout=10.0
+                )
+
+                # Send initialized notification
+                client.protocol.notify("initialized", InitializedParams())
+
+                logger.info(f"{server.name} LSP server initialized: {response}")
+
+            except asyncio.TimeoutError:
+                raise ConnectionError(f"{server.name} LSP server initialization timed out")
+
+            # Store client reference (GC protection)
+            server.client = client
+            server.initialized = True
+            server.created_at = time.time()
+            server.last_used = time.time()
+
+            # Reset restart attempts on successful start
+            self._restart_attempts[server.name] = 0
+
+            logger.info(f"{server.name} LSP server started successfully")
+
+        except Exception as e:
+            logger.error(f"Failed to start {server.name} LSP server: {e}", exc_info=True)
+            # Cleanup on failure
+            if server.client:
+                try:
+                    await server.client.stop()
+                except:
+                    pass
+            server.client = None
+            server.initialized = False
+            server.process = None
+            server.pid = None
+            raise
+
+    async def _restart_with_backoff(self, server: LSPServer):
+        """
+        Restart a crashed LSP server with exponential backoff.
+
+        Strategy: delay = 2^attempt + jitter (max 60s)
+
+        Args:
+            server: LSPServer to restart
+        """
+        import random
+
+        attempt = self._restart_attempts.get(server.name, 0)
+        self._restart_attempts[server.name] = attempt + 1
+
+        # Exponential backoff with jitter (max 60s)
+        delay = min(60, (2**attempt) + random.uniform(0, 1))
+
+        logger.warning(
+            f"{server.name} LSP server crashed. Restarting in {delay:.2f}s (attempt {attempt + 1})"
+        )
+        await asyncio.sleep(delay)
+
+        # Reset state before restart
+        server.initialized = False
+        server.client = None
+        server.process = None
+        server.pid = None
+
+        try:
+            await self._start_server(server)
+        except Exception as e:
+            logger.error(f"Restart failed for {server.name}: {e}")
+
+    async def _health_check_server(self, server: LSPServer) -> bool:
+        """
+        Perform health check on an LSP server.
+
+        Args:
+            server: LSPServer to check
+
+        Returns:
+            True if server is healthy, False otherwise
+        """
+        if not server.initialized or not server.client:
+            return False
+
+        try:
+            # Simple health check: send initialize request
+            # Most servers respond to repeated initialize calls
+            init_params = InitializeParams(
+                process_id=None, root_uri=None, capabilities=ClientCapabilities()
+            )
+            response = await asyncio.wait_for(
+                server.client.protocol.send_request_async("initialize", init_params),
+                timeout=LSP_CONFIG["health_check_timeout"],
+            )
+            logger.debug(f"{server.name} LSP server health check passed")
+            return True
+        except asyncio.TimeoutError:
+            logger.warning(f"{server.name} LSP server health check timed out")
+            return False
+        except Exception as e:
+            logger.warning(f"{server.name} LSP server health check failed: {e}")
+            return False
+
+    async def _shutdown_single_server(self, name: str, server: LSPServer):
+        """
+        Gracefully shutdown a single LSP server.
+
+        Args:
+            name: Server name (key)
+            server: LSPServer instance
+        """
+        if not server.initialized or not server.client:
+            return
+
+        try:
+            logger.info(f"Shutting down {name} LSP server")
+
+            # LSP protocol shutdown request
+            try:
+                await asyncio.wait_for(
+                    server.client.protocol.send_request_async("shutdown", None), timeout=5.0
+                )
+            except asyncio.TimeoutError:
+                logger.warning(f"{name} LSP server shutdown request timed out")
+
+            # Send exit notification
+            server.client.protocol.notify("exit", None)
+
+            # Stop the client
+            await server.client.stop()
+
+            # Terminate subprocess using stored process reference
+            if server.process is not None:
+                try:
+                    if server.process.returncode is not None:
+                        logger.debug(f"{name} already exited (code {server.process.returncode})")
+                    else:
+                        server.process.terminate()
+                        try:
+                            await asyncio.wait_for(server.process.wait(), timeout=2.0)
+                        except asyncio.TimeoutError:
+                            server.process.kill()
+                            await asyncio.wait_for(server.process.wait(), timeout=1.0)
+                except Exception as e:
+                    logger.warning(f"Error terminating {name}: {e}")
+
+            # Mark as uninitialized
+            server.initialized = False
+            server.client = None
+            server.process = None
+            server.pid = None
+
+        except Exception as e:
+            logger.error(f"Error shutting down {name} LSP server: {e}")
+
+    async def _background_health_monitor(self):
+        """
+        Background task for health checking and idle server shutdown.
+
+        Runs periodically to:
+        - Check health of running servers
+        - Shutdown idle servers
+        - Restart crashed servers
+        """
+        logger.info("LSP health monitor task started")
+        try:
+            while True:
+                await asyncio.sleep(LSP_CONFIG["health_check_interval"])
+
+                current_time = time.time()
+                idle_threshold = current_time - LSP_CONFIG["idle_timeout"]
+
+                async with self._lock:
+                    for name, server in self._servers.items():
+                        if not server.initialized or not server.client:
+                            continue
+
+                        # Check if server is idle
+                        if server.last_used < idle_threshold:
+                            logger.info(
+                                f"{name} LSP server idle for {(current_time - server.last_used) / 60:.1f} minutes, shutting down"
+                            )
+                            await self._shutdown_single_server(name, server)
+                            continue
+
+                        # Health check for active servers
+                        is_healthy = await self._health_check_server(server)
+                        if not is_healthy:
+                            logger.warning(f"{name} LSP server health check failed, restarting")
+                            await self._shutdown_single_server(name, server)
+                            try:
+                                await self._start_server(server)
+                            except Exception as e:
+                                logger.error(f"Failed to restart {name} LSP server: {e}")
+
+        except asyncio.CancelledError:
+            logger.info("LSP health monitor task cancelled")
+            raise
+        except Exception as e:
+            logger.error(f"LSP health monitor task error: {e}", exc_info=True)
+
+    def get_status(self) -> dict:
+        """Get status of managed servers including idle information."""
+        current_time = time.time()
+        status = {}
+        for name, server in self._servers.items():
+            idle_seconds = current_time - server.last_used
+            uptime_seconds = current_time - server.created_at if server.created_at else 0
+            status[name] = {
+                "running": server.initialized and server.client is not None,
+                "pid": server.pid,
+                "command": " ".join(server.command),
+                "restarts": self._restart_attempts.get(name, 0),
+                "idle_seconds": idle_seconds,
+                "idle_minutes": idle_seconds / 60.0,
+                "uptime_seconds": uptime_seconds,
+            }
+        return status
+
+    async def shutdown(self):
+        """
+        Gracefully shutdown all LSP servers.
+
+        Implements:
+        - Health monitor cancellation
+        - LSP protocol shutdown (shutdown request + exit notification)
+        - Pending task cancellation
+        - Process cleanup with timeout
+        """
+        logger.info("Shutting down LSP manager...")
+
+        # Cancel health monitor task
+        if self._health_monitor_task and not self._health_monitor_task.done():
+            logger.info("Cancelling health monitor task")
+            self._health_monitor_task.cancel()
+            try:
+                await self._health_monitor_task
+            except asyncio.CancelledError:
+                pass
+
+        async with self._lock:
+            for name, server in self._servers.items():
+                await self._shutdown_single_server(name, server)
+
+        logger.info("LSP manager shutdown complete")
+
+
+# Singleton accessor
+_manager_instance: Optional[LSPManager] = None
+_manager_lock = threading.Lock()
+
+
+def get_lsp_manager() -> LSPManager:
+    """Get the global LSP manager singleton."""
+    global _manager_instance
+    if _manager_instance is None:
+        with _manager_lock:
+            # Double-check pattern to avoid race condition
+            if _manager_instance is None:
+                _manager_instance = LSPManager()
+    return _manager_instance