chainlesschain 0.162.148 → 0.162.149

package/src/lib/lsp/__tests__/code-intelligence.integration.test.js

@@ -0,0 +1,129 @@
+/**
+ * LSP integration test — exercises the FULL stack (spawn → handshake → didOpen →
+ * query) against a REAL `typescript-language-server` if one is resolvable on
+ * PATH. When no server is installed (e.g. CI without the toolchain) the whole
+ * suite SKIPS visibly rather than passing hollowly ("不假绿" — no cosmetic green).
+ *
+ * To run it locally: `npm i -g typescript-language-server typescript` (or put a
+ * project-local one on PATH), then `npx vitest run code-intelligence.integration`.
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import os from "os";
+import fs from "fs";
+import path from "path";
+import { resolveBin } from "../lsp-server-registry.js";
+import { CodeIntelligence } from "../code-intelligence.js";
+
+const serverAvailable = Boolean(resolveBin("typescript-language-server"));
+const suite = serverAvailable ? describe : describe.skip;
+
+if (!serverAvailable) {
+  // Make the skip reason obvious in test output.
+  // eslint-disable-next-line no-console
+  console.warn(
+    "[lsp.integration] SKIP — no `typescript-language-server` on PATH. " +
+      "Install it to run real LSP integration coverage.",
+  );
+}
+
+suite("CodeIntelligence against a real typescript-language-server", () => {
+  let tmp;
+  let ci;
+
+  beforeAll(() => {
+    tmp = fs.mkdtempSync(path.join(os.tmpdir(), "cc-lsp-it-"));
+    fs.mkdirSync(path.join(tmp, "src"));
+    fs.writeFileSync(
+      path.join(tmp, "package.json"),
+      JSON.stringify({ name: "lsp-it", version: "1.0.0", private: true }),
+      "utf8",
+    );
+    fs.writeFileSync(
+      path.join(tmp, "tsconfig.json"),
+      JSON.stringify({
+        compilerOptions: {
+          strict: true,
+          target: "ES2020",
+          module: "ESNext",
+          moduleResolution: "node",
+        },
+        include: ["src"],
+      }),
+      "utf8",
+    );
+    fs.writeFileSync(
+      path.join(tmp, "src", "math.ts"),
+      "export function add(a: number, b: number): number {\n  return a + b;\n}\n",
+      "utf8",
+    );
+    fs.writeFileSync(
+      path.join(tmp, "src", "main.ts"),
+      'import { add } from "./math";\n\nconst total = add(1, 2);\nconsole.log(total);\nconst bad: number = notDeclared;\n',
+      "utf8",
+    );
+    ci = new CodeIntelligence({ projectRoot: tmp, coldStart: true });
+  });
+
+  afterAll(async () => {
+    if (ci) await ci.dispose();
+    try {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    } catch {
+      /* best effort */
+    }
+  });
+
+  it("resolves a cross-file definition", async () => {
+    // `add` usage in main.ts (line 3, col 15) → declaration in math.ts
+    const res = await ci.definition(path.join(tmp, "src", "main.ts"), 3, 15);
+    expect(res.available).toBe(true);
+    expect(res.locations.length).toBeGreaterThan(0);
+    expect(res.locations.some((l) => l.file.endsWith("math.ts"))).toBe(true);
+  }, 30000);
+
+  it("finds all references to a symbol across files", async () => {
+    // `add` declaration in math.ts (line 1, col 17)
+    const res = await ci.references(path.join(tmp, "src", "math.ts"), 1, 17);
+    expect(res.available).toBe(true);
+    // declaration + import + call site
+    expect(res.locations.length).toBeGreaterThanOrEqual(2);
+    expect(res.locations.some((l) => l.file.endsWith("main.ts"))).toBe(true);
+  }, 30000);
+
+  it("reports diagnostics for an undefined name", async () => {
+    const res = await ci.diagnostics(path.join(tmp, "src", "main.ts"), {
+      timeoutMs: 8000,
+    });
+    expect(res.available).toBe(true);
+    expect(res.diagnostics.some((d) => /notDeclared/.test(d.message))).toBe(
+      true,
+    );
+    const err = res.diagnostics.find((d) => d.severity === "error");
+    expect(err).toBeTruthy();
+  }, 30000);
+
+  it("lists document symbols", async () => {
+    const res = await ci.documentSymbols(path.join(tmp, "src", "math.ts"));
+    expect(res.available).toBe(true);
+    expect(
+      res.symbols.some((s) => s.name === "add" && s.kind === "function"),
+    ).toBe(true);
+  }, 30000);
+
+  it("previews a rename without mutating files", async () => {
+    const before = fs.readFileSync(path.join(tmp, "src", "math.ts"), "utf8");
+    const res = await ci.renamePreview(
+      path.join(tmp, "src", "math.ts"),
+      1,
+      17,
+      "sum",
+    );
+    expect(res.available).toBe(true);
+    expect(res.edits.length).toBeGreaterThan(0);
+    // preview only — the file on disk is unchanged
+    expect(fs.readFileSync(path.join(tmp, "src", "math.ts"), "utf8")).toBe(
+      before,
+    );
+  }, 30000);
+});

