@rmartz/merge-safety 0.14.0 → 0.16.0

package/dist/chunk-2QWRQ4Q5.js

@@ -0,0 +1,614 @@
+// src/lib/bounded-subprocess.ts
+import { spawn } from "child_process";
+function boundedRun(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      detached: true
+      // new process group, so we can kill the whole tree
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      try {
+        process.kill(-child.pid, "SIGKILL");
+      } catch {
+      }
+    }, options.timeoutMs);
+    if (options.input !== void 0 && child.stdin) {
+      child.stdin.on("error", () => {
+      });
+      child.stdin.write(options.input);
+      child.stdin.end();
+    }
+    child.stdout.on("data", (chunk) => stdout += chunk.toString());
+    child.stderr.on("data", (chunk) => stderr += chunk.toString());
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({ stdout, stderr, code, timedOut });
+    });
+  });
+}
+
+// src/breaking-diff.ts
+var CI_SENSITIVE_PACKAGES = /* @__PURE__ */ new Set(["eslint", "black", "pylint", "ruff", "prettier"]);
+var NON_DEPENDENCY_NPM_KEYS = /* @__PURE__ */ new Set(["version"]);
+var NPM_DEP_RE = /"([^"]+)"\s*:\s*"[\^~]?(\d+)\.(\d+)\.(\d+)/;
+var PIP_DEP_RE = /^\s*([A-Za-z0-9][A-Za-z0-9._-]*)\s*(?:==|~=|>=|<=|!=|<|>)\s*(\d+)(?:\.(\d+))?(?:\.(\d+))?/;
+var TEST_FILE_RE = /(\.test\.tsx?|\.spec\.tsx?|test_[^/]*\.py|[^/]*_test\.py)$/;
+var DIFF_HEADER_PATH_RE = / b\/(.+)$/;
+function normalizePackageName(name) {
+  return name.trim().toLowerCase().replace(/[-_.]+/g, "-");
+}
+function dependencyFileKind(diffGitLine) {
+  if (diffGitLine.includes("package.json")) return "npm";
+  if (/requirements[\w./-]*\.txt/.test(diffGitLine)) return "pip";
+  return null;
+}
+function isFileHeader(line) {
+  return line.startsWith("---") || line.startsWith("+++");
+}
+function dependencyChanges(diffText) {
+  const changes = [];
+  let kind = null;
+  for (const line of diffText.split("\n")) {
+    if (line.startsWith("diff --git")) {
+      kind = dependencyFileKind(line);
+      continue;
+    }
+    if (kind === null) continue;
+    if (isFileHeader(line)) continue;
+    if (!line.startsWith("-") && !line.startsWith("+")) continue;
+    const sign = line[0] === "-" ? "-" : "+";
+    const match = (kind === "npm" ? NPM_DEP_RE : PIP_DEP_RE).exec(line.slice(1));
+    if (!match) continue;
+    const name = match[1] ?? "";
+    if (kind === "npm" && NON_DEPENDENCY_NPM_KEYS.has(name.trim().toLowerCase())) continue;
+    const major = Number(match[2] ?? 0);
+    const minor = Number(match[3] ?? 0);
+    const patch = Number(match[4] ?? 0);
+    changes.push({ kind, sign, name, major, version: `${major}.${minor}.${patch}` });
+  }
+  return changes;
+}
+function indexChanges(changes) {
+  const removed = /* @__PURE__ */ new Map();
+  const added = /* @__PURE__ */ new Map();
+  for (const change of changes) {
+    const key = `${change.kind}:${normalizePackageName(change.name)}`;
+    (change.sign === "-" ? removed : added).set(key, change);
+  }
+  return { removed, added };
+}
+function majorVersionBumps(diffText) {
+  const { removed, added } = indexChanges(dependencyChanges(diffText));
+  const bumps = [];
+  for (const [key, addedChange] of added) {
+    const removedChange = removed.get(key);
+    if (removedChange && addedChange.major > removedChange.major) {
+      bumps.push(`${addedChange.name} ${removedChange.version} \u2192 ${addedChange.version}`);
+    }
+  }
+  return bumps;
+}
+function sensitivePackageBumps(diffText) {
+  const { removed, added } = indexChanges(dependencyChanges(diffText));
+  const bumps = [];
+  for (const [key, addedChange] of added) {
+    if (!CI_SENSITIVE_PACKAGES.has(normalizePackageName(addedChange.name))) continue;
+    const removedChange = removed.get(key);
+    if (removedChange && removedChange.version !== addedChange.version) {
+      bumps.push(`${addedChange.name} ${removedChange.version} \u2192 ${addedChange.version}`);
+    }
+  }
+  return bumps;
+}
+function materialTestChanges(diffText) {
+  const changed = [];
+  let file = null;
+  let hasAdds = false;
+  let hasRemoves = false;
+  const flush = () => {
+    if (file && hasAdds && hasRemoves && TEST_FILE_RE.test(file)) changed.push(file);
+  };
+  for (const line of diffText.split("\n")) {
+    if (line.startsWith("diff --git")) {
+      flush();
+      file = DIFF_HEADER_PATH_RE.exec(line)?.[1] ?? null;
+      hasAdds = false;
+      hasRemoves = false;
+      continue;
+    }
+    if (isFileHeader(line)) continue;
+    if (line.startsWith("+")) hasAdds = true;
+    else if (line.startsWith("-")) hasRemoves = true;
+  }
+  flush();
+  return changed;
+}
+function breakingDiffSignals(diffText) {
+  const signals = [];
+  const major = majorVersionBumps(diffText);
+  if (major.length) signals.push({ kind: "major-version-bump", detail: major });
+  const sensitive = sensitivePackageBumps(diffText);
+  if (sensitive.length) signals.push({ kind: "sensitive-package-bump", detail: sensitive });
+  const tests = materialTestChanges(diffText);
+  if (tests.length) signals.push({ kind: "material-test-changes", detail: tests });
+  return signals;
+}
+
+// src/conventional-commits.ts
+var BREAKING_SUBJECT_RE = /^[a-z]+(?:!(?:\([^)]*\))?|(?:\([^)]*\))?!):/;
+var BREAKING_FOOTER_RE = /^BREAKING[ -]CHANGE:/m;
+var CI_SUBJECT_RE = /^ci(\([^)]*\))?!?:/;
+var DOCS_SUBJECT_RE = /^docs(\([^)]*\))?!?:/;
+function firstLine(message) {
+  return message.split("\n", 1)[0] ?? "";
+}
+function isBreakingCommitMessage(message) {
+  return BREAKING_SUBJECT_RE.test(firstLine(message)) || BREAKING_FOOTER_RE.test(message);
+}
+function isCiCommitMessage(message) {
+  return CI_SUBJECT_RE.test(firstLine(message));
+}
+function isDocsCommitMessage(message) {
+  return DOCS_SUBJECT_RE.test(firstLine(message));
+}
+function isBreakingTitle(title) {
+  return BREAKING_SUBJECT_RE.test(title.trim());
+}
+function isCiTitle(title) {
+  return CI_SUBJECT_RE.test(title.trim());
+}
+function isDocsTitle(title) {
+  return DOCS_SUBJECT_RE.test(title.trim());
+}
+
+// src/reasons.ts
+var BREAKING_DIFF_REASONS = {
+  "major-version-bump": "dependency major bump",
+  "sensitive-package-bump": "CI-sensitive package version change",
+  "material-test-changes": "existing test file modified"
+};
+function nestedBullets(items) {
+  return items.map((item) => `  - ${item}`).join("\n");
+}
+function formatBaseCommit(commit) {
+  return `${commit.sha.slice(0, 7)} ${commit.subject}`;
+}
+function withDetail(sentence, detail) {
+  return detail.length ? `${sentence}
+${nestedBullets(detail)}` : sentence;
+}
+function breakingSignalDetail(signals) {
+  return signals.flatMap((s) => s.detail.map((d) => `${BREAKING_DIFF_REASONS[s.kind]}: ${d}`));
+}
+
+// src/staleness.ts
+function evaluateStaleness(facts) {
+  const reasons = [];
+  if (facts.isCurrent) return { needsUpdate: false, reasons };
+  const baseBreaking = facts.baseBreakingSinceMergeBase && !(facts.prIsDocs && !facts.prIsBreaking);
+  const prBreaking = facts.prIsBreaking && !facts.baseOnlyDocsSinceMergeBase;
+  const prCi = facts.prIsCi && !facts.prIsHotfix;
+  if (baseBreaking) {
+    reasons.push(
+      withDetail(
+        "A breaking change landed on the base since merge-base \u2014 rebase and re-run CI:",
+        facts.baseBreakingCommits.map(formatBaseCommit)
+      )
+    );
+  }
+  if (prBreaking) {
+    reasons.push(
+      withDetail(
+        "This PR is a breaking change \u2014 it must be current with the base before merge.",
+        breakingSignalDetail(facts.prBreakingDiffSignals)
+      )
+    );
+  }
+  if (prCi) {
+    reasons.push(
+      "This PR is a CI change \u2014 it must be current with the base before merge, so it is re-tested against the latest base and cannot green a guard against a pattern that has since regressed."
+    );
+  }
+  if (facts.baseCiSinceMergeBase) {
+    reasons.push(
+      withDetail(
+        "A CI change landed on the base since merge-base \u2014 rebase to re-test under it:",
+        facts.baseCiCommits.map(formatBaseCommit)
+      )
+    );
+  }
+  if (facts.fileOverlap) {
+    reasons.push(
+      withDetail(
+        "This PR changes files the base also changed since merge-base \u2014 sync with base and re-run CI before merging to ensure the changes are compatible:",
+        facts.overlappingFiles
+      )
+    );
+  }
+  const needsUpdate = baseBreaking || facts.baseCiSinceMergeBase || prBreaking || prCi || facts.fileOverlap;
+  return { needsUpdate, reasons };
+}
+
+// src/base-health.ts
+var FAILING_CI_CONCLUSIONS = ["failure", "timed_out", "startup_failure"];
+var GITHUB_ACTIONS_APP_SLUG = "github-actions";
+var NON_BUILD_PLATFORM_CHECKS = /* @__PURE__ */ new Set(["dependabot", "dependabot updates"]);
+function isGitHubActionsCheck(check) {
+  return check.appSlug === GITHUB_ACTIONS_APP_SLUG;
+}
+function isNonBuildPlatformCheck(name) {
+  return NON_BUILD_PLATFORM_CHECKS.has(name.trim().toLowerCase());
+}
+function isFailingCiConclusion(conclusion) {
+  return conclusion !== null && FAILING_CI_CONCLUSIONS.includes(conclusion);
+}
+function failingRequiredBaseChecks(checks, requiredContexts) {
+  if (!requiredContexts || requiredContexts.length === 0) return [];
+  const required = new Set(requiredContexts);
+  return checks.filter((c) => required.has(c.name) && isFailingCiConclusion(c.conclusion)).map((c) => c.name);
+}
+function failingFallbackBaseChecks(checks) {
+  return checks.filter(
+    (c) => isGitHubActionsCheck(c) && isFailingCiConclusion(c.conclusion) && !isNonBuildPlatformCheck(c.name)
+  ).map((c) => c.name);
+}
+
+// src/merge-safety.ts
+var MERGE_SAFETY_LABELS = ["update required", "merge conflict"];
+function isEvaluablePrState(state) {
+  return state === "OPEN";
+}
+var HOTFIX_LABEL = "hotfix";
+function overlappingFiles(prFiles, baseFiles) {
+  if (!prFiles.length || !baseFiles.length) return [];
+  const base = new Set(baseFiles);
+  return prFiles.filter((f) => base.has(f));
+}
+function evaluateMergeSafety(facts) {
+  const reasons = [];
+  if (facts.hasConflict) {
+    reasons.push("Git reports a merge conflict against the base \u2014 resolve it before merging.");
+  }
+  const baseUnhealthy = facts.baseCiFailing && !facts.prIsHotfix;
+  if (baseUnhealthy) {
+    reasons.push(
+      withDetail(
+        "The base branch's CI is failing \u2014 only hotfix PRs may merge until it is green (label this PR `hotfix` to override):",
+        facts.failingBaseChecks
+      )
+    );
+  }
+  const { needsUpdate, reasons: stalenessReasons } = evaluateStaleness(facts);
+  reasons.push(...stalenessReasons);
+  const needsAction = facts.hasConflict || baseUnhealthy;
+  const conclusion = needsAction ? "failure" : needsUpdate ? "pending" : "success";
+  const summary = conclusion === "success" ? "No update required: current, or no breaking/overlapping changes on the base, no conflict, and the base CI is green." : firstLine(reasons[0] ?? "Not safe to merge as-is.");
+  const title = facts.hasConflict ? "Merge conflict" : baseUnhealthy ? "Base CI failing" : needsUpdate ? "Update required" : "No update required";
+  const add = [];
+  if (needsUpdate) add.push("update required");
+  if (facts.hasConflict) add.push("merge conflict");
+  const remove = MERGE_SAFETY_LABELS.filter((l) => !add.includes(l));
+  return {
+    conclusion,
+    needsUpdate,
+    hasConflict: facts.hasConflict,
+    baseUnhealthy,
+    title,
+    reasons,
+    summary,
+    labels: { add, remove }
+  };
+}
+function errorMergeSafetyDecision(message) {
+  return {
+    conclusion: "failure",
+    needsUpdate: false,
+    hasConflict: false,
+    baseUnhealthy: false,
+    title: "Could not evaluate",
+    reasons: [message],
+    summary: `Could not evaluate merge safety: ${message}`,
+    labels: { add: [], remove: [] }
+  };
+}
+
+// src/merge-safety-facts.ts
+var GIT_TIMEOUT_MS = 3e4;
+function baseBranchName(baseRef) {
+  return baseRef.replace(/^refs\/heads\//, "").replace(/^origin\//, "");
+}
+function makeGitRunner(cwd) {
+  return async (args) => {
+    const r = await boundedRun("git", args, { timeoutMs: GIT_TIMEOUT_MS, cwd });
+    return r.code === 0 ? r.stdout : null;
+  };
+}
+function splitLines(out) {
+  return (out ?? "").split("\n").map((l) => l.trim()).filter(Boolean);
+}
+function parseBaseCommits(logOut) {
+  return logOut.split("\0").map((record) => record.replace(/^\n+/, "")).filter((record) => record.trim().length > 0).map((record) => {
+    const newline = record.indexOf("\n");
+    const sha = (newline === -1 ? record : record.slice(0, newline)).trim();
+    const message = newline === -1 ? "" : record.slice(newline + 1).trim();
+    return { sha, message };
+  });
+}
+var CI_PATH_RE = /^\.github\/(?:workflows|actions)\//;
+function isCiPath(path) {
+  return CI_PATH_RE.test(path);
+}
+function parseCiPathShas(logOut) {
+  const shas = /* @__PURE__ */ new Set();
+  for (const record of logOut.split("\0")) {
+    const [sha, ...files] = splitLines(record);
+    if (sha && files.some(isCiPath)) shas.add(sha);
+  }
+  return shas;
+}
+function selectCommits(commits, predicate) {
+  return commits.filter(predicate).map((c) => ({ sha: c.sha, subject: c.message.split("\n", 1)[0] ?? "" }));
+}
+async function gatherMergeSafetyFacts(meta, { baseRef = "origin/main", git, baseChecks, requiredChecks }) {
+  const mergeBase = (await git(["merge-base", meta.headSha, baseRef]))?.trim();
+  const baseTip = (await git(["rev-parse", baseRef]))?.trim();
+  if (!mergeBase || !baseTip) {
+    throw new Error(`could not resolve merge-base/base tip for ${meta.headSha}..${baseRef}`);
+  }
+  const isCurrent = mergeBase === baseTip;
+  const baseBranch = baseBranchName(baseRef);
+  const checks = await baseChecks(baseTip);
+  const required = await requiredChecks(baseBranch);
+  const failingBaseChecks = required && required.length > 0 ? failingRequiredBaseChecks(checks, required) : failingFallbackBaseChecks(checks);
+  const logOut = await git(["log", "-z", "--format=%H%n%B", `${mergeBase}..${baseRef}`]);
+  if (logOut === null) throw new Error(`git log failed for ${mergeBase}..${baseRef}`);
+  const commits = parseBaseCommits(logOut);
+  const baseBreakingCommits = selectCommits(commits, (c) => isBreakingCommitMessage(c.message));
+  const fileLogOut = await git([
+    "log",
+    "--format=%x00%H",
+    "--name-only",
+    `${mergeBase}..${baseRef}`
+  ]);
+  if (fileLogOut === null) throw new Error(`git log failed for ${mergeBase}..${baseRef}`);
+  const ciPathShas = parseCiPathShas(fileLogOut);
+  const baseCiCommits = selectCommits(
+    commits,
+    (c) => isCiCommitMessage(c.message) || ciPathShas.has(c.sha)
+  );
+  const baseFilesOut = await git(["diff", "--name-only", mergeBase, baseRef]);
+  if (baseFilesOut === null) throw new Error(`git diff failed for ${mergeBase}..${baseRef}`);
+  const baseFiles = splitLines(baseFilesOut);
+  const prFilesOut = await git(["diff", "--name-only", mergeBase, meta.headSha]);
+  if (prFilesOut === null) throw new Error(`git diff failed for ${mergeBase}..${meta.headSha}`);
+  const prFiles = splitLines(prFilesOut);
+  const overlaps = overlappingFiles(prFiles, baseFiles);
+  const prDiff = await git(["diff", "--unified=0", mergeBase, meta.headSha]);
+  if (prDiff === null) throw new Error(`git diff failed for ${mergeBase}..${meta.headSha}`);
+  const diffSignals = breakingDiffSignals(prDiff);
+  const labels = meta.labels.map((l) => l.toLowerCase());
+  return {
+    isCurrent,
+    // Each boolean is derived from its detail list — one computation, two views.
+    baseBreakingSinceMergeBase: baseBreakingCommits.length > 0,
+    baseCiSinceMergeBase: baseCiCommits.length > 0,
+    // The title's `!` is the only declared input (#82) — pr-policy's title check
+    // keeps it in step with the `breaking change` label. The diff can only add a
+    // reason to re-test the PR against a moved base (#53).
+    prIsBreaking: isBreakingTitle(meta.title) || diffSignals.length > 0,
+    prIsDocs: isDocsTitle(meta.title),
+    baseOnlyDocsSinceMergeBase: commits.length > 0 && commits.every((c) => isDocsCommitMessage(c.message)),
+    // Title or path (#67): a release-typed PR that changes CI is still re-tested.
+    prIsCi: isCiTitle(meta.title) || prFiles.some(isCiPath),
+    fileOverlap: overlaps.length > 0,
+    hasConflict: meta.mergeable.toUpperCase() === "CONFLICTING",
+    baseCiFailing: failingBaseChecks.length > 0,
+    prIsHotfix: labels.includes(HOTFIX_LABEL),
+    baseBreakingCommits,
+    baseCiCommits,
+    overlappingFiles: overlaps,
+    failingBaseChecks,
+    prBreakingDiffSignals: diffSignals
+  };
+}
+
+// src/api-fact-source.ts
+var COMPARE_MAX_COMMITS = 250;
+var COMPARE_MAX_FILES = 300;
+var COMMIT_MAX_FILES = 300;
+async function mapBounded(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const i = next++;
+      results[i] = await fn(items[i]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, worker));
+  return results;
+}
+function requireFiles(files, what) {
+  if (!Array.isArray(files)) throw new Error(`the GitHub API returned no file list for ${what}`);
+  return files;
+}
+function compareFiles(compare, side) {
+  const files = side === "base" && compare.total_commits === 0 && compare.files === void 0 ? [] : requireFiles(compare.files, `the ${side} diff`);
+  if (files.length >= COMPARE_MAX_FILES) {
+    throw new Error(
+      `${side} diff lists ${files.length} files, at the compare API's ${COMPARE_MAX_FILES}-file cap`
+    );
+  }
+  return files;
+}
+function synthesizePatch(files) {
+  return files.map((f) => {
+    const header = `diff --git a/${f.previous_filename ?? f.filename} b/${f.filename}`;
+    if (f.patch !== void 0) return `${header}
+${f.patch}
+`;
+    if (f.changes !== 0) {
+      throw new Error(`the compare API omitted the patch for ${f.filename}`);
+    }
+    return `${header}
+`;
+  }).join("");
+}
+function makeApiGitRunner({ repo, api, concurrency = 8 }) {
+  const tips = /* @__PURE__ */ new Map();
+  const comparisons = /* @__PURE__ */ new Map();
+  const loaded = [];
+  async function get(path) {
+    const body = await api(path);
+    if (body === null || body === void 0) throw new Error(`GitHub API read failed: ${path}`);
+    return body;
+  }
+  async function loadTip(baseRef) {
+    const branch = encodeURIComponent(baseBranchName(baseRef));
+    const b = await get(`repos/${repo}/branches/${branch}`);
+    return b.commit.sha;
+  }
+  function resolveTip(baseRef) {
+    let tip = tips.get(baseRef);
+    if (!tip) {
+      tip = loadTip(baseRef);
+      tips.set(baseRef, tip);
+    }
+    return tip;
+  }
+  async function loadComparison(head, baseRef) {
+    const tip = await resolveTip(baseRef);
+    const base = await get(`repos/${repo}/compare/${head}...${tip}`);
+    if (base.total_commits > base.commits.length) {
+      throw new Error(
+        `base moved by ${base.total_commits} commits, past the compare API's ${COMPARE_MAX_COMMITS}-commit cap`
+      );
+    }
+    const comparison = {
+      head,
+      baseRef,
+      tip,
+      mergeBase: base.merge_base_commit.sha,
+      base
+    };
+    loaded.push(comparison);
+    return comparison;
+  }
+  function compare(head, baseRef) {
+    const key = `${head}\0${baseRef}`;
+    let c = comparisons.get(key);
+    if (!c) {
+      c = loadComparison(head, baseRef);
+      comparisons.set(key, c);
+    }
+    return c;
+  }
+  function find(mergeBase, match) {
+    const c = loaded.find((l) => l.mergeBase === mergeBase && match(l));
+    if (!c) throw new Error(`no comparison loaded for merge base ${mergeBase}`);
+    return c;
+  }
+  function baseCommits(c) {
+    return [...c.base.commits].reverse();
+  }
+  async function loadPrFiles(c) {
+    const pr = await get(`repos/${repo}/compare/${c.tip}...${c.head}`);
+    if (pr.merge_base_commit.sha !== c.mergeBase) {
+      throw new Error(
+        `the PR and base compares disagree on the merge base (${pr.merge_base_commit.sha} vs ${c.mergeBase})`
+      );
+    }
+    return compareFiles(pr, "PR");
+  }
+  function prFiles(c) {
+    c.pr ??= loadPrFiles(c);
+    return c.pr;
+  }
+  async function commitRecord(commit) {
+    if ((commit.parents?.length ?? 1) > 1) return `\0${commit.sha}
+`;
+    const full = await get(`repos/${repo}/commits/${commit.sha}`);
+    const files = requireFiles(full.files, `base commit ${commit.sha}`).map((f) => f.filename);
+    if (files.length >= COMMIT_MAX_FILES && !files.some(isCiPath)) {
+      throw new Error(
+        `base commit ${commit.sha} lists ${files.length} files, at the commit API's ${COMMIT_MAX_FILES}-file cap`
+      );
+    }
+    return `\0${commit.sha}
+
+${files.join("\n")}
+`;
+  }
+  async function loadCiLog(c) {
+    const records = await mapBounded(baseCommits(c), concurrency, commitRecord);
+    return records.join("");
+  }
+  function ciLog(c) {
+    c.ciLog ??= loadCiLog(c);
+    return c.ciLog;
+  }
+  return async (args) => {
+    const [cmd, ...rest] = args;
+    const joined = rest.join(" ");
+    if (cmd === "merge-base" && rest.length === 2) {
+      return (await compare(rest[0], rest[1])).mergeBase;
+    }
+    if (cmd === "rev-parse" && rest.length === 1) return resolveTip(rest[0]);
+    const range = /^(\S+)\.\.(\S+)$/.exec(rest[rest.length - 1] ?? "");
+    if (cmd === "log" && range) {
+      const mergeBase = range[1] ?? "";
+      const baseRef = range[2] ?? "";
+      const c = find(mergeBase, (l) => l.baseRef === baseRef);
+      if (joined === `-z --format=%H%n%B ${mergeBase}..${baseRef}`) {
+        return baseCommits(c).map((commit) => `${commit.sha}
+${commit.commit.message}`).join("\0");
+      }
+      if (joined === `--format=%x00%H --name-only ${mergeBase}..${baseRef}`) return ciLog(c);
+    }
+    if (cmd === "diff" && rest.length === 3) {
+      const [flag, mergeBase, ref] = rest;
+      if (flag === "--name-only") {
+        const c = find(mergeBase, (l) => l.baseRef === ref || l.head === ref);
+        const files = c.baseRef === ref ? compareFiles(c.base, "base") : await prFiles(c);
+        return files.map((f) => f.filename).join("\n");
+      }
+      if (flag === "--unified=0") {
+        return synthesizePatch(await prFiles(find(mergeBase, (l) => l.head === ref)));
+      }
+    }
+    throw new Error(`the API fact source does not support \`git ${args.join(" ")}\``);
+  };
+}
+
+// src/index.ts
+var MERGE_SAFETY_CHECK_NAME = "merge-safety";
+var MERGE_SAFETY_COMMANDS = ["evaluate", "invalidate"];
+function isMergeSafetyCommand(value) {
+  return value !== void 0 && MERGE_SAFETY_COMMANDS.includes(value);
+}
+
+export {
+  boundedRun,
+  isEvaluablePrState,
+  evaluateMergeSafety,
+  errorMergeSafetyDecision,
+  makeGitRunner,
+  gatherMergeSafetyFacts,
+  COMPARE_MAX_COMMITS,
+  COMPARE_MAX_FILES,
+  COMMIT_MAX_FILES,
+  makeApiGitRunner,
+  MERGE_SAFETY_CHECK_NAME,
+  MERGE_SAFETY_COMMANDS,
+  isMergeSafetyCommand
+};