voidx 1.0.0__py3-none-any.whl

voidx/lsp/errors.py

@@ -0,0 +1,19 @@
+"""LSP error types."""
+
+from __future__ import annotations
+
+
+class LspError(Exception):
+    """Base class for LSP failures."""
+
+
+class LspConnectionError(LspError):
+    """Raised when a language server process cannot be used."""
+
+
+class LspRequestError(LspError):
+    """Raised when a server returns a JSON-RPC error response."""
+
+
+class LspServerUnavailable(LspError):
+    """Raised when no enabled server can handle a file."""

voidx/lsp/manager.py

@@ -0,0 +1,280 @@
+"""LSP server lifecycle and document operations."""
+
+from __future__ import annotations
+
+import asyncio
+import shutil
+from pathlib import Path
+from typing import Any
+
+from voidx.lsp.client import LspClient
+from voidx.lsp.config import install_hint_for, language_for_path, load_lsp_servers
+from voidx.lsp.errors import LspConnectionError, LspServerUnavailable
+from voidx.lsp.schema import (
+    LspDiagnostic,
+    LspDoctorCheck,
+    LspLocation,
+    LspRuntimeStatus,
+    LspServerConfig,
+    LspSymbol,
+    file_uri,
+    parse_document_symbols,
+    parse_locations,
+)
+from voidx.tools.base import resolve_safe
+
+
+class LspManager:
+    def __init__(self, workspace: str) -> None:
+        self.workspace = str(Path(workspace).resolve())
+        self._servers = load_lsp_servers(self.workspace)
+        self._clients: dict[str, LspClient] = {}
+        self._errors: dict[str, str] = {}
+        self._open_docs: dict[str, tuple[str, int, str]] = {}
+
+    @property
+    def servers(self) -> dict[str, LspServerConfig]:
+        return self._servers
+
+    async def stop_all(self) -> None:
+        clients = list(self._clients.values())
+        self._clients.clear()
+        self._open_docs.clear()
+        await asyncio.gather(*(client.stop() for client in clients), return_exceptions=True)
+
+    async def restart(self, language: str | None = None) -> None:
+        if language:
+            client = self._clients.pop(language, None)
+            if client is not None:
+                await client.stop()
+            self._errors.pop(language, None)
+            for uri, (doc_language, _, _) in list(self._open_docs.items()):
+                if doc_language == language:
+                    self._open_docs.pop(uri, None)
+            return
+        await self.stop_all()
+        self._errors.clear()
+        self._servers = load_lsp_servers(self.workspace)
+
+    def statuses(self) -> list[LspRuntimeStatus]:
+        result: list[LspRuntimeStatus] = []
+        for language, config in self._servers.items():
+            client = self._clients.get(language)
+            open_docs = sum(1 for doc_language, _, _ in self._open_docs.values() if doc_language == language)
+            if not config.enabled:
+                status = "disabled"
+            elif language in self._errors:
+                status = "error"
+            elif client is not None and client.connected:
+                status = "connected"
+            else:
+                status = "disconnected"
+            result.append(LspRuntimeStatus(
+                language=language,
+                command=" ".join([config.command, *config.args]).strip(),
+                status=status,
+                pid=client.pid if client is not None else None,
+                open_documents=open_docs,
+                error_message=self._errors.get(language, "") or (client.error_message if client else ""),
+            ))
+        return result
+
+    def doctor(self) -> list[LspDoctorCheck]:
+        checks: list[LspDoctorCheck] = []
+        for language, config in self._servers.items():
+            resolved = config.resolved_command or _resolve_command(config.command)
+            available = bool(resolved)
+            error = ""
+            if not config.enabled:
+                error = "Server disabled in config."
+            elif not available:
+                error = f"Command not found: {config.command}"
+            checks.append(LspDoctorCheck(
+                language=language,
+                command=" ".join([config.command, *config.args]).strip(),
+                enabled=config.enabled,
+                available=available,
+                resolved_path=resolved,
+                install_hint=install_hint_for(language) if not available else "",
+                error_message=error,
+                detected_source=config.detected_source,
+            ))
+        return checks
+
+    async def diagnostics(self, file_path: str | None = None, *, wait: float = 0.35) -> list[LspDiagnostic]:
+        if file_path:
+            client, uri = await self.open_document(file_path)
+            if wait > 0:
+                await asyncio.sleep(wait)
+            return client.diagnostics_for(uri)
+        result: list[LspDiagnostic] = []
+        for client in self._clients.values():
+            result.extend(client.all_diagnostics())
+        return result
+
+    async def document_symbols(self, file_path: str) -> list[LspSymbol]:
+        client, uri = await self.open_document(file_path)
+        value = await client.request("textDocument/documentSymbol", {
+            "textDocument": {"uri": uri},
+        })
+        return parse_document_symbols(uri, value)
+
+    async def workspace_symbols(self, query: str) -> list[LspSymbol]:
+        symbols: list[LspSymbol] = []
+        for language in self._servers:
+            try:
+                client = await self._ensure_client(language)
+            except LspServerUnavailable:
+                continue
+            value = await client.request("workspace/symbol", {"query": query})
+            symbols.extend(parse_document_symbols(file_uri(self.workspace), value))
+        return symbols
+
+    async def definition(self, file_path: str, line: int, character: int) -> list[LspLocation]:
+        client, uri = await self.open_document(file_path)
+        value = await client.request("textDocument/definition", {
+            "textDocument": {"uri": uri},
+            "position": _position(line, character),
+        })
+        return parse_locations(value)
+
+    async def references(
+        self,
+        file_path: str,
+        line: int,
+        character: int,
+        *,
+        include_declaration: bool = True,
+    ) -> list[LspLocation]:
+        client, uri = await self.open_document(file_path)
+        value = await client.request("textDocument/references", {
+            "textDocument": {"uri": uri},
+            "position": _position(line, character),
+            "context": {"includeDeclaration": include_declaration},
+        })
+        return parse_locations(value)
+
+    async def format_document(self, file_path: str) -> tuple[bool, str, str]:
+        path = self._resolve_path(file_path)
+        old_text = path.read_text(encoding="utf-8", errors="replace")
+        client, uri = await self.open_document(file_path)
+        edits = await client.request("textDocument/formatting", {
+            "textDocument": {"uri": uri},
+            "options": {"tabSize": 4, "insertSpaces": True},
+        })
+        new_text = apply_text_edits(old_text, edits if isinstance(edits, list) else [])
+        if new_text == old_text:
+            return False, old_text, old_text
+        path.write_text(new_text, encoding="utf-8")
+        await self.open_document(file_path)
+        return True, old_text, new_text
+
+    async def open_document(self, file_path: str) -> tuple[LspClient, str]:
+        path = self._resolve_path(file_path)
+        language = self._language_for(path)
+        client = await self._ensure_client(language)
+        uri = file_uri(path)
+        text = path.read_text(encoding="utf-8", errors="replace")
+        _, version, previous = self._open_docs.get(uri, (language, 0, ""))
+        if version == 0:
+            version = 1
+            await client.notify("textDocument/didOpen", {
+                "textDocument": {
+                    "uri": uri,
+                    "languageId": language,
+                    "version": version,
+                    "text": text,
+                },
+            })
+        elif previous != text:
+            version += 1
+            await client.notify("textDocument/didChange", {
+                "textDocument": {"uri": uri, "version": version},
+                "contentChanges": [{"text": text}],
+            })
+        self._open_docs[uri] = (language, version, text)
+        return client, uri
+
+    async def _ensure_client(self, language: str) -> LspClient:
+        config = self._servers.get(language)
+        if config is None or not config.enabled:
+            raise LspServerUnavailable(f"No enabled LSP server for language: {language}")
+        client = self._clients.get(language)
+        if client is not None and client.connected:
+            return client
+        self._check_command(config)
+        client = LspClient(config, cwd=self.workspace)
+        try:
+            await client.start(root_uri=file_uri(self.workspace))
+        except LspConnectionError as exc:
+            self._errors[language] = str(exc)
+            raise
+        self._errors.pop(language, None)
+        self._clients[language] = client
+        return client
+
+    def _resolve_path(self, file_path: str) -> Path:
+        path = resolve_safe(self.workspace, file_path)
+        if path is None:
+            raise LspServerUnavailable(f"Path traversal blocked: {file_path}")
+        if not path.exists():
+            raise LspServerUnavailable(f"File not found: {file_path}")
+        if path.is_dir():
+            raise LspServerUnavailable(f"Path is a directory: {file_path}")
+        return path
+
+    def _language_for(self, path: Path) -> str:
+        language = language_for_path(path, self._servers)
+        if language is None:
+            raise LspServerUnavailable(f"No LSP server configured for file type: {path.suffix or path.name}")
+        return language
+
+    def _check_command(self, config: LspServerConfig) -> None:
+        resolved = config.resolved_command or _resolve_command(config.command)
+        if resolved:
+            return
+        message = f"Command not found for {config.language} LSP: {config.command}"
+        self._errors[config.language] = message
+        raise LspServerUnavailable(message)
+
+
+def _position(line: int, character: int) -> dict[str, int]:
+    return {"line": max(line - 1, 0), "character": max(character, 0)}
+
+
+def _resolve_command(command: str) -> str:
+    path = Path(command)
+    if path.is_absolute() and path.exists():
+        return str(path)
+    resolved = shutil.which(command)
+    return resolved or ""
+
+
+def apply_text_edits(text: str, edits: list[Any]) -> str:
+    parsed: list[tuple[int, int, str]] = []
+    for edit in edits:
+        if not isinstance(edit, dict) or "range" not in edit:
+            continue
+        range_data = edit["range"]
+        if not isinstance(range_data, dict):
+            continue
+        start = range_data.get("start", {})
+        end = range_data.get("end", {})
+        if not isinstance(start, dict) or not isinstance(end, dict):
+            continue
+        start_offset = _offset_for_position(text, int(start.get("line", 0)), int(start.get("character", 0)))
+        end_offset = _offset_for_position(text, int(end.get("line", 0)), int(end.get("character", 0)))
+        parsed.append((start_offset, end_offset, str(edit.get("newText", ""))))
+    result = text
+    for start, end, new_text in sorted(parsed, key=lambda item: item[0], reverse=True):
+        result = result[:start] + new_text + result[end:]
+    return result
+
+
+def _offset_for_position(text: str, line: int, character: int) -> int:
+    lines = text.splitlines(keepends=True)
+    if line <= 0:
+        return min(character, len(lines[0]) if lines else len(text))
+    if line >= len(lines):
+        return len(text)
+    return sum(len(part) for part in lines[:line]) + min(character, len(lines[line]))

