@blzsky/variant 0.2.1 → 0.3.0-canary.0

package/dist/impact-PRZ6HEP5.js

@@ -1,735 +0,0 @@
-import {
-  mapLimit
-} from "./chunk-GDSZFIHM.js";
-import {
-  getChangedFiles
-} from "./chunk-7OPTWU6E.js";
-import {
-  buildImportGraph,
-  computeAffectedFiles
-} from "./chunk-XTYVVUWW.js";
-import {
-  loadPackageGraph
-} from "./chunk-3E5LBU3O.js";
-import {
-  readPathAliases
-} from "./chunk-KSHWC2XN.js";
-import {
-  updateSymbolGraph
-} from "./chunk-TCISS2AS.js";
-import {
-  deriveVerdict,
-  verdictText
-} from "./chunk-DRMASVYN.js";
-import {
-  assertBaseRef,
-  createClassifier
-} from "./chunk-FZEXZBXB.js";
-import {
-  readFileAtRef,
-  readFilesAtRef,
-  readHeadSha
-} from "./chunk-6BXSZPHC.js";
-import {
-  classificationLabel,
-  plural
-} from "./chunk-CXNXZLDG.js";
-import {
-  lines
-} from "./chunk-6J4XDG44.js";
-import {
-  getPrinter
-} from "./chunk-EISTWXDW.js";
-import "./chunk-RC23JQKI.js";
-import {
-  GitRefError,
-  ImpactReportError
-} from "./chunk-VYWPQKMS.js";
-
-// src/core/history/impact-log.ts
-import { mkdir, readFile, writeFile } from "fs/promises";
-import path from "path";
-var MAX_IMPACT_RECORDS = 1e3;
-var LOG_FILENAME = "impact.jsonl";
-var RECONCILIATION_FILENAME = "reconciliation.jsonl";
-function defaultHistoryDir(cwd) {
-  return path.join(cwd, ".variant", "history");
-}
-async function appendImpactPrediction(historyDir, prediction) {
-  return appendRecord(historyDir, LOG_FILENAME, prediction);
-}
-async function appendReconciliation(historyDir, reconciliation) {
-  return appendRecord(historyDir, RECONCILIATION_FILENAME, reconciliation);
-}
-async function appendRecord(historyDir, filename, record) {
-  try {
-    await mkdir(historyDir, { recursive: true });
-    const file = path.join(historyDir, filename);
-    let lines2 = [];
-    try {
-      lines2 = (await readFile(file, "utf8")).split("\n").filter((l) => l.trim() !== "");
-    } catch {
-    }
-    lines2.push(JSON.stringify(record));
-    if (lines2.length > MAX_IMPACT_RECORDS) {
-      lines2 = lines2.slice(-MAX_IMPACT_RECORDS);
-    }
-    await writeFile(file, `${lines2.join("\n")}
-`);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function readImpactPredictions(historyDir) {
-  return readRecords(historyDir, LOG_FILENAME);
-}
-async function readRecords(historyDir, filename) {
-  let raw;
-  try {
-    raw = await readFile(path.join(historyDir, filename), "utf8");
-  } catch {
-    return [];
-  }
-  const out = [];
-  for (const line of raw.split("\n")) {
-    const trimmed = line.trim();
-    if (trimmed === "") continue;
-    try {
-      out.push(JSON.parse(trimmed));
-    } catch {
-    }
-  }
-  return out;
-}
-
-// src/core/semantic/blast-radius.ts
-import { readFile as readFile2 } from "fs/promises";
-import path2 from "path";
-var TS_FILE = /\.(?:ts|tsx|mts|cts)$/;
-var CLASSIFY_CONCURRENCY = 16;
-function isAnalyzable(file) {
-  return TS_FILE.test(file) && !file.endsWith(".d.ts");
-}
-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 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 readFile2(path2.join(cwd, rel), "utf8");
-    } catch {
-      return null;
-    }
-  });
-  const classify = createClassifier();
-  const changed = await mapLimit(files, CLASSIFY_CONCURRENCY, async (file) => {
-    if (!isAnalyzable(file)) {
-      return {
-        filePath: file,
-        classification: "unanalyzed",
-        impactedSymbols: [],
-        propagates: false,
-        notes: [`${file}: not a TypeScript source; change not analyzed`]
-      };
-    }
-    const [before, after] = await Promise.all([
-      readBefore(file),
-      readAfter(file)
-    ]);
-    return toFileImpact(
-      await classify({
-        filePath: file,
-        before: before ?? "",
-        after: after ?? ""
-      })
-    );
-  });
-  return assembleBlastRadius(baseRef, changed, importGraph, {
-    packageDirs,
-    ...options.tasks === void 0 ? {} : { tasks: options.tasks }
-  });
-}
-function assembleBlastRadius(baseRef, changed, importGraph, options = {}) {
-  const notes = /* @__PURE__ */ new Set();
-  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.propagates) continue;
-    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 (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);
-  }
-  for (const file of affected) {
-    const fileUnresolved = importGraph.unresolved.get(file);
-    if (fileUnresolved !== void 0 && fileUnresolved.size > 0) {
-      notes.add(
-        `${file}: unresolved imports (${[...fileUnresolved].sort().join(", ")})`
-      );
-    }
-  }
-  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
-  };
-}
-function toFileImpact(result) {
-  const impactedSymbols = [
-    ...result.exportedSymbols.removed,
-    ...result.exportedSymbols.changed.filter((c) => c.kind !== "body").map((c) => c.name)
-  ].sort();
-  return {
-    filePath: result.filePath,
-    classification: result.classification,
-    impactedSymbols,
-    propagates: result.classification === "breaking",
-    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(path2.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 fileToPackage(file, packageDirs) {
-  let bestName;
-  let bestLength = -1;
-  for (const [name, dir] of Object.entries(packageDirs)) {
-    const prefix = `${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/test-impact.ts
-function defaultIsTestFile(file) {
-  return /(^|\/)__tests__\//.test(file) || /\.(test|spec)\.(ts|tsx|mts|cts)$/.test(file);
-}
-var TEST_CONFIG_FILE = /(^|\/)(package\.json|pnpm-lock\.yaml|package-lock\.json|yarn\.lock|tsconfig[^/]*\.json|(vitest|jest|playwright|vite)\.config\.[^/.]+(\.[^/]+)?)$/;
-var TEST_SETUP_FILE = /(^|\/)((vitest|jest)\.setup|setup-?tests|global-?(setup|teardown)|tests?\/setup)\.[cm]?[jt]sx?$/i;
-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);
-      }
-    }
-  }
-  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 confidence = Math.max(
-    0.3,
-    Math.round((radius.confidence - noteList.length * 0.1) * 100) / 100
-  );
-  return {
-    affectedTests: [...affected].sort(),
-    totalTests: allTests.length,
-    selectAll,
-    confidence,
-    notes: noteList
-  };
-}
-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 radius = await traceBlastRadius(cwd, { ...options, importGraph });
-  if (radius === null) return null;
-  return {
-    radius,
-    tests: computeTestImpact(
-      radius,
-      importGraph,
-      options.isTestFile === void 0 ? {} : { isTestFile: options.isTestFile }
-    )
-  };
-}
-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 predictImpact(cwd, options = {}) {
-  const baseRef = options.base ?? DEFAULT_IMPACT_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}"`
-    );
-  }
-  const verdict = deriveVerdict(
-    result.radius.changed.map((change) => change.classification),
-    { forceBuild: result.tests.selectAll }
-  );
-  const headSha = options.headSha !== void 0 ? options.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, result, verdict, historyLogged };
-}
-
-// src/core/impact/verify.ts
-import { realpathSync } from "fs";
-import { readFile as readFile3 } from "fs/promises";
-import path3 from "path";
-function realpathOrSelf(target) {
-  try {
-    return realpathSync.native(target);
-  } catch {
-    return target;
-  }
-}
-function escapes(relative) {
-  return relative === ".." || relative.startsWith(`..${path3.sep}`) || path3.isAbsolute(relative);
-}
-function toRelativePosix(cwd, testPath, realpath) {
-  let relative = testPath;
-  if (path3.isAbsolute(testPath)) {
-    relative = path3.relative(cwd, testPath);
-    if (escapes(relative)) {
-      relative = path3.relative(realpath(cwd), realpath(testPath));
-    }
-  }
-  return relative.replace(/\\/g, "/");
-}
-function parseFailedTests(cwd, raw, realpath = realpathOrSelf) {
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new ImpactReportError("it is not valid JSON");
-  }
-  if (typeof parsed !== "object" || parsed === null) {
-    throw new ImpactReportError("it is not a JSON object");
-  }
-  const results = parsed.testResults;
-  if (!Array.isArray(results)) {
-    throw new ImpactReportError("it has no `testResults` array");
-  }
-  const failed = [];
-  for (const entry of results) {
-    if (typeof entry !== "object" || entry === null) continue;
-    const { name, status } = entry;
-    if (status !== "failed" || typeof name !== "string") continue;
-    failed.push(toRelativePosix(cwd, name, realpath));
-  }
-  return [...new Set(failed)].sort();
-}
-function reconcile(prediction, failedTests) {
-  const selected = new Set(prediction.affectedTests);
-  const caught = [];
-  const falseSkips = [];
-  for (const test of failedTests) {
-    if (prediction.selectAll || selected.has(test)) caught.push(test);
-    else falseSkips.push(test);
-  }
-  return {
-    caught,
-    falseSkips,
-    falseSkipRate: failedTests.length === 0 ? 0 : falseSkips.length / failedTests.length
-  };
-}
-function selectPrediction(predictions, headSha) {
-  if (headSha !== void 0) {
-    for (let i = predictions.length - 1; i >= 0; i--) {
-      const candidate = predictions[i];
-      if (candidate?.headSha === headSha) {
-        return { prediction: candidate, matchedBy: "head-sha" };
-      }
-    }
-    return null;
-  }
-  const latest = predictions[predictions.length - 1];
-  return latest === void 0 ? null : { prediction: latest, matchedBy: "most-recent" };
-}
-async function readReport(cwd, reportPath) {
-  try {
-    return await readFile3(path3.resolve(cwd, reportPath), "utf8");
-  } catch (error) {
-    const code = error instanceof Error && "code" in error ? String(error.code) : "";
-    throw new ImpactReportError(
-      code === "ENOENT" ? `no file at ${reportPath}` : `${reportPath} could not be read${code === "" ? "" : ` (${code})`}`
-    );
-  }
-}
-async function verifyImpact(cwd, reportPath, options = {}) {
-  const historyDir = defaultHistoryDir(cwd);
-  const predictions = options.predictions ?? await readImpactPredictions(historyDir);
-  const match = selectPrediction(predictions, options.headSha);
-  if (match === null) return null;
-  const raw = await readReport(cwd, reportPath);
-  const failedTests = parseFailedTests(cwd, raw);
-  const { caught, falseSkips, falseSkipRate } = reconcile(
-    match.prediction,
-    failedTests
-  );
-  const historyLogged = options.log === false ? true : await appendReconciliation(historyDir, {
-    at: (/* @__PURE__ */ new Date()).toISOString(),
-    headSha: match.prediction.headSha,
-    baseRef: match.prediction.baseRef,
-    predictedTests: match.prediction.affectedTests.length,
-    totalTests: match.prediction.totalTests,
-    failedTests: failedTests.length,
-    caught: caught.length,
-    falseSkips: falseSkips.length
-  });
-  return {
-    prediction: match.prediction,
-    matchedBy: match.matchedBy,
-    failedTests,
-    caught,
-    falseSkips,
-    falseSkipRate,
-    historyLogged
-  };
-}
-
-// src/cli/render/impact.ts
-var MAX_LISTED_FILES = 20;
-var count = (value) => value.toLocaleString("en-US");
-var NO_PREDICTION_MESSAGE = "impact verify: no logged prediction to reconcile against. Run `variant impact` before the test run, or pass --head-sha for a specific commit.";
-function renderImpactJson(report, printer = getPrinter()) {
-  const { result, ...rest } = report;
-  lines(
-    printer,
-    JSON.stringify(
-      { ...rest, radius: result.radius, tests: result.tests },
-      null,
-      2
-    )
-  );
-}
-function renderImpact(report, printer = getPrinter()) {
-  const { radius, tests } = report.result;
-  lines(
-    printer,
-    "",
-    `Base ref: ${report.baseRef}`,
-    "",
-    `You changed ${plural(radius.changed.length, "file")}.`
-  );
-  for (const impact of radius.changed.slice(0, MAX_LISTED_FILES)) {
-    const symbols = impact.impactedSymbols.length > 0 ? `  (${impact.impactedSymbols.join(", ")})` : "";
-    lines(
-      printer,
-      `  ${classificationLabel(impact.classification)}  ${impact.filePath}${symbols}`
-    );
-  }
-  if (radius.changed.length > MAX_LISTED_FILES) {
-    lines(
-      printer,
-      `  \u2026 and ${count(radius.changed.length - MAX_LISTED_FILES)} more`
-    );
-  }
-  const packages = radius.affectedPackages.length > 0 ? `, ${plural(radius.affectedPackages.length, "package")} (${radius.affectedPackages.join(", ")})` : "";
-  lines(
-    printer,
-    "",
-    `Impact: ${plural(radius.affectedFiles.length, "file")}${packages}`
-  );
-  const skipped = tests.totalTests - tests.affectedTests.length;
-  lines(
-    printer,
-    "",
-    `Run:   ${plural(tests.affectedTests.length, "test file")}`,
-    `Skip:  ${plural(skipped, "test file")} (of ${count(tests.totalTests)} total)`,
-    "",
-    `Verdict:    ${verdictText(report.verdict)}`,
-    `Confidence: ${Math.round(tests.confidence * 100)}%  (report-only \u2014 run the full suite; skipping unlocks after shadow-mode validation)`
-  );
-  const notes = [...radius.notes, ...tests.notes];
-  if (notes.length > 0) {
-    lines(printer, "", "Notes:");
-    for (const note of notes) lines(printer, `  - ${note}`);
-  }
-  if (!report.historyLogged) {
-    lines(
-      printer,
-      "",
-      "(warning: could not write .variant/history/impact.jsonl \u2014 shadow-mode logging skipped)"
-    );
-  }
-}
-function renderImpactVerifyJson(result, printer = getPrinter()) {
-  const { prediction, ...rest } = result;
-  lines(
-    printer,
-    JSON.stringify(
-      { ...rest, predictedAt: prediction.at, baseRef: prediction.baseRef },
-      null,
-      2
-    )
-  );
-}
-function renderImpactVerify(result, printer = getPrinter()) {
-  const { prediction } = result;
-  lines(
-    printer,
-    "",
-    `Prediction: ${prediction.at} (${prediction.headSha ?? "no commit recorded"})`,
-    `Matched by: ${result.matchedBy === "head-sha" ? "head SHA" : "most recent \u2014 verify this is the right run"}`,
-    "",
-    `Predicted:  ${count(prediction.affectedTests.length)} of ${count(prediction.totalTests)} test files${prediction.selectAll ? " (selected all)" : ""}`,
-    `Failed:     ${plural(result.failedTests.length, "test file")}`
-  );
-  if (result.failedTests.length === 0) {
-    lines(
-      printer,
-      "",
-      "No failures in this run, so it neither confirms nor refutes the prediction."
-    );
-    return;
-  }
-  lines(
-    printer,
-    "",
-    `Caught:      ${count(result.caught.length)} (inside the predicted set)`,
-    `False skips: ${count(result.falseSkips.length)} (would have been missed)`
-  );
-  if (result.falseSkips.length > 0) {
-    lines(printer, "", "False skips:");
-    for (const test of result.falseSkips.slice(0, MAX_LISTED_FILES)) {
-      lines(printer, `  ${test}`);
-    }
-    if (result.falseSkips.length > MAX_LISTED_FILES) {
-      lines(
-        printer,
-        `  \u2026 and ${count(result.falseSkips.length - MAX_LISTED_FILES)} more`
-      );
-    }
-  }
-  lines(
-    printer,
-    "",
-    `False-skip rate this run: ${(result.falseSkipRate * 100).toFixed(1)}%`,
-    "One run is not a rate. Reconcile many before reading anything into it."
-  );
-  if (!result.historyLogged) {
-    lines(
-      printer,
-      "",
-      "(warning: could not write .variant/history/reconciliation.jsonl)"
-    );
-  }
-}
-
-// src/cli/commands/impact.ts
-async function registerImpactAction(opts = {}) {
-  const report = await predictImpact(process.cwd(), opts);
-  if (opts.json === true) {
-    renderImpactJson(report);
-    return;
-  }
-  renderImpact(report);
-}
-async function registerImpactVerifyAction(reportPath, opts = {}) {
-  const result = await verifyImpact(process.cwd(), reportPath, {
-    ...opts.headSha !== void 0 && { headSha: opts.headSha }
-  });
-  if (result === null) {
-    lines(getPrinter(), NO_PREDICTION_MESSAGE);
-    return;
-  }
-  if (opts.json === true) {
-    renderImpactVerifyJson(result);
-    return;
-  }
-  renderImpactVerify(result);
-}
-export {
-  registerImpactAction,
-  registerImpactVerifyAction
-};