@nudojs/service 0.2.0 → 0.3.0

package/package.json

@@ -1,13 +1,25 @@
 {
   "name": "@nudojs/service",
-  "version": "0.2.0",
+  "version": "0.3.0",
+  "description": "Shared inference service for Nudo IDE integrations — file analysis, completions, and .d.ts generation",
   "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "nudo",
+    "type-inference",
+    "javascript",
+    "language-service",
+    "dts-generation",
+    "analysis"
+  ],
   "main": "src/index.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nudojs/nudo.git",
     "directory": "packages/service"
   },
+  "homepage": "https://github.com/nudojs/nudo/tree/main/packages/service",
+  "bugs": "https://github.com/nudojs/nudo/issues",
   "publishConfig": {
     "access": "public",
     "provenance": true,
@@ -16,9 +28,10 @@
   "dependencies": {
     "@babel/traverse": "^7.29.0",
     "@babel/types": "^7.29.0",
-    "@nudojs/core": "0.2.0",
-    "@nudojs/parser": "0.2.0",
-    "@nudojs/cli": "0.2.0"
+    "@nudojs/core": "0.3.0",
+    "@nudojs/parser": "0.3.0",
+    "@nudojs/cli": "0.3.0",
+    "@nudojs/harvester": "0.2.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts"

package/src/__tests__/abs-bindings.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect, afterAll } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { collectAbsBindingsFromGraph, analyzeFile, getHoverAtPosition } from "@nudojs/service";
+import { formatAbs, absToString } from "@nudojs/core";
+
+const dirs: string[] = [];
+afterAll(() => {
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+describe("Abs bindings from module graph", () => {
+  it("includes local functions and imported names", () => {
+    const dir = mkdtempSync(join(tmpdir(), "nudo-abs-bind-"));
+    dirs.push(dir);
+    writeFileSync(join(dir, "math.js"), `export function double(x) { return x * 2; }\n`);
+    const main = `import { double } from "./math.js";
+export function run(n) { return double(n); }
+const k = 1;
+`;
+    const mainPath = join(dir, "main.js");
+    writeFileSync(mainPath, main, "utf-8");
+    const binds = collectAbsBindingsFromGraph(main, mainPath);
+    expect(binds.has("run")).toBe(true);
+    expect(binds.has("double")).toBe(true);
+    expect(binds.has("k")).toBe(true);
+    expect(formatAbs(binds.get("k")!)).toContain("1");
+  });
+
+  it("analyzeFile bindings prefer Abs projection for capable files", () => {
+    const dir = mkdtempSync(join(tmpdir(), "nudo-abs-bind2-"));
+    dirs.push(dir);
+    writeFileSync(join(dir, "math.js"), `export function double(x) { return x * 2; }\n`);
+    const main = `import { double } from "./math.js";
+export function run(n) { return double(n); }
+`;
+    const mainPath = join(dir, "main.js");
+    writeFileSync(mainPath, main, "utf-8");
+    const result = analyzeFile(mainPath, main);
+    expect(result.bindings.has("run")).toBe(true);
+    // imported binding should exist
+    expect(result.bindings.has("double")).toBe(true);
+  });
+
+  it("hover on local function returns abs", () => {
+    const src = `export function add(a, b) { return a + b; }
+`;
+    const h = getHoverAtPosition("/tmp/hover-abs.js", src, 1, 16);
+    // 不要求精确命中，但不应抛错
+    expect(h === null || typeof h.typeText === "string").toBe(true);
+  });
+});

package/src/__tests__/abs-call-records.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect, afterAll } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { analyzeFile } from "@nudojs/service";
+import { typeValueToString } from "@nudojs/core";
+
+const dirs: string[] = [];
+afterAll(() => {
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+describe("Abs call records with relative import", () => {
+  it("tags imported calls with targetModule and feeds externalFunctions", () => {
+    const dir = mkdtempSync(join(tmpdir(), "nudo-abs-call-"));
+    dirs.push(dir);
+    const bSrc = `export function triple(x) { return x * 3; }\n`;
+    const aSrc = `import { triple } from "./b.js";\nfunction caller(n) { return triple(n); }\nconst r = caller(4);\n`;
+    writeFileSync(join(dir, "b.js"), bSrc);
+    const aPath = resolve(dir, "a.js");
+    writeFileSync(aPath, aSrc);
+
+    const result = analyzeFile(aPath, aSrc);
+
+    expect(result.externalFunctions).toBeDefined();
+    expect(result.externalFunctions).toHaveLength(1);
+    const triple = result.externalFunctions![0];
+    expect(triple.name).toBe("triple");
+    expect(triple.fromModule).toContain("b.js");
+    expect(triple.cases).toHaveLength(1);
+    expect(typeValueToString(triple.cases[0].result)).toBe("12");
+  });
+});

package/src/__tests__/abs-calls.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect } from "vitest";
+import { analyzeFile } from "../analyzer.ts";
+import { typeValueToString } from "@nudojs/core";
+
+describe("self-contained Abs call records", () => {
+  it("collects call sites from Abs program eval", () => {
+    const source = `
+      function add(a, b) { return a + b; }
+      const r = add(2, 3);
+    `;
+    const result = analyzeFile("/t/abs-call.js", source);
+    const add = result.functions.find((f) => f.name === "add");
+    expect(add).toBeDefined();
+    expect(add!.cases.length).toBeGreaterThan(0);
+    expect(add!.cases[0]!.source).toBe("callsite");
+    expect(typeValueToString(add!.cases[0]!.result)).toBe("5");
+  });
+
+  it("self-contained entry still works", () => {
+    const source = `function scale(x) { return x + 1; }`;
+    const result = analyzeFile("/t/abs-entry.js", source);
+    const scale = result.functions.find((f) => f.name === "scale");
+    expect(scale!.entryOnly).toBe(true);
+    expect(scale!.cases[0]!.intension).toBeDefined();
+  });
+
+  it("mock seeds feed Abs path (call@ stays exact)", () => {
+    const source = `
+      // @nudo:mock parse = stub().returns(42)
+      function run() {
+        return parse();
+      }
+      const r = run();
+    `;
+    const result = analyzeFile("/t/abs-mock.js", source);
+    const run = result.functions.find((f) => f.name === "run");
+    expect(run).toBeDefined();
+    const call = run!.cases.find((c) => c.source === "callsite");
+    expect(call).toBeDefined();
+    expect(typeValueToString(call!.result)).toBe("42");
+  });
+
+  it("directive expected is carried on CaseResult", () => {
+    const source = `
+      /**
+       * @nudo:case "ok" (1) => T.number
+       * @nudo:case "bad" (1) => T.string
+       */
+      function id(x) { return x; }
+    `;
+    const result = analyzeFile("/t/abs-expected.js", source);
+    const id = result.functions.find((f) => f.name === "id");
+    const ok = id!.cases.find((c) => c.name === "ok");
+    const bad = id!.cases.find((c) => c.name === "bad");
+    expect(ok!.expected).toBeDefined();
+    expect(bad!.expected).toBeDefined();
+    expect(result.diagnostics.some((d) => d.code === "nudo:case-expected")).toBe(true);
+  });
+});

package/src/__tests__/abs-module-cache.test.ts

@@ -0,0 +1,121 @@
+import { it, expect, describe, afterAll, beforeEach } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  evalAbsModuleGraph,
+  defaultAbsLoadModule,
+  clearAbsModuleCache,
+  evictAbsModuleCacheFiles,
+} from "@nudojs/service";
+
+const dirs: string[] = [];
+
+function setup(files: Record<string, string>): string {
+  const dir = mkdtempSync(join(tmpdir(), "nudo-modcache-"));
+  dirs.push(dir);
+  for (const [f, src] of Object.entries(files)) {
+    writeFileSync(join(dir, f), src, "utf-8");
+  }
+  return dir;
+}
+
+beforeEach(() => clearAbsModuleCache());
+afterAll(() => {
+  clearAbsModuleCache();
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+describe("abs module session cache", () => {
+  it("reuses evaluated dependency exports across entries (skips re-read/re-eval)", () => {
+    const dir = setup({
+      "util.js": `export function inc(x) { return x + 1; }\n`,
+    });
+    let loads = 0;
+    const loadModule = (spec: string, fromFile: string): string | undefined => {
+      loads++;
+      return defaultAbsLoadModule(spec, fromFile);
+    };
+    const entry = (f: string) => `import { inc } from "./util.js";\nexport function go(x) { return inc(x); }`;
+
+    const g1 = evalAbsModuleGraph(entry("a.js"), join(dir, "a.js"), { loadModule });
+    expect(g1.modules["./util.js"]).toBeDefined();
+    const loadsAfterFirst = loads;
+
+    const g2 = evalAbsModuleGraph(entry("b.js"), join(dir, "b.js"), { loadModule });
+    expect(g2.modules["./util.js"]).toBeDefined();
+    // 缓存命中：第二个入口不再读盘重载 util.js
+    expect(loads).toBe(loadsAfterFirst);
+    // 同一条导出（引用同一对象）
+    expect(g2.modules["./util.js"]).toBe(g1.modules["./util.js"]);
+  });
+
+  it("invalidates by stat fingerprint when dependency content changes", () => {
+    const dir = setup({
+      "util.js": `export function inc(x) { return x + 1; }\n`,
+    });
+    const entry = `import { inc } from "./util.js";\nexport function go(x) { return inc(x); }`;
+    const entryFile = join(dir, "main.js");
+
+    const g1 = evalAbsModuleGraph(entry, entryFile);
+    expect(g1.modules["./util.js"]!.named.inc).toBeDefined();
+    expect(g1.modules["./util.js"]!.named.ver).toBeUndefined();
+
+    // 变更内容（size 必变 → 指纹必失效，与 mtime 精度无关）
+    writeFileSync(join(dir, "util.js"), `export function inc(x) { return x + 1; }\nexport const ver = 2;\n`, "utf-8");
+    const g2 = evalAbsModuleGraph(entry, entryFile);
+    expect(g2.modules["./util.js"]!.named.ver).toBeDefined();
+  });
+
+  it("clear and evict drop cached entries", () => {
+    const dir = setup({
+      "util.js": `export const n = 1;\n`,
+    });
+    let loads = 0;
+    const loadModule = (spec: string, fromFile: string): string | undefined => {
+      loads++;
+      return defaultAbsLoadModule(spec, fromFile);
+    };
+    const entry = `import { n } from "./util.js";\nexport function go() { return n; }`;
+    const entryFile = join(dir, "main.js");
+
+    evalAbsModuleGraph(entry, entryFile, { loadModule });
+    const loadsAfterFirst = loads;
+
+    clearAbsModuleCache();
+    evalAbsModuleGraph(entry, entryFile, { loadModule });
+    expect(loads).toBeGreaterThan(loadsAfterFirst);
+
+    const loadsAfterSecond = loads;
+    evictAbsModuleCacheFiles([join(dir, "util.js")]);
+    evalAbsModuleGraph(entry, entryFile, { loadModule });
+    expect(loads).toBeGreaterThan(loadsAfterSecond);
+  });
+
+  it("replays subtree load issues (missing) on cache hit", () => {
+    const dir = setup({
+      "util.js": `import { gone } from "./gone.js";\nexport const y = gone;\n`,
+    });
+    const entry = (f: string) => `import { y } from "./util.js";\nexport function go() { return y; }`;
+
+    const g1 = evalAbsModuleGraph(entry("a.js"), join(dir, "a.js"));
+    expect(g1.issues.some((i) => i.kind === "missing" && i.label === "./gone.js")).toBe(true);
+
+    const g2 = evalAbsModuleGraph(entry("b.js"), join(dir, "b.js"));
+    expect(g2.issues.some((i) => i.kind === "missing" && i.label === "./gone.js")).toBe(true);
+  });
+
+  it("replays cycle issues on cache hit", () => {
+    const dir = setup({
+      "a.js": `import { b } from "./b.js";\nexport const a = 1;\n`,
+      "b.js": `import { a } from "./a.js";\nexport const b = 2;\n`,
+    });
+    const entry = (f: string) => `import { a } from "./a.js";\nexport function go() { return a; }`;
+
+    const g1 = evalAbsModuleGraph(entry("e1.js"), join(dir, "e1.js"));
+    expect(g1.issues.some((i) => i.kind === "cycle")).toBe(true);
+
+    const g2 = evalAbsModuleGraph(entry("e2.js"), join(dir, "e2.js"));
+    expect(g2.issues.some((i) => i.kind === "cycle")).toBe(true);
+  });
+});

package/src/__tests__/abs-modules-graph.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect, afterAll } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { evalAbsModuleGraph } from "@nudojs/service";
+import { analyzeFn, litValue, numLit } from "@nudojs/core";
+
+const dirs: string[] = [];
+
+afterAll(() => {
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+function tmpProject(files: Record<string, string>): string {
+  const dir = mkdtempSync(join(tmpdir(), "nudo-abs-mod-"));
+  dirs.push(dir);
+  for (const [rel, src] of Object.entries(files)) {
+    const p = join(dir, rel);
+    mkdirSync(join(p, ".."), { recursive: true });
+    writeFileSync(p, src, "utf-8");
+  }
+  return dir;
+}
+
+describe("Abs module graph", () => {
+  it("evaluates a relative import and binds named exports", () => {
+    const dir = tmpProject({
+      "math.js": `
+export function double(x) { return x * 2; }
+export const answer = 42;
+`,
+      "main.js": `
+import { double, answer } from "./math.js";
+export function run(n) { return double(n); }
+`,
+    });
+    const mainSrc = `import { double, answer } from "./math.js";
+export function run(n) { return double(n); }
+`;
+    const { modules } = evalAbsModuleGraph(mainSrc, join(dir, "main.js"));
+    expect(modules["./math.js"]).toBeDefined();
+    expect(modules["./math.js"]!.named.double).toBeDefined();
+    expect(litValue(modules["./math.js"]!.named.answer!)).toBe(42);
+
+    const r = analyzeFn(
+      mainSrc,
+      "run",
+      [numLit(21)],
+      undefined,
+      undefined,
+      undefined,
+      modules,
+    );
+    expect(litValue(r)).toBe(42);
+  });
+
+  it("chained relative imports resolve", () => {
+    const dir = tmpProject({
+      "a.js": `export function inc(x) { return x + 1; }`,
+      "b.js": `
+import { inc } from "./a.js";
+export function twice(x) { return inc(inc(x)); }
+`,
+      "main.js": `
+import { twice } from "./b.js";
+export function go(x) { return twice(x); }
+`,
+    });
+    const mainSrc = `import { twice } from "./b.js";
+export function go(x) { return twice(x); }
+`;
+    const { modules } = evalAbsModuleGraph(mainSrc, join(dir, "main.js"));
+    const result = analyzeFn(
+      mainSrc,
+      "go",
+      [numLit(0)],
+      undefined,
+      undefined,
+      undefined,
+      modules,
+    );
+    expect(litValue(result)).toBe(2);
+  });
+
+  it("cycle does not hang", () => {
+    const dir = tmpProject({
+      "a.js": `
+import { b } from "./b.js";
+export function a(x) { return b(x); }
+`,
+      "b.js": `
+import { a } from "./a.js";
+export function b(x) { return x; }
+`,
+    });
+    const mainSrc = `import { a } from "./a.js"; export function go(x) { return a(x); }`;
+    const { modules } = evalAbsModuleGraph(mainSrc, join(dir, "main.js"));
+    expect(modules["./a.js"]).toBeDefined();
+  });
+});

package/src/__tests__/abs-typevalue-diff.test.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect } from "vitest";
+import { analyzeFile } from "../analyzer.ts";
+import { typeValueToString } from "@nudojs/core";
+
+/**
+ * Service 层 Abs ↔ TypeValue 差分门禁。
+ * 自包含源码：call@ 结果必须与 TypeValue 路径投影一致
+ * （Abs 成功时 callRecords 被 Abs 覆盖；此处验证覆盖后的结果合理）。
+ */
+describe("Abs vs TypeValue service differential", () => {
+  const samples: Array<{ name: string; source: string; fn: string; expect: string }> = [
+    {
+      name: "literal add",
+      source: `function add(a, b) { return a + b; }\nconst r = add(2, 3);`,
+      fn: "add",
+      expect: "5",
+    },
+    {
+      name: "string concat",
+      source: `function cat(a, b) { return a + b; }\nconst r = cat("x", "y");`,
+      fn: "cat",
+      expect: '"xy"',
+    },
+    {
+      name: "branch join",
+      source: `function f(n) { if (n > 0) return 1; return 0; }\nconst r = f(3);`,
+      fn: "f",
+      expect: "1",
+    },
+    {
+      name: "object field",
+      source: `function get(o) { return o.id; }\nconst r = get({ id: 7 });`,
+      fn: "get",
+      expect: "7",
+    },
+  ];
+
+  for (const s of samples) {
+    it(s.name, () => {
+      const result = analyzeFile(`/t/diff-${s.fn}.js`, s.source);
+      const fn = result.functions.find((f) => f.name === s.fn);
+      const call = fn!.cases.find((c) => c.source === "callsite");
+      expect(call, `no call@ for ${s.fn}`).toBeDefined();
+      expect(typeValueToString(call!.result)).toBe(s.expect);
+      // Abs 路径应填充 intension
+      expect(call!.intension).toBeDefined();
+    });
+  }
+
+  it("mock + call does not degrade to unknown", () => {
+    const source = `
+      // @nudo:mock handler = stub().returns("ok")
+      function run() { return handler(); }
+      const r = run();
+    `;
+    const result = analyzeFile("/t/diff-mock.js", source);
+    const run = result.functions.find((f) => f.name === "run");
+    const call = run!.cases.find((c) => c.source === "callsite");
+    expect(typeValueToString(call!.result)).not.toBe("unknown");
+    expect(typeValueToString(call!.result)).toBe('"ok"');
+  });
+
+  it("mock withArgs dispatches on Abs path (literal hit)", () => {
+    const source = `
+      // @nudo:mock id = stub().withArgs(21).returns("hit")
+      function run() { return id(21); }
+      const r = run();
+    `;
+    const result = analyzeFile("/t/diff-withargs.js", source);
+    const run = result.functions.find((f) => f.name === "run");
+    const call = run!.cases.find((c) => c.source === "callsite");
+    expect(typeValueToString(call!.result)).toBe('"hit"');
+  });
+
+  it("mock withArgs miss falls back to unknown", () => {
+    const source = `
+      // @nudo:mock id = stub().withArgs(21).returns("hit")
+      function run() { return id(99); }
+      const r = run();
+    `;
+    const result = analyzeFile("/t/diff-withargs-miss.js", source);
+    const run = result.functions.find((f) => f.name === "run");
+    const call = run!.cases.find((c) => c.source === "callsite");
+    expect(typeValueToString(call!.result)).toBe("unknown");
+  });
+
+  it("mock onFirstCall without returns is default value", () => {
+    const source = `
+      // @nudo:mock getPort = stub().onFirstCall(8080)
+      function run() { return getPort(); }
+      const r = run();
+    `;
+    const result = analyzeFile("/t/diff-onfirst.js", source);
+    const run = result.functions.find((f) => f.name === "run");
+    const call = run!.cases.find((c) => c.source === "callsite");
+    expect(typeValueToString(call!.result)).toBe("8080");
+  });
+
+  it("mock sinon.stub().onFirstCall().returns() matches Abs path", () => {
+    const source = `
+      // @nudo:mock fetch = sinon.stub().onFirstCall().returns({ data: "first" })
+      function run() { return fetch(); }
+      const r = run();
+    `;
+    const result = analyzeFile("/t/diff-onfirst-sinon.js", source);
+    const run = result.functions.find((f) => f.name === "run");
+    const call = run!.cases.find((c) => c.source === "callsite");
+    expect(typeValueToString(call!.result)).not.toBe("unknown");
+    expect(typeValueToString(call!.result)).toContain("first");
+  });
+});