muonroi-cli 1.2.0

package/src/lsp/manager.ts

@@ -0,0 +1,293 @@
+import { readFile } from "fs/promises";
+import path from "path";
+import { pathToFileURL } from "url";
+import { createRuntimeLspDefinitions, type RuntimeLspServerDefinition } from "./builtins";
+import { createLspClientSession, type LspClientSession } from "./client";
+import type { LspDiagnosticFile, LspQueryInput, LspToolResponse, NormalizedLspSettings } from "./types";
+
+interface ManagedClient {
+  key: string;
+  definition: RuntimeLspServerDefinition;
+  root: string;
+  client: LspClientSession;
+}
+
+interface WorkspaceLspManagerOptions {
+  createClient?: (input: {
+    serverId: string;
+    root: string;
+    definition: RuntimeLspServerDefinition;
+    settings: NormalizedLspSettings;
+  }) => Promise<LspClientSession | null>;
+}
+
+export interface WorkspaceLspManager {
+  touchFile(filePath: string, waitForDiagnostics?: boolean): Promise<LspDiagnosticFile[]>;
+  syncFile(
+    filePath: string,
+    content: string,
+    save?: boolean,
+    waitForDiagnostics?: boolean,
+  ): Promise<LspDiagnosticFile[]>;
+  query(input: LspQueryInput): Promise<LspToolResponse>;
+  close(): Promise<void>;
+}
+
+export function createWorkspaceLspManager(
+  cwd: string,
+  settings: NormalizedLspSettings,
+  options: WorkspaceLspManagerOptions = {},
+): WorkspaceLspManager {
+  const definitions = createRuntimeLspDefinitions(cwd, settings);
+  const clients = new Map<string, Promise<ManagedClient | null>>();
+
+  const createClient =
+    options.createClient ??
+    (async ({ serverId, root, definition, settings: normalizedSettings }) => {
+      const launch = await definition.resolveLaunch(root, normalizedSettings);
+      if (!launch?.command) return null;
+      return createLspClientSession({
+        serverId,
+        root,
+        launch,
+        startupTimeoutMs: normalizedSettings.startupTimeoutMs,
+        diagnosticsDebounceMs: normalizedSettings.diagnosticsDebounceMs,
+      });
+    });
+
+  async function getClientsForFile(filePath: string): Promise<ManagedClient[]> {
+    if (!settings.enabled) return [];
+
+    const normalizedPath = path.resolve(filePath);
+    const extension = path.extname(normalizedPath).toLowerCase();
+    const matches = definitions.filter((definition) => definition.extensions.includes(extension));
+    if (matches.length === 0) return [];
+
+    const resolved = await Promise.all(
+      matches.map(async (definition) => {
+        const root = await definition.resolveRoot(normalizedPath, cwd);
+        if (!root) return null;
+
+        const cacheKey = `${definition.id}:${root}`;
+        const inflight = clients.get(cacheKey);
+        if (inflight) return inflight;
+
+        const next = (async () => {
+          const client = await createClient({
+            serverId: definition.id,
+            root,
+            definition,
+            settings,
+          });
+          if (!client) return null;
+          return { key: cacheKey, definition, root, client };
+        })();
+
+        clients.set(cacheKey, next);
+        try {
+          const value = await next;
+          if (!value) {
+            clients.delete(cacheKey);
+          }
+          return value;
+        } catch (err) {
+          clients.delete(cacheKey);
+          const msg = err instanceof Error ? err.message : String(err);
+          console.error(`[lsp] Failed to start ${definition.id} for ${cacheKey}: ${msg}`);
+          return null;
+        }
+      }),
+    );
+
+    return resolved.filter((value): value is ManagedClient => value !== null);
+  }
+
+  async function touchFile(filePath: string, waitForDiagnostics = true): Promise<LspDiagnosticFile[]> {
+    const content = await readFile(filePath, "utf8");
+    return syncFile(filePath, content, false, waitForDiagnostics);
+  }
+
+  async function syncFile(
+    filePath: string,
+    content: string,
+    save = true,
+    waitForDiagnostics = true,
+  ): Promise<LspDiagnosticFile[]> {
+    const records = await getClientsForFile(filePath);
+    if (records.length === 0) return [];
+
+    const extension = path.extname(filePath).toLowerCase();
+    const diagnostics = await Promise.all(
+      records.map(async ({ key, definition, client }) => {
+        const languageId = definition.languageIds[extension] ?? (extension.slice(1) || "plaintext");
+        try {
+          await client.openOrChangeFile(filePath, languageId, content);
+          if (save) {
+            await client.saveFile(filePath);
+          }
+          if (waitForDiagnostics) {
+            await client.waitForDiagnostics(filePath);
+          }
+          return {
+            filePath,
+            serverId: client.serverId,
+            diagnostics: client.getDiagnostics(filePath),
+          };
+        } catch {
+          clients.delete(key);
+          return null;
+        }
+      }),
+    );
+
+    return diagnostics.filter((entry): entry is LspDiagnosticFile => entry !== null && entry.diagnostics.length > 0);
+  }
+
+  async function query(input: LspQueryInput): Promise<LspToolResponse> {
+    const normalizedPath = path.resolve(cwd, input.filePath);
+    const records = await getClientsForFile(normalizedPath);
+    if (records.length === 0) {
+      return {
+        success: false,
+        output: `No LSP server available for ${path.extname(normalizedPath) || "this file type"}.`,
+      };
+    }
+
+    const lspDiagnostics = await touchFile(normalizedPath, true);
+    const params = createOperationParams(input, normalizedPath);
+    const results = (
+      await Promise.all(
+        records.map(async ({ key, client }) => {
+          if (input.operation === "incomingCalls" || input.operation === "outgoingCalls") {
+            try {
+              const items = await client.sendRequest<unknown[]>("textDocument/prepareCallHierarchy", params);
+              const firstItem = Array.isArray(items) ? items[0] : undefined;
+              if (!firstItem) return [];
+              return client.sendRequest<unknown[]>(
+                input.operation === "incomingCalls" ? "callHierarchy/incomingCalls" : "callHierarchy/outgoingCalls",
+                { item: firstItem },
+              );
+            } catch {
+              clients.delete(key);
+              return [];
+            }
+          }
+
+          try {
+            return await client.sendRequest<unknown>(getOperationMethod(input.operation), params);
+          } catch {
+            clients.delete(key);
+            return [];
+          }
+        }),
+      )
+    )
+      .flatMap((result) => (Array.isArray(result) ? result : result ? [result] : []))
+      .filter(Boolean);
+
+    const output = results.length > 0 ? JSON.stringify(results, null, 2) : `No results found for ${input.operation}.`;
+    return {
+      success: true,
+      output,
+      lspDiagnostics,
+    };
+  }
+
+  async function close(): Promise<void> {
+    const entries = await Promise.allSettled([...clients.values()]);
+    const active = entries
+      .filter((entry): entry is PromiseFulfilledResult<ManagedClient | null> => entry.status === "fulfilled")
+      .map((entry) => entry.value)
+      .filter((value): value is ManagedClient => value !== null);
+    await Promise.allSettled(active.map((entry) => entry.client.stop()));
+    clients.clear();
+  }
+
+  return {
+    touchFile,
+    syncFile,
+    query,
+    close,
+  };
+}
+
+function getOperationMethod(operation: LspQueryInput["operation"]): string {
+  switch (operation) {
+    case "goToDefinition":
+      return "textDocument/definition";
+    case "findReferences":
+      return "textDocument/references";
+    case "hover":
+      return "textDocument/hover";
+    case "documentSymbol":
+      return "textDocument/documentSymbol";
+    case "workspaceSymbol":
+      return "workspace/symbol";
+    case "goToImplementation":
+      return "textDocument/implementation";
+    case "prepareCallHierarchy":
+      return "textDocument/prepareCallHierarchy";
+    case "incomingCalls":
+    case "outgoingCalls":
+      return "textDocument/prepareCallHierarchy";
+  }
+}
+
+function createOperationParams(input: LspQueryInput, absolutePath: string): Record<string, unknown> {
+  const uri = pathToFileURL(absolutePath).href;
+  const position = {
+    line: (input.line ?? 1) - 1,
+    character: (input.character ?? 1) - 1,
+  };
+
+  switch (input.operation) {
+    case "goToDefinition":
+    case "hover":
+    case "goToImplementation":
+    case "prepareCallHierarchy":
+    case "incomingCalls":
+    case "outgoingCalls":
+      return {
+        textDocument: { uri },
+        position,
+      };
+    case "findReferences":
+      return {
+        textDocument: { uri },
+        position,
+        context: { includeDeclaration: true },
+      };
+    case "documentSymbol":
+      return {
+        textDocument: { uri },
+      };
+    case "workspaceSymbol":
+      return {
+        query: input.query ?? "",
+      };
+  }
+}
+
+export function summarizeLspDiagnostics(diagnostics: LspDiagnosticFile[]): string | null {
+  const counts = diagnostics
+    .flatMap((entry) => entry.diagnostics)
+    .reduce(
+      (acc, diagnostic) => {
+        const severity = diagnostic.severity ?? 1;
+        if (severity === 1) acc.errors += 1;
+        else if (severity === 2) acc.warnings += 1;
+        else acc.infos += 1;
+        return acc;
+      },
+      { errors: 0, warnings: 0, infos: 0 },
+    );
+
+  const total = counts.errors + counts.warnings + counts.infos;
+  if (total === 0) return null;
+
+  const parts = [`${total} LSP issue${total === 1 ? "" : "s"}`];
+  if (counts.errors > 0) parts.push(`${counts.errors} error${counts.errors === 1 ? "" : "s"}`);
+  if (counts.warnings > 0) parts.push(`${counts.warnings} warning${counts.warnings === 1 ? "" : "s"}`);
+  if (counts.infos > 0) parts.push(`${counts.infos} info`);
+  return parts.join(" · ");
+}

