@nudojs/lsp 0.2.0 → 0.4.0

package/package.json

@@ -1,13 +1,24 @@
 {
   "name": "@nudojs/lsp",
-  "version": "0.2.0",
+  "version": "0.4.0",
+  "description": "Language Server Protocol implementation for the Nudo type inference engine",
   "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "nudo",
+    "type-inference",
+    "javascript",
+    "lsp",
+    "language-server"
+  ],
   "main": "src/server.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nudojs/nudo.git",
     "directory": "packages/lsp"
   },
+  "homepage": "https://github.com/nudojs/nudo/tree/main/packages/lsp",
+  "bugs": "https://github.com/nudojs/nudo/issues",
   "publishConfig": {
     "access": "public",
     "provenance": true,
@@ -16,8 +27,9 @@
   "dependencies": {
     "vscode-languageserver": "^9.0.0",
     "vscode-languageserver-textdocument": "^1.0.0",
-    "@nudojs/service": "0.2.0",
-    "@nudojs/core": "0.2.0"
+    "@nudojs/service": "0.3.0",
+    "@nudojs/core": "0.3.0",
+    "@nudojs/parser": "0.3.0"
   },
   "scripts": {
     "build": "tsup src/server.ts --format esm --dts"

package/src/__tests__/agent-check.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from "vitest";
+import { checkTool } from "../agent-tools.ts";
+
+const STD = `
+export const positive = number().gt(0);
+export const delay = number().gt(0);
+`;
+
+const src = `
+/// @nudo:import { positive } from "./std.nudo.js"
+/**
+ * @nudo:refine x positive
+ */
+function needsPositive(x) {
+  if (x > 0) return x;
+  return 0;
+}
+needsPositive(-1);
+`;
+
+const loadModule = (spec: string) =>
+  spec.includes("std.nudo") ? STD : undefined;
+
+describe("nudo.check agent tool", () => {
+  it("returns CheckJson v1 in json format", () => {
+    const r = checkTool(
+      { file: "/t/a.js", source: src, format: "json", loadModule },
+      { readFile: () => src },
+    );
+    const parsed = JSON.parse(r.content[0].text);
+    expect(parsed.version).toBe(1);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.issues.some((i: { code: string }) => i.code === "nudo:constraint-violated")).toBe(true);
+  });
+
+  it("text format includes actual/expected", () => {
+    const r = checkTool(
+      { file: "/t/a.js", source: src, loadModule },
+      { readFile: () => src },
+    );
+    const text = r.content[0].text;
+    expect(text).toContain("FAILED");
+    expect(text).toContain("actual");
+    expect(text).toContain("expected");
+    expect(text).toContain('"version": 1');
+  });
+});

package/src/__tests__/agent-hover.test.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect } from "vitest";
+import { hoverTool } from "../agent-tools.ts";
+
+describe("nudo.hover agent tool", () => {
+  it("returns lossless abs at position", () => {
+    const src = `const x = 1 + 2;\n`;
+    // col of `2` is 14 (0-based)
+    const r = hoverTool(
+      { file: "/t/h.js", line: 1, column: 14, source: src },
+      { readFile: () => src },
+    );
+    const payload = JSON.parse(r.content[0].text);
+    expect(payload.abs).toBeDefined();
+    expect(payload.abs).toContain("2");
+    expect(payload).toHaveProperty("ext");
+  });
+
+  it("can include inlays", () => {
+    const src = `function needsPositive(x) {\n  if (x > 0) return x;\n  return 0;\n}\n`;
+    const r = hoverTool(
+      { file: "/t/i.js", line: 1, column: 9, source: src, includeInlays: true },
+      { readFile: () => src },
+    );
+    const payload = JSON.parse(r.content[0].text);
+    expect(Array.isArray(payload.inlays)).toBe(true);
+    expect(payload.inlays.length).toBeGreaterThan(0);
+  });
+});

