@davmash/bygone 0.8.13 → 0.8.16

package/out/gitComparison.js

@@ -0,0 +1,354 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/gitComparison.ts
+var gitComparison_exports = {};
+__export(gitComparison_exports, {
+  createGitRunner: () => createGitRunner,
+  detectDefaultBaseRef: () => detectDefaultBaseRef,
+  listBranchCommits: () => listBranchCommits,
+  listChangedPaths: () => listChangedPaths,
+  materializeBranchReviewTrees: () => materializeBranchReviewTrees,
+  materializeGitTree: () => materializeGitTree,
+  parseNameStatusZ: () => parseNameStatusZ,
+  resolveBranchReviewRange: () => resolveBranchReviewRange,
+  resolveReviewPathPair: () => resolveReviewPathPair
+});
+module.exports = __toCommonJS(gitComparison_exports);
+var import_child_process = require("child_process");
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var DEFAULT_GIT_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
+function createGitRunner(maxBuffer = readGitMaxBuffer()) {
+  return (args, cwd) => (0, import_child_process.execFileSync)("git", [...args], {
+    cwd,
+    encoding: "utf8",
+    maxBuffer,
+    stdio: ["ignore", "pipe", "pipe"]
+  }).trimEnd();
+}
+function resolveBranchReviewRange(startPath, headRef = "HEAD", requestedBaseRef, runGit = createGitRunner()) {
+  const repoRoot = fs.realpathSync(runGit(["rev-parse", "--show-toplevel"], startPath));
+  const currentBranch = tryRunGit(runGit, ["symbolic-ref", "--quiet", "--short", "HEAD"], repoRoot);
+  const baseRef = requestedBaseRef || detectDefaultBaseRef(repoRoot, headRef, runGit);
+  const headOid = verifyCommit(repoRoot, headRef, runGit);
+  const baseOid = verifyCommit(repoRoot, baseRef, runGit);
+  const mergeBaseOids = runGit(["merge-base", "--all", baseOid, headOid], repoRoot).split("\n").filter(Boolean);
+  if (mergeBaseOids.length === 0) {
+    throw new Error(`No merge base exists between ${baseRef} and ${headRef}.`);
+  }
+  if (mergeBaseOids.length > 1) {
+    throw new Error(
+      `Multiple merge bases exist between ${baseRef} and ${headRef}: ${mergeBaseOids.map((oid) => oid.slice(0, 7)).join(", ")}. Pass one merge-base commit explicitly with --base.`
+    );
+  }
+  const mergeBaseOid = mergeBaseOids[0];
+  return {
+    repoRoot,
+    baseRef,
+    headRef,
+    baseOid,
+    headOid,
+    mergeBaseOid,
+    currentBranch: currentBranch || void 0,
+    dirty: runGit(["status", "--porcelain=v1", "--untracked-files=normal"], repoRoot).length > 0,
+    changedPaths: listChangedPaths(repoRoot, mergeBaseOid, headOid, runGit),
+    commits: listBranchCommits(repoRoot, mergeBaseOid, headOid, runGit)
+  };
+}
+function detectDefaultBaseRef(repoRoot, headRef = "HEAD", runGit = createGitRunner()) {
+  const remoteDefault = tryRunGit(
+    runGit,
+    ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"],
+    repoRoot
+  );
+  const candidates = [remoteDefault, "main", "master"].filter((candidate) => Boolean(candidate)).filter((candidate, index, all) => all.indexOf(candidate) === index);
+  for (const candidate of candidates) {
+    if (candidate !== headRef && canResolveCommit(repoRoot, candidate, runGit)) {
+      return candidate;
+    }
+  }
+  throw new Error("Could not detect a base branch. Pass --base <ref>.");
+}
+function listChangedPaths(repoRoot, baseOid, headOid, runGit = createGitRunner()) {
+  const output = runGit([
+    "diff",
+    "--name-status",
+    "-z",
+    "--find-renames",
+    "--find-copies",
+    baseOid,
+    headOid,
+    "--"
+  ], repoRoot);
+  return parseNameStatusZ(output);
+}
+function parseNameStatusZ(output) {
+  const fields = output.split("\0");
+  if (fields[fields.length - 1] === "") {
+    fields.pop();
+  }
+  const changedPaths = [];
+  for (let index = 0; index < fields.length; ) {
+    const status = fields[index++];
+    if (!status) {
+      continue;
+    }
+    const code = status[0];
+    const similarityText = status.slice(1);
+    const similarity = similarityText ? Number.parseInt(similarityText, 10) : void 0;
+    if (code === "R" || code === "C") {
+      const previousPath = fields[index++];
+      const nextPath = fields[index++];
+      if (previousPath && nextPath) {
+        changedPaths.push({
+          kind: code === "R" ? "renamed" : "copied",
+          path: nextPath,
+          previousPath,
+          similarity: Number.isFinite(similarity) ? similarity : void 0
+        });
+      }
+      continue;
+    }
+    const changedPath = fields[index++];
+    if (!changedPath) {
+      continue;
+    }
+    changedPaths.push({
+      kind: changeKindForStatus(code),
+      path: changedPath
+    });
+  }
+  return changedPaths;
+}
+function listBranchCommits(repoRoot, mergeBaseOid, headOid, runGit = createGitRunner()) {
+  const output = runGit([
+    "log",
+    "--reverse",
+    "--topo-order",
+    "--format=%H%x00%h%x00%cI%x00%s%x00%P%x1e",
+    `${mergeBaseOid}..${headOid}`
+  ], repoRoot);
+  return output.split("").map((record) => record.replace(/^\n+|\n+$/g, "")).filter(Boolean).map((record) => {
+    const [oid = "", shortOid = "", timestamp = "", summary = "", parents = ""] = record.split("\0");
+    return {
+      oid,
+      shortOid,
+      timestamp,
+      summary,
+      parentOids: parents.split(" ").filter(Boolean)
+    };
+  }).filter((commit) => Boolean(commit.oid));
+}
+function materializeBranchReviewTrees(review, leftRoot, rightRoot) {
+  for (const changedPath of review.changedPaths) {
+    if (changedPath.kind === "renamed") {
+      materializeGitPath(review.repoRoot, review.mergeBaseOid, changedPath.previousPath, leftRoot);
+      materializeGitPath(review.repoRoot, review.headOid, changedPath.path, rightRoot);
+      continue;
+    }
+    if (changedPath.kind !== "added" && changedPath.kind !== "copied") {
+      materializeGitPath(review.repoRoot, review.mergeBaseOid, changedPath.path, leftRoot);
+    }
+    if (changedPath.kind !== "deleted") {
+      materializeGitPath(review.repoRoot, review.headOid, changedPath.path, rightRoot);
+    }
+  }
+}
+function materializeGitTree(repoRoot, relativeDir, targetRoot, commit = "HEAD") {
+  for (const relativeFile of listGitBlobPaths(repoRoot, commit, relativeDir)) {
+    writeMaterializedGitFile(
+      targetRoot,
+      relativeFile,
+      readGitBlob(repoRoot, commit, relativeFile)
+    );
+  }
+}
+function resolveReviewPathPair(changedPaths, selectedPath) {
+  const changedPath = changedPaths.find((candidate) => candidate.path === selectedPath || candidate.previousPath === selectedPath);
+  if (!changedPath) {
+    return void 0;
+  }
+  const relatesDistinctPaths = (changedPath.kind === "renamed" || changedPath.kind === "copied") && Boolean(changedPath.previousPath);
+  const leftPath = changedPath.kind === "added" ? null : relatesDistinctPaths ? changedPath.previousPath ?? null : changedPath.path;
+  const rightPath = changedPath.kind === "deleted" ? null : changedPath.path;
+  const relationVerb = changedPath.kind === "renamed" ? "Renamed" : changedPath.kind === "copied" ? "Copied" : null;
+  return {
+    key: changedPath.path,
+    leftPath,
+    rightPath,
+    kind: changedPath.kind,
+    similarity: changedPath.similarity,
+    summary: relationVerb && changedPath.previousPath ? `${relationVerb} ${changedPath.previousPath} \u2192 ${changedPath.path}` + (changedPath.similarity === void 0 ? "" : ` \xB7 ${changedPath.similarity}% similarity`) : void 0
+  };
+}
+function verifyCommit(repoRoot, ref, runGit) {
+  try {
+    return runGit(["rev-parse", "--verify", `${ref}^{commit}`], repoRoot);
+  } catch {
+    throw new Error(`Could not resolve git ref "${ref}".`);
+  }
+}
+function canResolveCommit(repoRoot, ref, runGit) {
+  try {
+    verifyCommit(repoRoot, ref, runGit);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function tryRunGit(runGit, args, cwd) {
+  try {
+    return runGit(args, cwd);
+  } catch {
+    return "";
+  }
+}
+var GITLINK_MODE = "160000";
+function materializeGitPath(repoRoot, commit, relativePath, targetRoot) {
+  if (!relativePath || !isGitBlobPath(repoRoot, commit, relativePath)) {
+    return;
+  }
+  writeMaterializedGitFile(targetRoot, relativePath, readGitBlob(repoRoot, commit, relativePath));
+}
+function writeMaterializedGitFile(targetRoot, relativePath, content) {
+  const resolvedRoot = path.resolve(targetRoot);
+  const targetFile = path.resolve(resolvedRoot, relativePath);
+  if (targetFile !== resolvedRoot && !targetFile.startsWith(`${resolvedRoot}${path.sep}`)) {
+    throw new Error(`Refusing to materialize path outside review root: ${relativePath}`);
+  }
+  fs.mkdirSync(path.dirname(targetFile), { recursive: true });
+  fs.writeFileSync(targetFile, content);
+}
+function listGitBlobPaths(repoRoot, commit, relativeDir) {
+  if (commit === "INDEX") {
+    const args2 = ["ls-files", "--stage", "-z", "--"];
+    if (relativeDir) {
+      args2.push(relativeDir);
+    }
+    return parseNulRecords(runGitText(repoRoot, args2)).flatMap((record) => {
+      const parsed = parseIndexStageRecord(record);
+      return parsed && parsed.mode !== GITLINK_MODE ? [parsed.path] : [];
+    });
+  }
+  const args = ["ls-tree", "-r", "-z", commit];
+  if (relativeDir) {
+    args.push("--", relativeDir);
+  }
+  return parseNulRecords(runGitText(repoRoot, args)).flatMap((record) => {
+    const parsed = parseLsTreeRecord(record);
+    return parsed && parsed.type === "blob" ? [parsed.path] : [];
+  });
+}
+function isGitBlobPath(repoRoot, commit, relativePath) {
+  if (commit === "INDEX") {
+    return listGitBlobPaths(repoRoot, commit, relativePath).includes(relativePath);
+  }
+  const parsed = parseLsTreeRecord(parseNulRecords(runGitText(repoRoot, ["ls-tree", "-z", commit, "--", relativePath]))[0] ?? "");
+  return (parsed == null ? void 0 : parsed.type) === "blob";
+}
+function parseNulRecords(output) {
+  return output.split("\0").filter((record) => record.length > 0);
+}
+function parseLsTreeRecord(record) {
+  const tab = record.indexOf("	");
+  if (tab === -1) {
+    return void 0;
+  }
+  const type = record.slice(0, tab).split(" ")[1];
+  const relativePath = record.slice(tab + 1);
+  if (!type || !relativePath) {
+    return void 0;
+  }
+  return { type, path: relativePath };
+}
+function parseIndexStageRecord(record) {
+  const tab = record.indexOf("	");
+  if (tab === -1) {
+    return void 0;
+  }
+  const mode = record.slice(0, tab).split(" ")[0];
+  const relativePath = record.slice(tab + 1);
+  if (!mode || !relativePath) {
+    return void 0;
+  }
+  return { mode, path: relativePath };
+}
+function readGitBlob(repoRoot, commit, relativePath) {
+  const spec = commit && commit !== "INDEX" ? `${commit}:${relativePath}` : `:${relativePath}`;
+  return (0, import_child_process.execFileSync)("git", ["show", spec], {
+    cwd: repoRoot,
+    encoding: "buffer",
+    maxBuffer: readGitMaxBuffer(),
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+}
+function runGitText(repoRoot, args) {
+  return (0, import_child_process.execFileSync)("git", [...args], {
+    cwd: repoRoot,
+    encoding: "utf8",
+    maxBuffer: readGitMaxBuffer(),
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+}
+function changeKindForStatus(code) {
+  if (code === "A") {
+    return "added";
+  }
+  if (code === "D") {
+    return "deleted";
+  }
+  if (code === "M") {
+    return "modified";
+  }
+  if (code === "T") {
+    return "type-changed";
+  }
+  if (code === "U") {
+    return "unmerged";
+  }
+  return "unknown";
+}
+function readGitMaxBuffer() {
+  const parsed = Number.parseInt(process.env.BYGONE_GIT_MAX_BUFFER_BYTES ?? "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_GIT_MAX_BUFFER_BYTES;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createGitRunner,
+  detectDefaultBaseRef,
+  listBranchCommits,
+  listChangedPaths,
+  materializeBranchReviewTrees,
+  materializeGitTree,
+  parseNameStatusZ,
+  resolveBranchReviewRange,
+  resolveReviewPathPair
+});
+//# sourceMappingURL=gitComparison.js.map