muonroi-cli 1.2.0

package/src/lsp/client.ts

@@ -0,0 +1,342 @@
+import { type ChildProcessWithoutNullStreams, spawn } from "child_process";
+import { fileURLToPath, pathToFileURL } from "url";
+import {
+  createMessageConnection,
+  type MessageConnection,
+  StreamMessageReader,
+  StreamMessageWriter,
+} from "vscode-jsonrpc/node";
+import type { Diagnostic } from "vscode-languageserver-types";
+import type { LspDiagnostic, LspLaunchSpec } from "./types";
+
+export interface LspClientOptions {
+  serverId: string;
+  root: string;
+  launch: LspLaunchSpec;
+  startupTimeoutMs: number;
+  diagnosticsDebounceMs: number;
+}
+
+export interface LspClientSession {
+  readonly serverId: string;
+  readonly root: string;
+  openOrChangeFile(filePath: string, languageId: string, text: string): Promise<void>;
+  saveFile(filePath: string): Promise<void>;
+  closeFile(filePath: string): Promise<void>;
+  sendRequest<TResult>(method: string, params: unknown): Promise<TResult>;
+  waitForDiagnostics(filePath: string, timeoutMs?: number): Promise<LspDiagnostic[]>;
+  getDiagnostics(filePath: string): LspDiagnostic[];
+  stop(): Promise<void>;
+}
+
+interface DiagnosticWaiter {
+  resolve: () => void;
+  timer?: ReturnType<typeof setTimeout>;
+}
+
+export async function createLspClientSession(options: LspClientOptions): Promise<LspClientSession> {
+  const childProcess = await spawnProcess(options.launch, options.root);
+  const connection = createConnection(childProcess);
+  const versions = new Map<string, number>();
+  const diagnostics = new Map<string, LspDiagnostic[]>();
+  const waiters = new Map<string, DiagnosticWaiter[]>();
+  let stopped = false;
+
+  if (childProcess.stderr) {
+    childProcess.stderr.on("data", (data: Buffer) => {
+      const output = data.toString().trim();
+      if (output) {
+        console.error(`[lsp:${options.serverId}:stderr] ${output}`);
+      }
+    });
+  }
+
+  childProcess.on("exit", (code) => {
+    if (code !== 0 && code !== null && !stopped) {
+      console.error(`[lsp:${options.serverId}] process exited with code ${code}`);
+    }
+  });
+
+  connection.onNotification("textDocument/publishDiagnostics", (params: { uri: string; diagnostics: Diagnostic[] }) => {
+    const filePath = normalizeUriPath(params.uri);
+    diagnostics.set(filePath, params.diagnostics.map(normalizeDiagnostic));
+    const listeners = waiters.get(filePath) ?? [];
+    for (const waiter of listeners) {
+      if (waiter.timer) clearTimeout(waiter.timer);
+      waiter.timer = setTimeout(waiter.resolve, options.diagnosticsDebounceMs);
+    }
+  });
+
+  connection.onRequest("workspace/configuration", async () => [options.launch.initializationOptions ?? {}]);
+  connection.onRequest("window/workDoneProgress/create", async () => null);
+  connection.onRequest("client/registerCapability", async () => null);
+  connection.onRequest("client/unregisterCapability", async () => null);
+  connection.listen();
+
+  try {
+    await withTimeout(
+      connection.sendRequest("initialize", {
+        processId: childProcess.pid,
+        rootUri: pathToFileURL(options.root).href,
+        rootPath: options.root,
+        workspaceFolders: [
+          {
+            uri: pathToFileURL(options.root).href,
+            name: options.root.split(/[\\/]/).pop() || "workspace",
+          },
+        ],
+        initializationOptions: options.launch.initializationOptions ?? {},
+        capabilities: {
+          workspace: {
+            configuration: true,
+          },
+          textDocument: {
+            synchronization: {
+              didOpen: true,
+              didChange: true,
+              didSave: true,
+              willSave: false,
+              willSaveWaitUntil: false,
+            },
+            publishDiagnostics: {
+              relatedInformation: true,
+              versionSupport: true,
+            },
+            definition: {
+              linkSupport: true,
+            },
+            hover: {
+              contentFormat: ["markdown", "plaintext"],
+            },
+            documentSymbol: {
+              hierarchicalDocumentSymbolSupport: true,
+            },
+            callHierarchy: {
+              dynamicRegistration: false,
+            },
+          },
+          general: {
+            positionEncodings: ["utf-16"],
+          },
+        },
+      }),
+      options.startupTimeoutMs,
+      `LSP server "${options.serverId}" timed out during initialization`,
+    );
+
+    await connection.sendNotification("initialized", {});
+  } catch (error) {
+    connection.dispose();
+    try {
+      childProcess.kill("SIGTERM");
+    } catch {
+      // Already exited.
+    }
+    throw error;
+  }
+
+  return {
+    serverId: options.serverId,
+    root: options.root,
+    async openOrChangeFile(filePath, languageId, text) {
+      ensureActive(stopped, options.serverId);
+      const normalizedPath = normalizeFsPath(filePath);
+      const uri = pathToFileURL(normalizedPath).href;
+      const version = versions.get(normalizedPath);
+
+      diagnostics.delete(normalizedPath);
+
+      if (version === undefined) {
+        versions.set(normalizedPath, 0);
+        await connection.sendNotification("textDocument/didOpen", {
+          textDocument: {
+            uri,
+            languageId,
+            version: 0,
+            text,
+          },
+        });
+        return;
+      }
+
+      const nextVersion = version + 1;
+      versions.set(normalizedPath, nextVersion);
+      await connection.sendNotification("textDocument/didChange", {
+        textDocument: {
+          uri,
+          version: nextVersion,
+        },
+        contentChanges: [{ text }],
+      });
+    },
+    async saveFile(filePath) {
+      ensureActive(stopped, options.serverId);
+      const normalizedPath = normalizeFsPath(filePath);
+      if (!versions.has(normalizedPath)) return;
+      await connection.sendNotification("textDocument/didSave", {
+        textDocument: {
+          uri: pathToFileURL(normalizedPath).href,
+        },
+      });
+    },
+    async closeFile(filePath) {
+      ensureActive(stopped, options.serverId);
+      const normalizedPath = normalizeFsPath(filePath);
+      if (!versions.has(normalizedPath)) return;
+      versions.delete(normalizedPath);
+      await connection.sendNotification("textDocument/didClose", {
+        textDocument: {
+          uri: pathToFileURL(normalizedPath).href,
+        },
+      });
+    },
+    async sendRequest<_TResult>(method: string, params: unknown) {
+      ensureActive(stopped, options.serverId);
+      return connection.sendRequest(method, params);
+    },
+    async waitForDiagnostics(filePath, timeoutMs = 1_500) {
+      const normalizedPath = normalizeFsPath(filePath);
+      if (diagnostics.has(normalizedPath)) {
+        return diagnostics.get(normalizedPath) ?? [];
+      }
+
+      await new Promise<void>((resolve) => {
+        const entry: DiagnosticWaiter = {
+          resolve: () => {
+            cleanup();
+            resolve();
+          },
+        };
+        const cleanup = () => {
+          const next = (waiters.get(normalizedPath) ?? []).filter((item) => item !== entry);
+          if (next.length === 0) waiters.delete(normalizedPath);
+          else waiters.set(normalizedPath, next);
+        };
+
+        const fallback = setTimeout(() => {
+          cleanup();
+          resolve();
+        }, timeoutMs);
+
+        const originalResolve = entry.resolve;
+        entry.resolve = () => {
+          clearTimeout(fallback);
+          originalResolve();
+        };
+
+        waiters.set(normalizedPath, [...(waiters.get(normalizedPath) ?? []), entry]);
+      });
+
+      return diagnostics.get(normalizedPath) ?? [];
+    },
+    getDiagnostics(filePath) {
+      return diagnostics.get(normalizeFsPath(filePath)) ?? [];
+    },
+    async stop() {
+      if (stopped) return;
+      stopped = true;
+      try {
+        await connection.sendRequest("shutdown");
+      } catch {
+        // Some servers exit before responding to shutdown.
+      }
+      try {
+        await connection.sendNotification("exit", {});
+      } catch {
+        // Best-effort during shutdown.
+      }
+      connection.dispose();
+      try {
+        childProcess.kill("SIGTERM");
+      } catch {
+        // Process may have already exited.
+      }
+    },
+  };
+}
+
+function createConnection(process: ChildProcessWithoutNullStreams): MessageConnection {
+  return createMessageConnection(new StreamMessageReader(process.stdout), new StreamMessageWriter(process.stdin));
+}
+
+async function spawnProcess(launch: LspLaunchSpec, cwd: string): Promise<ChildProcessWithoutNullStreams> {
+  const child = spawn(launch.command, launch.args ?? [], {
+    cwd,
+    env: {
+      ...globalThis.process.env,
+      ...launch.env,
+    },
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    const cleanup = () => {
+      child.off("spawn", onSpawn);
+      child.off("error", onError);
+    };
+    const onSpawn = () => {
+      cleanup();
+      resolve();
+    };
+    const onError = (error: Error) => {
+      cleanup();
+      reject(error);
+    };
+    child.once("spawn", onSpawn);
+    child.once("error", onError);
+  });
+
+  return child;
+}
+
+function normalizeDiagnostic(input: Diagnostic): LspDiagnostic {
+  return {
+    message: input.message,
+    severity: input.severity,
+    source: input.source,
+    code: input.code !== undefined ? String(input.code) : undefined,
+    range: {
+      start: {
+        line: input.range.start.line,
+        character: input.range.start.character,
+      },
+      end: {
+        line: input.range.end.line,
+        character: input.range.end.character,
+      },
+    },
+  };
+}
+
+function normalizeUriPath(uri: string): string {
+  if (uri.startsWith("file://")) {
+    return normalizeFsPath(fileURLToPath(uri));
+  }
+  return normalizeFsPath(uri);
+}
+
+function normalizeFsPath(filePath: string): string {
+  return filePath.replace(/\\/g, "/");
+}
+
+function ensureActive(stopped: boolean, serverId: string): void {
+  if (stopped) {
+    throw new Error(`LSP client "${serverId}" is already stopped.`);
+  }
+}
+
+function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message = "Timed out"): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      },
+    );
+  });
+}

