@trac3er/oh-my-god 2.0.0 → 2.0.2

package/tools/lsp_client.py

@@ -0,0 +1,275 @@
+"""LSP client wrapper supporting stdio transport.
+
+Implements JSON-RPC 2.0 over stdio with Content-Length framing
+per the Language Server Protocol specification.
+
+Pure stdlib: subprocess, json, threading — no external dependencies.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import subprocess
+import threading
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_CONTENT_LENGTH_HEADER = "Content-Length: "
+_HEADER_SEPARATOR = "\r\n\r\n"
+_DEFAULT_TIMEOUT = 10.0
+
+
+class LSPClient:
+    """LSP client that communicates with a language server over stdio.
+
+    When ``server_cmd`` is None the client operates in **stub mode**:
+    ``start()`` returns False, ``is_connected()`` returns False, and
+    ``send_request()`` returns None.  This allows OMG to instantiate
+    the client unconditionally — LSP is always optional.
+    """
+
+    def __init__(
+        self,
+        server_cmd: list[str] | None = None,
+        transport: str = "stdio",
+        timeout: float = _DEFAULT_TIMEOUT,
+    ) -> None:
+        if transport != "stdio":
+            raise ValueError(f"Unsupported transport: {transport!r} (only 'stdio' is supported)")
+
+        self._server_cmd = server_cmd
+        self._transport = transport
+        self._timeout = timeout
+
+        self._process: subprocess.Popen[bytes] | None = None
+        self._request_id = 0
+        self._lock = threading.Lock()
+        self._connected = False
+        self._initialized = False
+
+    def start(self) -> bool:
+        """Start the language-server process.
+
+        Returns True on success, False if no server command was
+        configured (stub mode) or if the process failed to launch.
+        """
+        if self._server_cmd is None:
+            logger.debug("LSPClient in stub mode — no server_cmd provided")
+            return False
+
+        try:
+            self._process = subprocess.Popen(
+                self._server_cmd,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            self._connected = True
+            logger.info("LSP server started: %s (pid=%d)", self._server_cmd, self._process.pid)
+            return True
+        except (OSError, FileNotFoundError) as exc:
+            logger.error("Failed to start LSP server %s: %s", self._server_cmd, exc)
+            self._connected = False
+            return False
+
+    def initialize(
+        self,
+        root_uri: str,
+        capabilities: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Perform the LSP ``initialize`` handshake.
+
+        Returns the server capabilities dict, or an empty dict on
+        failure / stub mode.
+        """
+        if not self._connected:
+            return {}
+
+        params: dict[str, Any] = {
+            "processId": None,
+            "rootUri": root_uri,
+            "capabilities": capabilities or {},
+        }
+
+        result = self.send_request("initialize", params)
+        if result is None:
+            return {}
+
+        self.send_notification("initialized", {})
+        self.send_notification("initialized", {})
+        self._initialized = True
+        return result
+
+    def shutdown(self) -> None:
+        """Send ``shutdown`` then ``exit`` and tear down the process."""
+        if not self._connected or self._process is None:
+            return
+
+        try:
+            self.send_request("shutdown", {})
+            self.send_notification("exit", {})
+        except Exception:  # noqa: BLE001
+            logger.debug("Error during LSP shutdown sequence", exc_info=True)
+
+        self._cleanup_process()
+
+    def send_request(
+        self,
+        method: str,
+        params: dict[str, Any],
+    ) -> dict[str, Any] | None:
+        """Send a JSON-RPC **request** (expects a response).
+
+        Returns the ``result`` field of the response, or None on
+        timeout / error / not connected.
+        """
+        if not self._connected or self._process is None:
+            return None
+
+        with self._lock:
+            self._request_id += 1
+            req_id = self._request_id
+
+        message: dict[str, Any] = {
+            "jsonrpc": "2.0",
+            "id": req_id,
+            "method": method,
+            "params": params,
+        }
+
+        try:
+            self._write_message(message)
+            response = self._read_message()
+        except Exception:  # noqa: BLE001
+            logger.debug("send_request(%s) failed", method, exc_info=True)
+            return None
+
+        if response is None:
+            return None
+
+        if "error" in response:
+            logger.warning(
+                "LSP error for %s: %s",
+                method,
+                response["error"],
+            )
+            return None
+
+        return response.get("result")
+
+    def send_notification(
+        self,
+        method: str,
+        params: dict[str, Any],
+    ) -> None:
+        """Send a JSON-RPC **notification** (no ``id``, no response)."""
+        if not self._connected or self._process is None:
+            return
+
+        message: dict[str, Any] = {
+            "jsonrpc": "2.0",
+            "method": method,
+            "params": params,
+        }
+
+        try:
+            self._write_message(message)
+        except Exception:  # noqa: BLE001
+            logger.debug("send_notification(%s) failed", method, exc_info=True)
+
+    def is_connected(self) -> bool:
+        """Return True if the server process is alive and connected."""
+        if not self._connected or self._process is None:
+            return False
+        # Poll returns None while process is still running
+        return self._process.poll() is None
+
+    @staticmethod
+    def encode_message(body: dict[str, Any]) -> bytes:
+        """Encode a JSON-RPC message with Content-Length header.
+
+        Public so tests can verify framing without a live process.
+        """
+        payload = json.dumps(body, separators=(",", ":")).encode("utf-8")
+        header = f"Content-Length: {len(payload)}\r\n\r\n".encode("ascii")
+        return header + payload
+
+    def _write_message(self, body: dict[str, Any]) -> None:
+        """Write a framed JSON-RPC message to the server's stdin."""
+        assert self._process is not None and self._process.stdin is not None
+        raw = self.encode_message(body)
+        self._process.stdin.write(raw)
+        self._process.stdin.flush()
+
+    def _read_message(self) -> dict[str, Any] | None:
+        """Read one framed JSON-RPC message from the server's stdout.
+
+        Uses a background thread + join(timeout) so we never block
+        indefinitely.
+        """
+        assert self._process is not None and self._process.stdout is not None
+
+        result_holder: list[dict[str, Any] | None] = [None]
+
+        def _reader() -> None:
+            try:
+                stdout = self._process.stdout  # type: ignore[union-attr]
+                content_length = 0
+                content_length = 0
+                while True:
+                    line = stdout.readline()
+                    if not line:
+                        return  # EOF
+                    line_str = line.decode("ascii").strip()
+                    if not line_str:
+                        break
+                    if line_str.startswith(_CONTENT_LENGTH_HEADER.strip()):
+                        content_length = int(line_str[len(_CONTENT_LENGTH_HEADER.strip()):])
+
+                if content_length == 0:
+                    return
+
+                data = stdout.read(content_length)
+                if data:
+                    result_holder[0] = json.loads(data.decode("utf-8"))
+            except Exception:  # noqa: BLE001
+                logger.debug("_reader failed", exc_info=True)
+
+        thread = threading.Thread(target=_reader, daemon=True)
+        thread.start()
+        thread.join(timeout=self._timeout)
+
+        if thread.is_alive():
+            logger.warning("LSP read timed out after %.1fs", self._timeout)
+            return None
+
+        return result_holder[0]
+
+    def _cleanup_process(self) -> None:
+        """Terminate / kill the server process and reset state."""
+        self._connected = False
+        self._initialized = False
+        if self._process is None:
+            return
+        try:
+            self._process.terminate()
+            self._process.wait(timeout=3)
+        except subprocess.TimeoutExpired:
+            self._process.kill()
+            self._process.wait(timeout=1)
+        except Exception:  # noqa: BLE001
+            pass
+        finally:
+            self._process = None
+
+    def __enter__(self) -> LSPClient:
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.shutdown()
+
+    def __repr__(self) -> str:
+        cmd = self._server_cmd or "(stub)"
+        return f"<LSPClient cmd={cmd!r} connected={self.is_connected()}>"

