@nudojs/core 0.1.0 → 0.3.0

package/src/algebra/__tests__/bridge.test.ts

@@ -0,0 +1,160 @@
+import { describe, it, expect } from "vitest";
+import {
+  absToTypeValue,
+  typeValueToAbs,
+  bridgeIsLossy,
+  getTvConfidence,
+  numLit,
+  numVar,
+  gtNum,
+  v,
+  litValue,
+  formatShape,
+  analyzeFn,
+  objOf,
+  strLit,
+  boolLit,
+} from "../index.ts";
+import { typeValueToString, T } from "../../type-value.ts";
+
+describe("bridge Abs → TypeValue", () => {
+  it("literal 4 → literal 4 #exact", () => {
+    const tv = absToTypeValue(numLit(4));
+    expect(tv.kind).toBe("literal");
+    if (tv.kind === "literal") expect(tv.value).toBe(4);
+    expect(getTvConfidence(tv)).toBe("exact");
+  });
+
+  it("plain number prim → primitive number", () => {
+    const tv = absToTypeValue({
+      shape: { k: "prim", type: "number" },
+      conf: "exact",
+    });
+    expect(typeValueToString(tv)).toBe("number");
+  });
+
+  it("x>0 with pred → refined number", () => {
+    const a = numVar("x", gtNum(v("x"), 0));
+    const tv = absToTypeValue(a);
+    // term 是 var，会丢 term；pred 可 encode 为 refined
+    expect(tv.kind === "refined" || tv.kind === "primitive").toBe(true);
+    const lossy = bridgeIsLossy(a);
+    // 丢 term 是预期的
+    expect(lossy.reasons.some((r) => r.includes("term"))).toBe(true);
+  });
+
+  it("object slots map to object TypeValue", () => {
+    const o = objOf({
+      host: { value: strLit("localhost") },
+      port: { value: numLit(8080) },
+      debug: { value: boolLit(false) },
+    });
+    const tv = absToTypeValue(o);
+    expect(tv.kind).toBe("object");
+    expect(typeValueToString(tv)).toContain("host");
+    expect(typeValueToString(tv)).toContain("8080");
+  });
+});
+
+describe("bridge TypeValue → Abs", () => {
+  it("literal 6 → Abs exact 6", () => {
+    const abs = typeValueToAbs(T.literal(6));
+    expect(litValue(abs)).toBe(6);
+    expect(abs.conf).toBe("exact");
+  });
+
+  it("primitive string → prim string", () => {
+    const abs = typeValueToAbs(T.string);
+    expect(formatShape(abs)).toBe("string");
+  });
+
+  it("object → obj slots", () => {
+    const abs = typeValueToAbs(
+      T.object({ a: T.literal(1), b: T.string }),
+    );
+    expect(abs.shape.k).toBe("obj");
+  });
+
+  it("round-trip literal", () => {
+    const tv = absToTypeValue(numLit(42));
+    const back = typeValueToAbs(tv);
+    expect(litValue(back)).toBe(42);
+  });
+
+  it("round-trip primitive (lossless)", () => {
+    const abs0 = {
+      shape: { k: "prim" as const, type: "number" as const },
+      conf: "exact" as const,
+    };
+    const tv = absToTypeValue(abs0);
+    const back = typeValueToAbs(tv);
+    expect(formatShape(back)).toBe("number");
+  });
+});
+
+describe("bridgeIsLossy", () => {
+  it("literal is not lossy", () => {
+    expect(bridgeIsLossy(numLit(1)).lossy).toBe(false);
+  });
+  it("symbolic term is lossy", () => {
+    const src = `
+      function scale(x) { return x + 1; }
+    `;
+    const r = analyzeFn(src, "scale", [numVar("x")]);
+    expect(bridgeIsLossy(r).lossy).toBe(true);
+  });
+});
+
+describe("bridge any / conf / refined reverse (rewrite closeout)", () => {
+  it("Abs any projects as unknown but keeps path conf (not partial)", () => {
+    const a: import("../abs.ts").Abs = { shape: { k: "any" }, conf: "path" };
+    const tv = absToTypeValue(a);
+    expect(tv.kind).toBe("unknown");
+    expect(getTvConfidence(tv)).toBe("path");
+  });
+
+  it("Abs analysis-fail unknown keeps partial conf", () => {
+    const a: import("../abs.ts").Abs = { shape: { k: "unknown" }, conf: "partial" };
+    const tv = absToTypeValue(a);
+    expect(tv.kind).toBe("unknown");
+    expect(getTvConfidence(tv)).toBe("partial");
+  });
+
+  it("widened TypeValue does not round-trip as exact", () => {
+    const src = `
+      function scale(x) { return x + 1; }
+    `;
+    const r = analyzeFn(src, "scale", [numVar("x")]);
+    const tv = absToTypeValue(r);
+    const back = typeValueToAbs(tv);
+    expect(back.conf === "exact").toBe(false);
+  });
+
+  it("refined numeric pred reverse-encodes into Abs pred", () => {
+    const a = numVar("x", gtNum(v("x"), 0));
+    const tv = absToTypeValue(a);
+    expect(tv.kind).toBe("refined");
+    const back = typeValueToAbs(tv);
+    expect(back.shape.k).toBe("prim");
+    expect(back.pred).toBeDefined();
+    expect(back.pred!.op).toBe("gt");
+    // pred 右端恢复为字面量 0
+    if (back.pred!.op === "gt") {
+      expect(back.pred!.b.op).toBe("lit");
+      if (back.pred!.b.op === "lit") expect(back.pred!.b.value).toBe(0);
+    }
+  });
+
+  it("refined le reverse-encodes", () => {
+    const a: import("../abs.ts").Abs = {
+      shape: { k: "prim", type: "number" },
+      term: v("n"),
+      pred: { op: "le", a: v("n"), b: { op: "lit", value: 10 } },
+      conf: "path",
+    };
+    const tv = absToTypeValue(a);
+    expect(tv.kind).toBe("refined");
+    const back = typeValueToAbs(tv);
+    expect(back.pred?.op).toBe("le");
+  });
+});