voidx/lsp/schema.py

@@ -0,0 +1,179 @@
+"""Pydantic models for Language Server Protocol data."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Literal
+from urllib.parse import unquote, urlparse
+
+from pydantic import BaseModel, Field
+
+
+LspStatus = Literal["disabled", "disconnected", "connected", "error"]
+
+
+class LspPosition(BaseModel):
+    line: int = Field(ge=0)
+    character: int = Field(ge=0)
+
+
+class LspRange(BaseModel):
+    start: LspPosition
+    end: LspPosition
+
+
+class LspLocation(BaseModel):
+    uri: str
+    path: str
+    range: LspRange | None = None
+
+
+class LspDiagnostic(BaseModel):
+    uri: str
+    path: str
+    range: LspRange
+    severity: int | None = None
+    source: str = ""
+    code: str = ""
+    message: str
+
+
+class LspSymbol(BaseModel):
+    name: str
+    kind: int | None = None
+    path: str = ""
+    range: LspRange | None = None
+    selection_range: LspRange | None = None
+    container_name: str = ""
+
+
+class LspServerConfig(BaseModel):
+    language: str
+    command: str
+    args: list[str] = Field(default_factory=list)
+    extensions: list[str] = Field(default_factory=list)
+    enabled: bool = True
+    # Set after auto-detection: actual binary path found
+    resolved_command: str = ""
+    # Human-readable source of detection, e.g. "CursorPyright (Cursor ext)"
+    detected_source: str = ""
+
+
+class LspRuntimeStatus(BaseModel):
+    language: str
+    command: str = ""
+    status: LspStatus
+    pid: int | None = None
+    open_documents: int = 0
+    error_message: str = ""
+
+
+class LspDoctorCheck(BaseModel):
+    language: str
+    command: str
+    enabled: bool = True
+    available: bool = False
+    resolved_path: str = ""
+    install_hint: str = ""
+    error_message: str = ""
+    detected_source: str = ""
+
+
+def file_uri(path: str | Path) -> str:
+    return Path(path).resolve().as_uri()
+
+
+def path_from_uri(uri: str) -> str:
+    parsed = urlparse(uri)
+    if parsed.scheme != "file":
+        return uri
+    return unquote(parsed.path)
+
+
+def parse_range(data: dict[str, Any] | None) -> LspRange | None:
+    if not isinstance(data, dict):
+        return None
+    try:
+        return LspRange.model_validate(data)
+    except ValueError:
+        return None
+
+
+def parse_location(data: dict[str, Any]) -> LspLocation | None:
+    uri = data.get("uri") or data.get("targetUri")
+    if not isinstance(uri, str):
+        return None
+    range_data = data.get("range") or data.get("targetSelectionRange") or data.get("targetRange")
+    return LspLocation(
+        uri=uri,
+        path=path_from_uri(uri),
+        range=parse_range(range_data),
+    )
+
+
+def parse_locations(value: Any) -> list[LspLocation]:
+    if value is None:
+        return []
+    items = value if isinstance(value, list) else [value]
+    result: list[LspLocation] = []
+    for item in items:
+        if isinstance(item, dict):
+            location = parse_location(item)
+            if location is not None:
+                result.append(location)
+    return result
+
+
+def parse_diagnostics(uri: str, diagnostics: Any) -> list[LspDiagnostic]:
+    if not isinstance(diagnostics, list):
+        return []
+    result: list[LspDiagnostic] = []
+    for item in diagnostics:
+        if not isinstance(item, dict) or not isinstance(item.get("message"), str):
+            continue
+        range_data = parse_range(item.get("range"))
+        if range_data is None:
+            continue
+        code = item.get("code", "")
+        result.append(LspDiagnostic(
+            uri=uri,
+            path=path_from_uri(uri),
+            range=range_data,
+            severity=item.get("severity") if isinstance(item.get("severity"), int) else None,
+            source=str(item.get("source", "")),
+            code=str(code) if code is not None else "",
+            message=item["message"],
+        ))
+    return result
+
+
+def parse_document_symbols(uri: str, value: Any) -> list[LspSymbol]:
+    if not isinstance(value, list):
+        return []
+    result: list[LspSymbol] = []
+
+    def visit(items: list[Any], container: str = "") -> None:
+        for item in items:
+            if not isinstance(item, dict) or not isinstance(item.get("name"), str):
+                continue
+            location = item.get("location")
+            symbol_uri = uri
+            range_data = item.get("range")
+            selection_range = item.get("selectionRange")
+            if isinstance(location, dict):
+                symbol_uri = location.get("uri") or uri
+                range_data = location.get("range") or range_data
+            result.append(LspSymbol(
+                name=item["name"],
+                kind=item.get("kind") if isinstance(item.get("kind"), int) else None,
+                path=path_from_uri(symbol_uri),
+                range=parse_range(range_data),
+                selection_range=parse_range(selection_range),
+                container_name=str(item.get("containerName") or container or ""),
+            ))
+            children = item.get("children")
+            if isinstance(children, list):
+                visit(children, item["name"])
+
+    visit(value)
+    return result

voidx/lsp/service.py

@@ -0,0 +1,103 @@
+"""High-level LSP operations for tools and slash commands."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from voidx.lsp.manager import LspManager
+from voidx.lsp.schema import LspDiagnostic, LspLocation, LspSymbol
+
+
+class LspService:
+    def __init__(self, manager: LspManager) -> None:
+        self._manager = manager
+
+    async def diagnostics(self, file_path: str | None = None) -> str:
+        diagnostics = await self._manager.diagnostics(file_path)
+        if not diagnostics:
+            target = file_path or "opened files"
+            return f"No LSP diagnostics for {target}."
+        return "\n".join(_format_diagnostic(item, self._manager.workspace) for item in diagnostics)
+
+    async def symbols(self, file_path: str | None = None, query: str = "") -> str:
+        if file_path:
+            symbols = await self._manager.document_symbols(file_path)
+        elif query:
+            symbols = await self._manager.workspace_symbols(query)
+        else:
+            return "Provide file_path for document symbols or query for workspace symbols."
+        if not symbols:
+            return "No LSP symbols found."
+        return "\n".join(_format_symbol(item, self._manager.workspace) for item in symbols[:200])
+
+    async def definition(self, file_path: str, line: int, character: int) -> str:
+        locations = await self._manager.definition(file_path, line, character)
+        if not locations:
+            return "No definition found."
+        return "\n".join(_format_location(item, self._manager.workspace) for item in locations)
+
+    async def references(
+        self,
+        file_path: str,
+        line: int,
+        character: int,
+        *,
+        include_declaration: bool = True,
+    ) -> str:
+        locations = await self._manager.references(
+            file_path,
+            line,
+            character,
+            include_declaration=include_declaration,
+        )
+        if not locations:
+            return "No references found."
+        return "\n".join(_format_location(item, self._manager.workspace) for item in locations[:200])
+
+
+def _format_diagnostic(diagnostic: LspDiagnostic, workspace: str) -> str:
+    level = _severity_label(diagnostic.severity)
+    loc = _format_range_location(diagnostic.path, diagnostic.range, workspace)
+    source = f" [{diagnostic.source}]" if diagnostic.source else ""
+    code = f" {diagnostic.code}" if diagnostic.code else ""
+    return f"{loc}: {level}{source}{code}: {diagnostic.message}"
+
+
+def _format_symbol(symbol: LspSymbol, workspace: str) -> str:
+    path = _rel(symbol.path, workspace) if symbol.path else ""
+    if symbol.selection_range is not None:
+        path = _format_range_location(symbol.path, symbol.selection_range, workspace)
+    name = symbol.name
+    if symbol.container_name:
+        name = f"{symbol.container_name}.{name}"
+    kind = f"kind={symbol.kind}" if symbol.kind is not None else "symbol"
+    return f"{path}: {name} ({kind})" if path else f"{name} ({kind})"
+
+
+def _format_location(location: LspLocation, workspace: str) -> str:
+    if location.range is None:
+        return _rel(location.path, workspace)
+    return _format_range_location(location.path, location.range, workspace)
+
+
+def _format_range_location(path: str, range_data, workspace: str) -> str:
+    rel = _rel(path, workspace)
+    line = range_data.start.line + 1
+    character = range_data.start.character
+    return f"{rel}:{line}:{character}"
+
+
+def _rel(path: str, workspace: str) -> str:
+    try:
+        return str(Path(path).resolve().relative_to(Path(workspace).resolve())).replace("\\", "/")
+    except ValueError:
+        return path
+
+
+def _severity_label(severity: int | None) -> str:
+    return {
+        1: "error",
+        2: "warning",
+        3: "info",
+        4: "hint",
+    }.get(severity, "diagnostic")