local-coding-agent 1.1.0__py3-none-any.whl

local_coding_agent/lsp/_client.py

@@ -0,0 +1,322 @@
+"""LspClient: Stdio JSON-RPC Client."""
+
+from __future__ import annotations
+
+import concurrent.futures
+import os
+from pathlib import Path
+import subprocess
+import sys
+import threading
+from typing import Any, Mapping, Sequence
+
+from ._types import (
+    EXTENSION_TO_LANGUAGE,
+    LspConnectionError,
+    LspError,
+    LspHoverResult,
+    LspLocation,
+    LspResponseError,
+    LspSymbol,
+    LspTimeoutError,
+    MessageDecoder,
+    encode_message,
+    path_to_uri,
+)
+
+
+class LspClient:
+    """JSON-RPC Language Server client over stdio."""
+
+    def __init__(
+        self,
+        command: Sequence[str],
+        workspace_root: str | Path | None = None,
+        *,
+        timeout: float = 10.0,
+    ) -> None:
+        self.command = list(command)
+        self.workspace_root = str(Path(workspace_root).resolve()) if workspace_root else os.getcwd()
+        self.timeout = timeout
+        self.process: subprocess.Popen[bytes] | None = None
+        self._next_id = 1
+        self._lock = threading.Lock()
+        self._pending: dict[int, concurrent.futures.Future[dict[str, Any]]] = {}
+        self._reader_thread: threading.Thread | None = None
+        self._stopped = threading.Event()
+        self.server_capabilities: dict[str, Any] = {}
+
+    def start(self) -> None:
+        """Start language server child process and communication threads."""
+        if self.process is not None:
+            return
+        try:
+            self.process = subprocess.Popen(
+                self.command,
+                cwd=self.workspace_root,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.DEVNULL,
+            )
+        except OSError as e:
+            raise LspConnectionError(f"Failed to spawn LSP server {self.command!r}: {e}") from e
+
+        self._stopped.clear()
+        self._reader_thread = threading.Thread(target=self._read_loop, daemon=True)
+        self._reader_thread.start()
+
+    def _read_loop(self) -> None:
+        assert self.process is not None and self.process.stdout is not None
+        decoder = MessageDecoder()
+        read_fn = getattr(self.process.stdout, "read1", self.process.stdout.read)
+        try:
+            while not self._stopped.is_set():
+                chunk = read_fn(4096)
+                if not chunk:
+                    break
+                messages = decoder.push(chunk)
+                for msg in messages:
+                    self._handle_incoming(msg)
+        except (OSError, ValueError):
+            pass
+        finally:
+            self._fail_all_pending("LSP server connection closed")
+
+    def _handle_incoming(self, message: dict[str, Any]) -> None:
+        if "id" in message and message["id"] is not None:
+            msg_id = message["id"]
+            with self._lock:
+                future = self._pending.pop(msg_id, None)
+            if future is not None and not future.done():
+                if "error" in message and message["error"] is not None:
+                    err = message["error"]
+                    future.set_exception(
+                        LspResponseError(
+                            code=err.get("code", -1),
+                            message=err.get("message", "Unknown LSP error"),
+                            data=err.get("data"),
+                        )
+                    )
+                else:
+                    future.set_result(message)
+
+    def _fail_all_pending(self, reason: str) -> None:
+        with self._lock:
+            pending = list(self._pending.values())
+            self._pending.clear()
+        for fut in pending:
+            if not fut.done():
+                fut.set_exception(LspConnectionError(reason))
+
+    def send_request(
+        self,
+        method: str,
+        params: dict[str, Any] | None = None,
+        *,
+        timeout: float | None = None,
+    ) -> Any:
+        """Send a JSON-RPC request and wait for the response."""
+        if self.process is None or self.process.poll() is not None:
+            raise LspConnectionError("LSP server process is not running")
+
+        with self._lock:
+            req_id = self._next_id
+            self._next_id += 1
+            future: concurrent.futures.Future[dict[str, Any]] = concurrent.futures.Future()
+            self._pending[req_id] = future
+
+        request_obj = {
+            "jsonrpc": "2.0",
+            "id": req_id,
+            "method": method,
+            "params": params if params is not None else {},
+        }
+        data = encode_message(request_obj)
+        try:
+            assert self.process.stdin is not None
+            self.process.stdin.write(data)
+            self.process.stdin.flush()
+        except OSError as e:
+            with self._lock:
+                self._pending.pop(req_id, None)
+            raise LspConnectionError(f"Failed to write to LSP server stdin: {e}") from e
+
+        effective_timeout = timeout if timeout is not None else self.timeout
+        try:
+            response = future.result(timeout=effective_timeout)
+            return response.get("result")
+        except concurrent.futures.TimeoutError as e:
+            with self._lock:
+                self._pending.pop(req_id, None)
+            raise LspTimeoutError(f"LSP request '{method}' timed out after {effective_timeout}s") from e
+
+    def send_notification(self, method: str, params: dict[str, Any] | None = None) -> None:
+        """Send a JSON-RPC notification (no response expected)."""
+        if self.process is None or self.process.poll() is not None:
+            return
+        notification = {
+            "jsonrpc": "2.0",
+            "method": method,
+            "params": params if params is not None else {},
+        }
+        data = encode_message(notification)
+        try:
+            assert self.process.stdin is not None
+            self.process.stdin.write(data)
+            self.process.stdin.flush()
+        except OSError:
+            pass
+
+    def initialize(self, workspace_root: str | Path | None = None) -> dict[str, Any]:
+        """Perform standard LSP initialize handshake."""
+        root = str(Path(workspace_root).resolve()) if workspace_root else self.workspace_root
+        root_uri = path_to_uri(root)
+        params = {
+            "processId": os.getpid(),
+            "rootUri": root_uri,
+            "rootPath": root,
+            "capabilities": {
+                "textDocument": {
+                    "definition": {"dynamicRegistration": False, "linkSupport": True},
+                    "references": {"dynamicRegistration": False},
+                    "hover": {"contentFormat": ["markdown", "plaintext"]},
+                    "documentSymbol": {"hierarchicalDocumentSymbolSupport": True},
+                },
+                "workspace": {
+                    "workspaceFolders": True,
+                },
+            },
+            "workspaceFolders": [
+                {"uri": root_uri, "name": Path(root).name}
+            ],
+        }
+        res = self.send_request("initialize", params)
+        if isinstance(res, Mapping):
+            self.server_capabilities = dict(res.get("capabilities", {}))
+        self.send_notification("initialized", {})
+        return self.server_capabilities
+
+    def did_open(
+        self,
+        file_path: str | Path,
+        language_id: str | None = None,
+        content: str | None = None,
+        version: int = 1,
+    ) -> None:
+        """Send textDocument/didOpen notification."""
+        path = Path(file_path).resolve()
+        uri = path_to_uri(path)
+        if content is None:
+            try:
+                content = path.read_text(encoding="utf-8", errors="replace")
+            except OSError:
+                content = ""
+        lang = language_id or EXTENSION_TO_LANGUAGE.get(path.suffix.lower(), "plaintext")
+        self.send_notification(
+            "textDocument/didOpen",
+            {
+                "textDocument": {
+                    "uri": uri,
+                    "languageId": lang,
+                    "version": version,
+                    "text": content,
+                }
+            },
+        )
+
+    def did_close(self, file_path: str | Path) -> None:
+        """Send textDocument/didClose notification."""
+        uri = path_to_uri(Path(file_path).resolve())
+        self.send_notification("textDocument/didClose", {"textDocument": {"uri": uri}})
+
+    def definition(self, file_path: str | Path, line: int, character: int) -> list[LspLocation]:
+        """Query textDocument/definition for symbol locations."""
+        uri = path_to_uri(Path(file_path).resolve())
+        params = {
+            "textDocument": {"uri": uri},
+            "position": {"line": line, "character": character},
+        }
+        res = self.send_request("textDocument/definition", params)
+        if res is None:
+            return []
+        if isinstance(res, Mapping):
+            return [LspLocation.from_wire(res)]
+        if isinstance(res, Sequence):
+            return [LspLocation.from_wire(item) for item in res if isinstance(item, Mapping)]
+        return []
+
+    def references(
+        self,
+        file_path: str | Path,
+        line: int,
+        character: int,
+        include_declaration: bool = True,
+    ) -> list[LspLocation]:
+        """Query textDocument/references for symbol occurrences."""
+        uri = path_to_uri(Path(file_path).resolve())
+        params = {
+            "textDocument": {"uri": uri},
+            "position": {"line": line, "character": character},
+            "context": {"includeDeclaration": include_declaration},
+        }
+        res = self.send_request("textDocument/references", params)
+        if not res or not isinstance(res, Sequence):
+            return []
+        return [LspLocation.from_wire(item) for item in res if isinstance(item, Mapping)]
+
+    def hover(self, file_path: str | Path, line: int, character: int) -> LspHoverResult | None:
+        """Query textDocument/hover for symbol type and docstring information."""
+        uri = path_to_uri(Path(file_path).resolve())
+        params = {
+            "textDocument": {"uri": uri},
+            "position": {"line": line, "character": character},
+        }
+        res = self.send_request("textDocument/hover", params)
+        return LspHoverResult.from_wire(res)
+
+    def document_symbols(self, file_path: str | Path) -> list[LspSymbol]:
+        """Query textDocument/documentSymbol for file symbol outline."""
+        uri = path_to_uri(Path(file_path).resolve())
+        params = {"textDocument": {"uri": uri}}
+        res = self.send_request("textDocument/documentSymbol", params)
+        return LspSymbol.from_wire(res, file_uri=uri)
+
+    def shutdown(self) -> None:
+        """Gracefully shut down the language server."""
+        if self.process is None or self.process.poll() is not None:
+            return
+        try:
+            self.send_request("shutdown", None, timeout=3.0)
+        except Exception:
+            pass
+        self.send_notification("exit", None)
+
+    def stop(self) -> None:
+        """Terminate process and release reader resources."""
+        self._stopped.set()
+        if self.process is not None:
+            try:
+                self.shutdown()
+            except Exception:
+                pass
+            try:
+                if self.process.poll() is None:
+                    self.process.terminate()
+                    self.process.wait(timeout=2.0)
+            except Exception:
+                try:
+                    self.process.kill()
+                except Exception:
+                    pass
+            self.process = None
+        if self._reader_thread is not None:
+            self._reader_thread.join(timeout=1.0)
+            self._reader_thread = None
+
+    def __enter__(self) -> LspClient:
+        self.start()
+        self.initialize()
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        self.stop()

