@nudojs/service 0.2.1 → 0.3.0

package/src/__tests__/bpath-method-diag.test.ts

@@ -0,0 +1,45 @@
+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 { analyzeFile, clearBPathCache, tryBPathCallFull } from "@nudojs/service";
+import { $lit } from "@nudojs/core";
+
+const dirs: string[] = [];
+afterAll(() => {
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+describe("B-path method-missing diagnostics", () => {
+  it("records no-method on number receiver via B execution", () => {
+    clearBPathCache();
+    const dir = mkdtempSync(join(tmpdir(), "nudo-md-"));
+    dirs.push(dir);
+    const src = `
+export function badNum(n) {
+  return n.toUpperCase();
+}
+`;
+    const p = join(dir, "m.js");
+    writeFileSync(p, src, "utf-8");
+    const full = tryBPathCallFull(src, p, "badNum", [$lit(42)]);
+    expect(full).toBeDefined();
+    expect(full!.memberDiags?.length).toBeGreaterThanOrEqual(1);
+    expect(full!.memberDiags![0]!.name).toBe("toUpperCase");
+    expect(full!.memberDiags![0]!.receiver).toBe("number");
+  });
+
+  it("analyzeFile still reports no-method for top-level call", () => {
+    clearBPathCache();
+    const source = `
+function badNum(n) {
+  return n.toUpperCase();
+}
+const boom = badNum(42);
+`;
+    const result = analyzeFile("/test/badnum2.js", source);
+    const diags = result.diagnostics.filter((d) => d.code === "nudo:no-method");
+    expect(diags.length).toBeGreaterThanOrEqual(1);
+    expect(diags[0]!.message).toContain("toUpperCase");
+  });
+});

package/src/__tests__/bpath-module-diags.test.ts

@@ -0,0 +1,101 @@
+import { it, expect, describe, afterAll } from "vitest";
+import { analyzeFile, clearBPathCache, evalAbsModuleGraph } from "@nudojs/service";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const dirs: string[] = [];
+afterAll(() => {
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+function setup(files: Record<string, string>) {
+  const dir = mkdtempSync(join(tmpdir(), "nudo-bdiag-"));
+  dirs.push(dir);
+  writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "bdiag", version: "1.0.0" }));
+  for (const [name, src] of Object.entries(files)) {
+    writeFileSync(join(dir, name), src);
+  }
+  return dir;
+}
+
+function analyze(dir: string, src: string, file = "index.js") {
+  writeFileSync(join(dir, file), src);
+  clearBPathCache();
+  return analyzeFile(join(dir, file), src);
+}
+
+describe("B module-load diagnostics (host, no TypeValue double)", () => {
+  it("reports circular import once via B module graph", () => {
+    const dir = setup({
+      "a.js": `import { b } from "./b.js";
+export function a(n) { return n <= 0 ? 0 : b(n - 1); }
+`,
+      "b.js": `import { a } from "./a.js";
+export function b(n) { return n <= 0 ? 1 : a(n - 1); }
+`,
+    });
+    const src = `import { a } from "./a.js";
+/**
+ * @nudo:case "n" (2)
+ */
+export function go(n) { return a(n); }
+`;
+    const r = analyze(dir, src);
+    const cycles = r.diagnostics.filter((d) => d.code === "nudo:module-cycle");
+    expect(cycles.length).toBe(1);
+    expect(cycles[0]!.message).toContain("Circular module load");
+    expect(cycles[0]!.message).toContain("->");
+  });
+
+  it("reports missing relative import once via B module graph", () => {
+    const dir = setup({});
+    const src = `import { x } from "./nope.js";
+/**
+ * @nudo:case
+ */
+export function go() { return x; }
+`;
+    const r = analyze(dir, src);
+    const missing = r.diagnostics.filter((d) => d.code === "nudo:module-missing");
+    expect(missing.length).toBe(1);
+    expect(missing[0]!.message).toContain("nope.js");
+  });
+
+  it("B module graph issues come from evalAbsModuleGraph", () => {
+    const dir = setup({
+      "a.js": `import { b } from "./b.js";
+export function a() { return b(); }
+`,
+      "b.js": `import { a } from "./a.js";
+export function b() { return a(); }
+`,
+    });
+    const src = `import { a } from "./a.js";
+export function go() { return a(); }
+`;
+    writeFileSync(join(dir, "index.js"), src);
+    clearBPathCache();
+    const g = evalAbsModuleGraph(src, join(dir, "index.js"));
+    expect(g.issues.some((i) => i.kind === "cycle")).toBe(true);
+  });
+
+  it("recursion-truncated is not double-reported when Abs budget fires", () => {
+    const dir = setup({});
+    // 抽象参数触发调用预算截断；B Abs 路径与 TypeValue 都可能记 recursion:*
+    const src = `
+/**
+ * @nudo:case "n" (T.number)
+ */
+export function deep(n) {
+  if (n <= 0) return 0;
+  return 1 + deep(n - 1);
+}
+const boom = deep(3);
+`;
+    const r = analyze(dir, src);
+    const rec = r.diagnostics.filter((d) => d.code === "nudo:recursion-truncated");
+    // 至多一条（B 截断则压 TypeValue；否则 TypeValue 自报）
+    expect(rec.length).toBeLessThanOrEqual(1);
+  });
+});

package/src/__tests__/bpath-path-env.test.ts

@@ -0,0 +1,46 @@
+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 { analyzeFileAsync, clearBPathCache } from "@nudojs/service";
+import { typeValueToString } from "@nudojs/core";
+
+const dirs: string[] = [];
+afterAll(() => {
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+describe("B-path path-based @nudo:env", () => {
+  it("loads ./custom.env.ts globals", async () => {
+    clearBPathCache();
+    const dir = mkdtempSync(join(tmpdir(), "nudo-path-env-"));
+    dirs.push(dir);
+    writeFileSync(
+      join(dir, "custom.env.ts"),
+      `import { T } from "@nudojs/core";
+export function defineEnv() {
+  return {
+    globals: {
+      MAGIC: T.literal(99),
+    },
+  };
+}
+`,
+    );
+    const main = `/// @nudo:env ./custom.env.ts
+
+/**
+ * @nudo:case "t" ()
+ */
+function getMagic() {
+  return MAGIC;
+}
+`;
+    const p = join(dir, "main.js");
+    writeFileSync(p, main, "utf-8");
+    const result = await analyzeFileAsync(p, main);
+    const fn = result.functions.find((f) => f.name === "getMagic");
+    expect(fn).toBeDefined();
+    expect(typeValueToString(fn!.cases[0].result)).toBe("99");
+  });
+});

package/src/__tests__/bpath-reexport.test.ts

@@ -0,0 +1,131 @@
+import { it, expect, describe, afterAll } from "vitest";
+import { analyzeFile, clearBPathCache } from "@nudojs/service";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const dirs: string[] = [];
+afterAll(() => {
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+function setup(files: Record<string, string>) {
+  const dir = mkdtempSync(join(tmpdir(), "nudo-mod-"));
+  dirs.push(dir);
+  writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "mod", version: "1.0.0" }));
+  for (const [name, src] of Object.entries(files)) {
+    writeFileSync(join(dir, name), src);
+  }
+  return dir;
+}
+
+function goResult(dir: string, src: string) {
+  writeFileSync(join(dir, "index.js"), src);
+  clearBPathCache();
+  const r = analyzeFile(join(dir, "index.js"), src);
+  const f = r.functions.find((x) => x.name === "go");
+  return { result: f?.cases[0]?.result, diags: r.diagnostics };
+}
+
+describe("B-path re-export / export *", () => {
+  it("export { add } from './core.js'", () => {
+    const dir = setup({
+      "core.js": `export function add(a, b) { return a + b; }
+`,
+      "barrel.js": `export { add } from "./core.js";
+`,
+    });
+    const { result } = goResult(
+      dir,
+      `import { add } from "./barrel.js";
+/**
+ * @nudo:case "n" (2, 3)
+ */
+export function go(a, b) { return add(a, b); }
+`,
+    );
+    expect(result).toMatchObject({ kind: "literal", value: 5 });
+  });
+
+  it("export { add as default } from './core.js'", () => {
+    const dir = setup({
+      "core.js": `export function add(a, b) { return a + b; }
+`,
+      "barrel.js": `export { add as default } from "./core.js";
+`,
+    });
+    const { result } = goResult(
+      dir,
+      `import add from "./barrel.js";
+/**
+ * @nudo:case "n" (4, 6)
+ */
+export function go(a, b) { return add(a, b); }
+`,
+    );
+    expect(result).toMatchObject({ kind: "literal", value: 10 });
+  });
+
+  it("export * from './core.js'", () => {
+    const dir = setup({
+      "core.js": `export function add(a, b) { return a + b; }
+export function mul(a, b) { return a * b; }
+`,
+      "barrel.js": `export * from "./core.js";
+`,
+    });
+    const { result } = goResult(
+      dir,
+      `import { mul } from "./barrel.js";
+/**
+ * @nudo:case "n" (3, 5)
+ */
+export function go(a, b) { return mul(a, b); }
+`,
+    );
+    expect(result).toMatchObject({ kind: "literal", value: 15 });
+  });
+
+  it("class default export", () => {
+    const dir = setup({
+      "box.js": `export default class Box {
+  constructor(v) { this.v = v; }
+  get() { return this.v; }
+}
+`,
+    });
+    const { result } = goResult(
+      dir,
+      `import Box from "./box.js";
+/**
+ * @nudo:case "v" (7)
+ */
+export function go(v) {
+  const b = new Box(v);
+  return b.get();
+}
+`,
+    );
+    expect(result).toMatchObject({ kind: "literal", value: 7 });
+  });
+
+  it("async default export", () => {
+    const dir = setup({
+      "afn.js": `export default async function load(x) { return x + 1; }
+`,
+    });
+    const { result } = goResult(
+      dir,
+      `import load from "./afn.js";
+/**
+ * @nudo:case "x" (9)
+ */
+export async function go(x) { return await load(x); }
+`,
+    );
+    expect(result).toMatchObject({
+      kind: "promise",
+      value: { kind: "literal", value: 10 },
+    });
+  });
+});

package/src/__tests__/bpath-replace.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from "vitest";
+import { analyzeFile } from "@nudojs/service";
+import { typeValueToString } from "@nudojs/core";
+
+describe("@nudo:replace on B path", () => {
+  it("replaces only matching sub-expression", () => {
+    const source = `
+/**
+ * @nudo:case "test" (5, 10)
+ */
+function compute(a, b) {
+  // @nudo:replace a T.literal(100)
+  const result = a + b;
+  return result;
+}
+`;
+    const result = analyzeFile("/test/replace.js", source);
+    expect(typeValueToString(result.functions[0].cases[0].result)).toBe("110");
+  });
+
+  it("does not match partial identifiers", () => {
+    const source = `
+/**
+ * @nudo:case "test" ()
+ */
+function test() {
+  const aa = 1;
+  const a = 2;
+  // @nudo:replace a T.literal(99)
+  const result = aa + a;
+  return result;
+}
+`;
+    const result = analyzeFile("/test/replace2.js", source);
+    expect(typeValueToString(result.functions[0].cases[0].result)).toBe("100");
+  });
+
+  it("replaces call expression target", () => {
+    const source = `
+/**
+ * @nudo:case "test" ("{\"id\":1}")
+ */
+function process(input) {
+  // @nudo:replace JSON.parse(input) T.object({ id: T.number })
+  const data = JSON.parse(input);
+  return data.id;
+}
+`;
+    const result = analyzeFile("/test/replace3.js", source);
+    expect(typeValueToString(result.functions[0].cases[0].result)).toBe("number");
+  });
+});

package/src/__tests__/bpath-require.test.ts

@@ -0,0 +1,66 @@
+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 {
+  analyzeFile,
+  tryBPathCall,
+  isBPathCapable,
+  clearBPathCache,
+} from "@nudojs/service";
+import { typeValueToString, $lit, litValue } from "@nudojs/core";
+
+const dirs: string[] = [];
+afterAll(() => {
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+describe("B-path require", () => {
+  it("relative require injects Abs exports", () => {
+    clearBPathCache();
+    const dir = mkdtempSync(join(tmpdir(), "nudo-req-"));
+    dirs.push(dir);
+    writeFileSync(
+      join(dir, "math.js"),
+      `function double(x) { return x * 2; }\nexport { double };\n`,
+    );
+    const main = `
+const math = require("./math.js");
+/**
+ * @nudo:case "t" (21)
+ */
+export function go(n) {
+  return math.double(n);
+}
+`;
+    const p = join(dir, "main.js");
+    writeFileSync(p, main, "utf-8");
+    expect(isBPathCapable(main)).toBe(true);
+    const r = tryBPathCall(main, p, "go", [$lit(21)]);
+    expect(r).toBeDefined();
+    expect(litValue(r!)).toBe(42);
+  });
+
+  it("analyzeFile case works with require", () => {
+    clearBPathCache();
+    const dir = mkdtempSync(join(tmpdir(), "nudo-req2-"));
+    dirs.push(dir);
+    writeFileSync(join(dir, "util.js"), `export function inc(x) { return x + 1; }\n`);
+    const main = `
+const util = require("./util.js");
+/**
+ * @nudo:case "t" (1)
+ */
+function go(n) {
+  return util.inc(n);
+}
+`;
+    const p = join(dir, "main.js");
+    writeFileSync(p, main, "utf-8");
+    const result = analyzeFile(p, main);
+    const go = result.functions.find((f) => f.name === "go");
+    expect(go).toBeDefined();
+    const c = go!.cases.find((x) => x.name === "t");
+    expect(typeValueToString(c!.result)).toBe("2");
+  });
+});

package/src/__tests__/bpath-run.test.ts

@@ -0,0 +1,109 @@
+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 { runTranspiled, callTranspiledExport, $lit, litValue } from "@nudojs/core";
+import { tryBPathCall, isBPathCapable, analyzeFile } from "@nudojs/service";
+import { typeValueToString } from "@nudojs/core";
+
+const dirs: string[] = [];
+afterAll(() => {
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+function tmpPair(math: string, main: string) {
+  const dir = mkdtempSync(join(tmpdir(), "nudo-bpath-imp-"));
+  dirs.push(dir);
+  writeFileSync(join(dir, "math.js"), math, "utf-8");
+  writeFileSync(join(dir, "main.js"), main, "utf-8");
+  return { dir, mainPath: join(dir, "main.js"), main };
+}
+
+describe("B-path imported functions", () => {
+  it("runTranspiled + injected JS exports from dep", () => {
+    const dep = runTranspiled(`export function double(x) { return x * 2; }`);
+    const main = runTranspiled(
+      `import { double } from "./math.js";
+export function run(n) { return double(n); }`,
+      { modules: { "./math.js": dep as never } },
+    );
+    const r = callTranspiledExport(main, "run", [$lit(21)]);
+    expect(litValue(r)).toBe(42);
+  });
+
+  it("tryBPathCall via module graph (Abs absFunction dep)", () => {
+    const { main, mainPath } = tmpPair(
+      `export function double(x) { return x * 2; }`,
+      `import { double } from "./math.js";
+export function run(n) { return double(n); }
+`,
+    );
+    const r = tryBPathCall(main, mainPath, "run", [$lit(21)]);
+    expect(r).toBeDefined();
+    expect(litValue(r!)).toBe(42);
+  });
+
+  it("analyzeFile case polish uses B path for relative import", () => {
+    const { dir, main, mainPath } = tmpPair(
+      `export function triple(x) { return x * 3; }`,
+      `import { triple } from "./b.js";
+/**
+ * @nudo:case "four" (4)
+ */
+export function run(n) { return triple(n); }
+`.replace("./b.js", "./math.js"),
+    );
+    void dir;
+    const result = analyzeFile(mainPath, main);
+    const run = result.functions.find((f) => f.name === "run");
+    expect(run).toBeDefined();
+    const c = run!.cases.find((x) => x.name === "four");
+    expect(c).toBeDefined();
+    expect(typeValueToString(c!.result)).toBe("12");
+    // B 路径应挂上 intension
+    expect(c!.intension?.abs ?? c!.intension?.display).toBeTruthy();
+  });
+
+  it("isBPathCapable allows class, async, and require; rejects env", () => {
+    expect(isBPathCapable("function f() { return 1; }")).toBe(true);
+    expect(isBPathCapable("class A { constructor() { this.x = 1; } }")).toBe(true);
+    expect(isBPathCapable("async function f() { return 1; }")).toBe(true);
+    expect(isBPathCapable("const x = require('lodash');")).toBe(true);
+  });
+
+  it("object slots holding functions become first-class Abs fns (no raw JS leak)", () => {
+    // 回归：transpile 把函数表达式编译成真实 JS 函数；流进对象槽后
+    // 下游 absToTypeValue 读 .shape 曾裸崩（Cannot read properties of undefined (reading 'k')）
+    const dir = mkdtempSync(join(tmpdir(), "nudo-bpath-fnslot-"));
+    dirs.push(dir);
+    const p = join(dir, "main.js");
+    const src = `
+function helper(a, b) { return a; }
+export function make() {
+  const f = (x) => x + 1;
+  return { load: f, arrow: (y) => y, ref: helper };
+}
+`;
+    writeFileSync(p, src, "utf-8");
+    const r = tryBPathCall(src, p, "make", []);
+    expect(r).toBeDefined();
+    expect(r!.shape.k).toBe("obj");
+    const slots = (r!.shape as { slots: Record<string, { value: { shape: { k: string; params?: string[] } } }> }).slots;
+    expect(slots.load.value.shape.k).toBe("fn");
+    expect(slots.arrow.value.shape.params).toEqual(["y"]);
+    // 声明函数引用无参数名可恢复 → argN 回退（与 analyzer extractParamNames 口径一致）
+    expect(slots.ref.value.shape.params).toEqual(["arg0", "arg1"]);
+  });
+});
+
+describe("transpile import emission", () => {
+  it("preserves relative import", async () => {
+    const { transpile } = await import("@nudojs/core");
+    const out = transpile(
+      `import { double } from "./math.js";
+export function run(n) { return double(n); }`,
+    );
+    expect(out).toContain('from "./math.js"');
+    expect(out).toContain("double");
+  });
+});

package/src/__tests__/cjs-require.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect } from "vitest";
+import { writeFileSync, mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { collectStaticImports, collectDependencySpecs } from "../static-imports.ts";
+import { parse } from "@nudojs/parser";
+
+describe("CJS require static resolution", () => {
+  it("follows require('./x')", () => {
+    const dir = mkdtempSync(join(tmpdir(), "nudo-cjs-"));
+    try {
+      writeFileSync(
+        join(dir, "math.js"),
+        `function add(a, b) { return a + b; }\nexports.add = add;\nexports.scale = function (x) { return add(x, 1); };\n`,
+      );
+      writeFileSync(
+        join(dir, "index.js"),
+        `const { add } = require("./math.js");\nexports.double = function (x) { return add(x, x); };\n`,
+      );
+      const graph = collectStaticImports(join(dir, "index.js"));
+      expect(graph.size).toBe(2);
+      const index = graph.get(join(dir, "index.js"))!;
+      expect(index.named.has("double")).toBe(true);
+      const math = graph.get(join(dir, "math.js"))!;
+      expect(math.named.has("add")).toBe(true);
+      expect(math.poly.get("add")?.display).toContain("A1");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("collectDependencySpecs finds require strings", () => {
+    const ast = parse(`const a = require("./a.js");\nconst b = require("./b.js");\n`);
+    const specs = collectDependencySpecs(ast);
+    expect(specs).toContain("./a.js");
+    expect(specs).toContain("./b.js");
+  });
+
+  it("module.exports = fn registers export", () => {
+    const dir = mkdtempSync(join(tmpdir(), "nudo-cjs2-"));
+    try {
+      writeFileSync(
+        join(dir, "lib.js"),
+        `function hello() { return "hi"; }\nmodule.exports = hello;\n`,
+      );
+      writeFileSync(join(dir, "app.js"), `const hello = require("./lib.js");\nexports.f = hello;\n`);
+      const graph = collectStaticImports(join(dir, "app.js"));
+      const lib = graph.get(join(dir, "lib.js"))!;
+      expect(lib.named.has("hello")).toBe(true);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/__tests__/diagnostics.test.ts

@@ -30,36 +30,6 @@ function fn(x) {
     expect(unreachable!.suggestions!.length).toBeGreaterThan(0);
   });
 
-  it("should include code for assertion-failed diagnostics", () => {
-    const source = `
-/** @nudo:case "test" (1)
- *  @nudo:returns (T.string)
- */
-function fn(x) {
-  return x;
-}
-`;
-    const result = analyzeFile("test.js", source);
-    const assertion = result.diagnostics.find(d => d.message.includes("assertion"));
-    expect(assertion).toBeDefined();
-    expect(assertion!.code).toBe("nudo-assertion-failed");
-  });
-
-  it("should include suggestions for assertion-failed diagnostics", () => {
-    const source = `
-/** @nudo:case "test" (1)
- *  @nudo:returns (T.string)
- */
-function fn(x) {
-  return x;
-}
-`;
-    const result = analyzeFile("test.js", source);
-    const assertion = result.diagnostics.find(d => d.message.includes("assertion"));
-    expect(assertion!.suggestions).toBeDefined();
-    expect(assertion!.suggestions!.length).toBeGreaterThan(0);
-  });
-
   it("should generate nudo:builtin-unknown for uncovered APIs", () => {
     const source = `
 // @nudo:case "test" ()