@blzsky/variant 0.2.1 → 0.3.0-canary.0

package/dist/vitest.js

@@ -0,0 +1,356 @@
+import {
+  testRunFrom,
+  verifyRun
+} from "./chunk-MT4BOAAV.js";
+import {
+  changeBaseDeps,
+  defaultHistoryDir,
+  detectHeadSha
+} from "./chunk-H5C4SE73.js";
+import {
+  repositoryRoot,
+  resolveCommit
+} from "./chunk-RSIOYQOQ.js";
+import "./chunk-ACTY42RE.js";
+
+// src/reporters/shadow.ts
+import { spawn } from "child_process";
+import {
+  appendFile,
+  mkdir,
+  open,
+  readdir,
+  readFile,
+  stat,
+  unlink,
+  writeFile
+} from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var STALE_LOCK_MS = 10 * 6e4;
+var POLL_MS = 200;
+var KEEP_OUTCOME_MS = 60 * 6e4;
+var DISABLED = { finish: async () => {
+}, cancel: () => {
+} };
+function inCi(env) {
+  const ci = env["CI"];
+  return ci !== void 0 && ci !== "" && ci !== "false" && ci !== "0";
+}
+function isEnabled(options, env) {
+  if (env["VARIANT_SHADOW"] === "0") return false;
+  if (options.local === true || env["VARIANT_SHADOW"] === "1") return true;
+  return inCi(env);
+}
+function count(n, noun) {
+  return `${n} ${noun}${n === 1 ? "" : "s"}`;
+}
+function summaryLines(summary, result) {
+  const why = summary.unreached > 0 ? `: ${count(summary.unreached, "changed file")} reach${summary.unreached === 1 ? "es" : ""} no test` : summary.unselectedTests > 0 ? `: ${count(summary.unselectedTests, "changed JavaScript test")} could not be selected` : "";
+  const predicted = summary.selectAll ? `variant: selected all ${count(result.ranTests, "test file")}, because configuration changed.` : `variant: predicted ${result.predictedRan} of ${count(result.ranTests, "test file")} (${summary.resolution}${why}).`;
+  const failed = result.failedTests.length;
+  if (failed === 0) {
+    return [`${predicted} No failures, so nothing to check.`];
+  }
+  const missed = result.falseSkips.length;
+  if (missed === 0) {
+    return [
+      `${predicted} ${failed} failed, ${failed === 1 ? "and it was" : "all"} predicted.`
+    ];
+  }
+  return [
+    `${predicted} ${failed} failed, ${missed} NOT predicted:`,
+    ...result.falseSkips.map((file) => `  ${file}`),
+    "  Nothing was skipped. This is a false skip; please report it."
+  ];
+}
+function pendingPaths(root, headSha) {
+  const dir = path.join(defaultHistoryDir(root), "pending");
+  return {
+    dir,
+    lock: path.join(dir, `${headSha}.lock`),
+    done: path.join(dir, `${headSha}.json`)
+  };
+}
+async function acquire(lock, dir, now) {
+  await mkdir(dir, { recursive: true });
+  let takenAt = now();
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const handle = await open(lock, "wx");
+      await handle.writeFile(String(now()));
+      await handle.close();
+      return true;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      takenAt = await stat(lock).then(
+        (stats) => stats.mtimeMs,
+        () => now()
+      );
+      if (now() - takenAt < STALE_LOCK_MS) return takenAt;
+      await unlink(lock).catch(() => {
+      });
+    }
+  }
+  return takenAt;
+}
+async function prune(dir, now) {
+  const names = await readdir(dir).catch(() => []);
+  await Promise.all(
+    names.map(async (name) => {
+      const file = path.join(dir, name);
+      const age = await stat(file).then(
+        (stats) => now() - stats.mtimeMs,
+        () => 0
+      );
+      if (age > KEEP_OUTCOME_MS) await unlink(file).catch(() => {
+      });
+    })
+  );
+}
+async function readDone(done, since) {
+  try {
+    const parsed = JSON.parse(await readFile(done, "utf8"));
+    return parsed.at >= since ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function startShadow(cwd, options = {}, deps = shadowDeps()) {
+  if (!isEnabled(options, deps.env)) return DISABLED;
+  const startedAt = deps.now();
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  let cancelled = false;
+  let handle;
+  let held;
+  const say = (lines) => {
+    if (options.silent !== true) deps.write(`${lines.join("\n")}
+`);
+  };
+  const release = async () => {
+    if (held === void 0) return;
+    const lock = held;
+    held = void 0;
+    await unlink(lock).catch(() => {
+    });
+  };
+  const prediction = (async () => {
+    const root = await deps.repositoryRoot(cwd);
+    const headSha = await deps.headSha(root);
+    if (headSha === null || cancelled) return null;
+    const paths = pendingPaths(root, headSha);
+    if (inCi(deps.env)) {
+      const earlier = await readDone(paths.done, startedAt - STALE_LOCK_MS);
+      if (earlier !== null) return { root, headSha, outcome: earlier.outcome };
+    }
+    const lock = await acquire(paths.lock, paths.dir, deps.now);
+    if (lock === true) {
+      held = paths.lock;
+      if (cancelled) {
+        await release();
+        return null;
+      }
+      void prune(paths.dir, deps.now);
+      handle = deps.predict(root, headSha);
+      const outcome = await handle.result;
+      const done = { at: deps.now(), outcome };
+      await writeFile(paths.done, JSON.stringify(done)).catch(() => {
+      });
+      await release();
+      return { root, headSha, outcome };
+    }
+    while (!cancelled) {
+      const lockGone = await stat(paths.lock).then(
+        () => false,
+        () => true
+      );
+      if (lockGone) {
+        const done = await readDone(paths.done, lock - 1e3);
+        return {
+          root,
+          headSha,
+          outcome: done?.outcome ?? {
+            kind: "failed",
+            reason: "another test process was predicting and left no result"
+          }
+        };
+      }
+      await new Promise((resolve) => setTimeout(resolve, POLL_MS));
+    }
+    return null;
+  })();
+  prediction.catch(() => {
+  });
+  const stop = () => {
+    cancelled = true;
+    handle?.cancel();
+    void release();
+  };
+  return {
+    cancel: stop,
+    finish: async (results) => {
+      try {
+        let timer;
+        const timedOut = new Promise((resolve) => {
+          timer = setTimeout(() => resolve("timeout"), timeoutMs);
+        });
+        const settled = await Promise.race([prediction, timedOut]);
+        clearTimeout(timer);
+        if (settled === "timeout") {
+          stop();
+          say([
+            `variant: skipped (the prediction did not finish within ${Math.round(timeoutMs / 1e3)} s of the tests)`
+          ]);
+          return;
+        }
+        if (settled === null) return;
+        const { root, headSha, outcome } = settled;
+        if (outcome.kind === "none") {
+          say([`variant: no prediction (${outcome.reason})`]);
+          return;
+        }
+        if (outcome.kind === "failed") {
+          say([`variant: skipped (${outcome.reason})`]);
+          return;
+        }
+        const result = await deps.reconcile(root, results, headSha);
+        if (result === null) {
+          say(["variant: skipped (the prediction was not recorded)"]);
+          return;
+        }
+        const lines = summaryLines(outcome.summary, result);
+        say(lines);
+        const summaryFile = deps.env["GITHUB_STEP_SUMMARY"];
+        if (summaryFile !== void 0 && summaryFile !== "") {
+          await deps.appendSummary(summaryFile, `${lines.join("\n")}
+`).catch(() => {
+          });
+        }
+      } catch (error) {
+        stop();
+        say([
+          `variant: skipped (${error instanceof Error ? error.message : String(error)})`
+        ]);
+      }
+    }
+  };
+}
+function firstLine(text) {
+  return text.split("\n").map((line) => line.trim()).find((line) => line !== "") ?? "variant impact failed";
+}
+function parsePrediction(exitCode, stdout, stderr) {
+  if (exitCode !== 0) return { kind: "failed", reason: firstLine(stderr) };
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return { kind: "failed", reason: "variant impact printed no result" };
+  }
+  if (parsed.prediction === null) {
+    return { kind: "none", reason: parsed.reason ?? "nothing to compare" };
+  }
+  if (parsed.tests === void 0) {
+    return { kind: "failed", reason: "variant impact printed no result" };
+  }
+  return {
+    kind: "predicted",
+    summary: {
+      resolution: parsed.tests.resolution,
+      selectAll: parsed.tests.selectAll,
+      unreached: parsed.tests.unreached.length,
+      unselectedTests: parsed.tests.unselectedTests.length
+    }
+  };
+}
+function defaultCliPath() {
+  return fileURLToPath(new URL("./cli.js", import.meta.url));
+}
+function shadowDeps(cliPath = defaultCliPath()) {
+  return {
+    env: process.env,
+    now: () => Date.now(),
+    repositoryRoot: async (cwd) => await repositoryRoot(cwd) ?? cwd,
+    headSha: async (root) => await detectHeadSha(changeBaseDeps(root)) ?? await resolveCommit(root, "HEAD"),
+    predict: (root, headSha) => {
+      const child = spawn(
+        process.execPath,
+        [cliPath, "impact", "--json", "--head-sha", headSha],
+        { cwd: root, stdio: ["ignore", "pipe", "pipe"] }
+      );
+      let stdout = "";
+      let stderr = "";
+      child.stdout.on("data", (chunk) => {
+        stdout += new TextDecoder().decode(chunk);
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += new TextDecoder().decode(chunk);
+      });
+      const result = new Promise((resolve) => {
+        child.on(
+          "error",
+          (error) => resolve({ kind: "failed", reason: error.message })
+        );
+        child.on(
+          "close",
+          (code) => resolve(parsePrediction(code, stdout, stderr))
+        );
+      });
+      return { result, cancel: () => void child.kill("SIGKILL") };
+    },
+    reconcile: (root, results, headSha) => verifyRun(root, testRunFrom(root, results), { headSha }),
+    write: (line) => void process.stdout.write(line),
+    appendSummary: (file, text) => appendFile(file, text)
+  };
+}
+
+// src/reporters/vitest.ts
+function variantReporter(options = {}, deps) {
+  let root = process.cwd();
+  let watching = false;
+  let log;
+  let run;
+  return {
+    onInit(vitest) {
+      root = vitest.config.root;
+      watching = vitest.config.watch === true;
+      log = (line) => vitest.logger.log(line.replace(/\n$/, ""));
+    },
+    onTestRunStart() {
+      if (watching) return;
+      const effects = deps ?? shadowDeps();
+      run = startShadow(root, options, {
+        ...effects,
+        ...log !== void 0 && deps === void 0 && { write: log }
+      });
+    },
+    async onTestRunEnd(testModules, _unhandledErrors, reason) {
+      const current = run;
+      run = void 0;
+      if (current === void 0) return;
+      if (reason === "interrupted") {
+        current.cancel();
+        return;
+      }
+      await current.finish(
+        testModules.map((testModule) => ({
+          file: testModule.moduleId,
+          failed: testModule.state() === "failed"
+        }))
+      );
+    }
+  };
+}
+function variantReporters(options = {}) {
+  return [
+    "default",
+    ...process.env["GITHUB_ACTIONS"] === "true" ? ["github-actions"] : [],
+    variantReporter(options)
+  ];
+}
+var vitest_default = variantReporter;
+export {
+  vitest_default as default,
+  variantReporter,
+  variantReporters
+};

package/dist/workspace-PIQXG4ZD.js

@@ -0,0 +1,65 @@
+import {
+  auditWorkspace
+} from "./chunk-IFFZ46YS.js";
+import {
+  plural
+} from "./chunk-CXNXZLDG.js";
+import "./chunk-3E5LBU3O.js";
+import "./chunk-X3VVGTEV.js";
+import "./chunk-NFFXYYM6.js";
+import {
+  lines
+} from "./chunk-6J4XDG44.js";
+import {
+  getPrinter
+} from "./chunk-EISTWXDW.js";
+import "./chunk-DSQDMFQ6.js";
+import "./chunk-ACTY42RE.js";
+
+// src/cli/render/workspace.ts
+var MAX_FILES_SHOWN = 5;
+var NO_WORKSPACE_MESSAGE = "workspace check: no workspace packages found (pnpm-workspace.yaml or package.json `workspaces` required).";
+var DESCRIBE = {
+  "undeclared-workspace-dep": (v) => `${v.package} imports ${v.target} but does not declare it`,
+  "undeclared-external-dep": (v) => `${v.package} imports ${v.target} but neither it nor the workspace root declares it`,
+  "cross-package-relative-import": (v) => `${v.package} reaches into ${v.target} via a relative import (bypasses its public entry)`
+};
+function renderWorkspaceCheck(result, printer = getPrinter()) {
+  lines(printer, "", `Checked ${plural(result.packagesChecked, "package")}.`);
+  if (result.violations.length === 0) {
+    lines(printer, "", "No dependency violations found.");
+    return;
+  }
+  lines(printer, "");
+  for (const violation of result.violations) {
+    lines(printer, `  \u2717 ${DESCRIBE[violation.kind](violation)}`);
+    for (const file of violation.files.slice(0, MAX_FILES_SHOWN)) {
+      lines(printer, `      ${file}`);
+    }
+    if (violation.files.length > MAX_FILES_SHOWN) {
+      lines(
+        printer,
+        `      \u2026 and ${violation.files.length - MAX_FILES_SHOWN} more file(s)`
+      );
+    }
+  }
+  lines(printer, "", `${plural(result.violations.length, "violation")} found.`);
+}
+
+// src/cli/commands/workspace.ts
+async function registerWorkspaceCheckAction(opts = {}) {
+  const result = await auditWorkspace(process.cwd());
+  if (result === null) {
+    lines(getPrinter(), NO_WORKSPACE_MESSAGE);
+    return;
+  }
+  if (opts.json === true) {
+    lines(getPrinter(), JSON.stringify(result, null, 2));
+  } else {
+    renderWorkspaceCheck(result);
+  }
+  if (result.violations.length > 0) process.exitCode = 1;
+}
+export {
+  registerWorkspaceCheckAction
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blzsky/variant",
-  "version": "0.2.1",
+  "version": "0.3.0-canary.0",
   "description": "Change intelligence for TypeScript monorepos — AST-level blast radius, test impact, and a cached task DAG",
   "type": "module",
   "main": "dist/index.js",
@@ -9,6 +9,16 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./vitest": {
+      "import": {
+        "types": "./dist/vitest.d.ts",
+        "default": "./dist/vitest.js"
+      },
+      "require": {
+        "types": "./dist/vitest.d.cts",
+        "default": "./dist/vitest.cjs"
+      }
     }
   },
   "bin": {
@@ -69,7 +79,7 @@
   },
   "scripts": {
     "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
-    "build": "tsup",
+    "build": "pnpm clean && tsup",
     "test": "vitest",
     "test:run": "vitest run",
     "test:integration": "vitest run --project integration",
@@ -77,6 +87,7 @@
     "test:all": "vitest run --coverage",
     "bench": "node benchmarks/bench.mjs",
     "bench:quick": "node benchmarks/bench.mjs --quick",
+    "accuracy": "node accuracy/replay.mjs",
     "format": "biome format --write .",
     "format:check": "biome format .",
     "lint": "biome check .",

package/dist/chunk-DRMASVYN.js

@@ -1,25 +0,0 @@
-// src/core/semantic/verdict.ts
-function deriveVerdict(classifications, options = {}) {
-  if (options.forceBuild === true) return "build-required";
-  let verdict = "safe-to-skip";
-  for (const classification of classifications) {
-    if (classification === "breaking") return "build-required";
-    if (classification === "internal" || classification === "unanalyzed") {
-      verdict = "build-recommended";
-    }
-  }
-  return verdict;
-}
-var VERDICT_TEXT = {
-  "safe-to-skip": "safe to skip build",
-  "build-recommended": "build recommended",
-  "build-required": "build required"
-};
-function verdictText(verdict) {
-  return VERDICT_TEXT[verdict];
-}
-
-export {
-  deriveVerdict,
-  verdictText
-};

package/dist/chunk-KSHWC2XN.js

@@ -1,78 +0,0 @@
-// src/core/graph/tsconfig-paths.ts
-import { access } from "fs/promises";
-import path from "path";
-var MAX_WILDCARDS = 1;
-function toPathAliases(cwd, paths, baseUrl) {
-  if (paths === void 0) return [];
-  const base = baseUrl ?? cwd;
-  const aliases = [];
-  for (const [pattern, rawTargets] of Object.entries(paths)) {
-    const stars = pattern.split("*").length - 1;
-    if (stars > MAX_WILDCARDS) continue;
-    const wildcard = stars === 1;
-    const [prefix = "", suffix = ""] = wildcard ? pattern.split("*") : [pattern, ""];
-    const targets = [];
-    for (const target of rawTargets) {
-      if (target.split("*").length - 1 > MAX_WILDCARDS) continue;
-      const absolute = path.resolve(base, target);
-      const relative = path.relative(cwd, absolute).replace(/\\/g, "/");
-      if (relative === "" || relative.startsWith("../")) continue;
-      targets.push(relative);
-    }
-    if (targets.length > 0) {
-      aliases.push({ prefix, suffix, wildcard, targets });
-    }
-  }
-  aliases.sort((a, b) => b.prefix.length - a.prefix.length);
-  return aliases;
-}
-function matchPathAlias(spec, aliases) {
-  const bases = [];
-  for (const alias of aliases) {
-    if (!alias.wildcard) {
-      if (spec === alias.prefix) bases.push(...alias.targets);
-      continue;
-    }
-    if (spec.length < alias.prefix.length + alias.suffix.length || !spec.startsWith(alias.prefix) || !spec.endsWith(alias.suffix)) {
-      continue;
-    }
-    const captured = spec.slice(
-      alias.prefix.length,
-      spec.length - alias.suffix.length
-    );
-    for (const target of alias.targets) {
-      bases.push(target.replace("*", captured));
-    }
-  }
-  return bases;
-}
-async function readPathAliases(cwd, tsconfigName = "tsconfig.json") {
-  const configPath = path.join(cwd, tsconfigName);
-  try {
-    await access(configPath);
-  } catch {
-    return [];
-  }
-  const { ts } = await import("ts-morph");
-  const read = ts.readConfigFile(configPath, (file) => ts.sys.readFile(file));
-  if (read.error !== void 0 || read.config === void 0) return [];
-  const parsed = ts.parseJsonConfigFileContent(
-    read.config,
-    {
-      ...ts.sys,
-      // Enumerating every file in the workspace is pure waste: only
-      // `compilerOptions` is wanted, and a large repo makes this the most
-      // expensive call in the command.
-      readDirectory: () => [],
-      useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames
-    },
-    cwd
-  );
-  return toPathAliases(cwd, parsed.options.paths, parsed.options.baseUrl);
-}
-
-export {
-  toPathAliases,
-  matchPathAlias,
-  readPathAliases
-};