@aria-cli/tools 1.0.12 → 1.0.14

package/dist/executors/lsp-client.js

@@ -1,296 +0,0 @@
-/**
- * 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();
-}