local_coding_agent/lsp/_fallback.py

@@ -0,0 +1,297 @@
+"""Fallback AST & Regex Code Intelligence Engine."""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+import re
+from typing import Any
+
+from ._types import LspHoverResult, LspLocation, LspPosition, LspRange, LspSymbol, path_to_uri
+
+
+class FallbackLspEngine:
+    """Built-in code intelligence engine for offline environments & test runs."""
+
+    @staticmethod
+    def _get_word_at_pos(content: str, line: int, character: int) -> tuple[str, LspRange] | None:
+        lines = content.splitlines()
+        if line < 0 or line >= len(lines):
+            return None
+        line_text = lines[line]
+        if character < 0 or character > len(line_text):
+            return None
+
+        # Find word boundaries
+        start = character
+        while start > 0 and (line_text[start - 1].isalnum() or line_text[start - 1] == "_"):
+            start -= 1
+        end = character
+        while end < len(line_text) and (line_text[end].isalnum() or line_text[end] == "_"):
+            end += 1
+
+        if start >= end:
+            return None
+        word = line_text[start:end]
+        word_range = LspRange(LspPosition(line, start), LspPosition(line, end))
+        return word, word_range
+
+    def document_symbols(self, file_path: str | Path) -> list[LspSymbol]:
+        """Extract symbol outline using AST (for Python) or regex (for others)."""
+        path = Path(file_path).resolve()
+        if not path.is_file():
+            return []
+        try:
+            content = path.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return []
+
+        uri = path_to_uri(path)
+        if path.suffix.lower() in {".py", ".pyi"}:
+            return self._document_symbols_python(content, uri, str(path))
+        return self._document_symbols_regex(content, uri, str(path))
+
+    def _document_symbols_python(self, content: str, uri: str, file_path: str) -> list[LspSymbol]:
+        try:
+            tree = ast.parse(content)
+        except SyntaxError:
+            return self._document_symbols_regex(content, uri, file_path)
+
+        symbols: list[LspSymbol] = []
+
+        def visit_node(node: ast.AST, parent_kind: int | None = None) -> None:
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                kind = 6 if parent_kind == 5 else 12
+                kind_name = "Method" if kind == 6 else "Function"
+                start_line = max(0, getattr(node, "lineno", 1) - 1)
+                start_char = getattr(node, "col_offset", 0)
+                end_line = max(start_line, getattr(node, "end_lineno", start_line + 1) - 1)
+                end_char = getattr(node, "end_col_offset", start_char + len(node.name))
+                loc = LspLocation(
+                    uri=uri,
+                    range=LspRange(LspPosition(start_line, start_char), LspPosition(end_line, end_char)),
+                    file_path=file_path,
+                )
+                symbols.append(LspSymbol(name=node.name, kind=kind, kind_name=kind_name, location=loc))
+                for child in node.body:
+                    visit_node(child, parent_kind=kind)
+            elif isinstance(node, ast.ClassDef):
+                kind = 5
+                kind_name = "Class"
+                start_line = max(0, getattr(node, "lineno", 1) - 1)
+                start_char = getattr(node, "col_offset", 0)
+                end_line = max(start_line, getattr(node, "end_lineno", start_line + 1) - 1)
+                end_char = getattr(node, "end_col_offset", start_char + len(node.name))
+                loc = LspLocation(
+                    uri=uri,
+                    range=LspRange(LspPosition(start_line, start_char), LspPosition(end_line, end_char)),
+                    file_path=file_path,
+                )
+                symbols.append(LspSymbol(name=node.name, kind=kind, kind_name=kind_name, location=loc))
+                for child in node.body:
+                    visit_node(child, parent_kind=kind)
+            elif isinstance(node, ast.Assign):
+                for target in node.targets:
+                    if isinstance(target, ast.Name):
+                        name = target.id
+                        is_const = name.isupper()
+                        kind = 14 if is_const else 13
+                        kind_name = "Constant" if is_const else "Variable"
+                        start_line = max(0, getattr(target, "lineno", 1) - 1)
+                        start_char = getattr(target, "col_offset", 0)
+                        end_char = start_char + len(name)
+                        loc = LspLocation(
+                            uri=uri,
+                            range=LspRange(LspPosition(start_line, start_char), LspPosition(start_line, end_char)),
+                            file_path=file_path,
+                        )
+                        symbols.append(LspSymbol(name=name, kind=kind, kind_name=kind_name, location=loc))
+
+        for item in tree.body:
+            visit_node(item)
+        return symbols
+
+    def _document_symbols_regex(self, content: str, uri: str, file_path: str) -> list[LspSymbol]:
+        symbols: list[LspSymbol] = []
+        patterns = [
+            (re.compile(r"^\s*(?:async\s+)?def\s+([a-zA-Z_][a-zA-Z0-9_]*)"), 12, "Function"),
+            (re.compile(r"^\s*class\s+([a-zA-Z_][a-zA-Z0-9_]*)"), 5, "Class"),
+            (re.compile(r"^\s*(?:export\s+)?(?:async\s+)?function\s+([a-zA-Z_][a-zA-Z0-9_]*)"), 12, "Function"),
+            (re.compile(r"^\s*(?:export\s+)?(?:class|interface|type)\s+([a-zA-Z_][a-zA-Z0-9_]*)"), 5, "Class"),
+            (re.compile(r"^\s*(?:pub\s+)?fn\s+([a-zA-Z_][a-zA-Z0-9_]*)"), 12, "Function"),
+            (re.compile(r"^\s*(?:pub\s+)?(?:struct|enum|trait)\s+([a-zA-Z_][a-zA-Z0-9_]*)"), 23, "Struct"),
+            (re.compile(r"^\s*func\s+(?:\([^)]+\)\s+)?([a-zA-Z_][a-zA-Z0-9_]*)"), 12, "Function"),
+            (re.compile(r"^\s*type\s+([a-zA-Z_][a-zA-Z0-9_]*)\s+struct"), 23, "Struct"),
+        ]
+        for line_num, line_text in enumerate(content.splitlines()):
+            for pat, kind, kind_name in patterns:
+                m = pat.match(line_text)
+                if m:
+                    name = m.group(1)
+                    start_char = line_text.find(name)
+                    end_char = start_char + len(name)
+                    loc = LspLocation(
+                        uri=uri,
+                        range=LspRange(LspPosition(line_num, start_char), LspPosition(line_num, end_char)),
+                        file_path=file_path,
+                    )
+                    symbols.append(LspSymbol(name=name, kind=kind, kind_name=kind_name, location=loc))
+                    break
+        return symbols
+
+    def go_to_definition(
+        self,
+        file_path: str | Path,
+        line: int,
+        character: int,
+        workspace_root: str | Path | None = None,
+    ) -> list[LspLocation]:
+        """Navigate to symbol definition in file or workspace."""
+        path = Path(file_path).resolve()
+        if not path.is_file():
+            return []
+        try:
+            content = path.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return []
+
+        word_info = self._get_word_at_pos(content, line, character)
+        if not word_info:
+            return []
+        word, _ = word_info
+
+        # 1. Search in current file first
+        current_symbols = self.document_symbols(path)
+        for sym in current_symbols:
+            if sym.name == word:
+                return [sym.location]
+
+        # 2. Search in workspace files
+        root = Path(workspace_root).resolve() if workspace_root else path.parent
+        locations: list[LspLocation] = []
+        for file in root.rglob(f"*{path.suffix}"):
+            if file == path or not file.is_file():
+                continue
+            if any(part.startswith(".") or part in {"node_modules", "__pycache__", "venv", ".venv"} for part in file.parts):
+                continue
+            symbols = self.document_symbols(file)
+            for sym in symbols:
+                if sym.name == word:
+                    locations.append(sym.location)
+                    if len(locations) >= 5:
+                        return locations
+        return locations
+
+    def find_references(
+        self,
+        file_path: str | Path,
+        line: int,
+        character: int,
+        workspace_root: str | Path | None = None,
+        include_declaration: bool = True,
+    ) -> list[LspLocation]:
+        """Find occurrences and references of the symbol across workspace."""
+        path = Path(file_path).resolve()
+        if not path.is_file():
+            return []
+        try:
+            content = path.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return []
+
+        word_info = self._get_word_at_pos(content, line, character)
+        if not word_info:
+            return []
+        word, _ = word_info
+
+        root = Path(workspace_root).resolve() if workspace_root else path.parent
+        target_files = [path]
+        for f in root.rglob(f"*{path.suffix}"):
+            if f != path and f.is_file() and not any(part.startswith(".") or part in {"node_modules", "__pycache__", "venv", ".venv"} for part in f.parts):
+                target_files.append(f)
+
+        references: list[LspLocation] = []
+        word_regex = re.compile(rf"\b{re.escape(word)}\b")
+
+        for f in target_files:
+            try:
+                text = f.read_text(encoding="utf-8", errors="replace")
+            except OSError:
+                continue
+            file_uri = path_to_uri(f)
+            for line_idx, line_text in enumerate(text.splitlines()):
+                for match in word_regex.finditer(line_text):
+                    col_start = match.start()
+                    col_end = match.end()
+                    loc = LspLocation(
+                        uri=file_uri,
+                        range=LspRange(LspPosition(line_idx, col_start), LspPosition(line_idx, col_end)),
+                        file_path=str(f),
+                    )
+                    references.append(loc)
+                    if len(references) >= 100:
+                        return references
+        return references
+
+    def hover(
+        self,
+        file_path: str | Path,
+        line: int,
+        character: int,
+        workspace_root: str | Path | None = None,
+    ) -> LspHoverResult | None:
+        """Extract signature or docstring preview for the symbol under cursor."""
+        path = Path(file_path).resolve()
+        if not path.is_file():
+            return None
+        try:
+            content = path.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return None
+
+        word_info = self._get_word_at_pos(content, line, character)
+        if not word_info:
+            return None
+        word, word_range = word_info
+
+        # Check Python AST
+        if path.suffix.lower() in {".py", ".pyi"}:
+            try:
+                tree = ast.parse(content)
+                for node in ast.walk(tree):
+                    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.name == word:
+                        args = [a.arg for a in node.args.args]
+                        sig = f"def {node.name}({', '.join(args)})"
+                        doc = ast.get_docstring(node) or ""
+                        body = f"```python\n{sig}\n```"
+                        if doc:
+                            body += f"\n\n{doc}"
+                        return LspHoverResult(contents=body, range=word_range)
+                    elif isinstance(node, ast.ClassDef) and node.name == word:
+                        bases = [getattr(b, "id", "object") for b in node.bases if hasattr(b, "id")]
+                        sig = f"class {node.name}({', '.join(bases)})" if bases else f"class {node.name}"
+                        doc = ast.get_docstring(node) or ""
+                        body = f"```python\n{sig}\n```"
+                        if doc:
+                            body += f"\n\n{doc}"
+                        return LspHoverResult(contents=body, range=word_range)
+            except SyntaxError:
+                pass
+
+        # Regex fallback hover
+        lines = content.splitlines()
+        for idx, line_text in enumerate(lines):
+            if re.search(rf"\b(?:def|class|function|fn|func|struct)\s+{re.escape(word)}\b", line_text):
+                doc_lines = []
+                for prev_idx in range(idx - 1, max(-1, idx - 6), -1):
+                    prev = lines[prev_idx].strip()
+                    if prev.startswith(("#", "//", "/*", "*")):
+                        doc_lines.insert(0, prev)
+                    else:
+                        break
+                body = f"```\n{line_text.strip()}\n```"
+                if doc_lines:
+                    body += f"\n\n" + "\n".join(doc_lines)
+                return LspHoverResult(contents=body, range=word_range)
+
+        return LspHoverResult(contents=f"Symbol: `{word}`", range=word_range)