@wasm-idle/lsp 1.0.0-next.0

package/dist/python/package/wasm_idle_python_lsp/server.py

@@ -0,0 +1,480 @@
+from __future__ import annotations
+
+import ast
+import json
+from pathlib import Path
+from urllib.parse import unquote, urlparse
+
+try:
+    from jedi import Project, Script
+except Exception:
+    Project = None
+    Script = None
+
+from wasm_idle_lsp_bridge import emit
+
+SERVER_NAME = "wasm-idle-python-lsp"
+SERVER_VERSION = "0.2.0"
+WORKSPACE_ROOT = "/workspace"
+
+TEXT_DOCUMENT_SYNC_FULL = 1
+DIAGNOSTIC_SEVERITY_ERROR = 1
+
+COMPLETION_ITEM_KIND = {
+    "text": 1,
+    "method": 2,
+    "function": 3,
+    "constructor": 4,
+    "field": 5,
+    "variable": 6,
+    "class": 7,
+    "interface": 8,
+    "module": 9,
+    "property": 10,
+    "unit": 11,
+    "value": 12,
+    "enum": 13,
+    "keyword": 14,
+    "snippet": 15,
+    "color": 16,
+    "file": 17,
+    "reference": 18,
+    "folder": 19,
+    "enumMember": 20,
+    "constant": 21,
+    "struct": 22,
+    "event": 23,
+    "operator": 24,
+    "typeParameter": 25,
+}
+
+SYMBOL_KIND = {
+    "file": 1,
+    "module": 2,
+    "namespace": 3,
+    "package": 4,
+    "class": 5,
+    "method": 6,
+    "property": 7,
+    "field": 8,
+    "constructor": 9,
+    "enum": 10,
+    "interface": 11,
+    "function": 12,
+    "variable": 13,
+    "constant": 14,
+}
+
+COMPLETION_KIND_MAP = {
+    "module": COMPLETION_ITEM_KIND["module"],
+    "class": COMPLETION_ITEM_KIND["class"],
+    "instance": COMPLETION_ITEM_KIND["variable"],
+    "function": COMPLETION_ITEM_KIND["function"],
+    "param": COMPLETION_ITEM_KIND["variable"],
+    "path": COMPLETION_ITEM_KIND["file"],
+    "keyword": COMPLETION_ITEM_KIND["keyword"],
+    "statement": COMPLETION_ITEM_KIND["keyword"],
+    "property": COMPLETION_ITEM_KIND["property"],
+}
+
+SYMBOL_KIND_MAP = {
+    "module": SYMBOL_KIND["module"],
+    "class": SYMBOL_KIND["class"],
+    "function": SYMBOL_KIND["function"],
+    "statement": SYMBOL_KIND["variable"],
+    "instance": SYMBOL_KIND["variable"],
+    "param": SYMBOL_KIND["variable"],
+}
+
+
+def _uri_to_path(uri: str) -> str:
+    if uri.startswith("file://"):
+        return unquote(urlparse(uri).path)
+
+    parsed = urlparse(uri)
+    if parsed.scheme and parsed.path:
+        return unquote(parsed.path)
+
+    return uri
+
+
+def _path_to_uri(path: Path) -> str:
+    return path.as_posix()
+
+
+class Document:
+    def __init__(
+        self,
+        uri: str,
+        source: str,
+        version: int | None = None,
+        language_id: str | None = None,
+    ) -> None:
+        self.uri = uri
+        self.source = source
+        self.version = version
+        self.language_id = language_id
+        self.path = _uri_to_path(uri)
+
+    @property
+    def lines(self) -> list[str]:
+        lines = self.source.splitlines(True)
+        return lines or [""]
+
+    def offset_at(self, position: dict) -> int:
+        line = max(int(position.get("line", 0)), 0)
+        character = max(int(position.get("character", 0)), 0)
+        lines = self.lines
+        if line >= len(lines):
+            return len(self.source)
+
+        offset = sum(len(lines[idx]) for idx in range(line))
+        return offset + min(character, len(lines[line]))
+
+    def apply_change(self, change: dict) -> None:
+        if "range" not in change or change["range"] is None:
+            self.source = change.get("text", "")
+            return
+
+        change_range = change["range"]
+        start = self.offset_at(change_range["start"])
+        end = self.offset_at(change_range["end"])
+        self.source = self.source[:start] + change.get("text", "") + self.source[end:]
+
+
+class WasmIdlePythonLsp:
+    def __init__(self) -> None:
+        self.workspace_root = WORKSPACE_ROOT
+        Path(self.workspace_root).mkdir(parents=True, exist_ok=True)
+        self.project = self._create_project(self.workspace_root)
+        self.documents: dict[str, Document] = {}
+        self.shutdown_requested = False
+
+    def handle(self, payload: str) -> None:
+        message = json.loads(payload)
+        if message.get("jsonrpc") != "2.0":
+            return
+
+        method = message.get("method")
+        if not method:
+            return
+
+        if "id" in message:
+            self._handle_request(message["id"], method, message.get("params") or {})
+        else:
+            self._handle_notification(method, message.get("params") or {})
+
+    def _emit(self, body: dict) -> None:
+        emit(json.dumps(body))
+
+    def _respond(self, msg_id, result=None, error: dict | None = None) -> None:
+        response = {"jsonrpc": "2.0", "id": msg_id}
+        if error is not None:
+            response["error"] = error
+        else:
+            response["result"] = result
+        self._emit(response)
+
+    def _notify(self, method: str, params: dict) -> None:
+        self._emit({"jsonrpc": "2.0", "method": method, "params": params})
+
+    def _refresh_project(self, root_uri: str | None) -> None:
+        if root_uri:
+            self.workspace_root = _uri_to_path(root_uri)
+
+        Path(self.workspace_root).mkdir(parents=True, exist_ok=True)
+        self.project = self._create_project(self.workspace_root)
+
+    def _create_project(self, path: str):
+        if Project is None:
+            return None
+        return Project(
+            path=path,
+            smart_sys_path=True,
+            load_unsafe_extensions=False,
+        )
+
+    def _document(self, uri: str) -> Document:
+        return self.documents[uri]
+
+    def _mirror_document(self, uri: str) -> None:
+        document = self._document(uri)
+        path = Path(document.path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(document.source, encoding="utf-8")
+
+    def _script(self, uri: str) -> Script:
+        if Script is None:
+            raise RuntimeError("Python semantic LSP features require jedi")
+        document = self._document(uri)
+        return Script(code=document.source, path=document.path, project=self.project)
+
+    def _range_for_name(self, name) -> dict | None:
+        if name.line is None or name.column is None:
+            return None
+
+        return {
+            "start": {"line": name.line - 1, "character": name.column},
+            "end": {"line": name.line - 1, "character": name.column + len(name.name)},
+        }
+
+    def _location_for_name(self, name, fallback_uri: str) -> dict | None:
+        range_value = self._range_for_name(name)
+        if range_value is None:
+            return None
+
+        module_path = getattr(name, "module_path", None)
+        uri = fallback_uri
+        if module_path is not None:
+            uri = _path_to_uri(Path(module_path))
+
+        return {"uri": uri, "range": range_value}
+
+    def _completion_kind(self, name_type: str) -> int:
+        return COMPLETION_KIND_MAP.get(name_type, COMPLETION_ITEM_KIND["text"])
+
+    def _symbol_kind(self, name_type: str) -> int:
+        return SYMBOL_KIND_MAP.get(name_type, SYMBOL_KIND["variable"])
+
+    def _publish_diagnostics(self, uri: str) -> None:
+        document = self._document(uri)
+        diagnostics: list[dict] = []
+
+        try:
+            ast.parse(document.source, filename=document.path)
+        except SyntaxError as error:
+            line = max((error.lineno or 1) - 1, 0)
+            column = max((error.offset or 1) - 1, 0)
+            diagnostics.append(
+                {
+                    "range": {
+                        "start": {"line": line, "character": column},
+                        "end": {"line": line, "character": column + 1},
+                    },
+                    "severity": DIAGNOSTIC_SEVERITY_ERROR,
+                    "source": SERVER_NAME,
+                    "message": error.msg or "Syntax error",
+                }
+            )
+
+        self._notify(
+            "textDocument/publishDiagnostics",
+            {"uri": uri, "diagnostics": diagnostics},
+        )
+
+    def _hover_text(self, definitions) -> str | None:
+        chunks: list[str] = []
+        for definition in definitions:
+            description = getattr(definition, "description", "") or definition.name
+            doc = definition.docstring(raw=False).strip()
+            block = description if not doc else f"{description}\n\n{doc}"
+            if block and block not in chunks:
+                chunks.append(block)
+
+        if not chunks:
+            return None
+
+        return "\n\n---\n\n".join(chunks)
+
+    def _initialize(self, params: dict) -> dict:
+        root_uri = params.get("rootUri")
+        if not root_uri and params.get("workspaceFolders"):
+            root_uri = params["workspaceFolders"][0].get("uri")
+        self._refresh_project(root_uri)
+        capabilities = {
+            "textDocumentSync": TEXT_DOCUMENT_SYNC_FULL,
+        }
+        if Script is not None:
+            capabilities.update(
+                {
+                    "completionProvider": {
+                        "triggerCharacters": [".", "(", "[", '"', "'"],
+                        "resolveProvider": False,
+                    },
+                    "hoverProvider": True,
+                    "definitionProvider": True,
+                    "documentSymbolProvider": True,
+                    "signatureHelpProvider": {"triggerCharacters": ["(", ","]},
+                }
+            )
+        return {
+            "capabilities": capabilities,
+            "serverInfo": {"name": SERVER_NAME, "version": SERVER_VERSION},
+        }
+
+    def _shutdown(self):
+        self.shutdown_requested = True
+        return None
+
+    def _completion(self, params: dict) -> dict:
+        position = params["position"]
+        completions = self._script(params["textDocument"]["uri"]).complete(
+            line=position["line"] + 1,
+            column=position["character"],
+        )
+        items = []
+        for completion in completions:
+            item = {
+                "label": completion.name_with_symbols or completion.name,
+                "kind": self._completion_kind(completion.type),
+                "detail": completion.type,
+                "insertText": completion.complete or completion.name,
+            }
+            doc = completion.docstring(raw=False).strip()
+            if doc:
+                item["documentation"] = doc
+            items.append(item)
+        return {"isIncomplete": False, "items": items}
+
+    def _signature_help(self, params: dict) -> dict | None:
+        position = params["position"]
+        signatures = self._script(params["textDocument"]["uri"]).get_signatures(
+            line=position["line"] + 1,
+            column=position["character"],
+        )
+        if not signatures:
+            return None
+
+        items = []
+        for signature in signatures:
+            items.append(
+                {
+                    "label": signature.to_string(),
+                    "documentation": signature.docstring(raw=False).strip() or None,
+                    "parameters": [
+                        {"label": parameter.to_string()} for parameter in signature.params
+                    ],
+                }
+            )
+
+        return {"signatures": items, "activeSignature": 0, "activeParameter": 0}
+
+    def _hover(self, params: dict) -> dict | None:
+        position = params["position"]
+        definitions = self._script(params["textDocument"]["uri"]).infer(
+            line=position["line"] + 1,
+            column=position["character"],
+        )
+        hover_text = self._hover_text(definitions)
+        if not hover_text:
+            return None
+        return {"contents": {"kind": "markdown", "value": hover_text}}
+
+    def _definition(self, params: dict) -> list[dict] | None:
+        position = params["position"]
+        definitions = self._script(params["textDocument"]["uri"]).goto(
+            line=position["line"] + 1,
+            column=position["character"],
+            follow_imports=True,
+            follow_builtin_imports=True,
+        )
+        locations = [
+            location
+            for location in (
+                self._location_for_name(definition, params["textDocument"]["uri"])
+                for definition in definitions
+            )
+            if location is not None
+        ]
+        return locations or None
+
+    def _document_symbols(self, params: dict) -> list[dict]:
+        names = self._script(params["textDocument"]["uri"]).get_names(
+            all_scopes=True,
+            definitions=True,
+            references=False,
+        )
+        symbols = []
+        for name in names:
+            location = self._location_for_name(name, params["textDocument"]["uri"])
+            if location is None:
+                continue
+            symbols.append(
+                {
+                    "name": name.name,
+                    "kind": self._symbol_kind(name.type),
+                    "location": location,
+                    "containerName": getattr(name, "full_name", None) or name.name,
+                }
+            )
+        return symbols
+
+    def _handle_request(self, msg_id, method: str, params: dict) -> None:
+        try:
+            handlers = {
+                "initialize": self._initialize,
+                "shutdown": self._shutdown,
+            }
+            if Script is not None:
+                handlers.update(
+                    {
+                        "textDocument/completion": self._completion,
+                        "textDocument/signatureHelp": self._signature_help,
+                        "textDocument/hover": self._hover,
+                        "textDocument/definition": self._definition,
+                        "textDocument/documentSymbol": self._document_symbols,
+                    }
+                )
+            handler = handlers.get(method)
+            if handler is None:
+                self._respond(
+                    msg_id,
+                    error={"code": -32601, "message": f"Method not found: {method}"},
+                )
+                return
+            self._respond(msg_id, result=handler(params))
+        except Exception as error:
+            self._respond(
+                msg_id,
+                error={"code": -32603, "message": str(error) or "Internal server error"},
+            )
+
+    def _handle_notification(self, method: str, params: dict) -> None:
+        try:
+            if method == "initialized":
+                return
+            if method == "exit":
+                self.shutdown_requested = True
+                return
+            if method == "textDocument/didOpen":
+                text_document = params["textDocument"]
+                self.documents[text_document["uri"]] = Document(
+                    uri=text_document["uri"],
+                    source=text_document.get("text", ""),
+                    version=text_document.get("version"),
+                    language_id=text_document.get("languageId"),
+                )
+                self._mirror_document(text_document["uri"])
+                self._publish_diagnostics(text_document["uri"])
+                return
+            if method == "textDocument/didChange":
+                text_document = params["textDocument"]
+                document = self._document(text_document["uri"])
+                for change in params.get("contentChanges", []):
+                    document.apply_change(change)
+                document.version = text_document.get("version")
+                self._mirror_document(text_document["uri"])
+                self._publish_diagnostics(text_document["uri"])
+                return
+            if method == "textDocument/didSave":
+                text_document = params["textDocument"]
+                document = self._document(text_document["uri"])
+                if "text" in params and params["text"] is not None:
+                    document.source = params["text"]
+                self._mirror_document(text_document["uri"])
+                self._publish_diagnostics(text_document["uri"])
+                return
+            if method == "textDocument/didClose":
+                text_document = params["textDocument"]
+                self.documents.pop(text_document["uri"], None)
+                self._notify(
+                    "textDocument/publishDiagnostics",
+                    {"uri": text_document["uri"], "diagnostics": []},
+                )
+        except Exception:
+            return
+
+
+def create_bridge():
+    server = WasmIdlePythonLsp()
+    return server.handle

package/dist/python/protocol.d.ts

@@ -0,0 +1,28 @@
+export type PythonLspStatus = {
+    state: 'disabled';
+} | {
+    state: 'loading';
+    stage?: string;
+    loaded?: number;
+    total?: number;
+} | {
+    state: 'ready';
+} | {
+    state: 'error';
+    message: string;
+};
+export interface PythonLspWorkerInitMessage {
+    type: 'init';
+    pyodideBaseUrl: string;
+}
+export type PythonLspWorkerInboundMessage = PythonLspWorkerInitMessage | Record<string, unknown>;
+export type PythonLspWorkerOutboundMessage = {
+    type: 'progress';
+    stage: string;
+} | {
+    type: 'ready';
+} | {
+    type: 'error';
+    error: string;
+};
+//# sourceMappingURL=protocol.d.ts.map

package/dist/python/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../src/python/protocol.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GACxB;IAAE,KAAK,EAAE,UAAU,CAAA;CAAE,GACrB;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GACrE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAClB;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvC,MAAM,WAAW,0BAA0B;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,MAAM,6BAA6B,GAAG,0BAA0B,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEjG,MAAM,MAAM,8BAA8B,GACvC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACnC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/dist/python/protocol.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=protocol.js.map

package/dist/python/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../src/python/protocol.ts"],"names":[],"mappings":""}

package/dist/python/server.d.ts

@@ -0,0 +1,10 @@
+import type { EditorLanguageServerHandle, EditorLanguageServerOptions, EditorLanguageServerRuntimeOptions } from '../types.js';
+import type { PythonLspStatus } from './protocol.js';
+export interface PythonLanguageServerOptions extends EditorLanguageServerRuntimeOptions {
+    createWorker?: () => Worker;
+    currentUrl?: string;
+    onStatus?: (status: PythonLspStatus) => void;
+}
+export declare function createPythonLanguageServer(options?: EditorLanguageServerOptions | PythonLanguageServerOptions): Promise<EditorLanguageServerHandle>;
+export declare const getPythonLanguageServer: typeof createPythonLanguageServer;
+//# sourceMappingURL=server.d.ts.map

package/dist/python/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/python/server.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACX,0BAA0B,EAC1B,2BAA2B,EAC3B,kCAAkC,EAClC,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAAE,eAAe,EAAkC,MAAM,eAAe,CAAC;AAErF,MAAM,WAAW,2BAA4B,SAAQ,kCAAkC;IACtF,YAAY,CAAC,EAAE,MAAM,MAAM,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;CAC7C;AA6DD,wBAAsB,0BAA0B,CAC/C,OAAO,CAAC,EAAE,2BAA2B,GAAG,2BAA2B,GACjE,OAAO,CAAC,0BAA0B,CAAC,CAuBrC;AAED,eAAO,MAAM,uBAAuB,mCAA6B,CAAC"}

package/dist/python/server.js

@@ -0,0 +1,69 @@
+import { BrowserMessageReader, BrowserMessageWriter } from '../jsonrpc.js';
+import { resolvePythonLanguageServerBaseUrl } from '../runtime.js';
+import { createLanguageServerProgressReporter } from '../worker-client.js';
+const currentUrl = () => globalThis.location?.href || '';
+const createDefaultPythonLspWorker = () => new Worker(new URL('./worker.js', import.meta.url), { type: 'module' });
+function isPythonLanguageServerOptions(options) {
+    return typeof options === 'object' && !!options;
+}
+async function createServer(pyodideBaseUrl, createWorker, onStatus) {
+    const status = createLanguageServerProgressReporter(onStatus);
+    status.loading();
+    let resolveReady = () => { };
+    let rejectReady = (_error) => { };
+    const ready = new Promise((resolve, reject) => {
+        resolveReady = resolve;
+        rejectReady = reject;
+    });
+    const worker = createWorker();
+    const cleanup = () => {
+        worker.removeEventListener('message', readyListener);
+        worker.removeEventListener('error', errorListener);
+    };
+    const readyListener = (event) => {
+        switch (event.data?.type) {
+            case 'progress': {
+                status.progress({ stage: event.data.stage });
+                break;
+            }
+            case 'ready': {
+                cleanup();
+                status.ready();
+                resolveReady();
+                break;
+            }
+            case 'error': {
+                cleanup();
+                rejectReady(new Error(event.data?.error || 'Python LSP failed to initialize'));
+                break;
+            }
+        }
+    };
+    const errorListener = (event) => {
+        cleanup();
+        rejectReady(event.error || new Error(event.message || 'Python LSP worker failed'));
+    };
+    worker.addEventListener('message', readyListener);
+    worker.addEventListener('error', errorListener);
+    worker.postMessage({ type: 'init', pyodideBaseUrl });
+    await ready;
+    return worker;
+}
+export async function createPythonLanguageServer(options) {
+    const hostOptions = isPythonLanguageServerOptions(options) ? options : undefined;
+    const pyodideBaseUrl = resolvePythonLanguageServerBaseUrl(options, hostOptions?.currentUrl ?? currentUrl());
+    const worker = await createServer(pyodideBaseUrl, hostOptions?.createWorker || createDefaultPythonLspWorker, hostOptions?.onStatus);
+    const reader = new BrowserMessageReader(worker);
+    const writer = new BrowserMessageWriter(worker);
+    return {
+        transport: { reader, writer },
+        dispose: () => {
+            worker.terminate();
+            reader.dispose();
+            writer.dispose();
+            hostOptions?.onStatus?.({ state: 'disabled' });
+        }
+    };
+}
+export const getPythonLanguageServer = createPythonLanguageServer;
+//# sourceMappingURL=server.js.map

package/dist/python/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/python/server.ts"],"names":[],"mappings":"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"}

package/dist/python/worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worker.d.ts.map

package/dist/python/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../src/python/worker.ts"],"names":[],"mappings":""}