package/src/lib/lsp/__tests__/code-intelligence.test.js

@@ -0,0 +1,228 @@
+/**
+ * CodeIntelligence tests — result normalization + graceful degradation. Injects
+ * a fake LSPManager so no server runs; asserts that raw LSP shapes (Location vs
+ * LocationLink, DocumentSymbol vs SymbolInformation, WorkspaceEdit variants) are
+ * flattened to 1-based `{file,line,col}` and that "no server" degrades cleanly.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { CodeIntelligence, _deps } from "../code-intelligence.js";
+
+/** Fake manager: canned request results, or an "unavailable" verdict. */
+function fakeManager({ requestResult, unavailable, diagnostics } = {}) {
+  const client = {
+    request: async () => requestResult,
+    running: true,
+  };
+  return {
+    projectRoot: "/proj",
+    async ensureFor() {
+      if (unavailable) return { unavailable: true, reason: unavailable };
+      return {
+        client,
+        uri: "file:///proj/a.ts",
+        languageId: "typescript",
+        root: "/proj",
+      };
+    },
+    async didChangeFile() {
+      return this.ensureFor();
+    },
+    async waitForDiagnostics() {
+      return diagnostics || [];
+    },
+    async disposeAll() {},
+  };
+}
+
+let origRead;
+beforeEach(() => {
+  origRead = _deps.readFileSync;
+  _deps.readFileSync = () => "const foo = 1;\nfoo();\n";
+});
+afterEach(() => {
+  _deps.readFileSync = origRead;
+});
+
+describe("definition/references normalization", () => {
+  it("normalizes a plain Location to 1-based with a snippet", async () => {
+    const mgr = fakeManager({
+      requestResult: [
+        {
+          uri: "file:///proj/a.ts",
+          range: {
+            start: { line: 0, character: 6 },
+            end: { line: 0, character: 9 },
+          },
+        },
+      ],
+    });
+    const ci = new CodeIntelligence({ manager: mgr });
+    const res = await ci.definition("a.ts", 2, 1);
+    expect(res.available).toBe(true);
+    expect(res.locations[0]).toMatchObject({
+      file: expect.stringContaining("a.ts"),
+      line: 1, // 0 → 1
+      col: 7, // 6 → 7
+      endLine: 1,
+      endCol: 10,
+    });
+    expect(res.locations[0].snippet).toBe("const foo = 1;");
+  });
+
+  it("normalizes a LocationLink (targetUri/targetRange)", async () => {
+    const mgr = fakeManager({
+      requestResult: [
+        {
+          targetUri: "file:///proj/b.ts",
+          targetSelectionRange: {
+            start: { line: 4, character: 2 },
+            end: { line: 4, character: 5 },
+          },
+        },
+      ],
+    });
+    const ci = new CodeIntelligence({ manager: mgr });
+    const res = await ci.definition("a.ts", 2, 1);
+    expect(res.locations[0]).toMatchObject({ line: 5, col: 3 });
+    expect(res.locations[0].file).toContain("b.ts");
+  });
+});
+
+describe("graceful degradation", () => {
+  it("returns available:false with a reason when no server is installed", async () => {
+    const mgr = fakeManager({
+      unavailable: "no language server installed for typescript",
+    });
+    const ci = new CodeIntelligence({ manager: mgr });
+    const res = await ci.definition("a.ts", 1, 1);
+    expect(res).toEqual({
+      available: false,
+      reason: "no language server installed for typescript",
+    });
+  });
+});
+
+describe("document symbols", () => {
+  it("flattens hierarchical DocumentSymbols with container names", async () => {
+    const mgr = fakeManager({
+      requestResult: [
+        {
+          name: "MyClass",
+          kind: 5, // class
+          selectionRange: {
+            start: { line: 0, character: 6 },
+            end: { line: 0, character: 13 },
+          },
+          children: [
+            {
+              name: "method1",
+              kind: 6,
+              selectionRange: {
+                start: { line: 1, character: 2 },
+                end: { line: 1, character: 9 },
+              },
+            },
+          ],
+        },
+      ],
+    });
+    const ci = new CodeIntelligence({ manager: mgr });
+    const res = await ci.documentSymbols("a.ts");
+    expect(res.symbols).toHaveLength(2);
+    expect(res.symbols[0]).toMatchObject({
+      name: "MyClass",
+      kind: "class",
+      line: 1,
+    });
+    expect(res.symbols[1]).toMatchObject({
+      name: "method1",
+      kind: "method",
+      container: "MyClass",
+      line: 2,
+    });
+  });
+});
+
+describe("diagnostics", () => {
+  it("normalizes severity and position", async () => {
+    const mgr = fakeManager({
+      diagnostics: [
+        {
+          severity: 1,
+          message: "Cannot find name 'x'.",
+          range: {
+            start: { line: 3, character: 4 },
+            end: { line: 3, character: 5 },
+          },
+          code: 2304,
+          source: "ts",
+        },
+      ],
+    });
+    const ci = new CodeIntelligence({ manager: mgr });
+    const res = await ci.diagnostics("a.ts");
+    expect(res.diagnostics[0]).toMatchObject({
+      severity: "error",
+      message: "Cannot find name 'x'.",
+      line: 4,
+      col: 5,
+      code: "2304",
+      source: "ts",
+    });
+  });
+});
+
+describe("rename preview", () => {
+  it("flattens WorkspaceEdit.changes without applying", async () => {
+    const mgr = fakeManager({
+      requestResult: {
+        changes: {
+          "file:///proj/a.ts": [
+            {
+              range: {
+                start: { line: 0, character: 6 },
+                end: { line: 0, character: 9 },
+              },
+              newText: "bar",
+            },
+          ],
+        },
+      },
+    });
+    const ci = new CodeIntelligence({ manager: mgr });
+    const res = await ci.renamePreview("a.ts", 1, 7, "bar");
+    expect(res.edits).toHaveLength(1);
+    expect(res.edits[0].file).toContain("a.ts");
+    expect(res.edits[0].edits[0]).toMatchObject({
+      line: 1,
+      col: 7,
+      newText: "bar",
+    });
+  });
+
+  it("flattens WorkspaceEdit.documentChanges", async () => {
+    const mgr = fakeManager({
+      requestResult: {
+        documentChanges: [
+          {
+            textDocument: { uri: "file:///proj/c.ts", version: 2 },
+            edits: [
+              {
+                range: {
+                  start: { line: 9, character: 0 },
+                  end: { line: 9, character: 3 },
+                },
+                newText: "baz",
+              },
+            ],
+          },
+        ],
+      },
+    });
+    const ci = new CodeIntelligence({ manager: mgr });
+    const res = await ci.renamePreview("a.ts", 1, 1, "baz");
+    expect(res.edits[0].file).toContain("c.ts");
+    expect(res.edits[0].edits[0]).toMatchObject({ line: 10, newText: "baz" });
+  });
+});