package/src/algebra/__tests__/call-budget.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect } from "vitest";
+import { checkSource } from "../check.ts";
+import {
+  analyzeFn,
+  evalProgramAbs,
+  resetAbsCallBudget,
+  MAX_CALL_DEPTH,
+} from "../ast-eval.ts";
+import { pTrue } from "../pred.ts";
+import { num, unknown } from "../abs.ts";
+import type { Abs } from "../abs.ts";
+
+const FAC = `
+function fac(n) {
+  if (n <= 1) return 1;
+  return n * fac(n - 1);
+}
+`;
+
+const FIB = `
+function fib(n) {
+  if (n <= 1) return n;
+  return fib(n - 1) + fib(n - 2);
+}
+`;
+
+const MUTUAL = `
+function isEven(n) {
+  if (n === 0) return true;
+  return isOdd(n - 1);
+}
+function isOdd(n) {
+  if (n === 0) return false;
+  return isEven(n - 1);
+}
+`;
+
+describe("Abs call budget (recursion guard)", () => {
+  it("analyzeFn on factorial does not stack-overflow", () => {
+    resetAbsCallBudget();
+    const r = analyzeFn(FAC, "fac", [num()], pTrue);
+    expect(r).toBeDefined();
+    expect(r.shape.k === "unknown" || r.shape.k === "prim" || r.shape.k === "never").toBe(true);
+  });
+
+  it("analyzeFn on fib does not stack-overflow", () => {
+    resetAbsCallBudget();
+    const r = analyzeFn(FIB, "fib", [num()], pTrue);
+    expect(r).toBeDefined();
+  });
+
+  it("mutual recursion does not stack-overflow", () => {
+    resetAbsCallBudget();
+    const r = analyzeFn(MUTUAL, "isEven", [num()], pTrue);
+    expect(r).toBeDefined();
+  });
+
+  it("evalProgramAbs with top-level recursive call does not stack-overflow", () => {
+    resetAbsCallBudget();
+    const { last } = evalProgramAbs(`
+function count(n) {
+  if (n <= 0) return 0;
+  return 1 + count(n - 1);
+}
+const x = count(5);
+`);
+    expect(last).toBeDefined();
+  });
+
+  it("concrete base-case recursion still evaluates", () => {
+    // 调用深度在 64 内：count(5) 应给出字面量结果而非 opaque
+    resetAbsCallBudget();
+    const lit5: Abs = {
+      shape: { k: "prim", type: "number" },
+      term: { op: "lit", value: 5 },
+      conf: "exact",
+    };
+    const r = analyzeFn(
+      `
+function count(n) {
+  if (n <= 0) return 0;
+  return 1 + count(n - 1);
+}
+`,
+      "count",
+      [lit5],
+      pTrue,
+    );
+    // 5 层展开应收敛为字面量 5（或至少 number）
+    expect(r.shape.k === "prim" || r.shape.k === "never").toBe(true);
+    if (r.term && r.term.op === "lit") {
+      expect(r.term.value).toBe(5);
+    }
+  });
+
+  it("checkSource completes on factorial with structured diagnostics", () => {
+    const report = checkSource("/tmp/fac.js", FAC, pTrue, {});
+    expect(report).toBeDefined();
+    // 不得崩溃；递归截断记 warning
+    const codes = report.issues.map((i) => i.code);
+    expect(codes).toContain("nudo:recursion-truncated");
+    expect(report.issues.every((i) => i.severity !== undefined)).toBe(true);
+  });
+
+  it("depth budget constant is aligned with TypeValue evaluator", () => {
+    expect(MAX_CALL_DEPTH).toBe(64);
+  });
+
+  it("truncated result uses opaque conf, not partial-any", () => {
+    resetAbsCallBudget();
+    const r = analyzeFn(FAC, "fac", [num()], pTrue);
+    // 截断后应为 unknown+opaque，或仍能算出的 prim；绝不能是 exact 的假结果
+    if (r.shape.k === "unknown") {
+      expect(r.conf === "opaque" || r.conf === "partial" || r.conf === "widened").toBe(true);
+    }
+  });
+});

