llmcode-cli 1.0.0__py3-none-any.whl

llm_code/lsp/client.py

@@ -0,0 +1,298 @@
+"""LSP client: types, LspTransport, and LspClient."""
+from __future__ import annotations
+
+import asyncio
+import itertools
+import json
+import os
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any
+
+
+# ---------------------------------------------------------------------------
+# Data types
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class Location:
+    file: str
+    line: int
+    column: int
+
+
+@dataclass(frozen=True)
+class Diagnostic:
+    file: str
+    line: int
+    column: int
+    severity: str  # "error" | "warning" | "info" | "hint"
+    message: str
+    source: str
+
+
+@dataclass(frozen=True)
+class LspServerConfig:
+    command: str
+    args: tuple[str, ...] = ()
+    language: str = ""
+
+
+# ---------------------------------------------------------------------------
+# Transport abstraction
+# ---------------------------------------------------------------------------
+
+_SEVERITY_MAP: dict[int, str] = {
+    1: "error",
+    2: "warning",
+    3: "info",
+    4: "hint",
+}
+
+
+class LspTransport(ABC):
+    """Abstract base for LSP transports (Content-Length framed JSON-RPC)."""
+
+    @abstractmethod
+    async def start(self) -> None: ...
+
+    @abstractmethod
+    async def send_message(self, message: dict[str, Any]) -> None: ...
+
+    @abstractmethod
+    async def receive_message(self) -> dict[str, Any]: ...
+
+    @abstractmethod
+    async def close(self) -> None: ...
+
+
+class StdioLspTransport(LspTransport):
+    """LSP transport over subprocess stdin/stdout using Content-Length framing."""
+
+    RECEIVE_TIMEOUT = 30.0
+    CLOSE_WAIT_TIMEOUT = 5.0
+
+    def __init__(
+        self,
+        command: str,
+        args: tuple[str, ...] = (),
+    ) -> None:
+        self._command = command
+        self._args = args
+        self._process: asyncio.subprocess.Process | None = None
+
+    async def start(self) -> None:
+        self._process = await asyncio.create_subprocess_exec(
+            self._command,
+            *self._args,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env={**os.environ},
+        )
+
+    async def send_message(self, message: dict[str, Any]) -> None:
+        if self._process is None or self._process.stdin is None:
+            raise RuntimeError("Transport not started")
+        body = json.dumps(message).encode("utf-8")
+        header = f"Content-Length: {len(body)}\r\n\r\n".encode("ascii")
+        self._process.stdin.write(header + body)
+        await self._process.stdin.drain()
+
+    async def receive_message(self) -> dict[str, Any]:
+        if self._process is None or self._process.stdout is None:
+            raise RuntimeError("Transport not started")
+
+        headers: dict[str, str] = {}
+        while True:
+            line = await asyncio.wait_for(
+                self._process.stdout.readline(),
+                timeout=self.RECEIVE_TIMEOUT,
+            )
+            line_str = line.decode("ascii").strip()
+            if not line_str:
+                break
+            key, _, value = line_str.partition(":")
+            headers[key.strip().lower()] = value.strip()
+
+        content_length = int(headers.get("content-length", "0"))
+        body = await asyncio.wait_for(
+            self._process.stdout.readexactly(content_length),
+            timeout=self.RECEIVE_TIMEOUT,
+        )
+        return json.loads(body.decode("utf-8"))
+
+    async def close(self) -> None:
+        if self._process is None:
+            return
+        process = self._process
+        self._process = None
+        try:
+            if process.stdin and not process.stdin.is_closing():
+                process.stdin.close()
+        except Exception:
+            pass
+        try:
+            process.terminate()
+        except (ProcessLookupError, OSError):
+            pass
+        try:
+            await asyncio.wait_for(process.wait(), timeout=self.CLOSE_WAIT_TIMEOUT)
+        except asyncio.TimeoutError:
+            try:
+                process.kill()
+            except (ProcessLookupError, OSError):
+                pass
+            try:
+                await process.wait()
+            except Exception:
+                pass
+
+
+# ---------------------------------------------------------------------------
+# LSP client
+# ---------------------------------------------------------------------------
+
+
+class LspClient:
+    """High-level LSP client."""
+
+    def __init__(self, transport: LspTransport) -> None:
+        self._transport = transport
+        self._id_counter = itertools.count(1)
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    async def initialize(self, root_uri: str) -> dict[str, Any]:
+        result = await self._request(
+            "initialize",
+            {
+                "processId": None,
+                "clientInfo": {"name": "llm-code", "version": "0.1.0"},
+                "rootUri": root_uri,
+                "capabilities": {},
+            },
+        )
+        return result
+
+    async def goto_definition(
+        self, file_uri: str, line: int, col: int
+    ) -> list[Location]:
+        result = await self._request(
+            "textDocument/definition",
+            {
+                "textDocument": {"uri": file_uri},
+                "position": {"line": line, "character": col},
+            },
+        )
+        return self._parse_locations(result)
+
+    async def find_references(
+        self, file_uri: str, line: int, col: int
+    ) -> list[Location]:
+        result = await self._request(
+            "textDocument/references",
+            {
+                "textDocument": {"uri": file_uri},
+                "position": {"line": line, "character": col},
+                "context": {"includeDeclaration": True},
+            },
+        )
+        return self._parse_locations(result)
+
+    async def get_diagnostics(self, file_uri: str) -> list[Diagnostic]:
+        result = await self._request(
+            "textDocument/diagnostic",
+            {"textDocument": {"uri": file_uri}},
+        )
+        diagnostics: list[Diagnostic] = []
+        items = result.get("items", [])
+        for item in items:
+            uri = item.get("uri", file_uri)
+            for raw in item.get("diagnostics", []):
+                start = raw.get("range", {}).get("start", {})
+                severity_int = raw.get("severity", 1)
+                severity = _SEVERITY_MAP.get(severity_int, "error")
+                diagnostics.append(
+                    Diagnostic(
+                        file=uri,
+                        line=start.get("line", 0),
+                        column=start.get("character", 0),
+                        severity=severity,
+                        message=raw.get("message", ""),
+                        source=raw.get("source", ""),
+                    )
+                )
+        return diagnostics
+
+    async def did_open(self, file_uri: str, text: str) -> None:
+        """Send textDocument/didOpen notification (no response expected)."""
+        await self._notify(
+            "textDocument/didOpen",
+            {
+                "textDocument": {
+                    "uri": file_uri,
+                    "languageId": "plaintext",
+                    "version": 1,
+                    "text": text,
+                }
+            },
+        )
+
+    async def shutdown(self) -> None:
+        """Send shutdown + exit, then close transport."""
+        await self._request("shutdown", {})
+        await self._notify("exit", {})
+        await self._transport.close()
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    async def _request(self, method: str, params: dict[str, Any]) -> Any:
+        request_id = next(self._id_counter)
+        message: dict[str, Any] = {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "method": method,
+            "params": params,
+        }
+        await self._transport.send_message(message)
+        response = await self._transport.receive_message()
+
+        if "error" in response:
+            error = response["error"]
+            raise RuntimeError(
+                f"LSP error {error.get('code')}: {error.get('message', 'Unknown error')}"
+            )
+        return response.get("result")
+
+    async def _notify(self, method: str, params: dict[str, Any]) -> None:
+        """Send a JSON-RPC notification (no id, no response)."""
+        message: dict[str, Any] = {
+            "jsonrpc": "2.0",
+            "method": method,
+            "params": params,
+        }
+        await self._transport.send_message(message)
+
+    def _parse_locations(self, result: Any) -> list[Location]:
+        if result is None:
+            return []
+        if isinstance(result, dict):
+            result = [result]
+        locations = []
+        for item in result:
+            uri = item.get("uri", "")
+            start = item.get("range", {}).get("start", {})
+            locations.append(
+                Location(
+                    file=uri,
+                    line=start.get("line", 0),
+                    column=start.get("character", 0),
+                )
+            )
+        return locations