package/src/__tests__/agent-infer.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect } from "vitest";
+import { inferTool } from "../agent-tools.ts";
+
+describe("nudo.infer agent tool", () => {
+  const src = `function scale(x) { return x + 1; }\n`;
+
+  it("returns InferJson v1 with abs intension", () => {
+    const r = inferTool(
+      { file: "/t/scale.js", source: src, format: "json" },
+      { readFile: () => src },
+    );
+    const json = JSON.parse(r.content[0].text);
+    expect(json.version).toBe(1);
+    expect(json.functions[0].name).toBe("scale");
+    expect(json.functions[0].cases[0].intension.abs).toContain("#");
+  });
+
+  it("text format lists abs lines", () => {
+    const r = inferTool({ file: "/t/scale.js", source: src }, { readFile: () => src });
+    const text = r.content[0].text;
+    expect(text).toContain("scale");
+    expect(text).toContain("abs:");
+    expect(text).toContain('"version": 1');
+  });
+
+  it("filters by function name", () => {
+    const multi = `
+function a(x) { return x; }
+function b(x) { return x + 1; }
+`;
+    const r = inferTool(
+      { file: "/t/m.js", source: multi, format: "json", functions: ["b"] },
+      { readFile: () => multi },
+    );
+    const json = JSON.parse(r.content[0].text);
+    expect(json.functions.map((f: { name: string }) => f.name)).toEqual(["b"]);
+  });
+});

package/src/__tests__/check-diagnostics.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from "vitest";
+import { clearValidationState, checkToLspDiagnostics, validateText } from "../validation.ts";
+
+const STD = `
+export const positive = number().gt(0);
+`;
+
+const src = `
+/// @nudo:import { positive } from "./std.nudo.js"
+/**
+ * @nudo:refine x positive
+ */
+function needsPositive(x) {
+  if (x > 0) return x;
+  return 0;
+}
+needsPositive(-1);
+`;
+
+const loadModule = (spec: string) =>
+  spec.includes("std.nudo") ? STD : undefined;
+
+describe("Abs check as LSP diagnostics", () => {
+  it("maps constraint violations to nudo-check diagnostics", () => {
+    const diags = checkToLspDiagnostics("/t/check.js", src, loadModule);
+    expect(diags.length).toBeGreaterThan(0);
+    const d = diags[0]!;
+    expect(d.source).toBe("nudo-check");
+    expect(d.code).toBe("nudo:constraint-violated");
+    expect(d.message).toContain("actual");
+    expect(d.message).toContain("expected");
+  });
+
+  it("validateText publishes check diags first", async () => {
+    clearValidationState();
+    let sent: { source?: string; code?: string }[] = [];
+    await validateText("/t/check2.js", "file:///t/check2.js", src, 1, {
+      sendDiagnostics: (p) => {
+        sent = p.diagnostics.map((d) => ({ source: d.source, code: d.code as string }));
+      },
+    });
+    // validateText 用磁盘 loadModule；虚拟路径下无 std.nudo.js → 无 check diags 也可
+    // 至少不崩溃
+    expect(Array.isArray(sent)).toBe(true);
+  });
+});

package/src/__tests__/definition.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from "vitest";
+import { parse } from "@nudojs/parser";
+import { buildSymbolTable, findDefinition, findReferences } from "../symbols.ts";
+
+describe("symbol table", () => {
+  it("finds function definition", () => {
+    const source = `function add(a, b) { return a + b; }`;
+    const ast = parse(source);
+    const table = buildSymbolTable(ast, "file:///test.js");
+    const def = findDefinition(table, "add");
+    expect(def).not.toBeNull();
+    expect(def!.kind).toBe("function");
+    expect(def!.loc.start.line).toBe(1);
+  });
+
+  it("finds variable definition", () => {
+    const source = `const x = 42;`;
+    const ast = parse(source);
+    const table = buildSymbolTable(ast, "file:///test.js");
+    const def = findDefinition(table, "x");
+    expect(def).not.toBeNull();
+    expect(def!.kind).toBe("variable");
+  });
+
+  it("collects references", () => {
+    const source = `const x = 42; const y = x + 1;`;
+    const ast = parse(source);
+    const table = buildSymbolTable(ast, "file:///test.js");
+    const refs = table.references.filter((r) => r.name === "x");
+    expect(refs.length).toBeGreaterThan(0);
+  });
+});