package/src/algebra/__tests__/check-case-consistency.test.ts

@@ -0,0 +1,69 @@
+/**
+ * case ⊄ refine → nudo:case-inconsistency
+ * case 是契约的见证，不是另一套前置来源。
+ */
+import { describe, it, expect } from "vitest";
+import { checkSource, pTrue } from "../index.ts";
+import { withStdImport, stdOpts } from "./nudo-constraints.ts";
+
+function issuesOf(src: string) {
+  return checkSource("/t/case.js", withStdImport(src), pTrue, stdOpts);
+}
+
+describe("case vs refine", () => {
+  it("ok: case 实参满足契约", () => {
+    const r = issuesOf(`
+/**
+ * @nudo:refine x positive
+ * @nudo:case "ok" (5)
+ */
+function needsPositive(x) {
+  return x;
+}
+`);
+    expect(r.issues.filter((i) => i.code === "nudo:case-inconsistency")).toEqual([]);
+  });
+
+  it("error: case 实参 ⊭ refine", () => {
+    const r = issuesOf(`
+/**
+ * @nudo:refine x positive
+ * @nudo:case "neg" (-1)
+ */
+function needsPositive(x) {
+  return x;
+}
+`);
+    const err = r.issues.find((i) => i.code === "nudo:case-inconsistency");
+    expect(err).toBeDefined();
+    expect(err!.severity).toBe("error");
+    expect(err!.expected).toContain(">");
+    expect(err!.message).toContain("neg");
+  });
+
+  it("error: percent 上界违例", () => {
+    const r = issuesOf(`
+/**
+ * @nudo:refine n percent
+ * @nudo:case "big" (150)
+ */
+function pct(n) {
+  return n;
+}
+`);
+    expect(r.ok).toBe(false);
+    expect(r.issues.some((i) => i.code === "nudo:case-inconsistency")).toBe(true);
+  });
+
+  it("ok: 无 refine 的 case 不报", () => {
+    const r = issuesOf(`
+/**
+ * @nudo:case "any" (-1)
+ */
+function id(x) {
+  return x;
+}
+`);
+    expect(r.issues.filter((i) => i.code === "nudo:case-inconsistency")).toEqual([]);
+  });
+});

package/src/algebra/__tests__/check-gold.test.ts

