vite-plugin-nudo 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # vite-plugin-nudo
 
+## 0.3.0
+
+### Minor Changes
+
+- 5786fa5: Ship TypeScript-aware defaults and Abs check diagnostics in the Vite plugin.
+
+  - Default include covers `.js` / `.mjs` / `.ts` / `.mts`; exclude also skips `*.d.ts`.
+  - Glob matching is a real anchored RegExp (not `endsWith` heuristics).
+  - Runs `analyzeFileAsync` plus `checkSource` so Abs constraint issues surface as Vite warnings/errors.
+  - Exposes `clearAnalysisSessionCaches` for long-lived Vite processes.
+
+### Patch Changes
+
+- Updated dependencies [5786fa5]
+- Updated dependencies [5786fa5]
+  - @nudojs/core@0.3.0
+  - @nudojs/service@0.3.0
+
+## 0.2.1
+
+### Patch Changes
+
+- @nudojs/service@0.2.1
+
 ## 0.2.0
 
 ### Minor Changes

package/README.md

@@ -0,0 +1,38 @@
+# vite-plugin-nudo
+
+Vite plugin for build-time JavaScript type inference with [Nudo](https://github.com/nudojs/nudo).
+
+## What is Nudo?
+
+Nudo is a type inference engine for JavaScript. Instead of a separate type system, it runs your code with symbolic type values via abstract interpretation — no TypeScript, no build step.
+
+## This package
+
+`vite-plugin-nudo` runs Nudo analysis during your Vite build, reporting type diagnostics as build warnings or errors.
+
+## Install
+
+```bash
+npm install -D vite-plugin-nudo
+```
+
+## Usage
+
+```js
+// vite.config.js
+import nudo from 'vite-plugin-nudo'
+
+export default {
+  plugins: [
+    nudo({
+      include: '**/*.js',       // default
+      exclude: '**/node_modules/**', // default
+      failOnError: false,       // default
+    }),
+  ],
+}
+```
+
+## License
+
+[MIT](https://github.com/nudojs/nudo/blob/main/LICENSE)

package/dist/index.js

@@ -1,37 +1,105 @@
 // src/index.ts
-import { analyzeFile } from "@nudojs/service";
-var DEFAULT_INCLUDE = ["**/*.js"];
-var DEFAULT_EXCLUDE = ["**/node_modules/**"];
-function matchesPatterns(id, include, exclude) {
-  const isExcluded = exclude.some((p) => minimatch(id, p));
-  if (isExcluded) return false;
-  return include.some((p) => minimatch(id, p));
+import {
+  analyzeFileAsync,
+  defaultLoadModule as loadModule,
+  clearAnalysisSessionCaches
+} from "@nudojs/service";
+import { checkSource, pTrue } from "@nudojs/core";
+var NUDO_DIRECTIVE_RE = /@nudo:(case|mock|pure|skip|sample|refine|import|env|mock-module|as|replace)\b/;
+function checkIssuesToDiagnostics(id, code) {
+  try {
+    const report = checkSource(id, code, pTrue, { loadModule, fromFile: id });
+    return report.issues.filter((i) => i.severity === "error" || i.severity === "warning").map((i) => {
+      const line = i.line ?? 1;
+      const column = i.column ?? 0;
+      const parts = [i.message];
+      if (i.actual) parts.push(`actual: ${i.actual}`);
+      if (i.expected) parts.push(`expected: ${i.expected}`);
+      if (i.suggestion) parts.push(i.suggestion);
+      if (i.code) parts.push(`(${i.code})`);
+      return {
+        severity: i.severity === "error" ? "error" : "warning",
+        message: parts.join(" \xB7 "),
+        code: i.code,
+        range: {
+          start: { line, column },
+          end: { line, column: column + 1 }
+        }
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+var DEFAULT_INCLUDE = ["**/*.js", "**/*.mjs", "**/*.ts", "**/*.mts"];
+var DEFAULT_EXCLUDE = ["**/node_modules/**", "**/*.d.ts"];
+var REGEX_SPECIALS = /[\\^$.|?*+(){}\[\]]/;
+function escapeRegExpChar(ch) {
+  return REGEX_SPECIALS.test(ch) ? `\\${ch}` : ch;
 }
-function minimatch(str, pattern) {
-  if (pattern === "**/*.js") return str.endsWith(".js");
-  if (pattern === "**/node_modules/**") return str.includes("/node_modules/");
-  if (pattern.startsWith("**/")) {
-    return str.endsWith(pattern.slice(3)) || str.includes(pattern.slice(2));
+function segmentToRegExpSource(segment) {
+  let source = "";
+  for (const ch of segment) {
+    if (ch === "*") source += "[^/]*";
+    else if (ch === "?") source += "[^/]";
+    else source += escapeRegExpChar(ch);
   }
-  return str.includes(pattern);
+  return source;
+}
+function patternToRegExp(pattern) {
+  const segments = pattern.split("/");
+  let source = "";
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    const isLast = i === segments.length - 1;
+    if (segment === "**") {
+      if (isLast) {
+        source = source.endsWith("/") ? `${source.slice(0, -1)}(?:/.*)?` : `${source}.*`;
+      } else {
+        source += "(?:.*/)?";
+      }
+    } else {
+      source += segmentToRegExpSource(segment);
+      if (!isLast) source += "/";
+    }
+  }
+  return new RegExp(`^${source}$`);
+}
+function compilePattern(pattern) {
+  if (!/[*?]/.test(pattern)) return (id) => id.includes(pattern);
+  const regExp = patternToRegExp(pattern);
+  return (id) => regExp.test(id);
+}
+function compileAnyMatcher(patterns) {
+  const matchers = patterns.map(compilePattern);
+  return (id) => matchers.some((match) => match(id));
 }
 function nudoPlugin(options = {}) {
-  const include = options.include ?? DEFAULT_INCLUDE;
-  const exclude = options.exclude ?? DEFAULT_EXCLUDE;
+  const includeMatch = compileAnyMatcher(options.include ?? DEFAULT_INCLUDE);
+  const excludeMatch = compileAnyMatcher(options.exclude ?? DEFAULT_EXCLUDE);
   const failOnError = options.failOnError ?? false;
   const analysisCache = /* @__PURE__ */ new Map();
   return {
     name: "vite-plugin-nudo",
     buildStart() {
       analysisCache.clear();
+      clearAnalysisSessionCaches();
+    },
+    /** 任一文件变更后，未改 source 的 importer 再 transform 时可能命中陈旧会话缓存 */
+    watchChange() {
+      analysisCache.clear();
+      clearAnalysisSessionCaches();
     },
-    transform(code, id) {
-      if (!matchesPatterns(id, include, exclude)) return null;
-      if (!/@nudo:(case|mock|pure|skip|sample|returns)\b/.test(code)) return null;
+    async transform(code, id) {
+      if (excludeMatch(id)) return null;
+      if (!includeMatch(id)) return null;
+      if (!NUDO_DIRECTIVE_RE.test(code)) return null;
       try {
-        const result = analyzeFile(id, code);
-        analysisCache.set(id, result);
-        for (const diag of result.diagnostics) {
+        const result = await analyzeFileAsync(id, code);
+        const checkDiags = checkIssuesToDiagnostics(id, code);
+        const merged = { ...result, diagnostics: [...result.diagnostics, ...checkDiags] };
+        analysisCache.set(id, merged);
+        for (const diag of merged.diagnostics) {
           const loc = `${id}:${diag.range.start.line}:${diag.range.start.column}`;
           const msg = `[nudo] ${loc} ${diag.severity}: ${diag.message}`;
           if (diag.severity === "error") {

package/package.json

@@ -1,20 +1,32 @@
 {
   "name": "vite-plugin-nudo",
-  "version": "0.2.0",
+  "version": "0.3.0",
+  "description": "Vite plugin for build-time JavaScript type inference with Nudo",
   "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "nudo",
+    "type-inference",
+    "javascript",
+    "vite",
+    "vite-plugin"
+  ],
   "main": "src/index.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nudojs/nudo.git",
     "directory": "packages/vite-plugin"
   },
+  "homepage": "https://github.com/nudojs/nudo/tree/main/packages/vite-plugin",
+  "bugs": "https://github.com/nudojs/nudo/issues",
   "publishConfig": {
     "access": "public",
     "provenance": true,
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@nudojs/service": "0.2.0"
+    "@nudojs/core": "0.3.0",
+    "@nudojs/service": "0.3.0"
   },
   "peerDependencies": {
     "vite": ">=5.0.0"

package/src/__tests__/plugin.test.ts

@@ -1,5 +1,8 @@
 import { describe, it, expect, vi } from "vitest";
-import nudoPlugin from "../index.ts";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import nudoPlugin, { type NudoPluginOptions } from "../index.ts";
 
 describe("vite-plugin-nudo", () => {
   it("creates a plugin with correct name", () => {
@@ -7,19 +10,53 @@ describe("vite-plugin-nudo", () => {
     expect(plugin.name).toBe("vite-plugin-nudo");
   });
 
-  it("returns null for files without @nudo: directives", () => {
+  it("returns null for files without @nudo: directives", async () => {
     const plugin = nudoPlugin();
-    const result = plugin.transform.call({}, "const x = 1;", "/test/file.js");
+    const result = await plugin.transform.call({}, "const x = 1;", "/test/file.js");
     expect(result).toBeNull();
   });
 
-  it("returns null for node_modules files", () => {
+  it("analyzes files that only declare @nudo:refine (gate aligned with LSP)", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "nudo-vite-"));
+    try {
+      writeFileSync(
+        join(dir, "shapes.nudo.js"),
+        `export const positive = number().gt(0);\n`,
+        "utf-8",
+      );
+      const source = `/// @nudo:import { positive } from "./shapes.nudo.js"
+
+/**
+ * @nudo:refine x positive
+ */
+function needsPositive(x) {
+  return x;
+}
+const r = needsPositive(-1);
+`;
+      const filePath = join(dir, "refine-only.js");
+      writeFileSync(filePath, source, "utf-8");
+
+      const plugin = nudoPlugin();
+      const warnFn = vi.fn();
+      const ctx = { warn: warnFn, error: vi.fn() };
+      const result = await plugin.transform.call(ctx, source, filePath);
+      expect(result).toBeNull();
+      expect(warnFn).toHaveBeenCalled();
+      const msgs = warnFn.mock.calls.map((c) => String(c[0])).join("\n");
+      expect(msgs).toContain("constraint-violated");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("returns null for node_modules files", async () => {
     const plugin = nudoPlugin();
-    const result = plugin.transform.call({}, "const x = 1;", "/node_modules/pkg/file.js");
+    const result = await plugin.transform.call({}, "const x = 1;", "/node_modules/pkg/file.js");
     expect(result).toBeNull();
   });
 
-  it("analyzes files with @nudo: directives and reports warnings", () => {
+  it("analyzes files with @nudo: directives and reports warnings", async () => {
     const plugin = nudoPlugin();
     const warnFn = vi.fn();
     const ctx = { warn: warnFn, error: vi.fn() };
@@ -35,14 +72,14 @@ function safeSqrt(x) {
   return x;
 }
 `;
-    const result = plugin.transform.call(ctx, source, "/test/throws.js");
+    const result = await plugin.transform.call(ctx, source, "/test/throws.js");
     expect(result).toBeNull();
     expect(warnFn).toHaveBeenCalled();
   });
 
-  it("respects custom include patterns", () => {
+  it("respects custom include patterns", async () => {
     const plugin = nudoPlugin({ include: ["**/*.typed.js"] });
-    const result = plugin.transform.call({}, "const x = 1;", "/test/file.js");
+    const result = await plugin.transform.call({}, "const x = 1;", "/test/file.js");
     expect(result).toBeNull();
   });
 
@@ -60,22 +97,99 @@ function safeSqrt(x) {
     consoleSpy.mockRestore();
   });
 
-  it("errors when failOnError is true and diagnostics have errors", () => {
+  it("errors when failOnError is true and diagnostics have errors", async () => {
     const plugin = nudoPlugin({ failOnError: true });
     const errorFn = vi.fn();
     const warnFn = vi.fn();
     const ctx = { warn: warnFn, error: errorFn };
 
+    // case 期望返回类型与推断不符 → error 级诊断
     const source = `
 /**
- * @nudo:case "test" (T.number)
- * @nudo:returns (T.string)
+ * @nudo:case "test" (1) => T.string
  */
 function identity(x) {
   return x;
 }
 `;
-    plugin.transform.call(ctx, source, "/test/fail.js");
+    await plugin.transform.call(ctx, source, "/test/fail.js");
     expect(errorFn).toHaveBeenCalled();
   });
 });
+
+describe("vite-plugin-nudo glob matching", () => {
+  // 稳定产出 warning（throw 路径），用来证明文件被分析过
+  const directiveSource = `
+/**
+ * @nudo:case "negative" (-1)
+ */
+function safeSqrt(x) {
+  if (x < 0) {
+    throw new RangeError("negative input");
+  }
+  return x;
+}
+`;
+
+  async function wasAnalyzed(id: string, options: NudoPluginOptions = {}): Promise<boolean> {
+    const plugin = nudoPlugin(options);
+    const warnFn = vi.fn();
+    const ctx = { warn: warnFn, error: vi.fn() };
+    const result = await plugin.transform.call(ctx, directiveSource, id);
+    return result === null && warnFn.mock.calls.length > 0;
+  }
+
+  it("matches **/*.js at any depth by default", async () => {
+    expect(await wasAnalyzed("/file.js")).toBe(true);
+    expect(await wasAnalyzed("/project/src/nested/mod.js")).toBe(true);
+  });
+
+  it("default include covers js/mjs/ts but not cjs", async () => {
+    expect(await wasAnalyzed("/test/file.mjs")).toBe(true);
+    expect(await wasAnalyzed("/test/file.ts")).toBe(true);
+    expect(await wasAnalyzed("/test/file.cjs")).toBe(false);
+    expect(await wasAnalyzed("/test/file.d.ts")).toBe(false);
+  });
+
+  it("supports **/*.mjs include patterns", async () => {
+    const options = { include: ["**/*.mjs"] };
+    expect(await wasAnalyzed("/test/file.mjs", options)).toBe(true);
+    expect(await wasAnalyzed("/project/src/deep/file.mjs", options)).toBe(true);
+    expect(await wasAnalyzed("/test/file.js", options)).toBe(false);
+  });
+
+  it("supports **/*.ts include patterns", async () => {
+    const options = { include: ["**/*.ts"] };
+    expect(await wasAnalyzed("/src/util.ts", options)).toBe(true);
+    expect(await wasAnalyzed("/src/util.js", options)).toBe(false);
+    expect(await wasAnalyzed("/src/component.tsx", options)).toBe(false);
+  });
+
+  it("excludes **/node_modules/** at any depth by default", async () => {
+    expect(await wasAnalyzed("/project/node_modules/pkg/index.js")).toBe(false);
+    expect(await wasAnalyzed("/project/packages/a/node_modules/dep/lib.js")).toBe(false);
+  });
+
+  it("excludes **/<dir>/** directory segments without false positives", async () => {
+    const options = { include: ["**/*.js"], exclude: ["**/fixtures/**"] };
+    expect(await wasAnalyzed("/test/fixtures/case.js", options)).toBe(false);
+    expect(await wasAnalyzed("/test/case.js", options)).toBe(true);
+    // "my-fixtures" is not the "fixtures" segment, so it must stay included.
+    expect(await wasAnalyzed("/test/my-fixtures/case.js", options)).toBe(true);
+  });
+
+  it("gives exclude precedence over include", async () => {
+    const options = { include: ["**/*.js"], exclude: ["**/vendor/**"] };
+    expect(await wasAnalyzed("/src/vendor/lib.js", options)).toBe(false);
+    expect(await wasAnalyzed("/src/lib.js", options)).toBe(true);
+  });
+
+  it("falls back to literal substring matching for wildcard-free patterns", async () => {
+    const options = { include: ["generated"] };
+    expect(await wasAnalyzed("/src/generated/helpers.js", options)).toBe(true);
+    expect(await wasAnalyzed("/src/helpers.js", options)).toBe(false);
+
+    const excluded = { include: ["**/*.js"], exclude: ["snapshots"] };
+    expect(await wasAnalyzed("/src/snapshots/old.js", excluded)).toBe(false);
+  });
+});

package/src/index.ts

@@ -1,4 +1,11 @@
-import { analyzeFile, type AnalysisResult } from "@nudojs/service";
+import {
+  analyzeFileAsync,
+  defaultLoadModule as loadModule,
+  clearAnalysisSessionCaches,
+  type AnalysisResult,
+  type Diagnostic,
+} from "@nudojs/service";
+import { checkSource, pTrue } from "@nudojs/core";
 
 export type NudoPluginOptions = {
   include?: string[];
@@ -6,27 +13,103 @@ export type NudoPluginOptions = {
   failOnError?: boolean;
 };
 
-const DEFAULT_INCLUDE = ["**/*.js"];
-const DEFAULT_EXCLUDE = ["**/node_modules/**"];
+/** 与 LSP hasNudoDirectives 对齐：含 refine/import，避免漏掉契约文件 */
+const NUDO_DIRECTIVE_RE =
+  /@nudo:(case|mock|pure|skip|sample|refine|import|env|mock-module|as|replace)\b/;
 
-function matchesPatterns(id: string, include: string[], exclude: string[]): boolean {
-  const isExcluded = exclude.some((p) => minimatch(id, p));
-  if (isExcluded) return false;
-  return include.some((p) => minimatch(id, p));
+/** Abs check issues → service Diagnostic（与 evaluator 诊断同管道进 vite warn/error） */
+function checkIssuesToDiagnostics(id: string, code: string): Diagnostic[] {
+  try {
+    const report = checkSource(id, code, pTrue, { loadModule, fromFile: id });
+    return report.issues
+      .filter((i) => i.severity === "error" || i.severity === "warning")
+      .map((i) => {
+        const line = i.line ?? 1;
+        const column = i.column ?? 0;
+        const parts = [i.message];
+        if (i.actual) parts.push(`actual: ${i.actual}`);
+        if (i.expected) parts.push(`expected: ${i.expected}`);
+        if (i.suggestion) parts.push(i.suggestion);
+        if (i.code) parts.push(`(${i.code})`);
+        return {
+          severity: i.severity === "error" ? ("error" as const) : ("warning" as const),
+          message: parts.join(" · "),
+          code: i.code,
+          range: {
+            start: { line, column },
+            end: { line, column: column + 1 },
+          },
+        };
+      });
+  } catch {
+    return [];
+  }
 }
 
-function minimatch(str: string, pattern: string): boolean {
-  if (pattern === "**/*.js") return str.endsWith(".js");
-  if (pattern === "**/node_modules/**") return str.includes("/node_modules/");
-  if (pattern.startsWith("**/")) {
-    return str.endsWith(pattern.slice(3)) || str.includes(pattern.slice(2));
+const DEFAULT_INCLUDE = ["**/*.js", "**/*.mjs", "**/*.ts", "**/*.mts"];
+const DEFAULT_EXCLUDE = ["**/node_modules/**", "**/*.d.ts"];
+
+type Matcher = (id: string) => boolean;
+
+const REGEX_SPECIALS = /[\\^$.|?*+(){}\[\]]/;
+
+function escapeRegExpChar(ch: string): string {
+  return REGEX_SPECIALS.test(ch) ? `\\${ch}` : ch;
+}
+
+/** Translate one path segment (`**` segments are handled by the caller). */
+function segmentToRegExpSource(segment: string): string {
+  let source = "";
+  for (const ch of segment) {
+    if (ch === "*") source += "[^/]*";
+    else if (ch === "?") source += "[^/]";
+    else source += escapeRegExpChar(ch);
   }
-  return str.includes(pattern);
+  return source;
+}
+
+// Compile a glob pattern into an anchored RegExp. Supported syntax:
+// - a `**` segment: zero or more path segments, e.g. `**` + `/*.mjs` or `**` + `/node_modules/**`
+// - `*` / `?` inside a segment, never crossing `/`
+// - all other characters matched literally (regex specials are escaped)
+// Patterns without wildcards are treated as literal substrings by the caller.
+function patternToRegExp(pattern: string): RegExp {
+  const segments = pattern.split("/");
+  let source = "";
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    const isLast = i === segments.length - 1;
+    if (segment === "**") {
+      if (isLast) {
+        source = source.endsWith("/")
+          ? `${source.slice(0, -1)}(?:/.*)?`
+          : `${source}.*`;
+      } else {
+        source += "(?:.*/)?";
+      }
+    } else {
+      source += segmentToRegExpSource(segment);
+      if (!isLast) source += "/";
+    }
+  }
+  return new RegExp(`^${source}$`);
+}
+
+function compilePattern(pattern: string): Matcher {
+  if (!/[*?]/.test(pattern)) return (id) => id.includes(pattern);
+  const regExp = patternToRegExp(pattern);
+  return (id) => regExp.test(id);
+}
+
+/** Compile a pattern list into a matcher that is true when any pattern matches. */
+function compileAnyMatcher(patterns: string[]): Matcher {
+  const matchers = patterns.map(compilePattern);
+  return (id) => matchers.some((match) => match(id));
 }
 
 export default function nudoPlugin(options: NudoPluginOptions = {}): any {
-  const include = options.include ?? DEFAULT_INCLUDE;
-  const exclude = options.exclude ?? DEFAULT_EXCLUDE;
+  const includeMatch = compileAnyMatcher(options.include ?? DEFAULT_INCLUDE);
+  const excludeMatch = compileAnyMatcher(options.exclude ?? DEFAULT_EXCLUDE);
   const failOnError = options.failOnError ?? false;
 
   const analysisCache = new Map<string, AnalysisResult>();
@@ -36,17 +119,29 @@ export default function nudoPlugin(options: NudoPluginOptions = {}): any {
 
     buildStart() {
       analysisCache.clear();
+      // 全新构建：丢掉上一轮会话 memo，避免跨 build 陈旧命中
+      clearAnalysisSessionCaches();
+    },
+
+    /** 任一文件变更后，未改 source 的 importer 再 transform 时可能命中陈旧会话缓存 */
+    watchChange() {
+      analysisCache.clear();
+      clearAnalysisSessionCaches();
     },
 
-    transform(code: string, id: string) {
-      if (!matchesPatterns(id, include, exclude)) return null;
-      if (!/@nudo:(case|mock|pure|skip|sample|returns)\b/.test(code)) return null;
+    async transform(code: string, id: string) {
+      if (excludeMatch(id)) return null;
+      if (!includeMatch(id)) return null;
+      if (!NUDO_DIRECTIVE_RE.test(code)) return null;
 
       try {
-        const result = analyzeFile(id, code);
-        analysisCache.set(id, result);
+        // async 以便 path 型 @nudo:env 预加载（与 LSP analyzeFileAsync 对齐）
+        const result = await analyzeFileAsync(id, code);
+        const checkDiags = checkIssuesToDiagnostics(id, code);
+        const merged = { ...result, diagnostics: [...result.diagnostics, ...checkDiags] };
+        analysisCache.set(id, merged);
 
-        for (const diag of result.diagnostics) {
+        for (const diag of merged.diagnostics) {
           const loc = `${id}:${diag.range.start.line}:${diag.range.start.column}`;
           const msg = `[nudo] ${loc} ${diag.severity}: ${diag.message}`;