@blzsky/variant 0.2.1 → 0.3.0-canary.0

package/dist/chunk-KCEGA56S.js

@@ -0,0 +1,670 @@
+import {
+  buildImportGraph,
+  computeAffectedFiles,
+  importersOfUnindexed,
+  readManifests,
+  workspaceBlindSpots
+} from "./chunk-IFFZ46YS.js";
+import {
+  mapLimit
+} from "./chunk-GDSZFIHM.js";
+import {
+  getChangedFiles
+} from "./chunk-DMDAJPFJ.js";
+import {
+  loadPackageGraph
+} from "./chunk-3E5LBU3O.js";
+import {
+  appendImpactPrediction,
+  changeBaseDeps,
+  defaultHistoryDir,
+  resolveChangeBase
+} from "./chunk-H5C4SE73.js";
+import {
+  readPathAliases
+} from "./chunk-X3VVGTEV.js";
+import {
+  updateSymbolGraph
+} from "./chunk-NFFXYYM6.js";
+import {
+  assertBaseRef,
+  createClassifier
+} from "./chunk-MAK3HG46.js";
+import {
+  readFileAtRef,
+  readFilesAtRef,
+  readHeadSha
+} from "./chunk-RSIOYQOQ.js";
+import {
+  isStarReexportKey
+} from "./chunk-DSQDMFQ6.js";
+import {
+  GitRefError,
+  NoTestFilesError
+} from "./chunk-ACTY42RE.js";
+
+// src/core/semantic/blast-radius.ts
+import { readFile } from "fs/promises";
+import path from "path";
+var TS_FILE = /\.(?:ts|tsx|mts|cts)$/;
+var JS_FILE = /\.(?:[cm]?js|jsx)$/;
+var COMMONJS_EXPORT = /\bmodule\.exports\b|\bexports\.[A-Za-z_$]|\bexports\[/;
+var MODULE_FILE = /\.(?:[cm]?[jt]sx?|json)$/;
+function isModuleFile(file) {
+  return MODULE_FILE.test(file);
+}
+var DECLARATION_FILE = /\.d\.(?:ts|mts|cts)$/;
+var MAX_NOTE_FILES = 3;
+var CLASSIFY_CONCURRENCY = 16;
+function isOutsideWorkspace(file) {
+  return file.startsWith("../");
+}
+function isTypeScriptSource(file) {
+  return TS_FILE.test(file) && !DECLARATION_FILE.test(file);
+}
+function isSource(file) {
+  return isTypeScriptSource(file) || JS_FILE.test(file);
+}
+function isAnalyzable(file) {
+  return isSource(file) && !isOutsideWorkspace(file);
+}
+function widenCommonJs(impact, before, after) {
+  if (!JS_FILE.test(impact.filePath)) return impact;
+  if (impact.classification === "non-impacting") return impact;
+  if (!COMMONJS_EXPORT.test(`${before ?? ""}
+${after ?? ""}`)) return impact;
+  return {
+    ...impact,
+    classification: "breaking",
+    propagates: true,
+    ungated: true
+  };
+}
+function unanalyzedImpact(file) {
+  return {
+    filePath: file,
+    classification: "unanalyzed",
+    impactedSymbols: [],
+    propagates: false,
+    notes: []
+  };
+}
+async function batchedReaderFor(cwd, baseRef, relPaths) {
+  const batch = await readFilesAtRef(cwd, baseRef, relPaths);
+  if (batch === null) return (rel) => readFileAtRef(cwd, baseRef, rel);
+  return async (rel) => batch.get(rel) ?? null;
+}
+async function traceBlastRadius(cwd, options = {}) {
+  const baseRef = options.baseRef ?? "HEAD~1";
+  const changedFiles = options.changedFiles ?? await getChangedFiles({ cwd, baseRef });
+  if (changedFiles === null) return null;
+  const packageDirs = packageDirsFrom(cwd, options.packageGraph);
+  let importGraph = options.importGraph;
+  if (importGraph === void 0) {
+    const [{ graph: symbolGraph }, pathAliases] = await Promise.all([
+      updateSymbolGraph(
+        cwd,
+        options.graphDir === void 0 ? {} : { graphDir: options.graphDir }
+      ),
+      options.pathAliases ?? readPathAliases(cwd)
+    ]);
+    importGraph = buildImportGraph(symbolGraph, {
+      packageDirs,
+      pathAliases,
+      packageExports: packageExportsFrom(options.packageGraph)
+    });
+  }
+  const indexed = importGraph.imports;
+  const files = changedFiles.map(toPosix).sort();
+  const analyzable = files.filter(isAnalyzable);
+  const readBefore = options.readBefore ?? await batchedReaderFor(cwd, baseRef, analyzable);
+  const readAfter = options.readAfter ?? (async (rel) => {
+    try {
+      return await readFile(path.join(cwd, rel), "utf8");
+    } catch {
+      return null;
+    }
+  });
+  const classify = createClassifier();
+  const changed = await mapLimit(files, CLASSIFY_CONCURRENCY, async (file) => {
+    if (!isAnalyzable(file)) return unanalyzedImpact(file);
+    const [before, after] = await Promise.all([
+      readBefore(file),
+      readAfter(file)
+    ]);
+    if (after !== null && !indexed.has(file)) return unanalyzedImpact(file);
+    return widenCommonJs(
+      toFileImpact(
+        await classify({
+          filePath: file,
+          before: before ?? "",
+          after: after ?? ""
+        })
+      ),
+      before,
+      after
+    );
+  });
+  const manifests = options.manifests ?? await readManifests(cwd);
+  const blindSpots = workspaceBlindSpots({
+    externals: importGraph.externals,
+    packageNames: new Set(
+      (options.packageGraph?.packages ?? []).map((pkg) => pkg.manifest.name)
+    ),
+    manifests
+  });
+  return assembleBlastRadius(baseRef, changed, importGraph, {
+    packageDirs,
+    workspaceNotes: blindSpots.notes,
+    undiscoveredPackages: blindSpots.undiscovered,
+    packageRoots: [...manifests.keys()],
+    ...options.tasks === void 0 ? {} : { tasks: options.tasks }
+  });
+}
+function assembleBlastRadius(baseRef, changed, importGraph, options = {}) {
+  const notes = /* @__PURE__ */ new Set();
+  const repositoryNotes = new Set(options.workspaceNotes);
+  const affected = /* @__PURE__ */ new Set();
+  const firstHop = /* @__PURE__ */ new Set();
+  for (const impact of changed) {
+    for (const note of impact.notes) notes.add(note);
+    if (impact.classification === "non-impacting") continue;
+    affected.add(impact.filePath);
+    if (impact.classification === "unanalyzed" || !importGraph.imports.has(impact.filePath)) {
+      for (const importer of importersOfUnindexed(
+        importGraph,
+        impact.filePath
+      )) {
+        firstHop.add(importer);
+      }
+      continue;
+    }
+    if (!impact.propagates) continue;
+    const ungated = impact.ungated === true || impact.impactedSymbols.some(isStarReexportKey);
+    for (const dependent of importGraph.dependents.get(impact.filePath) ?? []) {
+      const edge = importGraph.edges.get(dependent)?.get(impact.filePath);
+      if (edge === void 0) {
+        firstHop.add(dependent);
+        continue;
+      }
+      if (edge.dynamic) {
+        notes.add(
+          `${dependent}: dynamic import of ${impact.filePath} \u2014 names unknowable`
+        );
+        firstHop.add(dependent);
+        continue;
+      }
+      if (ungated || edge.names.has("*")) {
+        firstHop.add(dependent);
+        continue;
+      }
+      if (impact.impactedSymbols.some((s) => edge.names.has(s))) {
+        firstHop.add(dependent);
+      }
+    }
+  }
+  for (const file of computeAffectedFiles(firstHop, importGraph)) {
+    affected.add(file);
+  }
+  const unanalyzed = changed.filter((impact) => impact.classification === "unanalyzed").map((impact) => impact.filePath);
+  const outside = unanalyzed.filter(isOutsideWorkspace);
+  const inside = unanalyzed.filter((file) => !isOutsideWorkspace(file));
+  const unindexed = inside.filter(isSource);
+  const notTypeScript = inside.filter((file) => !isSource(file));
+  if (notTypeScript.length > 0) {
+    const one = notTypeScript.length === 1;
+    notes.add(
+      `${notTypeScript.length} changed ${one ? "file is" : "files are"} not TypeScript or JavaScript and ${one ? "was" : "were"} not analyzed (${listPaths(notTypeScript)})`
+    );
+  }
+  if (unindexed.length > 0) {
+    const one = unindexed.length === 1;
+    notes.add(
+      `${unindexed.length} changed source ${one ? "file is" : "files are"} not in variant's index (ignored by git, in a build directory, or too large) and ${one ? "was" : "were"} not analyzed (${listPaths(unindexed)})`
+    );
+  }
+  if (outside.length > 0) {
+    const one = outside.length === 1;
+    notes.add(
+      `${outside.length} changed ${one ? "file is" : "files are"} outside the directory variant ran in and ${one ? "was" : "were"} not analyzed (${listPaths(outside)})`
+    );
+  }
+  const withUnresolved = [...affected].sort().flatMap((file) => {
+    const specs = importGraph.unresolved.get(file);
+    return specs === void 0 || specs.size === 0 ? [] : [`${file} (${[...specs].sort().join(", ")})`];
+  });
+  if (withUnresolved.length > 0) {
+    const one = withUnresolved.length === 1;
+    notes.add(
+      `${withUnresolved.length} affected ${one ? "file has" : "files have"} unresolved imports: ${listPaths(withUnresolved)}`
+    );
+  }
+  const impacting = changed.filter((impact) => impact.classification !== "non-impacting").map((impact) => impact.filePath);
+  if (importGraph.computed.size > 0) {
+    const loaders = [...importGraph.computed].sort();
+    repositoryNotes.add(
+      `${loaders.length} file(s) load a module through a fully computed import() or require() specifier (${listPaths(loaders)}); a change reached only that way selects no tests`
+    );
+    const touched = new Set(
+      impacting.filter(isModuleFile).map((file) => packageRootOf(file, options.packageRoots))
+    );
+    const near = loaders.filter(
+      (loader) => touched.has(packageRootOf(loader, options.packageRoots))
+    );
+    if (near.length > 0) {
+      notes.add(
+        `${near.length} file(s) in a package this change touches load a module through a fully computed import() or require() specifier (${listPaths(near)}); a changed file reached only that way selects no tests`
+      );
+    }
+  }
+  for (const [name, dir] of options.undiscoveredPackages ?? []) {
+    const prefix = dir === "" ? "" : `${dir}/`;
+    const inside2 = impacting.filter((file) => file.startsWith(prefix));
+    if (inside2.length > 0) {
+      const one = inside2.length === 1;
+      notes.add(
+        `${inside2.length} changed ${one ? "file belongs" : "files belong"} to ${name}, a local package variant did not find as a workspace package (${listPaths(inside2)}); files importing it by name are not reached`
+      );
+    }
+  }
+  const packageDirs = options.packageDirs ?? {};
+  const affectedPackages = /* @__PURE__ */ new Set();
+  for (const file of affected) {
+    const pkg = fileToPackage(file, packageDirs);
+    if (pkg !== void 0) affectedPackages.add(pkg);
+  }
+  const affectedTasks = [];
+  for (const taskName of Object.keys(options.tasks ?? {})) {
+    const sep = taskName.lastIndexOf(":");
+    if (sep === -1) continue;
+    if (affectedPackages.has(taskName.slice(0, sep))) {
+      affectedTasks.push(taskName);
+    }
+  }
+  const noteList = [...notes].sort();
+  const confidence = Math.max(
+    0.3,
+    Math.round((1 - noteList.length * 0.1) * 100) / 100
+  );
+  return {
+    baseRef,
+    changed,
+    affectedFiles: [...affected].sort(),
+    affectedPackages: [...affectedPackages].sort(),
+    affectedTasks: affectedTasks.sort(),
+    confidence,
+    notes: noteList,
+    repositoryNotes: [...repositoryNotes].sort()
+  };
+}
+function packageRootOf(file, packageRoots) {
+  let best = "";
+  for (const root of packageRoots ?? []) {
+    if (root !== "" && file.startsWith(`${root}/`) && root.length > best.length) {
+      best = root;
+    }
+  }
+  return best;
+}
+function toFileImpact(result) {
+  const impactedSymbols = [
+    ...result.exportedSymbols.added.filter(isStarReexportKey),
+    ...result.exportedSymbols.removed,
+    ...result.exportedSymbols.changed.filter((c) => c.kind !== "body").map((c) => c.name)
+  ].sort();
+  const ungated = result.syntaxErrors || impactedSymbols.some(isStarReexportKey);
+  return {
+    filePath: result.filePath,
+    classification: result.classification,
+    impactedSymbols,
+    propagates: result.classification === "breaking",
+    ...ungated && { ungated: true },
+    notes: result.confidenceNotes.map((n) => `${result.filePath}: ${n}`)
+  };
+}
+function packageDirsFrom(cwd, packageGraph) {
+  const out = {};
+  for (const pkg of packageGraph?.packages ?? []) {
+    out[pkg.manifest.name] = toPosix(path.relative(cwd, pkg.dir));
+  }
+  return out;
+}
+function packageExportsFrom(packageGraph) {
+  const out = {};
+  for (const pkg of packageGraph?.packages ?? []) {
+    if (pkg.manifest.exports !== void 0) {
+      out[pkg.manifest.name] = pkg.manifest.exports;
+    }
+  }
+  return out;
+}
+function listPaths(items) {
+  return items.length > MAX_NOTE_FILES ? `${items.slice(0, MAX_NOTE_FILES).join(", ")}, \u2026 ${items.length - MAX_NOTE_FILES} more` : items.join(", ");
+}
+function fileToPackage(file, packageDirs) {
+  let bestName;
+  let bestLength = -1;
+  for (const [name, dir] of Object.entries(packageDirs)) {
+    const prefix = dir === "" ? "" : `${dir}/`;
+    if (file.startsWith(prefix) && prefix.length > bestLength) {
+      bestName = name;
+      bestLength = prefix.length;
+    }
+  }
+  return bestName;
+}
+function toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+
+// 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;
+}
+function resolutionOf(confidence) {
+  if (confidence >= 0.9) return "high";
+  if (confidence >= 0.7) return "medium";
+  return "low";
+}
+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];
+}
+
+// src/core/semantic/test-impact.ts
+var JAVASCRIPT_TEST_FILE = /\.(?:test|spec)\.(?:js|jsx|mjs|cjs)$/;
+function isJavaScriptTestFile(file) {
+  return JAVASCRIPT_TEST_FILE.test(file);
+}
+function defaultIsTestFile(file) {
+  return /(^|\/)__tests__\//.test(file) || /\.(test|spec)\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/.test(file);
+}
+var TEST_CONFIG_FILE = /(^|\/)(package\.json|pnpm-lock\.yaml|pnpm-workspace\.yaml|package-lock\.json|npm-shrinkwrap\.json|yarn\.lock|bun\.lockb?|bunfig\.toml|tsconfig[^/]*\.json|(vitest|jest|playwright|vite|babel|next)\.config\.[^/.]+(\.[^/]+)?|vitest\.(workspace|projects)\.[^/.]+|\.babelrc(\.[^/]+)?)$/;
+var TEST_SETUP_FILE = /(^|\/)((vitest|jest)\.setup|setup-?tests|global-?(setup|teardown)|tests?\/setup)\.[cm]?[jt]sx?$/i;
+var PROSE_FILE = /\.(?:md|markdown|rst|txt|adoc)$/i;
+var UNREACHED_CONFIDENCE = 0.5;
+function invalidatesAllTests(filePath) {
+  return TEST_CONFIG_FILE.test(filePath) || TEST_SETUP_FILE.test(filePath);
+}
+function buildTestTrace(graph, options = {}) {
+  const isTest = options.isTestFile ?? defaultIsTestFile;
+  const closures = /* @__PURE__ */ new Map();
+  for (const file of [...graph.imports.keys()].sort()) {
+    if (isTest(file)) closures.set(file, closureOf(file, graph));
+  }
+  return { closures };
+}
+function buildCoverageMap(trace) {
+  const testsFor = /* @__PURE__ */ new Map();
+  for (const [test, closure] of trace.closures) {
+    for (const file of closure) {
+      let tests = testsFor.get(file);
+      if (tests === void 0) {
+        tests = /* @__PURE__ */ new Set();
+        testsFor.set(file, tests);
+      }
+      tests.add(test);
+    }
+  }
+  return { testsFor };
+}
+function computeTestImpact(radius, graph, options = {}) {
+  const trace = buildTestTrace(graph, options);
+  const coverage = buildCoverageMap(trace);
+  const allTests = [...trace.closures.keys()];
+  const notes = /* @__PURE__ */ new Set();
+  let selectAll = false;
+  for (const impact of radius.changed) {
+    if (invalidatesAllTests(impact.filePath)) {
+      selectAll = true;
+      notes.add(
+        `${impact.filePath}: build/test configuration changed \u2014 running all tests`
+      );
+    }
+  }
+  const affected = /* @__PURE__ */ new Set();
+  if (selectAll) {
+    for (const test of allTests) affected.add(test);
+  } else {
+    for (const file of radius.affectedFiles) {
+      for (const test of coverage.testsFor.get(file) ?? []) {
+        affected.add(test);
+      }
+    }
+  }
+  const unindexed = (file) => !graph.imports.has(file);
+  const javascriptTests = [...options.javascriptTests ?? []].filter(unindexed).sort();
+  const unselectedTests = radius.changed.map((impact) => impact.filePath).filter((file) => isJavaScriptTestFile(file) && unindexed(file));
+  if (unselectedTests.length > 0) {
+    const one = unselectedTests.length === 1;
+    notes.add(
+      `${unselectedTests.length} changed test ${one ? "file is" : "files are"} JavaScript, which variant does not index, and ${one ? "was" : "were"} not selected (${listPaths(unselectedTests)})`
+    );
+  }
+  const repositoryNotes = [];
+  if (javascriptTests.length > 0) {
+    const one = javascriptTests.length === 1;
+    repositoryNotes.push(
+      `${javascriptTests.length} JavaScript test ${one ? "file is" : "files are"} not indexed (${listPaths(javascriptTests)}); variant cannot select ${one ? "it" : "them"}, and code only ${one ? "it imports" : "they import"} looks untested`
+    );
+    const touched = new Set(
+      radius.changed.filter(
+        (impact) => impact.classification !== "non-impacting" && isModuleFile(impact.filePath) && !isJavaScriptTestFile(impact.filePath)
+      ).map((impact) => packageRootOf(impact.filePath, options.packageRoots))
+    );
+    const near = javascriptTests.filter(
+      (test) => touched.has(packageRootOf(test, options.packageRoots))
+    );
+    if (near.length > 0) {
+      const oneNear = near.length === 1;
+      notes.add(
+        `${near.length} JavaScript test ${oneNear ? "file" : "files"} in a package this change touches cannot be selected (${listPaths(near)})`
+      );
+    }
+  }
+  const tested = (file) => (coverage.testsFor.get(file)?.size ?? 0) > 0;
+  const unreached = [];
+  if (!selectAll) {
+    for (const impact of radius.changed) {
+      if (impact.classification === "non-impacting") continue;
+      if (PROSE_FILE.test(impact.filePath)) continue;
+      if (unselectedTests.includes(impact.filePath)) continue;
+      if (graph.imports.has(impact.filePath)) {
+        if (!tested(impact.filePath)) unreached.push(impact.filePath);
+        continue;
+      }
+      if (impact.classification !== "unanalyzed") continue;
+      const reached = [...importersOfUnindexed(graph, impact.filePath)].some(
+        tested
+      );
+      if (!reached) unreached.push(impact.filePath);
+    }
+  }
+  let blindSpots = 0;
+  for (const test of affected) {
+    const closure = trace.closures.get(test);
+    if (closure === void 0) continue;
+    for (const file of closure) {
+      const unresolvedForFile = graph.unresolved.get(file);
+      if (unresolvedForFile !== void 0 && unresolvedForFile.size > 0) {
+        blindSpots++;
+        break;
+      }
+    }
+  }
+  if (blindSpots > 0) {
+    notes.add(
+      `${blindSpots} selected test file(s) have unresolved imports in their closure \u2014 fixtures or assets may be missed`
+    );
+  }
+  const noteList = [...notes].sort();
+  const resolved = Math.max(
+    0.3,
+    Math.round((radius.confidence - noteList.length * 0.1) * 100) / 100
+  );
+  const confidence = selectAll ? 1 : unreached.length > 0 || unselectedTests.length > 0 ? Math.min(resolved, UNREACHED_CONFIDENCE) : resolved;
+  return {
+    affectedTests: [...affected].sort(),
+    totalTests: allTests.length,
+    selectAll,
+    unreached,
+    unselectedTests,
+    javascriptTests: javascriptTests.length,
+    confidence,
+    resolution: resolutionOf(confidence),
+    notes: noteList,
+    repositoryNotes
+  };
+}
+async function traceTestImpact(cwd, options = {}) {
+  let importGraph = options.importGraph;
+  if (importGraph === void 0) {
+    const [{ graph: symbolGraph }, pathAliases] = await Promise.all([
+      updateSymbolGraph(
+        cwd,
+        options.graphDir === void 0 ? {} : { graphDir: options.graphDir }
+      ),
+      options.pathAliases ?? readPathAliases(cwd)
+    ]);
+    importGraph = buildImportGraph(symbolGraph, {
+      packageDirs: packageDirsFrom(cwd, options.packageGraph),
+      pathAliases,
+      packageExports: packageExportsFrom(options.packageGraph)
+    });
+  }
+  const [manifests, javascriptTests] = await Promise.all([
+    options.manifests ?? readManifests(cwd),
+    options.javascriptTests ?? findJavaScriptTests(cwd)
+  ]);
+  const radius = await traceBlastRadius(cwd, {
+    ...options,
+    importGraph,
+    manifests
+  });
+  if (radius === null) return null;
+  return {
+    radius,
+    graph: importGraph,
+    tests: computeTestImpact(radius, importGraph, {
+      ...options.isTestFile !== void 0 && {
+        isTestFile: options.isTestFile
+      },
+      javascriptTests,
+      packageRoots: [...manifests.keys()]
+    })
+  };
+}
+async function findJavaScriptTests(cwd) {
+  const fg = (await import("fast-glob")).default;
+  const found = await fg("**/*.{test,spec}.{js,jsx,mjs,cjs}", {
+    cwd,
+    onlyFiles: true,
+    ignore: ["**/node_modules/**", "**/dist/**", ".git/**", ".variant/**"]
+  });
+  return found.map((file) => file.replace(/\\/g, "/")).sort();
+}
+function closureOf(start, graph) {
+  const closure = /* @__PURE__ */ new Set([start]);
+  let frontier = /* @__PURE__ */ new Set([start]);
+  while (frontier.size > 0) {
+    const next = /* @__PURE__ */ new Set();
+    for (const file of frontier) {
+      for (const target of graph.imports.get(file) ?? []) {
+        if (!closure.has(target)) {
+          closure.add(target);
+          next.add(target);
+        }
+      }
+    }
+    frontier = next;
+  }
+  return closure;
+}
+
+// src/core/impact/predict.ts
+var DEFAULT_IMPACT_BASE_REF = "HEAD~1";
+async function analyzeImpact(cwd, options = {}) {
+  const base = options.changedFiles === void 0 ? await resolveChangeBase(
+    options.base,
+    options.changeBaseDeps ?? changeBaseDeps(cwd)
+  ) : {
+    ref: options.base ?? DEFAULT_IMPACT_BASE_REF,
+    source: options.base === void 0 ? "previous-commit" : "flag",
+    label: options.base ?? "previous commit"
+  };
+  const baseRef = base.ref;
+  if (options.changedFiles === void 0) await assertBaseRef(cwd, baseRef);
+  const packageGraph = await loadPackageGraph(cwd).catch(() => void 0);
+  const result = await traceTestImpact(cwd, {
+    baseRef,
+    ...packageGraph !== void 0 && { packageGraph },
+    ...options.changedFiles !== void 0 && {
+      changedFiles: options.changedFiles
+    },
+    ...options.readBefore !== void 0 && { readBefore: options.readBefore }
+  });
+  if (result === null) {
+    throw new GitRefError(
+      `Could not list the files changed since "${baseRef}"`
+    );
+  }
+  return { base, result, packageGraph };
+}
+async function predictImpact(cwd, options = {}) {
+  const { base, result, packageGraph } = await analyzeImpact(cwd, options);
+  const baseRef = base.ref;
+  if (result.tests.totalTests === 0) throw new NoTestFilesError();
+  const verdict = deriveVerdict(
+    result.radius.changed.map((change) => change.classification),
+    { forceBuild: result.tests.selectAll }
+  );
+  const headSha = options.headSha !== void 0 ? options.headSha : base.headSha ?? await readHeadSha(cwd);
+  const historyLogged = await appendImpactPrediction(defaultHistoryDir(cwd), {
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    baseRef,
+    headSha,
+    changedFiles: result.radius.changed.map((change) => change.filePath),
+    affectedFiles: result.radius.affectedFiles.length,
+    affectedPackages: result.radius.affectedPackages,
+    affectedTests: result.tests.affectedTests,
+    totalTests: result.tests.totalTests,
+    selectAll: result.tests.selectAll,
+    verdict,
+    confidence: result.tests.confidence,
+    notes: [...result.radius.notes, ...result.tests.notes]
+  });
+  return {
+    baseRef,
+    baseSource: base.source,
+    baseLabel: base.label,
+    headSha,
+    result,
+    verdict,
+    packagesFound: packageGraph?.packages.length ?? 0,
+    historyLogged
+  };
+}
+
+export {
+  packageRootOf,
+  deriveVerdict,
+  verdictText,
+  isJavaScriptTestFile,
+  defaultIsTestFile,
+  PROSE_FILE,
+  invalidatesAllTests,
+  analyzeImpact,
+  predictImpact
+};