git-fs-s3 0.4.0 → 0.5.0

package/dist/ops.cjs

@@ -1,1060 +0,0 @@
-"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/ops/index.ts
-var ops_exports = {};
-__export(ops_exports, {
-  BANNER_WALK_DEPTH: () => BANNER_WALK_DEPTH,
-  HISTORY_WALK_DEPTH: () => HISTORY_WALK_DEPTH,
-  analyzeMerge: () => analyzeMerge,
-  assertBranchExists: () => assertBranchExists,
-  assertSafeBranchName: () => assertSafeBranchName,
-  authorNow: () => authorNow,
-  commitFilesToBare: () => commitFilesToBare,
-  createBranchFrom: () => createBranchFrom,
-  deleteBranchByName: () => deleteBranchByName,
-  deleteFileFromBare: () => deleteFileFromBare,
-  deleteFromTree: () => deleteFromTree,
-  fastForwardMerge: () => fastForwardMerge,
-  findTreeEntry: () => findTreeEntry,
-  getBlob: () => getBlob,
-  getCommit: () => getCommit,
-  getCommitDiff: () => getCommitDiff,
-  getCommitHistory: () => getCommitHistory,
-  getCommitLog: () => getCommitLog,
-  getDiffBetweenRefs: () => getDiffBetweenRefs,
-  getFileContent: () => getFileContent,
-  getFileFromRef: () => getFileFromRef,
-  getFileHistory: () => getFileHistory,
-  getLastCommitsForTree: () => getLastCommitsForTree,
-  getTreeFromRef: () => getTreeFromRef,
-  listBranches: () => listBranches,
-  listTreeEntries: () => listTreeEntries,
-  resolveCommit: () => resolveCommit,
-  resolveLooseRefFast: () => resolveLooseRefFast,
-  resultKeyPrefixes: () => resultKeyPrefixes,
-  upsertTree: () => upsertTree,
-  writeCommitToBare: () => writeCommitToBare
-});
-module.exports = __toCommonJS(ops_exports);
-
-// src/ops/branch.ts
-var import_isomorphic_git = __toESM(require("isomorphic-git"), 1);
-
-// src/git-errors.ts
-var GitError = class extends Error {
-  statusCode;
-  retryable;
-  constructor(message, statusCode = 500, retryable = false) {
-    super(message);
-    this.name = this.constructor.name;
-    this.statusCode = statusCode;
-    this.retryable = retryable;
-    Error.captureStackTrace?.(this, this.constructor);
-  }
-  toJSON() {
-    return {
-      error: this.name,
-      message: this.message,
-      statusCode: this.statusCode,
-      retryable: this.retryable
-    };
-  }
-};
-var GitPathNotFoundError = class extends GitError {
-  constructor(message) {
-    super(message, 404, false);
-  }
-};
-var GitObjectNotFoundError = class extends GitError {
-  constructor(message) {
-    super(message, 404, false);
-  }
-};
-var GitInvalidRequestError = class extends GitError {
-  constructor(message) {
-    super(message, 400, false);
-  }
-};
-
-// src/refs.ts
-var BAD_REF_COMPONENT = (
-  // biome-ignore lint/suspicious/noControlCharactersInRegex: control chars are exactly what git's own ref-name rules reject — this needs to match the same range.
-  /(^|[/.])([/.]|$)|^@$|@\{|[\x00-\x20\x7f~^:?*[\\]|\.lock(\/|$)/
-);
-var FULL_SHA_RE = /^[0-9a-f]{40}$/i;
-function isSafeBranchName(name) {
-  if (!name || name.startsWith("refs/") || name === "HEAD") return false;
-  if (FULL_SHA_RE.test(name)) return false;
-  return !BAD_REF_COMPONENT.test(name);
-}
-function qualifyBranchRef(ref) {
-  if (ref.startsWith("refs/") || ref === "HEAD" || FULL_SHA_RE.test(ref)) {
-    return ref;
-  }
-  return `refs/heads/${ref}`;
-}
-
-// src/ops/branch.ts
-function assertSafeBranchName(name) {
-  if (!isSafeBranchName(name)) {
-    throw new GitInvalidRequestError(`Invalid branch name: ${name}`);
-  }
-}
-var FULL_SHA_RE2 = /^[0-9a-f]{40}$/i;
-function hasRecursiveFileLister(fs) {
-  return typeof fs === "object" && fs !== null && "listFilesRecursively" in fs && typeof fs.listFilesRecursively === "function";
-}
-function getPromisesFs(fs) {
-  const promises = fs.promises;
-  return promises ?? null;
-}
-function decodeFileContent(content) {
-  return typeof content === "string" ? content : new TextDecoder().decode(content);
-}
-async function listLooseBranches(repo) {
-  return listLooseRefNames(repo, "refs/heads");
-}
-async function listLooseRefNames(repo, dir) {
-  if (!hasRecursiveFileLister(repo.fs)) return null;
-  const names = await repo.fs.listFilesRecursively(`${repo.gitdir}/${dir}`);
-  return names.filter(isSafeBranchName);
-}
-async function readPackedBranches(repo) {
-  if (!hasRecursiveFileLister(repo.fs)) return /* @__PURE__ */ new Map();
-  const promisesFs = getPromisesFs(repo.fs);
-  if (!promisesFs) return /* @__PURE__ */ new Map();
-  try {
-    const content = await promisesFs.readFile(
-      `${repo.gitdir}/packed-refs`,
-      "utf8"
-    );
-    const refs = /* @__PURE__ */ new Map();
-    for (const line of decodeFileContent(content).split("\n")) {
-      const match = /^([0-9a-f]{40}) refs\/heads\/(.+)$/i.exec(line);
-      if (match?.[1] && match[2] && isSafeBranchName(match[2])) {
-        refs.set(match[2], match[1]);
-      }
-    }
-    return refs;
-  } catch {
-    return /* @__PURE__ */ new Map();
-  }
-}
-async function getCurrentLooseBranch(repo) {
-  if (!hasRecursiveFileLister(repo.fs)) return null;
-  const promisesFs = getPromisesFs(repo.fs);
-  if (!promisesFs) return null;
-  try {
-    const content = await promisesFs.readFile(`${repo.gitdir}/HEAD`, "utf8");
-    const head = decodeFileContent(content).trim();
-    const match = /^ref: refs\/heads\/(.+)$/.exec(head);
-    return match?.[1] && isSafeBranchName(match[1]) ? match[1] : null;
-  } catch {
-    return null;
-  }
-}
-async function resolveLooseRefFast(repo, ref) {
-  const promisesFs = getPromisesFs(repo.fs);
-  if (promisesFs) {
-    try {
-      const content = await promisesFs.readFile(
-        `${repo.gitdir}/${ref}`,
-        "utf8"
-      );
-      const oid = decodeFileContent(content).trim();
-      if (FULL_SHA_RE2.test(oid)) return oid;
-    } catch {
-    }
-  }
-  return import_isomorphic_git.default.resolveRef({ ...repo, ref });
-}
-async function listBranches(repo) {
-  try {
-    const [looseBranches, looseCurrentBranch, packedBranches] = await Promise.all([
-      listLooseBranches(repo),
-      getCurrentLooseBranch(repo),
-      readPackedBranches(repo)
-    ]);
-    const branches = looseBranches === null ? await import_isomorphic_git.default.listBranches(repo) : [.../* @__PURE__ */ new Set([...looseBranches, ...packedBranches.keys()])].sort();
-    const currentBranch = looseBranches === null ? await import_isomorphic_git.default.currentBranch({ ...repo, fullname: false }).catch(() => null) : looseCurrentBranch;
-    return Promise.all(
-      branches.map(async (branch) => {
-        const packedCommit = packedBranches.get(branch);
-        return {
-          name: branch,
-          commit: packedCommit && !looseBranches?.includes(branch) ? packedCommit : await resolveLooseRefFast(repo, `refs/heads/${branch}`),
-          isDefault: branch === currentBranch
-        };
-      })
-    );
-  } catch (err) {
-    if (err.code === "NotFoundError") return [];
-    throw err;
-  }
-}
-async function createBranchFrom(repo, name, startPoint = "main") {
-  assertSafeBranchName(name);
-  assertSafeBranchName(startPoint);
-  const object = await resolveLooseRefFast(repo, `refs/heads/${startPoint}`);
-  await import_isomorphic_git.default.branch({ ...repo, ref: name, checkout: false, object });
-}
-async function deleteBranchByName(repo, name) {
-  assertSafeBranchName(name);
-  await import_isomorphic_git.default.deleteBranch({ ...repo, ref: name });
-}
-async function assertBranchExists(repo, name) {
-  assertSafeBranchName(name);
-  await resolveLooseRefFast(repo, `refs/heads/${name}`);
-}
-
-// src/ops/commit.ts
-var import_isomorphic_git3 = __toESM(require("isomorphic-git"), 1);
-
-// src/ops/tree.ts
-var import_isomorphic_git2 = __toESM(require("isomorphic-git"), 1);
-var joinPath = (prefix, name) => prefix ? `${prefix.replace(/\/+$/, "")}/${name}` : name;
-async function upsertTree(repo, treeOid, entries) {
-  const existing = treeOid ? (await import_isomorphic_git2.default.readTree({ ...repo, oid: treeOid })).tree : [];
-  const byName = new Map(existing.map((e) => [e.path, e]));
-  const direct = /* @__PURE__ */ new Map();
-  const nested = /* @__PURE__ */ new Map();
-  for (const [filePath, blobOid] of entries) {
-    const slash = filePath.indexOf("/");
-    if (slash === -1) {
-      direct.set(filePath, blobOid);
-    } else {
-      const dir = filePath.slice(0, slash);
-      const rest = filePath.slice(slash + 1);
-      if (!nested.has(dir)) nested.set(dir, /* @__PURE__ */ new Map());
-      nested.get(dir)?.set(rest, blobOid);
-    }
-  }
-  for (const [name, blobOid] of direct) {
-    byName.set(name, {
-      mode: "100644",
-      path: name,
-      oid: blobOid,
-      type: "blob"
-    });
-  }
-  const nestedResults = await Promise.all(
-    Array.from(nested, async ([dir, subEntries]) => {
-      const entry = byName.get(dir);
-      const subtreeOid = entry?.type === "tree" ? entry.oid : void 0;
-      const newOid = await upsertTree(repo, subtreeOid, subEntries);
-      return [dir, newOid];
-    })
-  );
-  for (const [dir, newOid] of nestedResults) {
-    byName.set(dir, { mode: "040000", path: dir, oid: newOid, type: "tree" });
-  }
-  return import_isomorphic_git2.default.writeTree({ ...repo, tree: Array.from(byName.values()) });
-}
-async function deleteFromTree(repo, treeOid, filePath) {
-  const existing = (await import_isomorphic_git2.default.readTree({ ...repo, oid: treeOid })).tree;
-  const byName = new Map(existing.map((e) => [e.path, e]));
-  const slash = filePath.indexOf("/");
-  if (slash === -1) {
-    byName.delete(filePath);
-  } else {
-    const dir = filePath.slice(0, slash);
-    const rest = filePath.slice(slash + 1);
-    const entry = byName.get(dir);
-    if (entry?.type === "tree") {
-      const newOid = await deleteFromTree(repo, entry.oid, rest);
-      byName.set(dir, { ...entry, oid: newOid });
-    }
-  }
-  return import_isomorphic_git2.default.writeTree({ ...repo, tree: Array.from(byName.values()) });
-}
-async function findTreeEntry(repo, rootTreeOid, treePath) {
-  if (!treePath) {
-    return { path: "", mode: "040000", type: "tree", oid: rootTreeOid };
-  }
-  const parts = treePath.split("/").filter(Boolean);
-  let currentTreeOid = rootTreeOid;
-  let currentPath = "";
-  for (const [index, part] of parts.entries()) {
-    const tree = await import_isomorphic_git2.default.readTree({ ...repo, oid: currentTreeOid });
-    const entry = tree.tree.find((candidate) => candidate.path === part);
-    if (!entry) return null;
-    currentPath = currentPath ? joinPath(currentPath, entry.path) : entry.path;
-    if (index === parts.length - 1) {
-      return {
-        path: currentPath,
-        mode: entry.mode,
-        type: entry.type,
-        oid: entry.oid
-      };
-    }
-    if (entry.type !== "tree") return null;
-    currentTreeOid = entry.oid;
-  }
-  return null;
-}
-async function listTreeEntries(repo, treeOid, prefix = "") {
-  const tree = await import_isomorphic_git2.default.readTree({ ...repo, oid: treeOid });
-  return tree.tree.map((entry) => ({
-    path: prefix ? joinPath(prefix, entry.path) : entry.path,
-    mode: entry.mode,
-    type: entry.type,
-    oid: entry.oid
-  }));
-}
-
-// src/ops/commit.ts
-function authorNow(name, email) {
-  return {
-    name,
-    email,
-    timestamp: Math.floor(Date.now() / 1e3),
-    timezoneOffset: 0
-  };
-}
-async function writeCommitToBare(repo, options) {
-  assertSafeBranchName(options.branch);
-  let parentOid;
-  let parentTreeOid;
-  try {
-    parentOid = await import_isomorphic_git3.default.resolveRef({
-      ...repo,
-      ref: `refs/heads/${options.branch}`
-    });
-    const { commit } = await import_isomorphic_git3.default.readCommit({ ...repo, oid: parentOid });
-    parentTreeOid = commit.tree;
-  } catch (err) {
-    if (err?.code !== "NotFoundError") {
-      throw err;
-    }
-  }
-  const treeOid = await options.buildTree(parentTreeOid);
-  const commitOid = await import_isomorphic_git3.default.writeCommit({
-    ...repo,
-    commit: {
-      message: options.message,
-      tree: treeOid,
-      parent: parentOid ? [parentOid] : [],
-      author: options.author,
-      committer: options.author
-    }
-  });
-  await import_isomorphic_git3.default.writeRef({
-    ...repo,
-    ref: `refs/heads/${options.branch}`,
-    value: commitOid,
-    force: true
-  });
-  return commitOid;
-}
-function commitFilesToBare(repo, options) {
-  return writeCommitToBare(repo, {
-    branch: options.branch,
-    message: options.message,
-    author: options.author,
-    buildTree: async (parentTreeOid) => {
-      const blobs = /* @__PURE__ */ new Map();
-      await Promise.all(
-        options.files.map(async (file) => {
-          const content = typeof file.content === "string" ? new TextEncoder().encode(file.content) : file.content;
-          const oid = await import_isomorphic_git3.default.writeBlob({ ...repo, blob: content });
-          blobs.set(file.path, oid);
-        })
-      );
-      return upsertTree(repo, parentTreeOid, blobs);
-    }
-  });
-}
-function deleteFileFromBare(repo, options) {
-  return writeCommitToBare(repo, {
-    branch: options.branch,
-    message: options.message,
-    author: options.author,
-    buildTree: async (parentTreeOid) => {
-      if (!parentTreeOid) {
-        throw new Error(`Branch ${options.branch} is empty`);
-      }
-      return deleteFromTree(repo, parentTreeOid, options.filePath);
-    }
-  });
-}
-
-// src/ops/diff.ts
-var import_diff = require("diff");
-var import_isomorphic_git5 = __toESM(require("isomorphic-git"), 1);
-
-// src/edge-utils.ts
-var textEncoder = new TextEncoder();
-var textDecoder = new TextDecoder();
-function decodeUtf8(data) {
-  return textDecoder.decode(data);
-}
-function toBase64(data) {
-  let binary = "";
-  for (let i = 0; i < data.length; i++)
-    binary += String.fromCharCode(data[i]);
-  return btoa(binary);
-}
-function hasNullByte(data) {
-  return data.includes(0);
-}
-function readBlobContent(blob) {
-  const isBinary = hasNullByte(blob);
-  return {
-    isBinary,
-    text: isBinary ? "" : decodeUtf8(blob),
-    bytes: blob
-  };
-}
-
-// src/ops/history.ts
-var import_isomorphic_git4 = __toESM(require("isomorphic-git"), 1);
-
-// src/ops/types.ts
-var runStep = (hooks, label, fn) => hooks?.step ? hooks.step(label, fn) : fn();
-function resultKeyPrefixes(gitdir) {
-  return [
-    `commitlog:${gitdir}:`,
-    `tree:${gitdir}:`,
-    `commits:${gitdir}:`,
-    `last-commits:${gitdir}:`,
-    `file-history:${gitdir}:`
-  ];
-}
-
-// src/ops/history.ts
-function wrapMissingObject(promise, context) {
-  return promise.catch((err) => {
-    if (err?.code === "NotFoundError") {
-      throw new GitObjectNotFoundError(
-        `Git data for ${context} is missing from storage. The repository may need to be re-pushed to repair it.`
-      );
-    }
-    throw err;
-  });
-}
-var isNotFound = (err) => err?.code === "NotFoundError";
-async function resolveCommit(repo, ref) {
-  const oid = await import_isomorphic_git4.default.resolveRef({ ...repo, ref: qualifyBranchRef(ref) });
-  const result = await wrapMissingObject(
-    import_isomorphic_git4.default.readCommit({ ...repo, oid }),
-    `${repo.gitdir} commit ${oid}`
-  );
-  return { oid, commit: result.commit };
-}
-async function getBlob(repo, sha) {
-  const { blob } = await wrapMissingObject(
-    import_isomorphic_git4.default.readBlob({ ...repo, oid: sha }),
-    `${repo.gitdir} blob ${sha}`
-  );
-  return blob;
-}
-async function getFileContent(repo, filePath, ref = "main", hooks) {
-  if (hooks?.prefetch) {
-    await runStep(hooks, "prefetch", hooks.prefetch);
-  }
-  const { commit } = await resolveCommit(repo, ref);
-  const context = `${repo.gitdir}@${ref}:${filePath}`;
-  const entry = await wrapMissingObject(
-    findTreeEntry(repo, commit.tree, filePath),
-    context
-  );
-  if (entry?.type !== "blob") {
-    throw new GitPathNotFoundError(`File not found: ${filePath}`);
-  }
-  const { blob } = await wrapMissingObject(
-    import_isomorphic_git4.default.readBlob({ ...repo, oid: entry.oid }),
-    context
-  );
-  return blob;
-}
-async function getCommit(repo, sha) {
-  const result = await wrapMissingObject(
-    import_isomorphic_git4.default.readCommit({ ...repo, oid: sha }),
-    `${repo.gitdir} commit ${sha}`
-  );
-  return { oid: result.oid, commit: result.commit, payload: result.payload };
-}
-function isFullyWalked(commits) {
-  const last = commits[commits.length - 1];
-  return !!last && last.commit.parent.length === 0;
-}
-async function getCommitLog(repo, options = {}, hooks) {
-  const ref = options.ref ?? "main";
-  const depth = options.depth ?? 50;
-  let headSha;
-  if (options.knownHeadSha) {
-    headSha = options.knownHeadSha;
-  } else {
-    try {
-      headSha = await import_isomorphic_git4.default.resolveRef({ ...repo, ref: qualifyBranchRef(ref) });
-    } catch (err) {
-      if (isNotFound(err)) return [];
-      throw err;
-    }
-  }
-  const cacheKey = `commitlog:${repo.gitdir}:${headSha}`;
-  const cached = hooks?.resultCache?.get(cacheKey);
-  if (cached && (cached.length >= depth || isFullyWalked(cached))) {
-    hooks?.onNote?.(
-      `getCommitLog: result-cache HIT for ${cacheKey} (depth=${depth})`
-    );
-    return cached.slice(0, depth);
-  }
-  hooks?.onNote?.(
-    `getCommitLog: result-cache MISS for ${cacheKey} (depth=${depth})`
-  );
-  if (hooks?.prefetch && depth >= (hooks.prefetchMinDepth ?? 5)) {
-    await runStep(hooks, "prefetch", hooks.prefetch);
-  }
-  const commits = await wrapMissingObject(
-    runStep(
-      hooks,
-      `git.log ${ref} depth=${depth}`,
-      () => import_isomorphic_git4.default.log({ ...repo, ref: headSha, depth })
-    ),
-    `${repo.gitdir}@${ref} history`
-  );
-  const result = commits.map((commit) => ({
-    oid: commit.oid,
-    commit: commit.commit,
-    payload: commit.payload || ""
-  }));
-  if (!cached || result.length > cached.length) {
-    hooks?.resultCache?.set(cacheKey, result);
-  }
-  return result;
-}
-async function getFileFromRef(repo, filePath, ref, hooks) {
-  const bytes = await getFileContent(repo, filePath, ref, hooks);
-  const isBinary = hasNullByte(bytes);
-  return {
-    content: isBinary ? toBase64(bytes) : decodeUtf8(bytes),
-    size: bytes.length,
-    isBinary
-  };
-}
-async function getTreeFromRef(repo, options = {}, hooks) {
-  const ref = options.ref ?? "main";
-  const treePath = options.treePath ?? "";
-  let commit;
-  let headSha;
-  try {
-    const resolved = await resolveCommit(repo, ref);
-    commit = resolved.commit;
-    headSha = resolved.oid;
-  } catch (err) {
-    if (isNotFound(err)) return [];
-    throw err;
-  }
-  const cacheKey = `tree:${repo.gitdir}:${headSha}:${treePath}`;
-  const cached = hooks?.resultCache?.get(cacheKey);
-  if (cached) {
-    hooks?.onNote?.(`getTreeFromRef: result-cache HIT for ${cacheKey}`);
-    return cached;
-  }
-  hooks?.onNote?.(`getTreeFromRef: result-cache MISS for ${cacheKey}`);
-  if (hooks?.prefetch) {
-    await runStep(hooks, "prefetch", hooks.prefetch);
-  }
-  const context = `${repo.gitdir}@${ref}:${treePath || "/"}`;
-  let result;
-  if (!treePath) {
-    result = await wrapMissingObject(
-      runStep(
-        hooks,
-        "listTreeEntries (root)",
-        () => listTreeEntries(repo, commit.tree)
-      ),
-      context
-    );
-  } else {
-    const entry = await wrapMissingObject(
-      runStep(
-        hooks,
-        `findTreeEntry ${treePath}`,
-        () => findTreeEntry(repo, commit.tree, treePath)
-      ),
-      context
-    );
-    if (!entry) {
-      throw new GitPathNotFoundError(
-        `Path "${treePath}" does not exist at ${ref}`
-      );
-    }
-    result = entry.type !== "tree" ? [] : await wrapMissingObject(
-      runStep(
-        hooks,
-        `listTreeEntries ${treePath}`,
-        () => listTreeEntries(repo, entry.oid, entry.path)
-      ),
-      context
-    );
-  }
-  hooks?.resultCache?.set(cacheKey, result);
-  return result;
-}
-async function getCommitHistory(repo, options, hooks) {
-  const limit = options.limit ?? 50;
-  const skip = options.skip ?? 0;
-  const headSha = await import_isomorphic_git4.default.resolveRef({ ...repo, ref: qualifyBranchRef(options.ref) }).catch(() => null);
-  const cacheKey = headSha ? `commits:${repo.gitdir}:${headSha}:${limit}:${skip}` : null;
-  if (cacheKey) {
-    const cached = hooks?.resultCache?.get(cacheKey);
-    if (cached) {
-      hooks?.onNote?.(`getCommitHistory: result-cache HIT for ${cacheKey}`);
-      return cached;
-    }
-  }
-  hooks?.onNote?.(
-    `getCommitHistory: result-cache MISS for ${cacheKey ?? "(no head)"}`
-  );
-  if (!headSha) return [];
-  const all = await getCommitLog(
-    repo,
-    { ref: options.ref, depth: limit + skip, knownHeadSha: headSha },
-    hooks
-  );
-  const result = all.slice(skip, skip + limit);
-  if (cacheKey) hooks?.resultCache?.set(cacheKey, result);
-  return result;
-}
-
-// src/ops/diff.ts
-function detectBlobContent(blob) {
-  return readBlobContent(blob);
-}
-function countContentLines(content) {
-  if (content.length === 0) return 0;
-  const lines = content.split("\n");
-  if (lines[lines.length - 1] === "") lines.pop();
-  return lines.length;
-}
-function createUnifiedPatch(params) {
-  const oldPath = params.oldPath ?? `a/${params.path}`;
-  const newPath = params.newPath ?? `b/${params.path}`;
-  const patchBody = (0, import_diff.createTwoFilesPatch)(
-    oldPath,
-    newPath,
-    params.before,
-    params.after,
-    "",
-    "",
-    { context: 3 }
-  ).replace(/^=+\n/, "");
-  return `diff --git a/${params.path} b/${params.path}
-${patchBody}`;
-}
-function summarizeDiff(files) {
-  return {
-    files,
-    totalAdditions: files.reduce((sum, f) => sum + f.additions, 0),
-    totalDeletions: files.reduce((sum, f) => sum + f.deletions, 0),
-    totalFiles: files.length
-  };
-}
-function buildDiffFile(path, status, before, after) {
-  const isBinary = !!(before?.isBinary || after?.isBinary);
-  return {
-    path,
-    status,
-    additions: !isBinary && after ? countContentLines(after.text) : 0,
-    deletions: !isBinary && before ? countContentLines(before.text) : 0,
-    patch: isBinary ? "" : createUnifiedPatch({
-      path,
-      before: before?.text ?? "",
-      after: after?.text ?? "",
-      oldPath: before ? void 0 : "/dev/null",
-      newPath: after ? void 0 : "/dev/null"
-    }),
-    isBinary,
-    oldContent: before && isBinary ? toBase64(before.bytes) : void 0,
-    newContent: after && isBinary ? toBase64(after.bytes) : void 0,
-    oldSize: before?.bytes.length,
-    newSize: after?.bytes.length
-  };
-}
-async function walkTreeDiff(repo, oldOid, newOid) {
-  const changes = await import_isomorphic_git5.default.walk({
-    ...repo,
-    trees: [import_isomorphic_git5.default.TREE({ ref: oldOid }), import_isomorphic_git5.default.TREE({ ref: newOid })],
-    map: async (filepath, [A, B]) => {
-      const [typeA, typeB] = await Promise.all([A?.type(), B?.type()]);
-      if (typeA === "tree" || typeB === "tree") return;
-      if (typeA && !typeB) {
-        const oidA2 = A ? await A.oid() : "";
-        const { blob } = await import_isomorphic_git5.default.readBlob({ ...repo, oid: oidA2 });
-        const before = detectBlobContent(blob);
-        return buildDiffFile(filepath, "deleted", before, null);
-      }
-      if (!typeA && typeB) {
-        const oidB2 = B ? await B.oid() : "";
-        const { blob } = await import_isomorphic_git5.default.readBlob({ ...repo, oid: oidB2 });
-        const after = detectBlobContent(blob);
-        return buildDiffFile(filepath, "added", null, after);
-      }
-      const [oidA, oidB] = await Promise.all([
-        A ? A.oid() : Promise.resolve(""),
-        B ? B.oid() : Promise.resolve("")
-      ]);
-      if (oidA !== oidB) {
-        const [{ blob: blobA }, { blob: blobB }] = await Promise.all([
-          import_isomorphic_git5.default.readBlob({ ...repo, oid: oidA }),
-          import_isomorphic_git5.default.readBlob({ ...repo, oid: oidB })
-        ]);
-        const before = detectBlobContent(blobA);
-        const after = detectBlobContent(blobB);
-        return buildDiffFile(filepath, "modified", before, after);
-      }
-      return null;
-    }
-  });
-  return (changes ?? []).filter(
-    (c) => c !== null && c !== void 0
-  );
-}
-async function getCommitDiff(repo, commitSha) {
-  try {
-    const commit = await getCommit(repo, commitSha);
-    const parent = commit.commit.parent[0];
-    if (!parent) {
-      const entries = [];
-      const stack = [
-        { treeOid: commit.commit.tree, prefix: "" }
-      ];
-      while (stack.length) {
-        const { treeOid, prefix } = stack.pop();
-        const { tree } = await import_isomorphic_git5.default.readTree({ ...repo, oid: treeOid });
-        for (const entry of tree) {
-          const full = prefix ? `${prefix}/${entry.path}` : entry.path;
-          if (entry.type === "tree") {
-            stack.push({ treeOid: entry.oid, prefix: full });
-          } else if (entry.type === "blob") {
-            entries.push({ path: full, oid: entry.oid });
-          }
-        }
-      }
-      const files2 = await Promise.all(
-        entries.map(async ({ path, oid }) => {
-          const { blob } = await import_isomorphic_git5.default.readBlob({ ...repo, oid });
-          const after = detectBlobContent(blob);
-          return buildDiffFile(path, "added", null, after);
-        })
-      );
-      return summarizeDiff(files2);
-    }
-    const files = await walkTreeDiff(repo, parent, commitSha);
-    return summarizeDiff(files);
-  } catch (error) {
-    throw new Error(`Failed to get commit diff: ${error}`);
-  }
-}
-async function getDiffBetweenRefs(repo, baseRef, compareRef) {
-  const [baseOid, compareOid] = await Promise.all([
-    import_isomorphic_git5.default.resolveRef({ ...repo, ref: qualifyBranchRef(baseRef) }),
-    import_isomorphic_git5.default.resolveRef({ ...repo, ref: qualifyBranchRef(compareRef) })
-  ]);
-  const files = await walkTreeDiff(repo, baseOid, compareOid);
-  return summarizeDiff(files);
-}
-
-// src/ops/file-history.ts
-var HISTORY_WALK_DEPTH = 400;
-var BANNER_WALK_DEPTH = 60;
-var PREFETCH_WINDOW = 24;
-function toEntry(commit) {
-  return {
-    sha: commit.oid,
-    message: commit.commit.message.trim(),
-    authorName: commit.commit.author.name,
-    authorEmail: commit.commit.author.email,
-    createdAt: new Date(commit.commit.author.timestamp * 1e3).toISOString()
-  };
-}
-async function getFileHistory(repo, options, hooks) {
-  const limit = options.limit ?? 30;
-  const maxDepth = options.maxDepth ?? HISTORY_WALK_DEPTH;
-  const walkDepth = Math.max(maxDepth, limit);
-  const commits = await runStep(
-    hooks,
-    `getCommitLog depth=${walkDepth}`,
-    () => getCommitLog(repo, { ref: options.ref, depth: walkDepth }, hooks)
-  );
-  const head = commits[0];
-  if (!head) return { entries: [], truncated: false };
-  const cacheKey = `file-history:${repo.gitdir}:${head.oid}:${options.filePath}:${limit}:${maxDepth}`;
-  const cached = hooks?.resultCache?.get(cacheKey);
-  if (cached) {
-    hooks?.onNote?.("getFileHistory: result-cache HIT, skipping history walk");
-    return cached;
-  }
-  hooks?.onNote?.("getFileHistory: result-cache MISS, walking history");
-  const byOid = new Map(commits.map((commit) => [commit.oid, commit]));
-  const oidByCommitTree = /* @__PURE__ */ new Map();
-  async function resolveOid(commitTreeOid) {
-    const cachedOid = oidByCommitTree.get(commitTreeOid);
-    if (cachedOid !== void 0) return cachedOid;
-    const entry = await findTreeEntry(repo, commitTreeOid, options.filePath);
-    const oid = entry?.type === "blob" ? entry.oid : null;
-    oidByCommitTree.set(commitTreeOid, oid);
-    return oid;
-  }
-  const entries = [];
-  let truncated = false;
-  outer: for (let windowStart = 0; windowStart < commits.length; windowStart += PREFETCH_WINDOW) {
-    const windowEnd = Math.min(windowStart + PREFETCH_WINDOW, commits.length);
-    const prefetchEnd = Math.min(windowEnd + 1, commits.length);
-    await Promise.all(
-      commits.slice(windowStart, prefetchEnd).map((commit) => resolveOid(commit.commit.tree))
-    );
-    for (let i = windowStart; i < windowEnd; i++) {
-      const commit = commits[i];
-      if (!commit) break outer;
-      const parentSha = commit.commit.parent[0];
-      const parentCommit = parentSha ? byOid.get(parentSha) : void 0;
-      if (parentSha && !parentCommit) {
-        truncated = true;
-        break outer;
-      }
-      const [oid, parentOid] = await Promise.all([
-        resolveOid(commit.commit.tree),
-        parentCommit ? resolveOid(parentCommit.commit.tree) : Promise.resolve(null)
-      ]);
-      if (oid !== parentOid) {
-        entries.push(toEntry(commit));
-        if (entries.length >= limit) {
-          truncated = i < commits.length - 1;
-          break outer;
-        }
-      }
-    }
-  }
-  const result = { entries, truncated };
-  hooks?.resultCache?.set(cacheKey, result);
-  return result;
-}
-
-// src/ops/last-commit.ts
-var HISTORY_WALK_DEPTH2 = 400;
-var PREFETCH_WINDOW2 = 24;
-function toLastCommitInfo(commit) {
-  return {
-    sha: commit.oid,
-    message: commit.commit.message.trim(),
-    authorName: commit.commit.author.name,
-    authorEmail: commit.commit.author.email,
-    createdAt: new Date(commit.commit.author.timestamp * 1e3).toISOString()
-  };
-}
-async function getLastCommitsForTree(repo, options, hooks) {
-  const treePath = options.treePath ?? "";
-  const depth = options.depth ?? HISTORY_WALK_DEPTH2;
-  const commits = await runStep(
-    hooks,
-    `getCommitLog depth=${depth}`,
-    () => getCommitLog(repo, { ref: options.ref, depth }, hooks)
-  );
-  hooks?.onNote?.(`getLastCommitsForTree: ${commits.length} commits in log`);
-  const head = commits[0];
-  if (!head) return {};
-  const cacheKey = `last-commits:${repo.gitdir}:${head.oid}:${treePath}`;
-  const cachedResult = hooks?.resultCache?.get(cacheKey);
-  if (cachedResult) {
-    hooks?.onNote?.(
-      "getLastCommitsForTree: result-cache HIT, skipping history walk"
-    );
-    return cachedResult;
-  }
-  hooks?.onNote?.("getLastCommitsForTree: result-cache MISS, walking history");
-  const byOid = new Map(commits.map((commit) => [commit.oid, commit]));
-  const dirOidByCommitTree = /* @__PURE__ */ new Map();
-  const childrenByDirOid = /* @__PURE__ */ new Map();
-  async function resolveDirOid(commitTreeOid) {
-    const cached = dirOidByCommitTree.get(commitTreeOid);
-    if (cached !== void 0) return cached;
-    const entry = await findTreeEntry(repo, commitTreeOid, treePath);
-    const dirOid = entry?.type === "tree" ? entry.oid : null;
-    dirOidByCommitTree.set(commitTreeOid, dirOid);
-    return dirOid;
-  }
-  async function resolveChildren(dirOid) {
-    if (dirOid === null) return [];
-    const cached = childrenByDirOid.get(dirOid);
-    if (cached) return cached;
-    const children = await listTreeEntries(repo, dirOid, treePath);
-    childrenByDirOid.set(dirOid, children);
-    return children;
-  }
-  const headDirOid = await resolveDirOid(head.commit.tree);
-  if (headDirOid === null) return {};
-  const headChildren = await resolveChildren(headDirOid);
-  const remaining = new Set(headChildren.map((entry) => entry.path));
-  const result = {};
-  let commitsWalked = 0;
-  let prefetchWindows = 0;
-  const walkStart = performance.now();
-  outer: for (let windowStart = 0; windowStart < commits.length && remaining.size > 0; windowStart += PREFETCH_WINDOW2) {
-    const windowEnd = Math.min(windowStart + PREFETCH_WINDOW2, commits.length);
-    const prefetchEnd = Math.min(windowEnd + 1, commits.length);
-    prefetchWindows++;
-    const dirOids = await Promise.all(
-      commits.slice(windowStart, prefetchEnd).map((commit) => resolveDirOid(commit.commit.tree))
-    );
-    await Promise.all(
-      [...new Set(dirOids)].map((dirOid) => resolveChildren(dirOid))
-    );
-    for (let i = windowStart; i < windowEnd; i++) {
-      if (remaining.size === 0) break outer;
-      const commit = commits[i];
-      if (!commit) break outer;
-      commitsWalked++;
-      const parentSha = commit.commit.parent[0];
-      const parentCommit = parentSha ? byOid.get(parentSha) : void 0;
-      if (parentSha && !parentCommit) break outer;
-      const [dirOid, parentDirOid] = await Promise.all([
-        resolveDirOid(commit.commit.tree),
-        parentCommit ? resolveDirOid(parentCommit.commit.tree) : Promise.resolve(null)
-      ]);
-      if (dirOid === parentDirOid) continue;
-      const [children, parentChildren] = await Promise.all([
-        resolveChildren(dirOid),
-        resolveChildren(parentDirOid)
-      ]);
-      const childByName = new Map(
-        children.map((entry) => [entry.path, entry.oid])
-      );
-      const parentChildByName = new Map(
-        parentChildren.map((entry) => [entry.path, entry.oid])
-      );
-      for (const name of remaining) {
-        if (childByName.get(name) !== parentChildByName.get(name)) {
-          result[name] = toLastCommitInfo(commit);
-        }
-      }
-      for (const name of Object.keys(result)) {
-        remaining.delete(name);
-      }
-    }
-  }
-  hooks?.onNote?.(
-    `getLastCommitsForTree: walked ${commitsWalked}/${commits.length} commits across ${prefetchWindows} prefetch windows in ${(performance.now() - walkStart).toFixed(1)}ms, ${dirOidByCommitTree.size} unique tree lookups, ${remaining.size} entries never resolved`
-  );
-  hooks?.resultCache?.set(cacheKey, result);
-  return result;
-}
-
-// src/ops/merge.ts
-var import_isomorphic_git6 = __toESM(require("isomorphic-git"), 1);
-async function analyzeMerge(repo, sourceBranch, targetBranch) {
-  assertSafeBranchName(sourceBranch);
-  assertSafeBranchName(targetBranch);
-  try {
-    const [sourceOid, targetOid] = await Promise.all([
-      import_isomorphic_git6.default.resolveRef({ ...repo, ref: qualifyBranchRef(sourceBranch) }),
-      import_isomorphic_git6.default.resolveRef({ ...repo, ref: qualifyBranchRef(targetBranch) })
-    ]);
-    const isDescendant = await import_isomorphic_git6.default.isDescendent({
-      ...repo,
-      oid: sourceOid,
-      ancestor: targetOid
-    });
-    return {
-      canMerge: true,
-      hasConflicts: false,
-      conflictingFiles: [],
-      fastForward: isDescendant
-    };
-  } catch (err) {
-    if (err?.code !== "NotFoundError") {
-      throw err;
-    }
-    return {
-      canMerge: false,
-      hasConflicts: true,
-      conflictingFiles: [],
-      fastForward: false
-    };
-  }
-}
-async function fastForwardMerge(repo, sourceBranch, targetBranch) {
-  assertSafeBranchName(sourceBranch);
-  assertSafeBranchName(targetBranch);
-  const [sourceOid, targetOid] = await Promise.all([
-    import_isomorphic_git6.default.resolveRef({ ...repo, ref: `refs/heads/${sourceBranch}` }),
-    import_isomorphic_git6.default.resolveRef({ ...repo, ref: `refs/heads/${targetBranch}` })
-  ]);
-  const isFF = await import_isomorphic_git6.default.isDescendent({
-    ...repo,
-    oid: sourceOid,
-    ancestor: targetOid
-  });
-  if (!isFF) return null;
-  await import_isomorphic_git6.default.writeRef({
-    ...repo,
-    ref: `refs/heads/${targetBranch}`,
-    value: sourceOid,
-    force: true
-  });
-  return { success: true, commitSha: sourceOid };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BANNER_WALK_DEPTH,
-  HISTORY_WALK_DEPTH,
-  analyzeMerge,
-  assertBranchExists,
-  assertSafeBranchName,
-  authorNow,
-  commitFilesToBare,
-  createBranchFrom,
-  deleteBranchByName,
-  deleteFileFromBare,
-  deleteFromTree,
-  fastForwardMerge,
-  findTreeEntry,
-  getBlob,
-  getCommit,
-  getCommitDiff,
-  getCommitHistory,
-  getCommitLog,
-  getDiffBetweenRefs,
-  getFileContent,
-  getFileFromRef,
-  getFileHistory,
-  getLastCommitsForTree,
-  getTreeFromRef,
-  listBranches,
-  listTreeEntries,
-  resolveCommit,
-  resolveLooseRefFast,
-  resultKeyPrefixes,
-  upsertTree,
-  writeCommitToBare
-});
-//# sourceMappingURL=ops.cjs.map