@aria-cli/tools 1.0.19 → 1.0.33

package/dist/executors/lsp-client.js

@@ -0,0 +1,297 @@
+/**
+ * Native LSP Client — uses vscode-jsonrpc for proper message framing.
+ *
+ * Same approach as Claude Code: createMessageConnection over stdio.
+ * Same configuration as Claude Code's LSP plugins.
+ * Supports: TypeScript, Python, Go, Rust, C/C++, Swift, Java, Kotlin, Lua, PHP, Ruby, C#.
+ */
+import { spawn } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+// vscode-jsonrpc: same library Claude Code uses for LSP message framing.
+// Direct import via createRequire (package lacks ESM exports field).
+const require_ = createRequire(fileURLToPath(import.meta.url));
+const { createMessageConnection, StreamMessageReader, StreamMessageWriter } = require_("vscode-jsonrpc/node");
+export const LSP_SERVERS = {
+    typescript: {
+        command: "typescript-language-server",
+        args: ["--stdio"],
+        extensionToLanguage: {
+            ".ts": "typescript",
+            ".tsx": "typescriptreact",
+            ".js": "javascript",
+            ".jsx": "javascriptreact",
+            ".mts": "typescript",
+            ".cts": "typescript",
+            ".mjs": "javascript",
+            ".cjs": "javascript",
+        },
+        startupTimeout: 30_000,
+    },
+    python: {
+        command: "pyright-langserver",
+        args: ["--stdio"],
+        extensionToLanguage: { ".py": "python", ".pyi": "python" },
+        startupTimeout: 60_000,
+    },
+    go: {
+        command: "gopls",
+        args: [],
+        extensionToLanguage: { ".go": "go" },
+        startupTimeout: 30_000,
+    },
+    rust: {
+        command: "rust-analyzer",
+        args: [],
+        extensionToLanguage: { ".rs": "rust" },
+        startupTimeout: 60_000,
+    },
+    "c/cpp": {
+        command: "clangd",
+        args: ["--background-index"],
+        extensionToLanguage: {
+            ".c": "c",
+            ".h": "c",
+            ".cpp": "cpp",
+            ".cc": "cpp",
+            ".cxx": "cpp",
+            ".hpp": "cpp",
+            ".hxx": "cpp",
+        },
+        startupTimeout: 30_000,
+    },
+    swift: {
+        command: "sourcekit-lsp",
+        args: [],
+        extensionToLanguage: { ".swift": "swift" },
+        startupTimeout: 30_000,
+    },
+    java: {
+        command: "jdtls",
+        args: [],
+        extensionToLanguage: { ".java": "java" },
+        startupTimeout: 120_000,
+    },
+    kotlin: {
+        command: "kotlin-language-server",
+        args: ["--stdio"],
+        extensionToLanguage: { ".kt": "kotlin", ".kts": "kotlin" },
+        startupTimeout: 120_000,
+    },
+    lua: {
+        command: "lua-language-server",
+        args: [],
+        extensionToLanguage: { ".lua": "lua" },
+        startupTimeout: 30_000,
+    },
+    php: {
+        command: "intelephense",
+        args: ["--stdio"],
+        extensionToLanguage: { ".php": "php" },
+        startupTimeout: 30_000,
+    },
+    ruby: {
+        command: "ruby-lsp",
+        args: [],
+        extensionToLanguage: { ".rb": "ruby", ".rake": "ruby", ".gemspec": "ruby" },
+        startupTimeout: 30_000,
+    },
+    csharp: {
+        command: "csharp-ls",
+        args: [],
+        extensionToLanguage: { ".cs": "csharp" },
+        startupTimeout: 30_000,
+    },
+};
+// Build reverse lookup: file extension → server name
+const EXT_TO_SERVER = new Map();
+for (const [serverName, config] of Object.entries(LSP_SERVERS)) {
+    for (const ext of Object.keys(config.extensionToLanguage)) {
+        EXT_TO_SERVER.set(ext, serverName);
+    }
+}
+export function getServerForFile(filePath) {
+    const ext = filePath.slice(filePath.lastIndexOf("."));
+    return EXT_TO_SERVER.get(ext);
+}
+export function getLanguageId(filePath) {
+    const ext = filePath.slice(filePath.lastIndexOf("."));
+    const serverName = EXT_TO_SERVER.get(ext);
+    if (!serverName)
+        return undefined;
+    return LSP_SERVERS[serverName]?.extensionToLanguage[ext];
+}
+// ---------------------------------------------------------------------------
+// LSP Server Instance — uses vscode-jsonrpc createMessageConnection
+// ---------------------------------------------------------------------------
+export class LspServer {
+    process = null;
+    connection = null;
+    initialized = false;
+    openFiles = new Set();
+    diagnosticsReceived = new Set();
+    serverName;
+    config;
+    rootUri;
+    constructor(serverName, rootPath) {
+        this.serverName = serverName;
+        const cfg = LSP_SERVERS[serverName];
+        if (!cfg)
+            throw new Error(`Unknown LSP server: ${serverName}`);
+        this.config = cfg;
+        this.rootUri = `file://${resolve(rootPath)}`;
+    }
+    async start() {
+        if (this.connection)
+            return;
+        this.process = spawn(this.config.command, this.config.args, {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.process.stderr?.on("data", () => {
+            // Swallow stderr — language servers are noisy
+        });
+        this.process.on("exit", () => {
+            this.connection?.dispose();
+            this.connection = null;
+            this.process = null;
+            this.initialized = false;
+            this.openFiles.clear();
+            this.diagnosticsReceived.clear();
+        });
+        // Create vscode-jsonrpc connection — handles Content-Length framing,
+        // request/response matching, notification routing. Same as Claude Code.
+        this.connection = createMessageConnection(new StreamMessageReader(this.process.stdout), new StreamMessageWriter(this.process.stdin));
+        // Listen for diagnostics notifications (signals file analysis complete)
+        this.connection.onNotification("textDocument/publishDiagnostics", (params) => {
+            const p = params;
+            if (p.uri)
+                this.diagnosticsReceived.add(p.uri);
+        });
+        this.connection.listen();
+        // Initialize handshake
+        await this.connection.sendRequest("initialize", {
+            processId: globalThis.process.pid,
+            rootUri: this.rootUri,
+            capabilities: {
+                textDocument: {
+                    definition: { dynamicRegistration: false },
+                    references: { dynamicRegistration: false },
+                    hover: { dynamicRegistration: false, contentFormat: ["plaintext", "markdown"] },
+                    documentSymbol: { dynamicRegistration: false },
+                    rename: { dynamicRegistration: false, prepareSupport: false },
+                    publishDiagnostics: { relatedInformation: true },
+                },
+                workspace: {
+                    workspaceFolders: true,
+                },
+            },
+            workspaceFolders: [{ uri: this.rootUri, name: "root" }],
+        });
+        this.connection.sendNotification("initialized", {});
+        this.initialized = true;
+    }
+    async stop() {
+        if (!this.connection)
+            return;
+        try {
+            await this.connection.sendRequest("shutdown");
+            this.connection.sendNotification("exit");
+        }
+        catch {
+            // Force kill if graceful shutdown fails
+        }
+        this.connection.dispose();
+        this.connection = null;
+        this.process?.kill("SIGTERM");
+        this.process = null;
+        this.initialized = false;
+    }
+    // Ensure a file is opened in the language server
+    async openFile(filePath) {
+        const uri = `file://${resolve(filePath)}`;
+        if (this.openFiles.has(uri))
+            return;
+        const languageId = getLanguageId(filePath);
+        if (!languageId)
+            return;
+        let text;
+        try {
+            text = readFileSync(resolve(filePath), "utf-8");
+        }
+        catch {
+            return;
+        }
+        this.connection?.sendNotification("textDocument/didOpen", {
+            textDocument: { uri, languageId, version: 1, text },
+        });
+        this.openFiles.add(uri);
+        // No wait needed. LSP servers queue requests after didOpen and respond
+        // when ready. Tested: TypeScript responds to hover in 239ms with zero
+        // wait (before diagnostics arrive). Pyright responds after its analysis.
+        // The sendRequest in the caller will block until the server responds.
+    }
+    // --- LSP Operations ---
+    async definition(filePath, line, character) {
+        await this.ensureReady(filePath);
+        return this.connection.sendRequest("textDocument/definition", {
+            textDocument: { uri: `file://${resolve(filePath)}` },
+            position: { line, character },
+        });
+    }
+    async references(filePath, line, character) {
+        await this.ensureReady(filePath);
+        return this.connection.sendRequest("textDocument/references", {
+            textDocument: { uri: `file://${resolve(filePath)}` },
+            position: { line, character },
+            context: { includeDeclaration: true },
+        });
+    }
+    async hover(filePath, line, character) {
+        await this.ensureReady(filePath);
+        return this.connection.sendRequest("textDocument/hover", {
+            textDocument: { uri: `file://${resolve(filePath)}` },
+            position: { line, character },
+        });
+    }
+    async documentSymbols(filePath) {
+        await this.ensureReady(filePath);
+        return this.connection.sendRequest("textDocument/documentSymbol", {
+            textDocument: { uri: `file://${resolve(filePath)}` },
+        });
+    }
+    async rename(filePath, line, character, newName) {
+        await this.ensureReady(filePath);
+        return this.connection.sendRequest("textDocument/rename", {
+            textDocument: { uri: `file://${resolve(filePath)}` },
+            position: { line, character },
+            newName,
+        });
+    }
+    // --- Internals ---
+    async ensureReady(filePath) {
+        if (!this.initialized)
+            await this.start();
+        await this.openFile(filePath);
+    }
+}
+// ---------------------------------------------------------------------------
+// Server Pool — one server per language, shared across queries
+// ---------------------------------------------------------------------------
+const serverPool = new Map();
+export function getOrCreateServer(serverName, rootPath) {
+    const key = `${serverName}:${rootPath}`;
+    let server = serverPool.get(key);
+    if (!server) {
+        server = new LspServer(serverName, rootPath);
+        serverPool.set(key, server);
+    }
+    return server;
+}
+export async function shutdownAll() {
+    const stops = [...serverPool.values()].map((s) => s.stop());
+    await Promise.allSettled(stops);
+    serverPool.clear();
+}
+//# sourceMappingURL=lsp-client.js.map