@nudojs/lsp 0.3.0 → 0.4.0

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__/lsp-integration.test.ts

@@ -11,6 +11,8 @@ import {
   generateDts,
   typeValueToZodSchema,
   generateGuardFunction,
+  buildSemanticTokens,
+  SEMANTIC_TOKEN_TYPES,
 } from "@nudojs/service";
 import { T } from "@nudojs/core";
 import { parse } from "@nudojs/parser";
@@ -79,7 +81,6 @@ function first(arr) {
 }
 
 /**
- * @nudo:returns (T.string)
  * @nudo:case "num" (42)
  */
 function alwaysString(x) {
@@ -109,13 +110,6 @@ describe("LSP Integration - Full Pipeline", () => {
         expect(hint.label).toBeTruthy();
       }
     });
-
-    it("generates diagnostics for assertion failures", () => {
-      const result = analyzeFile(filePath, testCode);
-      const assertionDiags = result.diagnostics.filter(d => d.code === "nudo-assertion-failed");
-      expect(assertionDiags.length).toBeGreaterThan(0);
-      expect(assertionDiags[0].message).toContain("inferred");
-    });
   });
 
   describe("getTypeAtPosition", () => {
@@ -691,8 +685,9 @@ describe("LSP Integration - Agent Tools (whatIf / suggestCase / trace)", () => {
 
       // without assumptions x=1 folds to a literal and y = 2
       expect(base.content[0].text).toContain('Type of "y": 2');
-      // with x:string the + operator widens y to string — the assumption really flowed
-      expect(assumed.content[0].text).toContain('Type of "y": string');
+      // with x:string the + operator keeps template structure — the assumption really flowed
+      expect(assumed.content[0].text).toContain('Type of "y":');
+      expect(assumed.content[0].text).toContain("string");
       expect(assumed.content[0].text).not.toBe(base.content[0].text);
       expect(assumed.content[0].text).toContain("Bindings applied: x: string");
     });
@@ -747,7 +742,8 @@ describe("LSP Integration - Agent Tools (whatIf / suggestCase / trace)", () => {
         const viaUri = whatIf(
           { file: `file://${plainPath}`, bindings: [{ name: "x", type: "string" }], target: "y" },
         );
-        expect(viaUri.content[0].text).toContain('Type of "y": string');
+        expect(viaUri.content[0].text).toContain('Type of "y":');
+        expect(viaUri.content[0].text).toContain("string");
 
         // normalizeFilePath decodes and resolves both forms identically
         expect(normalizeFilePath(`file://${plainPath}`)).toBe(normalizeFilePath(plainPath));
@@ -820,3 +816,106 @@ describe("LSP Integration - Agent Tools (whatIf / suggestCase / trace)", () => {
     expect(zero.content[0].text).toContain("Suggested: /** @nudo:case */");
   });
 });
+
+// 来源：IDE 深度批次——service 层 semantic tokens 提取（server.ts 只接线，
+// 此处直接测 buildSemanticTokens，不 import server.ts）
+describe("LSP Integration - Semantic Tokens", () => {
+  const tokenSrc = [
+    "const answer = 42;",                      // L1: answer → variable
+    "const double = (n) => n * 2;",            // L2: double → function（推断）, n → parameter
+    "function add(a, b) { return a + b; }",    // L3: add → function, a/b → parameter
+    'const config = { host: "x", run() {} };', // L4: config → variable, host → property, run → method
+    "answer + double(1) + add(1, config.host);", // L5: 纯使用位，不上色
+  ].join("\n");
+
+  type Decoded = { line: number; char: number; length: number; typeIndex: number; modifiers: number };
+
+  const decode = (data: number[]): Decoded[] => {
+    expect(data.length % 5).toBe(0);
+    const out: Decoded[] = [];
+    let line = 0;
+    let char = 0;
+    for (let i = 0; i < data.length; i += 5) {
+      const [deltaLine, deltaChar, length, typeIndex, modifiers] = data.slice(i, i + 5);
+      line += deltaLine;
+      char = deltaLine === 0 ? char + deltaChar : deltaChar;
+      out.push({ line, char, length, typeIndex, modifiers });
+    }
+    return out;
+  };
+
+  it("emits LSP five-tuples for top-level const/function/params/object keys", () => {
+    const data = buildSemanticTokens("/test/sem-tok.js", tokenSrc);
+
+    // LSP 相对编码契约：首个 token deltaLine=0；数据是五元组扁平数组
+    expect(data[0]).toBe(0);
+
+    const tokens = decode(data);
+
+    // 单调不减（按 line、再按 char 排序）
+    for (let i = 1; i < tokens.length; i++) {
+      const prev = tokens[i - 1];
+      const cur = tokens[i];
+      expect(cur.line).toBeGreaterThan(prev.line - 1);
+      if (cur.line === prev.line) expect(cur.char).toBeGreaterThan(prev.char);
+    }
+
+    const find = (line: number, char: number) => tokens.find((t) => t.line === line && t.char === char);
+
+    // 顶层 const：数值绑定 → variable；函数绑定（箭头）→ function
+    const answer = find(0, 6);
+    expect(answer).toMatchObject({
+      length: "answer".length,
+      typeIndex: SEMANTIC_TOKEN_TYPES.indexOf("variable"),
+      modifiers: 1, // declaration
+    });
+    const double = find(1, 6);
+    expect(double).toMatchObject({
+      length: "double".length,
+      typeIndex: SEMANTIC_TOKEN_TYPES.indexOf("function"),
+    });
+
+    // 函数声明名 + 参数
+    expect(find(2, 9)).toMatchObject({ length: 3, typeIndex: SEMANTIC_TOKEN_TYPES.indexOf("function") });
+    expect(find(2, 13)).toMatchObject({ length: 1, typeIndex: SEMANTIC_TOKEN_TYPES.indexOf("parameter") });
+    expect(find(2, 16)).toMatchObject({ length: 1, typeIndex: SEMANTIC_TOKEN_TYPES.indexOf("parameter") });
+    // 箭头函数参数
+    expect(find(1, 16)).toMatchObject({ length: 1, typeIndex: SEMANTIC_TOKEN_TYPES.indexOf("parameter") });
+
+    // 对象键：数据属性 → property；方法/函数值键 → method
+    expect(find(3, 17)).toMatchObject({ length: 4, typeIndex: SEMANTIC_TOKEN_TYPES.indexOf("property") });
+    expect(find(3, 28)).toMatchObject({ length: 3, typeIndex: SEMANTIC_TOKEN_TYPES.indexOf("method") });
+
+    // length 与标识符长度一致（全量断言，逐 token）
+    const idents: [number, number, string][] = [
+      [0, 6, "answer"], [1, 6, "double"], [1, 16, "n"],
+      [2, 9, "add"], [2, 13, "a"], [2, 16, "b"],
+      [3, 6, "config"], [3, 17, "host"], [3, 28, "run"],
+    ];
+    for (const [line, char, name] of idents) {
+      expect(find(line, char)?.length).toBe(name.length);
+    }
+
+    // 纯使用位不上色：L5 的 answer/double/config.host 引用无 token
+    expect(tokens.filter((t) => t.line === 4)).toEqual([]);
+    // 声明位恰 9 个 token，无多余（AST 其他标识符均未上色）
+    expect(tokens).toHaveLength(9);
+  });
+
+  it("colors a top-level const arrow binding as function via inference", () => {
+    // 推断驱动的证据：同样叫 double，绑定非函数时必须是 variable
+    const data = buildSemanticTokens("/test/sem-tok-var.js", "const double = 42;\ndouble;\n");
+    const tokens = decode(data);
+    expect(tokens).toHaveLength(1);
+    expect(tokens[0]).toMatchObject({
+      line: 0,
+      char: 6,
+      length: 6,
+      typeIndex: SEMANTIC_TOKEN_TYPES.indexOf("variable"),
+    });
+  });
+
+  it("returns empty tokens for unparseable source", () => {
+    expect(buildSemanticTokens("/test/broken.js", "const (")).toEqual([]);
+  });
+});

package/src/__tests__/nudo-dep-evict.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import {
+  clearValidationState,
+  handleNudoDepFileChanged,
+  nudoDepParents,
+  registerNudoImportDeps,
+  validateText,
+  type ValidateTextDeps,
+} from "../validation.ts";
+import { generalizeFromAst, getGeneralizeMemoSize, resetGeneralizeMemo } from "@nudojs/core";
+
+describe("*.nudo.js watched-file → targeted eviction + parent revalidate", () => {
+  beforeEach(() => {
+    clearValidationState();
+  });
+
+  it("registerNudoImportDeps records parent → dep edges", () => {
+    const dir = mkdtempSync(join(tmpdir(), "nudo-dep-idx-"));
+    const parent = join(dir, "a.js");
+    const dep = join(dir, "shapes.nudo.js");
+    registerNudoImportDeps(
+      parent,
+      `/// @nudo:import { positive } from "./shapes.nudo.js"\nfunction f(x){return x;}\n`,
+    );
+    expect(nudoDepParents.get(resolve(dep).replace(/\\/g, "/"))).toContain(
+      resolve(parent).replace(/\\/g, "/"),
+    );
+  });
+
+  it("handleNudoDepFileChanged revalidates open parent and evicts memo deps", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "nudo-dep-chg-"));
+    const parent = join(dir, "a.js");
+    const dep = join(dir, "shapes.nudo.js");
+    writeFileSync(dep, "export const positive = number().gt(0);\n");
+    const parentSrc = `/// @nudo:import { positive } from "./shapes.nudo.js"
+/**
+ * @nudo:refine x positive
+ */
+function needsPositive(x) {
+  return x;
+}
+needsPositive(-1);
+`;
+    writeFileSync(parent, parentSrc);
+    // 模拟已验证会话：登记 @nudo:import 边
+    registerNudoImportDeps(parent, parentSrc);
+
+    // 建立 generalize 缓存（含 dep 路径索引）
+    const loadModule = (spec: string, fromFile: string) => {
+      if (spec.includes("shapes")) return "export const positive = number().gt(0);\n";
+      return undefined;
+    };
+    const g1 = generalizeFromAst("needsPositive", parentSrc, {
+      refine: { loadModule, fromFile: parent },
+    });
+    expect(g1).toBeDefined();
+    expect(getGeneralizeMemoSize()).toBeGreaterThan(0);
+
+    let revalidated = 0;
+    const sent = new Map<string, unknown[]>();
+    const openDocs = new Map([
+      [
+        resolve(parent).replace(/\\/g, "/"),
+        {
+          uri: `file://${parent}`,
+          version: 2,
+          getText: () => parentSrc,
+        },
+      ],
+    ]);
+    const deps: ValidateTextDeps = {
+      sendDiagnostics: (p) => {
+        sent.set(p.uri, p.diagnostics);
+        revalidated++;
+      },
+      getOpenDocumentByPath: (p) => openDocs.get(p.replace(/\\/g, "/")),
+    };
+
+    await handleNudoDepFileChanged(dep, deps);
+
+    // 定向逐出后，同参 generalize 得新实例
+    const g2 = generalizeFromAst("needsPositive", parentSrc, {
+      refine: { loadModule, fromFile: parent },
+    });
+    expect(g2).toBeDefined();
+    expect(g2).not.toBe(g1);
+    // 打开中的父文件被重检
+    expect(revalidated).toBeGreaterThan(0);
+    expect(sent.has(`file://${parent}`)).toBe(true);
+  });
+
+  it("does nothing when no parent depends on the path", async () => {
+    resetGeneralizeMemo();
+    const before = getGeneralizeMemoSize();
+    await handleNudoDepFileChanged("/nope/x.nudo.js", {
+      sendDiagnostics: () => {},
+    });
+    expect(getGeneralizeMemoSize()).toBe(before);
+  });
+});