package/tools/lsp_discovery.py

@@ -0,0 +1,231 @@
+"""LSP Server Auto-Discovery Tool
+
+Scans for available LSP servers based on language configurations.
+Searches in: node_modules/.bin/, .venv/bin/, system PATH
+
+Feature flag: OMG_LSP_TOOLS_ENABLED (default: False)
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import shutil
+import sys
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# Try to load YAML, fall back to JSON
+try:
+    import yaml
+    HAS_YAML = True
+except ImportError:
+    HAS_YAML = False
+
+
+def _load_language_config(project_dir: str = ".") -> dict[str, Any]:
+    """Load language configuration from YAML or JSON.
+    
+    Returns dict with 'languages' key containing list of language configs.
+    Falls back to empty dict if file not found.
+    """
+    config_path = Path(project_dir) / "config" / "lsp_languages.yaml"
+    
+    if not config_path.exists():
+        return {"languages": []}
+    
+    try:
+        if HAS_YAML:
+            with open(config_path, "r", encoding="utf-8") as f:
+                return yaml.safe_load(f) or {"languages": []}
+        else:
+            # Fallback: try to parse as JSON
+            with open(config_path, "r", encoding="utf-8") as f:
+                content = f.read()
+                # Simple YAML to JSON conversion for basic cases
+                # This is a minimal fallback - just try JSON first
+                try:
+                    return json.loads(content)
+                except json.JSONDecodeError:
+                    # If JSON fails, return empty config
+                    return {"languages": []}
+    except Exception as e:
+        logger.error(f"Failed to load language config: {e}")
+        return {"languages": []}
+
+
+def _expand_path(path_str: str) -> str:
+    """Expand ~ and environment variables in path."""
+    return os.path.expanduser(os.path.expandvars(path_str))
+
+
+def _find_in_paths(binary_name: str, search_paths: list[str]) -> str | None:
+    """Find binary in list of paths.
+    
+    Args:
+        binary_name: Name of binary to find (e.g., 'pylsp')
+        search_paths: List of paths to search (may contain ~ and env vars)
+    
+    Returns:
+        Full path to binary if found, None otherwise
+    """
+    for path_str in search_paths:
+        expanded = _expand_path(path_str)
+        
+        # If path is a directory, look for binary inside
+        if os.path.isdir(expanded):
+            binary_path = os.path.join(expanded, binary_name)
+            if os.path.isfile(binary_path) and os.access(binary_path, os.X_OK):
+                return binary_path
+        # If path is a file, check if it matches
+        elif os.path.isfile(expanded) and os.access(expanded, os.X_OK):
+            if os.path.basename(expanded) == binary_name:
+                return expanded
+    
+    return None
+
+
+def _find_in_system_path(binary_name: str) -> str | None:
+    """Find binary in system PATH.
+    
+    Args:
+        binary_name: Name of binary to find
+    
+    Returns:
+        Full path to binary if found, None otherwise
+    """
+    return shutil.which(binary_name)
+
+
+def discover_lsp_servers(project_dir: str = ".") -> list[dict[str, Any]]:
+    """Discover available LSP servers in project.
+    
+    Scans for LSP servers defined in config/lsp_languages.yaml.
+    For each language, checks discovery_paths and system PATH.
+    
+    Args:
+        project_dir: Project directory to scan (default: current directory)
+    
+    Returns:
+        List of dicts with keys:
+        - language: Language name
+        - server_command: Command to start server
+        - server_name: Human-readable server name
+        - found_at: Full path to server binary (or None if not found)
+        - available: Boolean indicating if server was found
+    """
+    config = _load_language_config(project_dir)
+    languages = config.get("languages", [])
+    
+    discovered = []
+    
+    for lang_config in languages:
+        language = lang_config.get("name", "unknown")
+        server_command = lang_config.get("server_command", [])
+        server_name = lang_config.get("server_name", "unknown")
+        discovery_paths = lang_config.get("discovery_paths", [])
+        
+        # Get the binary name (first element of server_command)
+        if not server_command:
+            discovered.append({
+                "language": language,
+                "server_command": server_command,
+                "server_name": server_name,
+                "found_at": None,
+                "available": False,
+            })
+            continue
+        
+        binary_name = server_command[0]
+        
+        # Search in discovery_paths first
+        found_at = _find_in_paths(binary_name, discovery_paths)
+        
+        # Fall back to system PATH
+        if not found_at:
+            found_at = _find_in_system_path(binary_name)
+        
+        discovered.append({
+            "language": language,
+            "server_command": server_command,
+            "server_name": server_name,
+            "found_at": found_at,
+            "available": found_at is not None,
+        })
+    
+    return discovered
+
+
+def _is_enabled() -> bool:
+    """Check if LSP discovery is enabled via feature flag.
+    
+    Checks env var first (OMG_LSP_TOOLS_ENABLED), then settings.json.
+    """
+    # Check environment variable
+    env_val = os.environ.get("OMG_LSP_TOOLS_ENABLED", "").lower()
+    if env_val in ("0", "false", "no"):
+        return False
+    if env_val in ("1", "true", "yes"):
+        return True
+    
+    # Check settings.json
+    try:
+        project_dir = os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
+        settings_path = os.path.join(project_dir, "settings.json")
+        if os.path.exists(settings_path):
+            with open(settings_path, "r", encoding="utf-8") as f:
+                settings = json.load(f)
+                features = settings.get("_oal", {}).get("features", {})
+                if "LSP_TOOLS" in features:
+                    return features["LSP_TOOLS"]
+    except Exception:
+        pass
+    
+    # Default: disabled (opt-in)
+    return False
+
+
+def main():
+    """CLI entry point for LSP discovery.
+    
+    Usage:
+        python3 tools/lsp_discovery.py --project <dir>
+    
+    Outputs JSON to stdout with list of discovered servers.
+    """
+    import argparse
+    
+    parser = argparse.ArgumentParser(
+        description="Discover available LSP servers in project"
+    )
+    parser.add_argument(
+        "--project",
+        default=".",
+        help="Project directory to scan (default: current directory)"
+    )
+    
+    args = parser.parse_args()
+    
+    # Discover servers (works regardless of feature flag)
+    servers = discover_lsp_servers(args.project)
+    
+    # Output as JSON
+    output = {
+        "project_dir": os.path.abspath(args.project),
+        "enabled": _is_enabled(),
+        "servers": servers,
+        "summary": {
+            "total": len(servers),
+            "available": sum(1 for s in servers if s["available"]),
+            "unavailable": sum(1 for s in servers if not s["available"]),
+        }
+    }
+    
+    json.dump(output, sys.stdout, indent=2)
+
+
+if __name__ == "__main__":
+    main()