llm_code/lsp/detector.py

@@ -0,0 +1,42 @@
+"""LSP server auto-detector: discovers language servers from project marker files."""
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from llm_code.lsp.client import LspServerConfig
+
+# Maps marker filename -> (command, args, language)
+_DETECTORS: dict[str, tuple[str, list[str], str]] = {
+    "pyproject.toml": ("pyright-langserver", ["--stdio"], "python"),
+    "setup.py": ("pyright-langserver", ["--stdio"], "python"),
+    "requirements.txt": ("pyright-langserver", ["--stdio"], "python"),
+    "package.json": ("typescript-language-server", ["--stdio"], "typescript"),
+    "tsconfig.json": ("typescript-language-server", ["--stdio"], "typescript"),
+    "go.mod": ("gopls", ["serve"], "go"),
+    "Cargo.toml": ("rust-analyzer", [], "rust"),
+}
+
+
+def detect_lsp_servers(cwd: Path) -> dict[str, LspServerConfig]:
+    """Detect available LSP servers based on marker files in *cwd*.
+
+    Returns a mapping of language -> LspServerConfig.
+    Only includes languages where the server binary exists on PATH.
+    If multiple markers for the same language are found, the language
+    appears only once.
+    """
+    found: dict[str, LspServerConfig] = {}
+    for marker, (command, args, language) in _DETECTORS.items():
+        if language in found:
+            continue
+        if not (cwd / marker).exists():
+            continue
+        if shutil.which(command) is None:
+            continue
+        found[language] = LspServerConfig(
+            command=command,
+            args=tuple(args),
+            language=language,
+        )
+    return found