package/src/agent-tools.ts

@@ -14,10 +14,17 @@
  */
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { analyzeFile, buildCaseDirective } from "@nudojs/service";
+import {
+  analyzeFile,
+  buildCaseDirective,
+  getHoverAtPosition,
+  collectAbsInlays,
+  serializeInferJson,
+} from "@nudojs/service";
 import { parse } from "@nudojs/parser";
-import { T, typeValueToString } from "@nudojs/core";
-import type { TypeValue } from "@nudojs/core";
+import { T, typeValueToString, checkSource, serializeCheckJson, pTrue } from "@nudojs/core";
+import type { TypeValue, CheckJson } from "@nudojs/core";
+import { lspLoadModule } from "./validation.ts";
 
 export type TypeBinding = { name: string; type: string };
 
@@ -207,6 +214,160 @@ function analysisError(err: unknown): AgentToolResult {
   return textResult(`Error: ${(err as Error).message}`);
 }
 
+export type CheckToolParams = {
+  file: string;
+  source?: string;
+  /** "json" → CheckJson only；缺省人类可读摘要 + JSON */
+  format?: "text" | "json";
+  /** 解析 @nudo:import 的相对 .nudo.js（测试可注入） */
+  loadModule?: (spec: string, fromFile: string) => string | undefined;
+};
+
+/**
+ * Agent 门禁工具：返回 CheckJson v1 契约（与 CLI --json 同构）。
+ */
+export function checkTool(
+  params: CheckToolParams,
+  deps: AgentToolDeps = {},
+): AgentToolResult {
+  try {
+    const filePath = normalizeFilePath(params.file);
+    const source = params.source ?? readSource(filePath, deps);
+    const report = checkSource(filePath, source, pTrue, {
+      loadModule: params.loadModule ?? lspLoadModule,
+      fromFile: filePath,
+    });
+    const json = serializeCheckJson(report);
+    if (params.format === "json") {
+      return textResult(JSON.stringify(json, null, 2));
+    }
+    const lines: string[] = [
+      json.ok ? "nudo check OK" : "nudo check FAILED",
+      `${json.summary.errors} error · ${json.summary.warnings} warning · ${json.summary.functions} fn`,
+    ];
+    for (const i of json.issues) {
+      if (i.severity === "info") continue;
+      const loc = i.line != null ? ` L${i.line}` : "";
+      lines.push(`[${i.severity}]${loc} ${i.message}`);
+      if (i.actual) lines.push(`  actual:   ${i.actual}`);
+      if (i.expected) lines.push(`  expected: ${i.expected}`);
+    }
+    lines.push("");
+    lines.push(JSON.stringify(json, null, 2));
+    return textResult(lines.join("\n"));
+  } catch (err) {
+    return analysisError(err);
+  }
+}
+
+export type HoverToolParams = {
+  file: string;
+  /** 1-based 行 */
+  line: number;
+  /** 0-based 列 */
+  column: number;
+  source?: string;
+  /** true 时同时返回该文件全部 Abs inlay */
+  includeInlays?: boolean;
+  /** 可选：*.nudo.js 加载（契约进 inlay） */
+  loadModule?: (spec: string, fromFile: string) => string | undefined;
+};
+
+/**
+ * Agent hover：无损 Abs（不经 TypeValue bridge）。
+ * 与 LSP hover 同一信息源。
+ */
+export function hoverTool(
+  params: HoverToolParams,
+  deps: AgentToolDeps = {},
+): AgentToolResult {
+  try {
+    const filePath = normalizeFilePath(params.file);
+    const source = params.source ?? readSource(filePath, deps);
+    const hover = getHoverAtPosition(filePath, source, params.line, params.column);
+    const payload: Record<string, unknown> = {
+      file: filePath,
+      line: params.line,
+      column: params.column,
+      abs: hover?.abs ?? null,
+      absMultiline: hover?.absMultiline ?? null,
+      intension: hover?.intension ?? null,
+      /** 有损外延，仅对照 */
+      ext: hover?.typeText ?? null,
+    };
+    if (params.includeInlays) {
+      payload.inlays = collectAbsInlays(source, {
+        loadModule: params.loadModule ?? lspLoadModule,
+        fromFile: filePath,
+      });
+    }
+    return textResult(JSON.stringify(payload, null, 2));
+  } catch (err) {
+    return analysisError(err);
+  }
+}
+
+export type InferToolParams = {
+  file: string;
+  source?: string;
+  /** "json" → InferJson only；缺省摘要 + JSON */
+  format?: "text" | "json";
+  /** 只返回这些函数名（可选过滤） */
+  functions?: string[];
+};
+
+/**
+ * Agent infer：InferJson v1 契约（与 CLI infer --json 同构）。
+ * intension 携带无损 Abs；args/result 为 TypeValue 投影。
+ */
+export function inferTool(
+  params: InferToolParams,
+  deps: AgentToolDeps = {},
+): AgentToolResult {
+  try {
+    const filePath = normalizeFilePath(params.file);
+    const source = params.source ?? readSource(filePath, deps);
+    const result = analyzeFile(filePath, source);
+    let json = serializeInferJson(result, filePath);
+    if (params.functions && params.functions.length > 0) {
+      const keep = new Set(params.functions);
+      const filtered = json.functions.filter((f) => keep.has(f.name));
+      let cases = 0;
+      for (const f of filtered) {
+        cases += (f as { cases?: unknown[] }).cases?.length ?? 0;
+      }
+      const summary = {
+        ...json.summary,
+        functions: filtered.length,
+        cases,
+      };
+      json = { ...json, functions: filtered, summary } as typeof json;
+    }
+    if (params.format === "json") {
+      return textResult(JSON.stringify(json, null, 2));
+    }
+    const lines: string[] = [
+      `nudo infer  ${json.file}`,
+      `${json.summary.functions} fn · ${json.summary.cases} case · ${json.summary.diagnostics} diag`,
+    ];
+    for (const f of json.functions) {
+      lines.push("");
+      lines.push(`${f.name}${f.entryOnly ? "  [entry-only]" : ""}`);
+      for (const c of f.cases) {
+        const args = c.args.join(", ");
+        lines.push(`  ${c.name}: (${args}) => ${c.result}`);
+        if (c.intension?.abs) lines.push(`    abs: ${c.intension.abs}`);
+        else if (c.intension?.display) lines.push(`    intension: ${c.intension.display}`);
+      }
+    }
+    lines.push("");
+    lines.push(JSON.stringify(json, null, 2));
+    return textResult(lines.join("\n"));
+  } catch (err) {
+    return analysisError(err);
+  }
+}
+
 export type WhatIfParams = {
   file: string;
   bindings?: TypeBinding[];

package/src/semantic-tokens.ts

@@ -1,45 +1,9 @@
-export const TOKEN_TYPES = [
-  "function",
-  "variable",
-  "parameter",
-  "property",
-  "type",
-  "keyword",
-  "string",
-  "number",
-  "comment",
-  "decorator",
-] as const;
-
-export const TOKEN_MODIFIERS = [
-  "declaration",
-  "readonly",
-  "deprecated",
-  "unreachable",
-] as const;
-
-export type SemanticToken = {
-  line: number;
-  char: number;
-  length: number;
-  typeIndex: number;
-  modifierBitmask: number;
-};
-
-export function encodeSemanticTokens(tokens: SemanticToken[]): number[] {
-  const result: number[] = [];
-  let prevLine = 0;
-  let prevChar = 0;
-
-  for (const token of tokens) {
-    const deltaLine = token.line - prevLine;
-    const deltaChar = deltaLine === 0 ? token.char - prevChar : token.char;
-
-    result.push(deltaLine, deltaChar, token.length, token.typeIndex, token.modifierBitmask);
-
-    prevLine = token.line;
-    prevChar = token.char;
-  }
-
-  return result;
-}
+// Semantic tokens 的图例与编码单一来源在 @nudojs/service（提取器
+// buildSemanticTokens 与图例同处一模块，tokenType 索引不可能与图例漂移）。
+// 此处仅按 server.ts 原引用名（TOKEN_TYPES/TOKEN_MODIFIERS）再导出。
+export {
+  SEMANTIC_TOKEN_TYPES as TOKEN_TYPES,
+  SEMANTIC_TOKEN_MODIFIERS as TOKEN_MODIFIERS,
+  encodeSemanticTokens,
+  type SemanticToken,
+} from "@nudojs/service";