package/src/lsp/manager.test.ts

@@ -0,0 +1,164 @@
+import { mkdir, mkdtemp, rm, writeFile } from "fs/promises";
+import os from "os";
+import path from "path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { LspClientSession } from "./client";
+import { createWorkspaceLspManager } from "./manager";
+import type { NormalizedLspSettings } from "./types";
+
+const BASE_SETTINGS: NormalizedLspSettings = {
+  enabled: true,
+  tool: true,
+  autoInstall: false,
+  startupTimeoutMs: 5_000,
+  diagnosticsDebounceMs: 0,
+  builtins: {
+    typescript: {
+      enabled: false,
+    },
+  },
+  servers: [
+    {
+      id: "fake-ts",
+      command: "fake-lsp",
+      extensions: [".ts"],
+      languageIds: {
+        ".ts": "typescript",
+      },
+      rootMarkers: [".git"],
+    },
+  ],
+};
+
+const tempDirs: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+
+describe("createWorkspaceLspManager", () => {
+  it("routes queries through the matching LSP client", async () => {
+    const root = await createTempWorkspace();
+    const filePath = path.join(root, "src", "demo.ts");
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, "const demo = 1;\n");
+
+    const sendRequest = vi.fn(async (method: string, params: unknown) => {
+      expect(method).toBe("textDocument/definition");
+      expect(params).toMatchObject({
+        position: {
+          line: 4,
+          character: 2,
+        },
+      });
+      return [{ uri: "file:///demo.ts", range: { start: { line: 1, character: 0 }, end: { line: 1, character: 4 } } }];
+    });
+    const client = createFakeClient({ sendRequest });
+
+    const manager = createWorkspaceLspManager(root, BASE_SETTINGS, {
+      createClient: async () => client,
+    });
+
+    const result = await manager.query({
+      operation: "goToDefinition",
+      filePath,
+      line: 5,
+      character: 3,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("file:///demo.ts");
+    expect(client.openOrChangeFile).toHaveBeenCalledWith(filePath, "typescript", "const demo = 1;\n");
+    expect(client.waitForDiagnostics).toHaveBeenCalledWith(filePath);
+
+    await manager.close();
+    expect(client.stop).toHaveBeenCalled();
+  });
+
+  it("returns diagnostics after syncing a saved file", async () => {
+    const root = await createTempWorkspace();
+    const filePath = path.join(root, "demo.ts");
+    const diagnostics = [
+      {
+        filePath,
+        serverId: "fake-ts",
+        diagnostics: [
+          {
+            message: "Type error",
+            severity: 1,
+            range: {
+              start: { line: 0, character: 0 },
+              end: { line: 0, character: 4 },
+            },
+          },
+        ],
+      },
+    ];
+
+    const client = createFakeClient({
+      diagnostics: diagnostics[0].diagnostics,
+    });
+
+    const manager = createWorkspaceLspManager(root, BASE_SETTINGS, {
+      createClient: async () => client,
+    });
+
+    const result = await manager.syncFile(filePath, "const broken = true;\n", true, true);
+
+    expect(result).toEqual(diagnostics);
+    expect(client.saveFile).toHaveBeenCalledWith(filePath);
+    expect(client.waitForDiagnostics).toHaveBeenCalledWith(filePath);
+
+    await manager.close();
+  });
+
+  it("reports when no matching server exists", async () => {
+    const root = await createTempWorkspace();
+    const filePath = path.join(root, "demo.rb");
+    await writeFile(filePath, "puts 'hello'\n");
+
+    const manager = createWorkspaceLspManager(root, { ...BASE_SETTINGS, servers: [] });
+    const result = await manager.query({
+      operation: "hover",
+      filePath,
+      line: 1,
+      character: 1,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.output).toContain("No LSP server available");
+
+    await manager.close();
+  });
+});
+
+async function createTempWorkspace(): Promise<string> {
+  const root = await mkdtemp(path.join(os.tmpdir(), "muonroi-lsp-manager-"));
+  tempDirs.push(root);
+  await mkdir(path.join(root, ".git"), { recursive: true });
+  return root;
+}
+
+function createFakeClient(input: {
+  diagnostics?: LspClientSession["getDiagnostics"] extends (filePath: string) => infer TResult ? TResult : never;
+  sendRequest?: (method: string, params: unknown) => Promise<unknown>;
+}): LspClientSession & {
+  openOrChangeFile: ReturnType<typeof vi.fn>;
+  saveFile: ReturnType<typeof vi.fn>;
+  waitForDiagnostics: ReturnType<typeof vi.fn>;
+  stop: ReturnType<typeof vi.fn>;
+} {
+  const diagnostics = input.diagnostics ?? [];
+  return {
+    serverId: "fake-ts",
+    root: "/tmp",
+    openOrChangeFile: vi.fn(async () => {}),
+    saveFile: vi.fn(async () => {}),
+    closeFile: vi.fn(async () => {}),
+    sendRequest: (async <TResult>(method: string, params: unknown) =>
+      (input.sendRequest ? await input.sendRequest(method, params) : []) as TResult) as LspClientSession["sendRequest"],
+    waitForDiagnostics: vi.fn(async () => diagnostics),
+    getDiagnostics: vi.fn(() => diagnostics),
+    stop: vi.fn(async () => {}),
+  };
+}