@nudojs/cli 0.3.0 → 0.3.1

package/dist/index.js

@@ -0,0 +1,829 @@
+#!/usr/bin/env node
+import { createRequire as __nudoCreateRequire } from "module";
+const require = __nudoCreateRequire(import.meta.url);
+import {
+  resetMemo
+} from "./chunk-YDM4HHQ4.js";
+
+// src/index.ts
+import { readFileSync, existsSync, watch, readdirSync, statSync, writeFileSync, mkdirSync } from "fs";
+import { resolve, dirname, relative, join, basename } from "path";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+import { typeValueToString as typeValueToString2 } from "@nudojs/core";
+import {
+  typeValueToZodSchema,
+  generateGuardFunction,
+  generateGuardFunctionFromAbs,
+  generateFunctionDtsLines,
+  analyzeFileAsync,
+  buildModuleGraph,
+  computeDirtySet,
+  topoSortDirty,
+  collectCallRecords,
+  stripGeneratedCaseDirectives,
+  insertGeneratedCaseDirectives,
+  unifiedDiff,
+  isNudoTargetPath,
+  collectDtsFromEntry,
+  evictAnalysisCachesForFiles
+} from "@nudojs/service";
+import { harvestDts, emitEnvModule } from "@nudojs/harvester";
+
+// src/run-test.ts
+import { isSubtypeOf, typeValueToString } from "@nudojs/core";
+function buildTestReport(file, result) {
+  const outcomes = [];
+  for (const fn of result.functions) {
+    for (const c of fn.cases) {
+      if (c.source !== "directive") continue;
+      const actual = typeValueToString(c.result);
+      if (!c.expected) {
+        outcomes.push({
+          fn: fn.name,
+          caseName: c.name,
+          ok: true,
+          unchecked: true,
+          actual
+        });
+        continue;
+      }
+      const expected = typeValueToString(c.expected);
+      let ok = false;
+      try {
+        ok = isSubtypeOf(c.result, c.expected);
+      } catch {
+        ok = false;
+      }
+      outcomes.push({
+        fn: fn.name,
+        caseName: c.name,
+        ok,
+        unchecked: false,
+        expected,
+        actual
+      });
+    }
+  }
+  return {
+    file,
+    passed: outcomes.filter((o) => o.ok && !o.unchecked).length,
+    failed: outcomes.filter((o) => !o.ok).length,
+    unchecked: outcomes.filter((o) => o.unchecked).length,
+    outcomes
+  };
+}
+function formatTestReport(r) {
+  const lines = [];
+  lines.push(`nudo test  ${r.file}`);
+  if (r.passed + r.failed + r.unchecked === 0) {
+    lines.push("No @nudo:case directives found.");
+    return lines.join("\n");
+  }
+  lines.push(r.failed === 0 ? "PASS" : "FAILED");
+  lines.push(`  ${r.passed} passed \xB7 ${r.failed} failed \xB7 ${r.unchecked} unchecked`);
+  lines.push("");
+  for (const o of r.outcomes) {
+    if (o.unchecked) {
+      lines.push(`  [unchecked] ${o.fn}  case "${o.caseName}" \u2192 ${o.actual}`);
+    } else if (o.ok) {
+      lines.push(`  [ok]   ${o.fn}  case "${o.caseName}" \u2192 ${o.actual}`);
+    } else {
+      lines.push(`  [FAIL] ${o.fn}  case "${o.caseName}"`);
+      lines.push(`         expected: ${o.expected}`);
+      lines.push(`         actual:   ${o.actual}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/index.ts
+var program = new Command();
+function readPackageVersion() {
+  const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  return pkg.version ?? "0.0.0";
+}
+program.name("nudo").description("Nudo type inference engine").version(readPackageVersion());
+async function reemitUpdate(filePath, source, callsites) {
+  const stripped = stripGeneratedCaseDirectives(source);
+  const result = await analyzeFileAsync(filePath, stripped.source, void 0, callsites);
+  const emitOut = insertGeneratedCaseDirectives(stripped.source, result);
+  return { result, emitOut, removed: stripped.removed };
+}
+function collectExternalRecords(sites) {
+  const records = [];
+  for (const site of sites) {
+    const sitePath = resolve(site);
+    if (!existsSync(sitePath)) {
+      console.error(`Callsite file not found: ${sitePath}`);
+      process.exitCode = 1;
+      continue;
+    }
+    const siteFiles = statSync(sitePath).isDirectory() ? collectNudoFiles(sitePath) : [sitePath];
+    for (const sf of siteFiles) {
+      records.push(...collectCallRecords(sf, readFileSync(sf, "utf-8")));
+    }
+  }
+  return records.length > 0 ? records : void 0;
+}
+async function runInfer(file, options = {}) {
+  const filePath = resolve(file);
+  const source = readFileSync(filePath, "utf-8");
+  let result = await analyzeFileAsync(filePath, source, void 0, options.callsites);
+  let emitOut;
+  if (options.emit) {
+    if (options.emit.mode === "update") {
+      const re = await reemitUpdate(filePath, source, options.callsites);
+      result = re.result;
+      emitOut = re.emitOut;
+    } else {
+      emitOut = insertGeneratedCaseDirectives(source, result);
+    }
+  }
+  if (result.functions.length === 0 && !result.externalFunctions?.length) {
+    console.log("No functions with @nudo:case directives found.");
+    return;
+  }
+  const dtsLines = [];
+  for (const fn of result.functions) {
+    const loc = fn.loc;
+    const locStr = `${relative(process.cwd(), filePath)}:${loc.start.line}:${loc.start.column}`;
+    const header = options.showLoc ? `=== ${fn.name} (${locStr}) ===` : `=== ${fn.name} ===`;
+    console.log(`${header}
+`);
+    if (options.dts) {
+      dtsLines.push(...generateFunctionDtsLines(fn));
+    }
+    if (fn.skipped) {
+      if (fn.combined) {
+        console.log(`Skipped (declared): ${typeValueToString2(fn.combined)}`);
+      } else {
+        console.log("Skipped (no return type declared)");
+      }
+      console.log();
+      continue;
+    }
+    for (const c of fn.cases) {
+      const argsStr = c.args.map(typeValueToString2).join(", ");
+      let line = `Case "${c.name}": (${argsStr}) => ${typeValueToString2(c.result)}`;
+      if (c.throws.kind !== "never") line += ` throws ${typeValueToString2(c.throws)}`;
+      console.log(line);
+      if (c.intension?.display) {
+        console.log(`    intension: ${c.intension.display}`);
+      } else if (c.intension?.term || c.intension?.pred) {
+        const parts = [];
+        if (c.intension.term) parts.push(`term=${c.intension.term}`);
+        if (c.intension.pred) parts.push(`pred: ${c.intension.pred}`);
+        if (c.intension.conf) parts.push(`#${c.intension.conf}`);
+        console.log(`    ${parts.join("  ")}`);
+      }
+      if (c.intension?.abs) {
+        console.log(`    abs: ${c.intension.abs}`);
+      }
+    }
+    if (fn.entryOnly) {
+      console.log("# no call sites found; parameters default to unknown");
+    }
+    if (fn.cases.length > 1 && fn.combined) {
+      console.log(`
+Combined: ${typeValueToString2(fn.combined)}`);
+    }
+    console.log();
+  }
+  if (result.externalFunctions && result.externalFunctions.length > 0) {
+    const byModule = /* @__PURE__ */ new Map();
+    for (const fn of result.externalFunctions) {
+      const mod = fn.fromModule ?? "";
+      const list = byModule.get(mod);
+      if (list) list.push(fn);
+      else byModule.set(mod, [fn]);
+    }
+    for (const [mod, fns] of byModule) {
+      const rel = relative(process.cwd(), mod) || mod;
+      console.log(`--- ${rel} (imported) ---
+`);
+      for (const fn of fns) {
+        console.log(`=== ${fn.name} ===
+`);
+        for (const c of fn.cases) {
+          const argsStr = c.args.map(typeValueToString2).join(", ");
+          let line = `Case "${c.name}": (${argsStr}) => ${typeValueToString2(c.result)}`;
+          if (c.throws.kind !== "never") line += ` throws ${typeValueToString2(c.throws)}`;
+          console.log(line);
+        }
+        if (fn.cases.length > 1 && fn.combined) {
+          console.log(`
+Combined: ${typeValueToString2(fn.combined)}`);
+        }
+        console.log();
+      }
+    }
+  }
+  if (options.dts && dtsLines.length > 0) {
+    const dtsPath = filePath.replace(/\.[cm]?js$|\.ts$/, ".d.ts");
+    const dtsContent = dtsLines.join("\n") + "\n";
+    writeFileSync(dtsPath, dtsContent, "utf-8");
+    console.log(`Generated: ${relative(process.cwd(), dtsPath)}`);
+  }
+  if (result.diagnostics.length > 0) {
+    console.log("Diagnostics:\n");
+    for (const d of result.diagnostics) {
+      const loc = `${relative(process.cwd(), filePath)}:${d.range.start.line}:${d.range.start.column}`;
+      console.log(`  [${d.severity}] ${loc} ${d.message}${d.code ? ` (${d.code})` : ""}`);
+      if (d.origin) {
+        console.log(`    \u2192 value originates at ${d.origin.line}:${d.origin.column}`);
+      }
+    }
+    console.log();
+  }
+  if (options.emit && emitOut) {
+    const relPath = relative(process.cwd(), filePath) || filePath;
+    const skippedLines = emitOut.skipped.map((s) => `  ${s.fn}: ${s.reason}${s.detail ? ` (${s.detail})` : ""}`);
+    if (emitOut.source === source) {
+      console.log("No changes.");
+      for (const line of skippedLines) console.log(line);
+      return;
+    }
+    if (options.emit.dryRun) {
+      console.log(`Would emit cases \u2192 ${relPath} (dry run)`);
+      for (const w of emitOut.written) console.log(`  ${w.fn}: ${w.cases.join(", ")}`);
+      for (const line of skippedLines) console.log(line);
+      console.log();
+      process.stdout.write(unifiedDiff(source, emitOut.source, relPath));
+      if (options.emit.exitOnDiff) process.exitCode = 1;
+      return;
+    }
+    writeFileSync(filePath, emitOut.source, "utf-8");
+    const directiveCount = emitOut.written.reduce((n, w) => n + w.cases.length, 0);
+    console.log(
+      `Emitted cases \u2192 ${relPath} (${directiveCount} directive(s) across ${emitOut.written.length} function(s))`
+    );
+    for (const w of emitOut.written) console.log(`  ${w.fn}: ${w.cases.join(", ")}`);
+    for (const line of skippedLines) console.log(line);
+  }
+}
+async function runInferJson(file, externalRecords) {
+  const filePath = resolve(file);
+  const source = readFileSync(filePath, "utf-8");
+  const result = await analyzeFileAsync(filePath, source, void 0, externalRecords);
+  const { serializeInferJson } = await import("@nudojs/service");
+  console.log(JSON.stringify(serializeInferJson(result, filePath), null, 2));
+}
+program.command("infer").description("Infer types from a JS/TS file (or a directory of them) \u2014 functions with @nudo:case directives use them; all other functions are inferred from call sites (whole-program analysis)").argument("<file>", "Path to the JS/TS file (or directory)").option("--dts", "Generate .d.ts file").option("--loc", "Show source locations in output").option("--json", "Output as JSON").option("--callsites <paths...>", "Usage-site files (tests/apps) to harvest real call shapes from; their calls to this file's exports become synthesized cases").option("--emit-cases [mode]", "Write synthesized call-site cases back into the source as @nudo:case directives (call@ prefix); mode: update (default: add)").option("--dry-run", "With --emit-cases: print a unified diff instead of writing to disk").option("--exit-on-diff", "With --dry-run: exit with code 1 when the diff is non-empty").action(
+  async (file, opts) => {
+    let emit;
+    if (opts.emitCases !== void 0) {
+      let mode;
+      if (opts.emitCases === true) mode = "add";
+      else if (opts.emitCases === "update") mode = "update";
+      else {
+        console.error(`Invalid --emit-cases value: ${opts.emitCases} (expected: =update, or omit the value for add)`);
+        process.exitCode = 1;
+        return;
+      }
+      if (opts.json) {
+        console.error("--emit-cases cannot be combined with --json");
+        process.exitCode = 1;
+        return;
+      }
+      emit = { mode, dryRun: opts.dryRun === true, exitOnDiff: opts.exitOnDiff === true };
+    }
+    if (opts.exitOnDiff && !opts.dryRun) {
+      console.error("--exit-on-diff requires --dry-run");
+      process.exitCode = 1;
+      return;
+    }
+    let externalRecords;
+    if (opts.callsites?.length) {
+      externalRecords = collectExternalRecords(opts.callsites);
+    }
+    const target = resolve(file);
+    if (existsSync(target) && statSync(target).isDirectory()) {
+      const files = collectNudoFiles(target);
+      if (files.length === 0) {
+        console.log("No nudo files found in directory.");
+        return;
+      }
+      if (opts.json) {
+        console.error("--json requires a single file, not a directory");
+        process.exitCode = 1;
+        return;
+      }
+      for (const f of files) {
+        try {
+          await runInfer(f, { dts: opts.dts, showLoc: opts.loc, callsites: externalRecords, emit });
+        } catch (err) {
+          console.error(`Error analyzing ${relative(process.cwd(), f)}:`, err.message);
+        }
+      }
+      return;
+    }
+    if (opts.json) {
+      await runInferJson(file, externalRecords);
+    } else {
+      await runInfer(file, { dts: opts.dts, showLoc: opts.loc, callsites: externalRecords, emit });
+    }
+  }
+);
+async function runCheck(file, opts = {}) {
+  const filePath = resolve(file);
+  const source = readFileSync(filePath, "utf-8");
+  const { checkSource, formatCheckReport, serializeCheckJson, pTrue } = await import("@nudojs/core");
+  const { defaultLoadModule: loadModule } = await import("@nudojs/service");
+  const algebraReport = checkSource(filePath, source, pTrue, {
+    loadModule,
+    fromFile: filePath
+  });
+  if (opts.json) {
+    console.log(JSON.stringify(serializeCheckJson(algebraReport), null, 2));
+  } else {
+    console.log(formatCheckReport(algebraReport, { verbose: true }));
+  }
+  if (!algebraReport.ok) {
+    process.exitCode = 1;
+  }
+}
+function resolveTargets(path) {
+  const resolved = resolve(path);
+  if (!existsSync(resolved)) {
+    console.error(`Not found: ${resolved}`);
+    process.exitCode = 1;
+    return [];
+  }
+  if (statSync(resolved).isDirectory()) {
+    const files = collectNudoFiles(resolved);
+    if (files.length === 0) {
+      console.error(`No nudo files found in directory: ${resolved}`);
+      process.exitCode = 1;
+    }
+    return files;
+  }
+  return [resolved];
+}
+program.command("types").description("Type-as-computation view: show term + constraints from the algebra (not just extensional shape)").argument("<file>", "Path to the JS/TS file or a directory of them").option("--fn <name>", "Only analyze this function").option("--assume <pred...>", "Assume constraints, e.g. x>0 y>=1").option("--generalize", "Show polymorphic signatures via symbolic execution").action(
+  async (file, opts) => {
+    const targets = resolveTargets(file);
+    if (targets.length === 0) return;
+    for (const t of targets) {
+      await runTypes(t, opts);
+      if (targets.length > 1) console.log("");
+    }
+  }
+);
+async function runTypes(filePath, opts) {
+  const { readFileSync: readFileSync2 } = await import("fs");
+  const { basename: basename2 } = await import("path");
+  const algebra = await import("@nudojs/core");
+  const source = readFileSync2(filePath, "utf8");
+  let phi = algebra.pTrue;
+  const assumeIds = /* @__PURE__ */ new Set();
+  for (const a of opts.assume ?? []) {
+    const m = /^([A-Za-z_$][\w$]*)\s*(>=|>)\s*(-?\d+(?:\.\d+)?)$/.exec(a.trim());
+    if (!m) {
+      console.error(`\u65E0\u6CD5\u89E3\u6790 --assume: ${a}\uFF08\u652F\u6301 x>0 / x>=1\uFF09`);
+      continue;
+    }
+    const id = m[1];
+    const n = Number(m[3]);
+    phi = algebra.gtNum(algebra.v(id), n);
+    assumeIds.add(id);
+  }
+  const list = opts.fn ? [opts.fn] : algebra.listFunctionNames(source);
+  if (list.length === 0) {
+    console.error(`\u672A\u627E\u5230\u51FD\u6570: ${basename2(filePath)}`);
+    process.exitCode = 1;
+    return;
+  }
+  const { defaultLoadModule: loadModule } = await import("@nudojs/service");
+  console.log(`nudo types  ${basename2(filePath)}`);
+  if (assumeIds.size > 0) {
+    console.log(`assume: ${[...assumeIds].map((id) => `${id} > 0`).join(", ")}`);
+  }
+  if (opts.generalize) {
+    console.log("mode: generalize (symbolic \u03B1)\n");
+  } else {
+    console.log("");
+  }
+  for (const name of list) {
+    if (opts.generalize) {
+      const g = algebra.generalizeFromAst(name, source, {
+        refine: { loadModule, fromFile: filePath }
+      });
+      if (!g) continue;
+      console.log(g.display);
+      console.log("");
+      continue;
+    }
+    const args = algebra.buildArgsFromAssume(source, name, assumeIds);
+    const result = algebra.analyzeFn(source, name, args, phi);
+    const label = `${name}(${args.map((a) => algebra.formatShape(a)).join(", ")})`;
+    console.log(algebra.formatAbsMultiline(result, label));
+    console.log("");
+  }
+}
+program.command("check").description("Check JS/TS file(s) or directory(s) for type errors \u2014 exits with code 1 when errors are found").argument("<paths...>", "File(s) or directory(s) to check").option("--json", "Emit stable CheckJson (CI / Agent contract; single file only)").action(async (paths, opts) => {
+  const targets = [];
+  for (const p of paths) {
+    targets.push(...resolveTargets(p));
+  }
+  if (targets.length === 0) return;
+  if (opts.json && targets.length > 1) {
+    console.error("--json requires a single file, not multiple targets");
+    process.exitCode = 1;
+    return;
+  }
+  for (const t of targets) {
+    await runCheck(t, opts);
+  }
+});
+program.command("test").description("Run @nudo:case directives as assertions (case-as-test); exit 1 on failure").argument("<file>", "Path to the JS/TS file or a directory of them").action(async (file) => {
+  const targets = resolveTargets(file);
+  if (targets.length === 0) return;
+  for (const filePath of targets) {
+    const source = readFileSync(filePath, "utf-8");
+    try {
+      const result = await analyzeFileAsync(filePath, source);
+      const report = buildTestReport(filePath, result);
+      console.log(formatTestReport(report));
+      if (report.failed > 0) process.exitCode = 1;
+    } catch (err) {
+      console.error(`nudo test failed to analyze ${filePath}: ${err.message}`);
+      process.exitCode = 1;
+    }
+  }
+});
+var displayPath = (p) => {
+  const rel = relative(process.cwd(), p);
+  return rel === "" || rel.startsWith("..") ? p : rel;
+};
+async function doctorFile(filePath, records) {
+  const report = { file: displayPath(filePath), functions: 0, entryOnly: 0, uncovered: [] };
+  let source;
+  try {
+    source = readFileSync(filePath, "utf-8");
+  } catch (err) {
+    report.error = err.message;
+    return report;
+  }
+  try {
+    const result = await analyzeFileAsync(filePath, source, void 0, records);
+    report.functions = result.functions.length;
+    report.entryOnly = result.functions.filter((fn) => fn.entryOnly).length;
+    report.uncovered = result.functions.filter((fn) => fn.cases.length === 0 && !fn.skipped && !fn.entryOnly).map((fn) => fn.name);
+    if (records) {
+      const { emitOut, removed } = await reemitUpdate(filePath, source, records);
+      if (emitOut.source !== source) {
+        report.drift = {
+          added: emitOut.written.reduce((n, w) => n + w.cases.length, 0),
+          removed: removed.length
+        };
+      }
+    }
+  } catch (err) {
+    report.error = err.message;
+  }
+  return report;
+}
+async function runDoctor(paths, opts) {
+  const targetPaths = paths.length > 0 ? paths : ["."];
+  const externalRecords = opts.callsites?.length ? collectExternalRecords(opts.callsites) : void 0;
+  const files = [];
+  const reports = [];
+  for (const p of targetPaths) {
+    const abs = resolve(p);
+    if (!existsSync(abs)) {
+      reports.push({ file: displayPath(abs), functions: 0, entryOnly: 0, uncovered: [], error: `File not found: ${abs}` });
+      continue;
+    }
+    files.push(...statSync(abs).isDirectory() ? collectNudoFiles(abs) : [abs]);
+  }
+  for (const filePath of files) {
+    reports.push(await doctorFile(filePath, externalRecords));
+  }
+  const driftCount = reports.filter((r) => r.drift).length;
+  const errorCount = reports.filter((r) => r.error).length;
+  const uncoveredTotal = reports.reduce((n, r) => n + r.uncovered.length, 0);
+  const failed = driftCount > 0 || errorCount > 0;
+  if (opts.json) {
+    console.log(
+      JSON.stringify(
+        {
+          // ok 与退出码一致：drift/报错 → false；uncovered 仅为信息级不影响
+          ok: !failed,
+          files: reports.map((r) => ({
+            file: r.file,
+            functions: r.functions,
+            entryOnly: r.entryOnly,
+            uncovered: r.uncovered,
+            ...r.drift ? { drift: r.drift } : {},
+            ...r.error ? { error: r.error } : {}
+          })),
+          summary: { files: reports.length, drift: driftCount, errors: errorCount, uncovered: uncoveredTotal }
+        },
+        null,
+        2
+      )
+    );
+  } else {
+    if (reports.length === 0) {
+      console.log("No files to check.");
+      return;
+    }
+    for (const r of reports) {
+      console.log(`${r.file}`);
+      if (r.error) {
+        console.log(`  \u2717 error: ${r.error}`);
+        continue;
+      }
+      const entryInfo = r.entryOnly > 0 ? `, ${r.entryOnly} entry-only` : "";
+      console.log(`  \xB7 ${r.functions} function(s)${entryInfo}`);
+      if (r.uncovered.length > 0) {
+        console.log(`  \u26A0 uncovered (no cases): ${r.uncovered.join(", ")}`);
+      }
+      if (r.drift) {
+        const refresh = `nudo infer ${r.file} --callsites ${(opts.callsites ?? []).join(" ")} --emit-cases=update`;
+        console.log(
+          `  \u2717 drift: ${r.drift.added + r.drift.removed} directive(s) changed (+${r.drift.added} new, -${r.drift.removed} removed) \u2014 refresh with: ${refresh.trim()}`
+        );
+      }
+    }
+    console.log(
+      `
+Summary: ${reports.length} file(s) \xB7 ${driftCount} drift \xB7 ${errorCount} error(s) \xB7 ${uncoveredTotal} uncovered function(s)`
+    );
+    console.log(failed ? "Result: FAIL (drift or errors found)" : "Result: OK (uncovered function(s) are informational only)");
+  }
+  if (failed) process.exitCode = 1;
+}
+program.command("doctor").description("Health-check JS files: functions without cases, call-site solidification drift (--callsites), analysis errors \u2014 exits 1 on drift/errors").argument("[paths...]", "File(s) or directory(s) to check (default: current directory)").option("--callsites <paths...>", "Usage-site files (tests/apps): re-solidify per current call shapes and report drift when directives would change").option("--json", "Output as JSON").action(async (paths, opts) => {
+  await runDoctor(paths, opts);
+});
+program.command("watch").description("Watch file(s) for changes and re-run inference").argument("<path>", "File or directory to watch").option("--dts", "Generate .d.ts files on each change").action((watchPath, opts) => {
+  const resolved = resolve(watchPath);
+  const isDir = existsSync(resolved) && statSync(resolved).isDirectory();
+  const getFiles = () => {
+    if (!isDir) return [resolved];
+    return collectNudoFiles(resolved);
+  };
+  let graph = buildModuleGraph(getFiles());
+  const runAll = async () => {
+    console.clear();
+    console.log(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Analyzing...
+`);
+    for (const f of getFiles()) {
+      try {
+        await runInfer(f, { dts: opts.dts, showLoc: true });
+      } catch (err) {
+        console.error(`Error analyzing ${relative(process.cwd(), f)}:`, err.message);
+      }
+    }
+    graph = buildModuleGraph(getFiles());
+    console.log(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Watching for changes...`);
+  };
+  const runIncremental = async (changedFiles) => {
+    const files = getFiles();
+    const tracked = new Set(files);
+    const dirtyUnion = /* @__PURE__ */ new Set();
+    for (const cf of changedFiles) {
+      for (const d of computeDirtySet(graph.dependents, cf)) dirtyUnion.add(d);
+    }
+    const dirty = [...dirtyUnion].filter((f) => tracked.has(f));
+    if (dirty.length === 0) return;
+    const ordered = topoSortDirty(graph.imports, dirty);
+    console.clear();
+    console.log(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Analyzing (incremental)...
+`);
+    const t0 = performance.now();
+    resetMemo();
+    evictAnalysisCachesForFiles(ordered);
+    for (const f of ordered) {
+      try {
+        await runInfer(f, { dts: opts.dts, showLoc: true });
+      } catch (err) {
+        console.error(`Error analyzing ${relative(process.cwd(), f)}:`, err.message);
+      }
+    }
+    const elapsed = Math.round(performance.now() - t0);
+    console.log(`Incremental: re-analyzed ${ordered.length}, skipped ${files.length - ordered.length} (${elapsed}ms)`);
+    console.log(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Watching for changes...`);
+    graph = buildModuleGraph(getFiles());
+  };
+  runAll().catch(() => {
+  });
+  let debounceTimer = null;
+  const watchTarget = isDir ? resolved : dirname(resolved);
+  const pendingChanged = /* @__PURE__ */ new Set();
+  watch(watchTarget, { recursive: isDir }, (_event, filename) => {
+    if (!filename) return;
+    const fullPath = isDir ? join(watchTarget, filename) : resolved;
+    if (!isNudoTargetPath(fullPath)) return;
+    if (!existsSync(fullPath)) return;
+    pendingChanged.add(fullPath);
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      const changedFiles = [...pendingChanged];
+      pendingChanged.clear();
+      runIncremental(changedFiles).catch(() => {
+      });
+    }, 200);
+  });
+});
+function collectNudoFiles(dir) {
+  const results = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory() && entry.name !== "node_modules") {
+      results.push(...collectNudoFiles(fullPath));
+    } else if (entry.isFile() && isNudoTargetPath(fullPath)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+async function runGenerate(file, format, output) {
+  const filePath = resolve(file);
+  const source = readFileSync(filePath, "utf-8");
+  const result = await analyzeFileAsync(filePath, source);
+  const functions = result.functions.filter(
+    (f) => f.cases.some((c) => c.source === "directive")
+  );
+  if (functions.length === 0) {
+    console.log("No functions with @nudo:case directives found.");
+    return;
+  }
+  const zodChunks = [];
+  const guardChunks = [];
+  const dtsChunks = [];
+  for (const fn of functions) {
+    const caseResults = fn.cases.filter((c) => c.source === "directive");
+    const baseName = fn.name;
+    if (format === "zod" || format === "all") {
+      const lines = [`
+// === ${baseName} Zod Schemas ===`];
+      for (const c of caseResults) {
+        const inputSchemas = c.args.map((a, i) => `arg${i}: ${typeValueToZodSchema(a)}`).join(", ");
+        const outputSchema = typeValueToZodSchema(c.result);
+        lines.push(`// Case "${c.name}":`);
+        lines.push(`// Input: { ${inputSchemas} }`);
+        lines.push(`// Output: ${outputSchema}`);
+      }
+      zodChunks.push(lines.join("\n"));
+    }
+    if (format === "guard" || format === "all") {
+      const lines = [`
+// === ${baseName} Type Guards ===`];
+      for (const c of caseResults) {
+        const guardName = `is${baseName}${c.name.charAt(0).toUpperCase() + c.name.slice(1)}Output`;
+        if (c.abs) {
+          lines.push(generateGuardFunctionFromAbs(guardName, c.abs));
+        } else {
+          lines.push(generateGuardFunction(guardName, c.result));
+        }
+      }
+      guardChunks.push(lines.join("\n"));
+    }
+    if (format === "dts" || format === "all") {
+      dtsChunks.push(generateFunctionDtsLines(fn).join("\n"));
+    }
+  }
+  const stem = basename(filePath).replace(/\.[cm]?[jt]s$/, "");
+  if (output) {
+    const outDir = resolve(output);
+    mkdirSync(outDir, { recursive: true });
+    const written = [];
+    if (zodChunks.length > 0) {
+      const p = join(outDir, `${stem}.nudo.zod.ts`);
+      writeFileSync(p, zodChunks.join("\n") + "\n", "utf-8");
+      written.push(p);
+    }
+    if (guardChunks.length > 0) {
+      const p = join(outDir, `${stem}.nudo.guard.ts`);
+      writeFileSync(p, guardChunks.join("\n") + "\n", "utf-8");
+      written.push(p);
+    }
+    if (dtsChunks.length > 0) {
+      const p = join(outDir, `${stem}.d.ts`);
+      writeFileSync(p, dtsChunks.join("\n") + "\n", "utf-8");
+      written.push(p);
+    }
+    for (const p of written) {
+      console.log(`wrote ${relative(process.cwd(), p)}`);
+    }
+    return;
+  }
+  for (const chunk of [...zodChunks, ...guardChunks, ...dtsChunks]) {
+    console.log(chunk);
+  }
+}
+program.command("generate").description("Generate runtime validators from inferred types").argument("<file>", "JavaScript file to analyze").option("--format <format>", "Output format: zod, guard, dts, all", "all").option("--output <dir>", "Write validator files to this directory (omit for stdout)").action(async (file, options) => {
+  const format = options.format;
+  if (!["zod", "guard", "dts", "all"].includes(format)) {
+    console.error(`Unknown --format ${format}; expected zod | guard | dts | all`);
+    process.exitCode = 1;
+    return;
+  }
+  await runGenerate(file, format, options.output);
+});
+program.command("emit").description("Emit TypeScript .d.ts declarations from inferred types (npm compatibility exit)").argument("<file>", "JavaScript file to analyze").option("--output <dir>", "Write <stem>.d.ts to this directory (omit for stdout)").action(async (file, options) => {
+  await runGenerate(file, "dts", options.output);
+});
+program.command("guard").description("Generate runtime type-guard functions from inferred result types").argument("<file>", "JavaScript file to analyze").option("--output <dir>", "Write <stem>.nudo.guard.ts to this directory (omit for stdout)").action(async (file, options) => {
+  await runGenerate(file, "guard", options.output);
+});
+var HARVEST_MAX_FILES = 200;
+function runHarvest(pkg, outOpt) {
+  const typesDir = resolve(process.cwd(), "node_modules", "@types", pkg);
+  if (!existsSync(typesDir)) {
+    console.error(`Error: ${relative(process.cwd(), typesDir)} not found.`);
+    console.error(`Install the package first, e.g. pnpm add -D @types/${pkg}`);
+    process.exitCode = 1;
+    return;
+  }
+  let entry = join(typesDir, "index.d.ts");
+  const pkgJsonPath = join(typesDir, "package.json");
+  if (existsSync(pkgJsonPath)) {
+    try {
+      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+      const declared = pkgJson.types ?? pkgJson.typings;
+      if (typeof declared === "string") {
+        const candidate = resolve(typesDir, declared);
+        if (existsSync(candidate)) entry = candidate;
+      }
+    } catch {
+    }
+  }
+  if (!existsSync(entry)) {
+    console.error(`Error: no .d.ts entry found in ${relative(process.cwd(), typesDir)} (tried ${basename(entry)}).`);
+    process.exitCode = 1;
+    return;
+  }
+  const files = collectDtsFromEntry(entry, HARVEST_MAX_FILES);
+  if (files.length === 0) {
+    console.error(`Error: no .d.ts files collected from ${relative(process.cwd(), entry)}.`);
+    process.exitCode = 1;
+    return;
+  }
+  const env = harvestDts(files);
+  const code = emitEnvModule(env, `@types/${pkg}`);
+  const out = resolve(outOpt ?? `nudo-harvest-${pkg}.ts`);
+  writeFileSync(out, code, "utf-8");
+  console.log(`Harvested @types/${pkg} \u2192 ${relative(process.cwd(), out) || out}`);
+  console.log(`  files:    ${env.stats.files}`);
+  console.log(`  symbols:  ${env.stats.symbols}`);
+  console.log(`  skipped:  ${env.stats.skipped}`);
+  console.log(`
+Usage \u2014 add this directive at the top of your JS file:`);
+  const outDir = dirname(out);
+  const hintPath = resolve(process.cwd()) === outDir ? basename(out) : out;
+  console.log(`  /// @nudo:env ${hintPath}`);
+}
+program.command("harvest").description("Convert @types/<pkg> .d.ts declarations into a Nudo env file (TS source using T.* constructors)").argument("[pkg]", "Package name under @types (e.g. node)").option("--out <file>", "Output .ts env file (default: ./nudo-harvest-<pkg>.ts)").option("--auto [dir]", "Scan directory (default .) for bare imports and report auto-harvestable @types packages").action(async (pkg, opts) => {
+  if (opts.auto !== void 0) {
+    const dir = resolve(typeof opts.auto === "string" ? opts.auto : ".");
+    const files = existsSync(dir) && statSync(dir).isDirectory() ? collectNudoFiles(dir) : existsSync(dir) ? [dir] : [];
+    if (files.length === 0) {
+      console.error(`No inference targets under ${dir}`);
+      process.exitCode = 1;
+      return;
+    }
+    const { collectBarePackages, harvestPackageCached, formatHarvestSummary } = await import("@nudojs/service");
+    const seen = /* @__PURE__ */ new Set();
+    const report = [];
+    for (const f of files) {
+      let src;
+      try {
+        src = readFileSync(f, "utf-8");
+      } catch {
+        continue;
+      }
+      for (const p of collectBarePackages(src)) {
+        if (seen.has(p)) continue;
+        seen.add(p);
+        const h = harvestPackageCached(p, dirname(f));
+        if (h) report.push(formatHarvestSummary(h));
+        else report.push(`${p}: no .d.ts / @types (skipped)`);
+      }
+    }
+    if (report.length === 0) {
+      console.log("No bare imports found (or nothing to harvest).");
+      return;
+    }
+    console.log(`auto harvest candidates under ${relative(process.cwd(), dir) || "."}:
+`);
+    for (const line of report) console.log(line);
+    console.log(`
+Analysis injects these automatically; use \`nudo harvest <pkg>\` to write a persistent env file.`);
+    return;
+  }
+  if (!pkg) {
+    console.error("Error: <pkg> is required (or use --auto).");
+    process.exitCode = 1;
+    return;
+  }
+  runHarvest(pkg, opts.out);
+});
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err instanceof Error ? process.env.NUDO_DEBUG ? err.stack : err.message : err);
+  process.exitCode = 1;
+});