package/src/lsp/npm-cache.test.ts

@@ -0,0 +1,68 @@
+import { mkdir, rm, writeFile } from "fs/promises";
+import os from "os";
+import path from "path";
+import { afterEach, describe, expect, it } from "vitest";
+import { lspNpmWhich } from "./npm-cache";
+
+const tempDirs: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+
+describe("lspNpmWhich", () => {
+  it("resolves a single binary from a pre-populated cache", async () => {
+    const dir = await createFakePackageCache("fake-server", { "fake-server": "lib/cli.js" });
+    const result = await lspNpmWhich("fake-server");
+
+    expect(result).toBe(path.join(dir, "node_modules", ".bin", "fake-server"));
+  });
+
+  it("resolves the correct binary from a multi-binary package", async () => {
+    const dir = await createFakePackageCache("multi-bin", {
+      "multi-bin": "lib/main.js",
+      "multi-bin-helper": "lib/helper.js",
+    });
+    const result = await lspNpmWhich("multi-bin");
+
+    expect(result).toBe(path.join(dir, "node_modules", ".bin", "multi-bin"));
+  });
+
+  it("returns null when the package cannot be installed", async () => {
+    const result = await lspNpmWhich("@nonexistent-scope/totally-fake-package-that-does-not-exist-12345");
+    expect(result).toBeNull();
+  });
+});
+
+async function createFakePackageCache(pkg: string, binEntries: Record<string, string>): Promise<string> {
+  const cacheRoot = path.join(os.homedir(), ".muonroi-cli", "cache", "lsp", pkg);
+  tempDirs.push(cacheRoot);
+
+  const binDir = path.join(cacheRoot, "node_modules", ".bin");
+  const pkgDir = path.join(cacheRoot, "node_modules", pkg);
+  await mkdir(binDir, { recursive: true });
+  await mkdir(pkgDir, { recursive: true });
+
+  for (const [name, target] of Object.entries(binEntries)) {
+    const targetPath = path.join(pkgDir, target);
+    await mkdir(path.dirname(targetPath), { recursive: true });
+    await writeFile(targetPath, "#!/usr/bin/env node\n", { mode: 0o755 });
+
+    const linkPath = path.join(binDir, name);
+    const { symlink } = await import("fs/promises");
+    await symlink(path.relative(binDir, targetPath), linkPath).catch(() => {
+      // Fallback: write a stub file if symlinks fail (Windows)
+      return writeFile(linkPath, `#!/bin/sh\nnode "${targetPath}" "$@"\n`, { mode: 0o755 });
+    });
+  }
+
+  await writeFile(
+    path.join(pkgDir, "package.json"),
+    JSON.stringify({
+      name: pkg,
+      bin: Object.keys(binEntries).length === 1 ? Object.values(binEntries)[0] : binEntries,
+    }),
+  );
+
+  return cacheRoot;
+}