@@ -0,0 +1,290 @@
+import { describe, it, expect } from "vitest";
+import { checkSource, pTrue } from "../index.ts";
+import { withStdImport, stdOpts } from "./nudo-constraints.ts";
+
+/**
+ * nudo check 金标：多形态 JS 片段上的门禁行为。
+ * 每条：source + 期望 ok / 期望出现的 issue code。
+ */
+
+type Gold = {
+  name: string;
+  source: string;
+  expectOk: boolean;
+  expectCode?: string;
+};
+
+const golds: Gold[] = [
+  {
+    name: "valid positive call",
+    source: `
+/**
+ * @nudo:refine x positive
+ */
+function needsPositive(x) {
+  if (x > 0) return x;
+  return 0;
+}
+const r = needsPositive(5);
+`,
+    expectOk: true,
+  },
+  {
+    name: "negative call violates x>0",
+    source: `
+/**
+ * @nudo:refine x positive
+ */
+function needsPositive(x) {
+  if (x > 0) return x;
+  return 0;
+}
+const r = needsPositive(-1);
+`,
+    expectOk: false,
+    expectCode: "nudo:constraint-violated",
+  },
+  {
+    name: "range guard lo is clamp not violation",
+    source: `
+function clampId(id) {
+  if (id < 1) return 1;
+  if (id > 9999) return 9999;
+  return id;
+}
+clampId(0);
+`,
+    // `id < 1` 是回退守卫，不作为调用前置
+    expectOk: true,
+  },
+  {
+    name: "range guard valid mid",
+    source: `
+function clampId(id) {
+  if (id < 1) return 1;
+  if (id > 9999) return 9999;
+  return id;
+}
+clampId(50);
+`,
+    expectOk: true,
+  },
+  {
+    name: "pure arithmetic no constraints",
+    source: `
+function add(a, b) { return a + b; }
+const r = add(1, 2);
+`,
+    expectOk: true,
+  },
+  {
+    name: "ESM export function still listed",
+    source: `
+export function scale(x) { return x + 1; }
+`,
+    expectOk: true,
+  },
+  {
+    name: "async function listed",
+    source: `
+export async function load(id) { return id + 1; }
+`,
+    expectOk: true,
+  },
+  {
+    name: "class constructor listed",
+    source: `
+class Counter {
+  constructor(n) { this.n = n; }
+  get() { return this.n; }
+}
+export function main() { return new Counter(1).get(); }
+`,
+    expectOk: true,
+  },
+  // --- 真阳性：必须报 ---
+  {
+    name: "zero violates x>0",
+    source: `
+/**
+ * @nudo:refine x positive
+ */
+function needsPositive(x) {
+  if (x > 0) return x;
+  return 0;
+}
+needsPositive(0);
+`,
+    expectOk: false,
+    expectCode: "nudo:constraint-violated",
+  },
+  {
+    name: "unary negative call",
+    source: `
+/**
+ * @nudo:refine x positive
+ */
+function needsPositive(x) {
+  if (x > 0) return x;
+  return 0;
+}
+needsPositive(-3);
+`,
+    expectOk: false,
+    expectCode: "nudo:constraint-violated",
+  },
+  {
+    name: "x>=1 rejects 0",
+    source: `
+/**
+ * @nudo:refine i atLeast1
+ */
+function idx(i) {
+  if (i >= 1) return i;
+  return 1;
+}
+idx(0);
+`,
+    expectOk: false,
+    expectCode: "nudo:constraint-violated",
+  },
+  {
+    name: "upper bound x<10 rejects 10",
+    source: `
+/**
+ * @nudo:refine n small
+ */
+function small(n) {
+  if (n < 10) return n;
+  return 9;
+}
+small(10);
+`,
+    expectOk: false,
+    expectCode: "nudo:constraint-violated",
+  },
+  // --- 真阴性：不得误报（clamp / 无前置） ---
+  {
+    name: "clamp negative input is not violation",
+    source: `
+function clamp(n, lo, hi) {
+  if (n < lo) return lo;
+  if (n > hi) return hi;
+  return n;
+}
+clamp(-5, 0, 100);
+`,
+    expectOk: true,
+  },
+  {
+    name: "no guard no constraint",
+    source: `
+function double(n) { return n * 2; }
+double(-1);
+`,
+    expectOk: true,
+  },
+  {
+    name: "equality guard is not numeric precondition",
+    source: `
+function onlyZero(x) {
+  if (x === 0) return 0;
+  return 1;
+}
+onlyZero(5);
+`,
+    expectOk: true,
+  },
+  {
+    name: "min boundary valid",
+    source: `
+function needsPositive(x) {
+  if (x > 0) return x;
+  return 0;
+}
+needsPositive(1);
+`,
+    expectOk: true,
+  },
+  // --- 结构 ---
+  {
+    name: "arrow function constraint",
+    source: `
+/**
+ * @nudo:refine x positive
+ */
+const needsPositive = (x) => {
+  if (x > 0) return x;
+  return 0;
+};
+needsPositive(-2);
+`,
+    expectOk: false,
+    expectCode: "nudo:constraint-violated",
+  },
+  {
+    name: "export default function",
+    source: `
+/**
+ * @nudo:refine x positive
+ */
+export default function needsPositive(x) {
+  if (x > 0) return x;
+  return 0;
+}
+needsPositive(-1);
+`,
+    expectOk: false,
+    expectCode: "nudo:constraint-violated",
+  },
+  {
+    name: "both bounds mid valid",
+    source: `
+/**
+ * @nudo:refine n percent
+ */
+function pct(n) {
+  if (n >= 0 && n <= 100) return n;
+  return 0;
+}
+pct(50);
+`,
+    expectOk: true,
+  },
+  {
+    name: "both bounds high invalid",
+    source: `
+/**
+ * @nudo:refine n percent
+ */
+function pct(n) {
+  if (n >= 0 && n <= 100) return n;
+  return 0;
+}
+pct(150);
+`,
+    expectOk: false,
+    expectCode: "nudo:constraint-violated",
+  },
+];
+
+describe("nudo check gold standards", () => {
+  for (const g of golds) {
+    it(g.name, () => {
+      const report = checkSource("gold.js", withStdImport(g.source), pTrue, stdOpts);
+      expect(report.ok, formatIssues(report)).toBe(g.expectOk);
+      if (g.expectCode) {
+        expect(
+          report.issues.some((i) => i.code === g.expectCode),
+          formatIssues(report),
+        ).toBe(true);
+      }
+      // 每个 case 至少能列出函数或明确无函数
+      expect(Array.isArray(report.signatures)).toBe(true);
+    });
+  }
+});
+
+function formatIssues(r: { issues: Array<{ severity: string; code: string; message: string }> }): string {
+  return r.issues.map((i) => `${i.severity} ${i.code}: ${i.message}`).join("; ") || "(none)";
+}

