chainlesschain 0.162.148 → 0.162.150

package/src/lib/lsp/__tests__/lsp-server-registry.test.js

@@ -0,0 +1,128 @@
+/**
+ * lsp-server-registry tests — language mapping, bin resolution (project-local
+ * wins over PATH), plugin server registration, and availability probing. FS
+ * existence is faked via `_deps.existsSync`; no real toolchain needed.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import path from "path";
+import {
+  languageIdForFile,
+  resolveServer,
+  resolveBin,
+  probeServers,
+  registerLanguageServer,
+  _resetPluginServers,
+  _deps,
+} from "../lsp-server-registry.js";
+
+let origExists;
+beforeEach(() => {
+  origExists = _deps.existsSync;
+  _resetPluginServers();
+});
+afterEach(() => {
+  _deps.existsSync = origExists;
+  _resetPluginServers();
+});
+
+/** existsSync true only for the given absolute paths (normalized separators). */
+function existsFor(paths) {
+  const set = new Set(paths.map((p) => p.replace(/\\/g, "/")));
+  _deps.existsSync = (p) => set.has(String(p).replace(/\\/g, "/"));
+}
+
+describe("languageIdForFile", () => {
+  it("maps common extensions", () => {
+    expect(languageIdForFile("a.ts")).toBe("typescript");
+    expect(languageIdForFile("a.TSX")).toBe("typescriptreact");
+    expect(languageIdForFile("a.py")).toBe("python");
+    expect(languageIdForFile("a.go")).toBe("go");
+    expect(languageIdForFile("a.rs")).toBe("rust");
+  });
+  it("returns null for unsupported extensions", () => {
+    expect(languageIdForFile("a.txt")).toBeNull();
+    expect(languageIdForFile("noext")).toBeNull();
+  });
+});
+
+describe("resolveBin", () => {
+  it("prefers project node_modules/.bin over PATH", () => {
+    const isWin = process.platform === "win32";
+    const binName = isWin
+      ? "typescript-language-server.cmd"
+      : "typescript-language-server";
+    const localBin = path.join("/proj", "node_modules", ".bin", binName);
+    existsFor([localBin]);
+    const resolved = resolveBin("typescript-language-server", "/proj");
+    expect(resolved.replace(/\\/g, "/")).toBe(localBin.replace(/\\/g, "/"));
+  });
+
+  it("returns null when nothing resolves", () => {
+    existsFor([]);
+    expect(resolveBin("nonexistent-server", "/proj")).toBeNull();
+  });
+});
+
+describe("resolveServer", () => {
+  it("resolves a TS server command with --stdio args", () => {
+    const isWin = process.platform === "win32";
+    const binName = isWin
+      ? "typescript-language-server.cmd"
+      : "typescript-language-server";
+    existsFor([path.join("/proj", "node_modules", ".bin", binName)]);
+    const s = resolveServer("typescript", "/proj");
+    expect(s).toMatchObject({
+      languageId: "typescript",
+      id: "typescript-language-server",
+      args: ["--stdio"],
+    });
+    expect(s.command).toContain("typescript-language-server");
+  });
+
+  it("returns null for a language with no installed server", () => {
+    existsFor([]);
+    expect(resolveServer("rust", "/proj")).toBeNull();
+  });
+
+  it("returns null for an unknown language", () => {
+    existsFor([]);
+    expect(resolveServer("cobol", "/proj")).toBeNull();
+  });
+});
+
+describe("plugin server registration", () => {
+  it("registers an extra language server and its extensions", () => {
+    registerLanguageServer({
+      languageId: "zig",
+      extensions: [".zig"],
+      command: "zls",
+      args: [],
+    });
+    expect(languageIdForFile("a.zig")).toBe("zig");
+    const isWin = process.platform === "win32";
+    existsFor([
+      path.join("/proj", "node_modules", ".bin", isWin ? "zls.cmd" : "zls"),
+    ]);
+    const s = resolveServer("zig", "/proj");
+    expect(s).toMatchObject({ id: "zls" });
+  });
+
+  it("rejects an incomplete registration", () => {
+    expect(() => registerLanguageServer({ languageId: "x" })).toThrow(
+      /requires/,
+    );
+  });
+});
+
+describe("probeServers", () => {
+  it("reports availability per server family", () => {
+    existsFor([]); // nothing installed
+    const rows = probeServers("/proj");
+    expect(rows.every((r) => r.available === false)).toBe(true);
+    // one row per distinct server id (TS family collapses)
+    const ids = rows.map((r) => r.id);
+    expect(new Set(ids).size).toBe(ids.length);
+    expect(ids).toContain("typescript-language-server");
+  });
+});

package/src/lib/lsp/benchmark.js

