@nudojs/core 0.3.0 → 0.4.0

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

@@ -1,117 +0,0 @@
-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

@@ -1,69 +0,0 @@
-/**
- * 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

@@ -1,290 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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([]);
-  });
-});

package/src/algebra/__tests__/check-mini-repo.test.ts

@@ -1,49 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { readFileSync } from "node:fs";
-import { resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { checkSource, pTrue } from "../index.ts";
-import { withStdImport, stdOpts } from "./nudo-constraints.ts";
-
-const root = resolve(dirname(fileURLToPath(import.meta.url)), "../../../../../");
-const mini = (f: string) => readFileSync(resolve(root, "docs/examples/mini-repo", f), "utf8");
-
-/**
- * mini-repo 人工金标：文件级 check 期望。
- * 这是「替换 tsc」的 recall 基线——新增违例模式时先补这里。
- */
-describe("mini-repo check gold", () => {
-  it("validators.js: no false positives", () => {
-    const r = checkSource("validators.js", mini("validators.js"));
-    expect(r.ok, r.issues.map((i) => i.message).join("; ")).toBe(true);
-    expect(r.signatures.map((f) => f.name)).toContain("isPositive");
-    expect(r.signatures.map((f) => f.name)).toContain("clamp");
-  });
-
-  it("store.js: class methods listed", () => {
-    const r = checkSource("store.js", mini("store.js"));
-    expect(r.ok).toBe(true);
-  });
-
-  it("user-service.js: ok (no literal violating calls)", () => {
-    const r = checkSource("user-service.js", mini("user-service.js"));
-    expect(r.ok, r.issues.map((i) => `${i.severity} ${i.message}`).join("; ")).toBe(true);
-  });
-
-  it("inline violating snippet still caught (TP recall)", () => {
-    // isPositive 是谓词（无 if-return-param 前置）；真正门禁用 refine
-    const src = `
-/**
- * @nudo:refine x positive
- */
-function needsPositive(x) {
-  if (x > 0) return x;
-  return 0;
-}
-needsPositive(-1);
-`;
-    const r = checkSource("tp.js", withStdImport(src), pTrue, stdOpts);
-    expect(r.ok).toBe(false);
-    expect(r.issues.some((i) => i.code === "nudo:constraint-violated")).toBe(true);
-  });
-});

package/src/algebra/__tests__/check-real-commander.test.ts

@@ -1,43 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { readFileSync, existsSync, readdirSync } from "node:fs";
-import { join, dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { checkSource } from "../index.ts";
-
-/**
- * 真实包精度门禁：commander（devDep）上不得出现任何 error 级误报。
- * 包不存在时跳过（非 monorepo 环境）。
- */
-
-const root = resolve(dirname(fileURLToPath(import.meta.url)), "../../../../..");
-const commanderLib = join(root, "node_modules/commander/lib");
-
-const ERROR_CODES = [
-  "nudo:constraint-violated",
-  "nudo:assign-mismatch",
-  "nudo:arg-structure",
-] as const;
-
-describe("real package precision (commander)", () => {
-  const hasPkg = existsSync(commanderLib);
-
-  it.runIf(hasPkg)("no false-positive errors (constraint / assign / arg-structure)", () => {
-    const files = readdirSync(commanderLib).filter((f) => f.endsWith(".js"));
-    expect(files.length).toBeGreaterThan(0);
-
-    const violations: string[] = [];
-    let scanned = 0;
-    for (const f of files) {
-      const source = readFileSync(join(commanderLib, f), "utf8");
-      const r = checkSource(`commander/${f}`, source);
-      scanned++;
-      for (const i of r.issues) {
-        if (i.severity === "error" && (ERROR_CODES as readonly string[]).includes(i.code)) {
-          violations.push(`commander/${f}:${i.line ?? "?"} [${i.code}] ${i.message}`);
-        }
-      }
-    }
-    expect(scanned).toBeGreaterThan(3);
-    expect(violations, violations.join("\n")).toEqual([]);
-  });
-});