package/src/algebra/__tests__/check-json.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from "vitest";
+import { checkSource, serializeCheckJson, pTrue } from "../index.ts";
+import { withStdImport, stdOpts } from "./nudo-constraints.ts";
+
+describe("CheckJson contract v1", () => {
+  const src = `
+/**
+ * @nudo:refine x positive
+ */
+function needsPositive(x) {
+  if (x > 0) return x;
+  return 0;
+}
+needsPositive(-1);
+`;
+
+  it("has stable top-level fields", () => {
+    const j = serializeCheckJson(checkSource("c.js", withStdImport(src), pTrue, stdOpts));
+    expect(j.version).toBe(1);
+    expect(j.file).toBe("c.js");
+    expect(j.ok).toBe(false);
+    expect(j.summary).toMatchObject({
+      errors: expect.any(Number),
+      warnings: expect.any(Number),
+      infos: expect.any(Number),
+      functions: expect.any(Number),
+    });
+    expect(Array.isArray(j.signatures)).toBe(true);
+    expect(Array.isArray(j.issues)).toBe(true);
+  });
+
+  it("signatures carry abs display + detail", () => {
+    const j = serializeCheckJson(checkSource("c.js", withStdImport(src), pTrue, stdOpts));
+    const sig = j.signatures.find((s) => s.name === "needsPositive");
+    expect(sig).toBeDefined();
+    expect(sig!.params).toEqual(["x"]);
+    expect(sig!.abs).toContain("#");
+    expect(typeof sig!.conf).toBe("string");
+  });
+
+  it("issues carry actual/expected for violations", () => {
+    const j = serializeCheckJson(checkSource("c.js", withStdImport(src), pTrue, stdOpts));
+    const err = j.issues.find((i) => i.code === "nudo:constraint-violated");
+    expect(err).toBeDefined();
+    expect(err!.actual).toBeDefined();
+    expect(err!.expected).toBeDefined();
+    expect(err!.line).toBeGreaterThan(0);
+  });
+
+  it("ok file has ok:true and empty error issues", () => {
+    const j = serializeCheckJson(
+      checkSource("ok.js", `function f(x){ return x+1; }\nf(1);\n`, pTrue, stdOpts),
+    );
+    expect(j.ok).toBe(true);
+    expect(j.issues.filter((i) => i.severity === "error")).toEqual([]);
+  });
+});