@@ -0,0 +1,257 @@
+/**
+ * LSP code-intelligence latency benchmark.
+ *
+ * Measures the two numbers the Phase 2 acceptance criteria call for on real
+ * repos: **startup latency** (cold spawn + project index + first answer) and
+ * **per-query latency** (warm def / refs / hover / diagnostics / symbols), plus
+ * best-effort server-process RSS. Pure timing/stat helpers are separated out so
+ * they are unit-testable without spawning anything.
+ *
+ * Deliberately drives the SAME `CodeIntelligence` the agent tool uses, so the
+ * numbers reflect real agent-path latency, not a synthetic micro-path.
+ */
+
+import { CodeIntelligence } from "./code-intelligence.js";
+
+/** now() in fractional milliseconds — injectable for deterministic tests. */
+export const _deps = {
+  now: () => Number(process.hrtime.bigint() / 1000n) / 1000,
+  sampleRss: sampleRssDefault,
+};
+
+/** p-th percentile (0..100) of an UNSORTED sample via linear interpolation. */
+export function percentile(samples, p) {
+  if (!samples.length) return null;
+  const sorted = [...samples].sort((a, b) => a - b);
+  if (sorted.length === 1) return sorted[0];
+  const rank = (p / 100) * (sorted.length - 1);
+  const lo = Math.floor(rank);
+  const hi = Math.ceil(rank);
+  if (lo === hi) return sorted[lo];
+  return sorted[lo] + (sorted[hi] - sorted[lo]) * (rank - lo);
+}
+
+/** Summary stats for a latency sample (all in ms), rounded to 0.1ms. */
+export function summarize(samples) {
+  if (!samples.length) return { n: 0 };
+  const round = (x) => (x == null ? null : Math.round(x * 10) / 10);
+  const sum = samples.reduce((a, b) => a + b, 0);
+  return {
+    n: samples.length,
+    min: round(Math.min(...samples)),
+    median: round(percentile(samples, 50)),
+    p95: round(percentile(samples, 95)),
+    max: round(Math.max(...samples)),
+    mean: round(sum / samples.length),
+  };
+}
+
+/**
+ * Run the benchmark. Returns a structured report; never throws for the
+ * "no server installed" case (returns { available:false, reason }).
+ *
+ * @param {object} opts
+ * @param {string} opts.projectRoot
+ * @param {string} opts.file          a real source file in the project
+ * @param {number} [opts.runs=20]     timed iterations per operation
+ * @param {number} [opts.warmup=2]    untimed warmup iterations per operation
+ * @param {(msg:string)=>void} [opts.onProgress]
+ */
+export async function runLatencyBenchmark(opts) {
+  const {
+    projectRoot,
+    file,
+    runs = 20,
+    warmup = 2,
+    onProgress = () => {},
+  } = opts;
+  const ci = new CodeIntelligence({ projectRoot, coldStart: true });
+  const report = {
+    file,
+    runs,
+    available: true,
+    coldStartMs: null,
+    probe: null,
+    ops: {},
+    server: null,
+  };
+  try {
+    // --- cold start: first query pays spawn + project index ---
+    onProgress("cold start (spawn + index + first query)…");
+    const t0 = _deps.now();
+    const first = await ci.documentSymbols(file);
+    report.coldStartMs = round1(_deps.now() - t0);
+    if (!first.available) {
+      return { available: false, reason: first.reason };
+    }
+
+    // --- choose a probe position from a real symbol (so def/refs have a target) ---
+    const probe = pickProbe(first.symbols);
+    report.probe = probe;
+
+    // best-effort server memory now that it's warm
+    report.server = await captureServerInfo(ci);
+
+    // --- timed operations (warm) ---
+    const ops = [
+      { name: "document_symbols", run: () => ci.documentSymbols(file) },
+      {
+        name: "definition",
+        run: () => ci.definition(file, probe.line, probe.col),
+        needsProbe: true,
+      },
+      {
+        name: "references",
+        run: () => ci.references(file, probe.line, probe.col),
+        needsProbe: true,
+      },
+      {
+        name: "hover",
+        run: () => ci.hover(file, probe.line, probe.col),
+        needsProbe: true,
+      },
+      {
+        name: "diagnostics",
+        run: () => ci.diagnostics(file, { timeoutMs: 4000 }),
+      },
+    ];
+
+    for (const op of ops) {
+      if (op.needsProbe && !probe) {
+        report.ops[op.name] = { skipped: "no probe symbol" };
+        continue;
+      }
+      onProgress(`${op.name} …`);
+      for (let i = 0; i < warmup; i++) await op.run();
+      const samples = [];
+      for (let i = 0; i < runs; i++) {
+        const s = _deps.now();
+        await op.run();
+        samples.push(_deps.now() - s);
+      }
+      report.ops[op.name] = summarize(samples);
+    }
+    return report;
+  } finally {
+    await ci.dispose();
+  }
+}
+
+function pickProbe(symbols) {
+  if (!Array.isArray(symbols) || !symbols.length) return null;
+  // Prefer a function/method/class — those have meaningful def/refs.
+  const preferred = symbols.find((s) =>
+    ["function", "method", "class"].includes(s.kind),
+  );
+  const s = preferred || symbols[0];
+  return { line: s.line, col: s.col, name: s.name, kind: s.kind };
+}
+
+async function captureServerInfo(ci) {
+  try {
+    const servers = ci.manager.listServers();
+    if (!servers.length) return null;
+    const s = servers[0];
+    const rssMb = s.pid != null ? await _deps.sampleRss(s.pid) : null;
+    return { serverId: s.serverId, pid: s.pid, rssMb };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Best-effort resident-set-size (MB) of the server, summed over the pid AND its
+ * descendants. This matters on Windows: a `.cmd` server is launched through
+ * `cmd.exe /c`, so the tracked pid is the launcher and the real language server
+ * (node/tsserver) is a child — measuring only the launcher reports a few MB and
+ * lies. We sum the whole subtree. Returns null if it can't be read (never throws
+ * — memory is a bonus metric, not load-bearing).
+ */
+async function sampleRssDefault(pid) {
+  const { execFileSync } = await import("child_process");
+  try {
+    if (process.platform === "win32") {
+      // One snapshot of every process → parent map → sum the subtree at `pid`.
+      const csv = execFileSync(
+        "wmic",
+        [
+          "process",
+          "get",
+          "ProcessId,ParentProcessId,WorkingSetSize",
+          "/format:csv",
+        ],
+        { encoding: "utf8", windowsHide: true, maxBuffer: 16 * 1024 * 1024 },
+      );
+      const bytes = sumSubtreeRssFromWmicCsv(csv, pid);
+      return bytes != null ? Math.round(bytes / (1024 * 1024)) : null;
+    }
+    // POSIX: not wrapped, so the pid is the real server. Sum pid + children.
+    const out = execFileSync("ps", ["-o", "pid=,ppid=,rss="], {
+      encoding: "utf8",
+    });
+    const rows = out
+      .trim()
+      .split(/\r?\n/)
+      .map((l) => l.trim().split(/\s+/).map(Number));
+    const kb = sumSubtreeRss(
+      rows.map(([p, pp, rss]) => ({ pid: p, ppid: pp, val: rss })),
+      pid,
+    );
+    return kb != null ? Math.round(kb / 1024) : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Parse `wmic ... /format:csv` output and sum WorkingSetSize over pid's subtree (bytes). */
+export function sumSubtreeRssFromWmicCsv(csv, rootPid) {
+  const lines = csv
+    .split(/\r?\n/)
+    .map((l) => l.trim())
+    .filter(Boolean);
+  const header = lines.find((l) => /ProcessId/i.test(l));
+  if (!header) return null;
+  const cols = header.split(",");
+  const iPid = cols.findIndex((c) => /^ProcessId$/i.test(c));
+  const iPpid = cols.findIndex((c) => /^ParentProcessId$/i.test(c));
+  const iRss = cols.findIndex((c) => /^WorkingSetSize$/i.test(c));
+  if (iPid < 0 || iPpid < 0 || iRss < 0) return null;
+  const rows = [];
+  for (const l of lines) {
+    if (l === header || /ProcessId/i.test(l)) continue;
+    const f = l.split(",");
+    const pid = Number(f[iPid]);
+    const ppid = Number(f[iPpid]);
+    const val = Number(f[iRss]);
+    if (Number.isFinite(pid))
+      rows.push({ pid, ppid, val: Number.isFinite(val) ? val : 0 });
+  }
+  return sumSubtreeRss(rows, rootPid);
+}
+
+/** Sum `val` over `rootPid` and all its transitive descendants. */
+export function sumSubtreeRss(rows, rootPid) {
+  const childrenOf = new Map();
+  const valOf = new Map();
+  for (const r of rows) {
+    valOf.set(r.pid, r.val);
+    if (!childrenOf.has(r.ppid)) childrenOf.set(r.ppid, []);
+    childrenOf.get(r.ppid).push(r.pid);
+  }
+  if (!valOf.has(rootPid)) return null;
+  let total = 0;
+  const seen = new Set();
+  const stack = [rootPid];
+  while (stack.length) {
+    const p = stack.pop();
+    if (seen.has(p)) continue;
+    seen.add(p);
+    total += valOf.get(p) || 0;
+    for (const c of childrenOf.get(p) || []) stack.push(c);
+  }
+  return total;
+}
+
+function round1(x) {
+  return Math.round(x * 10) / 10;
+}