package/src/lib/lsp/__tests__/jsonrpc-stream.test.js

@@ -0,0 +1,104 @@
+/**
+ * jsonrpc-stream tests — LSP Content-Length framing. Pure, no IO. Pins the
+ * split-chunk / multi-message / multibyte-length / lenient-LF edge cases that a
+ * naive framer gets wrong.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  encodeMessage,
+  parseContentLength,
+  MessageBuffer,
+} from "../jsonrpc-stream.js";
+
+describe("encodeMessage", () => {
+  it("frames a message with a byte-accurate Content-Length", () => {
+    const buf = encodeMessage({ jsonrpc: "2.0", id: 1, method: "ping" });
+    const text = buf.toString("utf8");
+    const body = JSON.stringify({ jsonrpc: "2.0", id: 1, method: "ping" });
+    expect(text).toBe(
+      `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`,
+    );
+  });
+
+  it("counts BYTES not characters for multibyte content", () => {
+    const buf = encodeMessage({ text: "你好" }); // 6 UTF-8 bytes for the two chars
+    const headerLen = Number(
+      /Content-Length: (\d+)/.exec(buf.toString("utf8"))[1],
+    );
+    const body = JSON.stringify({ text: "你好" });
+    expect(headerLen).toBe(Buffer.byteLength(body, "utf8"));
+    // round-trips through the buffer intact
+    const mb = new MessageBuffer().append(buf);
+    expect(mb.read()).toEqual({ text: "你好" });
+  });
+});
+
+describe("parseContentLength", () => {
+  it("reads the header case-insensitively", () => {
+    expect(parseContentLength("content-length: 42")).toBe(42);
+    expect(parseContentLength("Content-Length:   7\r\nContent-Type: x")).toBe(
+      7,
+    );
+  });
+  it("returns null when absent or invalid", () => {
+    expect(parseContentLength("Content-Type: application/json")).toBeNull();
+    expect(parseContentLength("Content-Length: abc")).toBeNull();
+  });
+});
+
+describe("MessageBuffer", () => {
+  it("decodes a single framed message", () => {
+    const mb = new MessageBuffer();
+    mb.append(encodeMessage({ id: 1, result: "ok" }));
+    expect(mb.read()).toEqual({ id: 1, result: "ok" });
+    expect(mb.read()).toBeNull();
+  });
+
+  it("decodes multiple messages in one chunk", () => {
+    const mb = new MessageBuffer();
+    const chunk = Buffer.concat([
+      encodeMessage({ id: 1 }),
+      encodeMessage({ id: 2 }),
+      encodeMessage({ id: 3 }),
+    ]);
+    mb.append(chunk);
+    expect(mb.readAll().map((m) => m.id)).toEqual([1, 2, 3]);
+  });
+
+  it("reassembles a message split across chunks (header and body)", () => {
+    const full = encodeMessage({ id: 7, method: "textDocument/definition" });
+    const mb = new MessageBuffer();
+    // split mid-header and mid-body
+    for (let i = 0; i < full.length; i += 5) {
+      mb.append(full.slice(i, i + 5));
+    }
+    expect(mb.read()).toEqual({ id: 7, method: "textDocument/definition" });
+    expect(mb.hasPartial).toBe(false);
+  });
+
+  it("retains a partial frame until the rest arrives", () => {
+    const full = encodeMessage({ id: 9 });
+    const mb = new MessageBuffer();
+    mb.append(full.slice(0, full.length - 3));
+    expect(mb.read()).toBeNull();
+    expect(mb.hasPartial).toBe(true);
+    mb.append(full.slice(full.length - 3));
+    expect(mb.read()).toEqual({ id: 9 });
+  });
+
+  it("tolerates LF-only header separators", () => {
+    const body = JSON.stringify({ id: 5 });
+    const mb = new MessageBuffer();
+    mb.append(`Content-Length: ${body.length}\n\n${body}`);
+    expect(mb.read()).toEqual({ id: 5 });
+  });
+
+  it("skips a body that isn't valid JSON but stays aligned for the next frame", () => {
+    const mb = new MessageBuffer();
+    const bad = "Content-Length: 3\r\n\r\n{{{";
+    mb.append(bad + encodeMessage({ id: 2 }).toString("utf8"));
+    // bad frame dropped, good one still decoded
+    expect(mb.read()).toEqual({ id: 2 });
+  });
+});