llm_code/lsp/manager.py

@@ -0,0 +1,56 @@
+"""LSP server manager: lifecycle management for multiple language servers."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from llm_code.lsp.client import LspClient, LspServerConfig, StdioLspTransport
+
+
+class LspServerManager:
+    """Manages a pool of running LSP clients, keyed by language."""
+
+    def __init__(self) -> None:
+        self._clients: dict[str, LspClient] = {}
+
+    async def start_server(
+        self, name: str, config: LspServerConfig, root_path: Path
+    ) -> LspClient:
+        """Start a single LSP server and return a connected LspClient.
+
+        *name* is used as the key (typically the language name).
+        """
+        transport = StdioLspTransport(command=config.command, args=config.args)
+        await transport.start()
+        client = LspClient(transport)
+        root_uri = root_path.as_uri()
+        await client.initialize(root_uri)
+        self._clients[name] = client
+        return client
+
+    async def start_all(
+        self, configs: dict[str, LspServerConfig], root_path: Path
+    ) -> None:
+        """Start all servers from a language -> config mapping.
+
+        Failures are logged and skipped so one broken server does not block others.
+        """
+        for name, config in configs.items():
+            try:
+                await self.start_server(name, config, root_path)
+            except Exception as exc:
+                import warnings
+                warnings.warn(f"Failed to start LSP server '{name}': {exc}", stacklevel=2)
+
+    async def stop_all(self) -> None:
+        """Shutdown all running servers gracefully."""
+        clients = list(self._clients.values())
+        self._clients.clear()
+        for client in clients:
+            try:
+                await client.shutdown()
+            except Exception:
+                pass
+
+    def get_client(self, language: str) -> LspClient | None:
+        """Return the LspClient for *language*, or None if not running."""
+        return self._clients.get(language)

llm_code/lsp/tools.py

@@ -0,0 +1,288 @@
+"""LSP tools: goto-definition, find-references, diagnostics."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from pydantic import BaseModel
+
+from llm_code.lsp.manager import LspServerManager
+from llm_code.tools.base import PermissionLevel, Tool, ToolResult
+
+# ---------------------------------------------------------------------------
+# File-extension -> language mapping
+# ---------------------------------------------------------------------------
+
+_EXT_LANGUAGE: dict[str, str] = {
+    ".py": "python",
+    ".pyi": "python",
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "typescript",
+    ".jsx": "typescript",
+    ".go": "go",
+    ".rs": "rust",
+}
+
+
+def _language_for_file(file_path: str) -> str:
+    suffix = Path(file_path).suffix.lower()
+    return _EXT_LANGUAGE.get(suffix, "")
+
+
+# ---------------------------------------------------------------------------
+# Pydantic input models
+# ---------------------------------------------------------------------------
+
+
+class _PositionInput(BaseModel):
+    file: str
+    line: int
+    column: int
+
+
+class _FileInput(BaseModel):
+    file: str
+
+
+# ---------------------------------------------------------------------------
+# Tools
+# ---------------------------------------------------------------------------
+
+
+class LspGotoDefinitionTool(Tool):
+    """Jump to the definition of a symbol at a given file position."""
+
+    def __init__(self, manager: LspServerManager) -> None:
+        self._manager = manager
+
+    @property
+    def name(self) -> str:
+        return "lsp_goto_definition"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Go to the definition of the symbol at the given file position "
+            "using the language server."
+        )
+
+    @property
+    def input_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "file": {"type": "string", "description": "Absolute path to the file"},
+                "line": {
+                    "type": "integer",
+                    "description": "0-based line number",
+                },
+                "column": {
+                    "type": "integer",
+                    "description": "0-based column number",
+                },
+            },
+            "required": ["file", "line", "column"],
+        }
+
+    @property
+    def required_permission(self) -> PermissionLevel:
+        return PermissionLevel.READ_ONLY
+
+    @property
+    def input_model(self) -> type[_PositionInput]:
+        return _PositionInput
+
+    def is_read_only(self, args: dict) -> bool:
+        return True
+
+    def is_concurrency_safe(self, args: dict) -> bool:
+        return True
+
+    def execute(self, args: dict) -> ToolResult:
+        import asyncio
+        import concurrent.futures
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = None
+        if loop and loop.is_running():
+            with concurrent.futures.ThreadPoolExecutor() as pool:
+                return pool.submit(asyncio.run, self.execute_async(args)).result()
+        return asyncio.run(self.execute_async(args))
+
+    async def execute_async(self, args: dict) -> ToolResult:
+        file_path = args["file"]
+        line = int(args["line"])
+        column = int(args["column"])
+
+        language = _language_for_file(file_path)
+        client = self._manager.get_client(language)
+        if client is None:
+            return ToolResult(
+                output=f"No LSP client available for language '{language}' (file: {file_path})",
+                is_error=True,
+            )
+
+        file_uri = Path(file_path).as_uri()
+        locations = await client.goto_definition(file_uri, line, column)
+
+        if not locations:
+            return ToolResult(output="No definition found.")
+
+        lines = []
+        for loc in locations:
+            lines.append(f"{loc.file}:{loc.line}:{loc.column}")
+        return ToolResult(output="\n".join(lines))
+
+
+class LspFindReferencesTool(Tool):
+    """Find all references to the symbol at a given file position."""
+
+    def __init__(self, manager: LspServerManager) -> None:
+        self._manager = manager
+
+    @property
+    def name(self) -> str:
+        return "lsp_find_references"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Find all references to the symbol at the given file position "
+            "using the language server."
+        )
+
+    @property
+    def input_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "file": {"type": "string", "description": "Absolute path to the file"},
+                "line": {"type": "integer", "description": "0-based line number"},
+                "column": {"type": "integer", "description": "0-based column number"},
+            },
+            "required": ["file", "line", "column"],
+        }
+
+    @property
+    def required_permission(self) -> PermissionLevel:
+        return PermissionLevel.READ_ONLY
+
+    @property
+    def input_model(self) -> type[_PositionInput]:
+        return _PositionInput
+
+    def is_read_only(self, args: dict) -> bool:
+        return True
+
+    def is_concurrency_safe(self, args: dict) -> bool:
+        return True
+
+    def execute(self, args: dict) -> ToolResult:
+        import asyncio
+        import concurrent.futures
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = None
+        if loop and loop.is_running():
+            with concurrent.futures.ThreadPoolExecutor() as pool:
+                return pool.submit(asyncio.run, self.execute_async(args)).result()
+        return asyncio.run(self.execute_async(args))
+
+    async def execute_async(self, args: dict) -> ToolResult:
+        file_path = args["file"]
+        line = int(args["line"])
+        column = int(args["column"])
+
+        language = _language_for_file(file_path)
+        client = self._manager.get_client(language)
+        if client is None:
+            return ToolResult(
+                output=f"No LSP client available for language '{language}' (file: {file_path})",
+                is_error=True,
+            )
+
+        file_uri = Path(file_path).as_uri()
+        references = await client.find_references(file_uri, line, column)
+
+        if not references:
+            return ToolResult(output="No references found.")
+
+        lines = []
+        for loc in references:
+            lines.append(f"{loc.file}:{loc.line}:{loc.column}")
+        return ToolResult(output="\n".join(lines))
+
+
+class LspDiagnosticsTool(Tool):
+    """Get diagnostics (errors, warnings) for a file from the language server."""
+
+    def __init__(self, manager: LspServerManager) -> None:
+        self._manager = manager
+
+    @property
+    def name(self) -> str:
+        return "lsp_diagnostics"
+
+    @property
+    def description(self) -> str:
+        return "Get diagnostics (errors, warnings, hints) for a file using the language server."
+
+    @property
+    def input_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "file": {"type": "string", "description": "Absolute path to the file"},
+            },
+            "required": ["file"],
+        }
+
+    @property
+    def required_permission(self) -> PermissionLevel:
+        return PermissionLevel.READ_ONLY
+
+    @property
+    def input_model(self) -> type[_FileInput]:
+        return _FileInput
+
+    def is_read_only(self, args: dict) -> bool:
+        return True
+
+    def is_concurrency_safe(self, args: dict) -> bool:
+        return True
+
+    def execute(self, args: dict) -> ToolResult:
+        import asyncio
+        import concurrent.futures
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = None
+        if loop and loop.is_running():
+            with concurrent.futures.ThreadPoolExecutor() as pool:
+                return pool.submit(asyncio.run, self.execute_async(args)).result()
+        return asyncio.run(self.execute_async(args))
+
+    async def execute_async(self, args: dict) -> ToolResult:
+        file_path = args["file"]
+
+        language = _language_for_file(file_path)
+        client = self._manager.get_client(language)
+        if client is None:
+            return ToolResult(
+                output=f"No LSP client available for language '{language}' (file: {file_path})",
+                is_error=True,
+            )
+
+        file_uri = Path(file_path).as_uri()
+        diagnostics = await client.get_diagnostics(file_uri)
+
+        if not diagnostics:
+            return ToolResult(output="No diagnostics found — file looks clean.")
+
+        lines = []
+        for d in diagnostics:
+            lines.append(f"{d.file}:{d.line}:{d.column} [{d.severity}] {d.message} ({d.source})")
+        return ToolResult(output="\n".join(lines))