@blzsky/variant 0.2.0

package/dist/impact-AF453PLK.js

@@ -0,0 +1,702 @@
+import {
+  mapLimit
+} from "./chunk-GDSZFIHM.js";
+import {
+  getChangedFiles
+} from "./chunk-MZZOE7L4.js";
+import {
+  buildImportGraph,
+  computeAffectedFiles
+} from "./chunk-XTYVVUWW.js";
+import {
+  loadPackageGraph
+} from "./chunk-3E5LBU3O.js";
+import {
+  readPathAliases
+} from "./chunk-KSHWC2XN.js";
+import {
+  updateSymbolGraph
+} from "./chunk-VTJ67TT5.js";
+import {
+  ImpactReportError
+} from "./chunk-RVXUCJYA.js";
+import {
+  deriveVerdict,
+  verdictText
+} from "./chunk-DRMASVYN.js";
+import {
+  createClassifier
+} from "./chunk-LJDDS4RR.js";
+import {
+  readFileAtRef,
+  readFilesAtRef,
+  readHeadSha
+} from "./chunk-XUBWCTJZ.js";
+import {
+  classificationLabel,
+  plural
+} from "./chunk-CXNXZLDG.js";
+import {
+  lines
+} from "./chunk-6J4XDG44.js";
+import {
+  getPrinter
+} from "./chunk-V22IPJ7A.js";
+import "./chunk-O4LZKXNZ.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\.[^/.]+(\.[^/]+)?)$/;
+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 (impact.classification === "unanalyzed" && TEST_CONFIG_FILE.test(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;
+  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) return null;
+  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 { readFile as readFile3 } from "fs/promises";
+import path3 from "path";
+function toRelativePosix(cwd, testPath) {
+  const relative = path3.isAbsolute(testPath) ? path3.relative(cwd, testPath) : testPath;
+  return relative.replace(/\\/g, "/");
+}
+function parseFailedTests(cwd, raw) {
+  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));
+  }
+  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 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 readFile3(path3.resolve(cwd, reportPath), "utf8");
+  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.";
+var NO_CHANGED_FILES_MESSAGE = "impact: could not determine changed files (is this a git repository with at least one prior commit?). Pass --base <ref> against a valid ref.";
+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 (report === null) {
+    lines(getPrinter(), NO_CHANGED_FILES_MESSAGE);
+    return;
+  }
+  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
+};