@aria-cli/tools 1.0.8 → 1.0.10

package/src/executors/lsp-client.ts

@@ -1,355 +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, type ChildProcess } 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",
-) as {
-  createMessageConnection: (reader: unknown, writer: unknown) => VscodeConnection;
-  StreamMessageReader: new (stream: NodeJS.ReadableStream) => unknown;
-  StreamMessageWriter: new (stream: NodeJS.WritableStream) => unknown;
-};
-
-interface VscodeConnection {
-  sendRequest(method: string, params?: unknown): Promise<unknown>;
-  sendNotification(method: string, params?: unknown): void;
-  onNotification(method: string, handler: (params: unknown) => void): void;
-  listen(): void;
-  dispose(): void;
-}
-
-// ---------------------------------------------------------------------------
-// Language server registry — same config as Claude Code LSP plugins
-// ---------------------------------------------------------------------------
-
-export interface LspServerConfig {
-  command: string;
-  args: string[];
-  extensionToLanguage: Record<string, string>;
-  startupTimeout: number;
-}
-
-export const LSP_SERVERS: Record<string, LspServerConfig> = {
-  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<string, string>();
-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: string): string | undefined {
-  const ext = filePath.slice(filePath.lastIndexOf("."));
-  return EXT_TO_SERVER.get(ext);
-}
-
-export function getLanguageId(filePath: string): string | undefined {
-  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 {
-  private process: ChildProcess | null = null;
-  private connection: VscodeConnection | null = null;
-  private initialized = false;
-  private openFiles = new Set<string>();
-  private diagnosticsReceived = new Set<string>();
-  readonly serverName: string;
-  readonly config: LspServerConfig;
-  private rootUri: string;
-
-  constructor(serverName: string, rootPath: string) {
-    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(): Promise<void> {
-    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: unknown) => {
-      const p = params as { uri?: string };
-      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(): Promise<void> {
-    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: string): Promise<void> {
-    const uri = `file://${resolve(filePath)}`;
-    if (this.openFiles.has(uri)) return;
-
-    const languageId = getLanguageId(filePath);
-    if (!languageId) return;
-
-    let text: string;
-    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: string, line: number, character: number): Promise<unknown> {
-    await this.ensureReady(filePath);
-    return this.connection!.sendRequest("textDocument/definition", {
-      textDocument: { uri: `file://${resolve(filePath)}` },
-      position: { line, character },
-    });
-  }
-
-  async references(filePath: string, line: number, character: number): Promise<unknown> {
-    await this.ensureReady(filePath);
-    return this.connection!.sendRequest("textDocument/references", {
-      textDocument: { uri: `file://${resolve(filePath)}` },
-      position: { line, character },
-      context: { includeDeclaration: true },
-    });
-  }
-
-  async hover(filePath: string, line: number, character: number): Promise<unknown> {
-    await this.ensureReady(filePath);
-    return this.connection!.sendRequest("textDocument/hover", {
-      textDocument: { uri: `file://${resolve(filePath)}` },
-      position: { line, character },
-    });
-  }
-
-  async documentSymbols(filePath: string): Promise<unknown> {
-    await this.ensureReady(filePath);
-    return this.connection!.sendRequest("textDocument/documentSymbol", {
-      textDocument: { uri: `file://${resolve(filePath)}` },
-    });
-  }
-
-  async rename(
-    filePath: string,
-    line: number,
-    character: number,
-    newName: string,
-  ): Promise<unknown> {
-    await this.ensureReady(filePath);
-    return this.connection!.sendRequest("textDocument/rename", {
-      textDocument: { uri: `file://${resolve(filePath)}` },
-      position: { line, character },
-      newName,
-    });
-  }
-
-  // --- Internals ---
-
-  private async ensureReady(filePath: string): Promise<void> {
-    if (!this.initialized) await this.start();
-    await this.openFile(filePath);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Server Pool — one server per language, shared across queries
-// ---------------------------------------------------------------------------
-
-const serverPool = new Map<string, LspServer>();
-
-export function getOrCreateServer(serverName: string, rootPath: string): LspServer {
-  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(): Promise<void> {
-  const stops = [...serverPool.values()].map((s) => s.stop());
-  await Promise.allSettled(stops);
-  serverPool.clear();
-}