package/src/lsp/npm-cache.ts

@@ -0,0 +1,108 @@
+import Arborist from "@npmcli/arborist";
+import { access, mkdir, readdir, readFile, rm } from "fs/promises";
+import os from "os";
+import path from "path";
+
+const CACHE_ROOT = path.join(os.homedir(), ".muonroi-cli", "cache", "lsp");
+const locks = new Map<string, Promise<unknown>>();
+
+function packageDir(pkg: string): string {
+  const sanitized =
+    process.platform === "win32"
+      ? Array.from(pkg, (ch) => (/[<>:"|?*]/.test(ch) || ch.charCodeAt(0) < 32 ? "_" : ch)).join("")
+      : pkg;
+  return path.join(CACHE_ROOT, sanitized);
+}
+
+export async function lspNpmWhich(pkg: string): Promise<string | null> {
+  const dir = packageDir(pkg);
+  const binDir = path.join(dir, "node_modules", ".bin");
+
+  const pick = async (): Promise<string | undefined> => {
+    const files = await readdir(binDir).catch(() => []);
+    if (files.length === 0) return undefined;
+    if (files.length === 1) return files[0];
+
+    const pkgJsonPath = path.join(dir, "node_modules", pkg, "package.json");
+    const pkgJson = await readJsonSafe<{ bin?: string | Record<string, string> }>(pkgJsonPath);
+    if (pkgJson?.bin) {
+      const unscoped = pkg.startsWith("@") ? pkg.split("/")[1]! : pkg;
+      const bin = pkgJson.bin;
+      if (typeof bin === "string") return unscoped;
+      const keys = Object.keys(bin);
+      if (keys.length === 1) return keys[0];
+      return bin[unscoped] ? unscoped : keys[0];
+    }
+    return files[0];
+  };
+
+  const bin = await pick();
+  if (bin) return path.join(binDir, bin);
+
+  try {
+    await rm(path.join(dir, "package-lock.json"), { force: true });
+    await lspNpmAdd(pkg);
+  } catch {
+    return null;
+  }
+  const resolved = await pick();
+  if (!resolved) return null;
+  return path.join(binDir, resolved);
+}
+
+export async function lspNpmAdd(pkg: string): Promise<string> {
+  return withPackageLock(pkg, async () => {
+    const dir = packageDir(pkg);
+    await mkdir(dir, { recursive: true });
+
+    const arborist = new Arborist({
+      path: dir,
+      binLinks: true,
+      progress: false,
+      savePrefix: "",
+      ignoreScripts: true,
+    } as ConstructorParameters<typeof Arborist>[0]);
+
+    const tree = await arborist.loadVirtual().catch(() => undefined);
+    if (tree) {
+      const first = tree.edgesOut.values().next().value?.to;
+      if (first?.path) return first.path as string;
+    }
+
+    const result = await arborist.reify({
+      add: [pkg],
+      save: true,
+      saveType: "prod" as const,
+    });
+
+    const first = result.edgesOut.values().next().value?.to;
+    if (!first?.path) throw new Error(`Failed to install ${pkg}`);
+    return first.path as string;
+  });
+}
+
+async function readJsonSafe<T>(filePath: string): Promise<T | undefined> {
+  try {
+    await access(filePath);
+    const raw = await readFile(filePath, "utf8");
+    return JSON.parse(raw) as T;
+  } catch {
+    return undefined;
+  }
+}
+
+async function withPackageLock<T>(pkg: string, fn: () => Promise<T>): Promise<T> {
+  const key = `lsp-install:${pkg}`;
+  while (locks.has(key)) {
+    await locks.get(key)!.catch(() => {});
+  }
+  const task = fn();
+  locks.set(key, task);
+  try {
+    return await task;
+  } finally {
+    if (locks.get(key) === task) {
+      locks.delete(key);
+    }
+  }
+}

package/src/lsp/runtime.ts

@@ -0,0 +1,70 @@
+import { existsSync } from "fs";
+import path from "path";
+import { getCurrentLspSettings } from "../utils/settings";
+import { createWorkspaceLspManager, summarizeLspDiagnostics, type WorkspaceLspManager } from "./manager";
+import type { LspDiagnosticFile, LspQueryInput, LspToolResponse } from "./types";
+
+const managers = new Map<string, WorkspaceLspManager>();
+
+export async function queryLsp(cwd: string, input: LspQueryInput): Promise<LspToolResponse> {
+  const manager = getOrCreateManager(cwd);
+  return manager.query({
+    ...input,
+    filePath: path.isAbsolute(input.filePath) ? input.filePath : path.resolve(cwd, input.filePath),
+  });
+}
+
+export async function syncFileWithLsp(
+  cwd: string,
+  filePath: string,
+  content: string,
+  save = true,
+  waitForDiagnostics = true,
+): Promise<LspDiagnosticFile[]> {
+  const manager = getOrCreateManager(cwd);
+  return manager.syncFile(
+    path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath),
+    content,
+    save,
+    waitForDiagnostics,
+  );
+}
+
+export function isLspToolEnabled(_cwd: string): boolean {
+  const settings = getCurrentLspSettings();
+  return settings.enabled && settings.tool;
+}
+
+export function summarizeDiagnostics(diagnostics: LspDiagnosticFile[]): string | null {
+  return summarizeLspDiagnostics(diagnostics);
+}
+
+export async function shutdownWorkspaceLspManager(cwd: string): Promise<void> {
+  const key = resolveManagerKey(cwd);
+  const manager = managers.get(key);
+  if (!manager) return;
+  managers.delete(key);
+  await manager.close();
+}
+
+function getOrCreateManager(cwd: string): WorkspaceLspManager {
+  const key = resolveManagerKey(cwd);
+  const existing = managers.get(key);
+  if (existing) return existing;
+
+  const manager = createWorkspaceLspManager(key, getCurrentLspSettings());
+  managers.set(key, manager);
+  return manager;
+}
+
+function resolveManagerKey(cwd: string): string {
+  let current = path.resolve(cwd);
+  while (true) {
+    if (existsSync(path.join(current, ".muonroi-cli")) || existsSync(path.join(current, ".git"))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) return current;
+    current = parent;
+  }
+}

package/src/lsp/smoke.test.ts

@@ -0,0 +1,72 @@
+import { execSync } from "child_process";
+import { mkdirSync, rmSync, writeFileSync } from "fs";
+import os from "os";
+import path from "path";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { createLspClientSession } from "./client.js";
+
+let tsServerAvailable = false;
+let tmpDir = "";
+
+beforeAll(() => {
+  // Check if typescript-language-server AND typescript are both available
+  try {
+    execSync("bunx typescript-language-server --version", { timeout: 5000, stdio: "pipe" });
+    execSync("bunx tsc --version", { timeout: 5000, stdio: "pipe" });
+    tsServerAvailable = true;
+  } catch {
+    tsServerAvailable = false;
+  }
+
+  // Create temp directory with a minimal TypeScript project
+  tmpDir = path.join(os.tmpdir(), `lsp-smoke-${Date.now()}`);
+  mkdirSync(tmpDir, { recursive: true });
+
+  writeFileSync(
+    path.join(tmpDir, "tsconfig.json"),
+    JSON.stringify({ compilerOptions: { strict: true } }, null, 2),
+    "utf8",
+  );
+
+  writeFileSync(path.join(tmpDir, "test.ts"), "const x: number = 1;\n", "utf8");
+});
+
+afterAll(() => {
+  try {
+    rmSync(tmpDir, { recursive: true, force: true });
+  } catch {
+    // Best-effort cleanup
+  }
+});
+
+describe("LSP smoke test — createLspClientSession", () => {
+  it.skipIf(!tsServerAvailable || !!process.env.CI)(
+    "initializes LSP session with typescript-language-server", { timeout: 30000 }, async () => {
+
+    const session = await createLspClientSession({
+      serverId: "ts-smoke",
+      root: tmpDir,
+      launch: { command: "bunx", args: ["typescript-language-server", "--stdio"] },
+      startupTimeoutMs: 15000,
+      diagnosticsDebounceMs: 500,
+    });
+
+    expect(session.serverId).toBe("ts-smoke");
+
+    await session.openOrChangeFile(path.join(tmpDir, "test.ts"), "typescript", "const x: number = 1;");
+
+    await session.stop();
+  });
+
+  it("createLspClientSession rejects for non-existent command", { timeout: 10000 }, async () => {
+    await expect(
+      createLspClientSession({
+        serverId: "bad",
+        root: os.tmpdir(),
+        launch: { command: "nonexistent-lsp-binary-xyz" },
+        startupTimeoutMs: 2000,
+        diagnosticsDebounceMs: 500,
+      }),
+    ).rejects.toThrow();
+  });
+});