git-fs-s3 0.3.5

package/dist/ops.js

@@ -0,0 +1,889 @@
+import {
+  GitInvalidRequestError,
+  GitObjectNotFoundError,
+  GitPathNotFoundError
+} from "./chunk-T5NHPY7U.js";
+import {
+  decodeUtf8,
+  hasNullByte,
+  isSafeBranchName,
+  qualifyBranchRef,
+  readBlobContent,
+  toBase64
+} from "./chunk-4QPWSRYC.js";
+
+// src/ops/branch.ts
+import git from "isomorphic-git";
+function assertSafeBranchName(name) {
+  if (!isSafeBranchName(name)) {
+    throw new GitInvalidRequestError(`Invalid branch name: ${name}`);
+  }
+}
+async function listBranches(repo) {
+  try {
+    const [branches, currentBranch] = await Promise.all([
+      git.listBranches(repo),
+      git.currentBranch({ ...repo, fullname: false }).catch(() => null)
+    ]);
+    return Promise.all(
+      branches.map(async (branch) => ({
+        name: branch,
+        commit: await git.resolveRef({ ...repo, ref: `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 git.resolveRef({
+    ...repo,
+    ref: `refs/heads/${startPoint}`
+  });
+  await git.branch({ ...repo, ref: name, checkout: false, object });
+}
+async function deleteBranchByName(repo, name) {
+  assertSafeBranchName(name);
+  await git.deleteBranch({ ...repo, ref: name });
+}
+async function assertBranchExists(repo, name) {
+  assertSafeBranchName(name);
+  await git.resolveRef({ ...repo, ref: `refs/heads/${name}` });
+}
+
+// src/ops/commit.ts
+import git3 from "isomorphic-git";
+
+// src/ops/tree.ts
+import git2 from "isomorphic-git";
+var joinPath = (prefix, name) => prefix ? `${prefix.replace(/\/+$/, "")}/${name}` : name;
+async function upsertTree(repo, treeOid, entries) {
+  const existing = treeOid ? (await git2.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 git2.writeTree({ ...repo, tree: Array.from(byName.values()) });
+}
+async function deleteFromTree(repo, treeOid, filePath) {
+  const existing = (await git2.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 git2.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 git2.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 git2.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 git3.resolveRef({
+      ...repo,
+      ref: `refs/heads/${options.branch}`
+    });
+    const { commit } = await git3.readCommit({ ...repo, oid: parentOid });
+    parentTreeOid = commit.tree;
+  } catch (err) {
+    if (err?.code !== "NotFoundError") {
+      throw err;
+    }
+  }
+  const treeOid = await options.buildTree(parentTreeOid);
+  const commitOid = await git3.writeCommit({
+    ...repo,
+    commit: {
+      message: options.message,
+      tree: treeOid,
+      parent: parentOid ? [parentOid] : [],
+      author: options.author,
+      committer: options.author
+    }
+  });
+  await git3.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 git3.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
+import { createTwoFilesPatch } from "diff";
+import git5 from "isomorphic-git";
+
+// src/ops/history.ts
+import git4 from "isomorphic-git";
+
+// 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 git4.resolveRef({ ...repo, ref: qualifyBranchRef(ref) });
+  const result = await wrapMissingObject(
+    git4.readCommit({ ...repo, oid }),
+    `${repo.gitdir} commit ${oid}`
+  );
+  return { oid, commit: result.commit };
+}
+async function getBlob(repo, sha) {
+  const { blob } = await wrapMissingObject(
+    git4.readBlob({ ...repo, oid: sha }),
+    `${repo.gitdir} blob ${sha}`
+  );
+  return blob;
+}
+async function getFileContent(repo, filePath, ref = "main") {
+  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(
+    git4.readBlob({ ...repo, oid: entry.oid }),
+    context
+  );
+  return blob;
+}
+async function getCommit(repo, sha) {
+  const result = await wrapMissingObject(
+    git4.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 git4.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}`,
+      () => git4.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) {
+  const bytes = await getFileContent(repo, filePath, ref);
+  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 git4.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 = 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
+  };
+}
+async function walkTreeDiff(repo, oldOid, newOid) {
+  const changes = await git5.walk({
+    ...repo,
+    trees: [git5.TREE({ ref: oldOid }), git5.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 git5.readBlob({ ...repo, oid: oidA2 });
+        const before = detectBlobContent(blob);
+        return {
+          path: filepath,
+          status: "deleted",
+          additions: 0,
+          deletions: before.isBinary ? 0 : countContentLines(before.text),
+          patch: before.isBinary ? "" : createUnifiedPatch({
+            path: filepath,
+            before: before.text,
+            after: "",
+            newPath: "/dev/null"
+          }),
+          isBinary: before.isBinary,
+          oldContent: before.isBinary ? toBase64(before.bytes) : void 0,
+          oldSize: before.bytes.length
+        };
+      }
+      if (!typeA && typeB) {
+        const oidB2 = B ? await B.oid() : "";
+        const { blob } = await git5.readBlob({ ...repo, oid: oidB2 });
+        const after = detectBlobContent(blob);
+        return {
+          path: filepath,
+          status: "added",
+          additions: after.isBinary ? 0 : countContentLines(after.text),
+          deletions: 0,
+          patch: after.isBinary ? "" : createUnifiedPatch({
+            path: filepath,
+            before: "",
+            after: after.text,
+            oldPath: "/dev/null"
+          }),
+          isBinary: after.isBinary,
+          newContent: after.isBinary ? toBase64(after.bytes) : void 0,
+          newSize: after.bytes.length
+        };
+      }
+      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([
+          git5.readBlob({ ...repo, oid: oidA }),
+          git5.readBlob({ ...repo, oid: oidB })
+        ]);
+        const before = detectBlobContent(blobA);
+        const after = detectBlobContent(blobB);
+        const isBinary = before.isBinary || after.isBinary;
+        return {
+          path: filepath,
+          status: "modified",
+          additions: isBinary ? 0 : countContentLines(after.text),
+          deletions: isBinary ? 0 : countContentLines(before.text),
+          patch: isBinary ? "" : createUnifiedPatch({
+            path: filepath,
+            before: before.text,
+            after: after.text
+          }),
+          isBinary,
+          oldContent: isBinary ? toBase64(before.bytes) : void 0,
+          newContent: isBinary ? toBase64(after.bytes) : void 0,
+          oldSize: before.bytes.length,
+          newSize: after.bytes.length
+        };
+      }
+      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 git5.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 git5.readBlob({ ...repo, oid });
+          const after = detectBlobContent(blob);
+          return {
+            path,
+            status: "added",
+            additions: after.isBinary ? 0 : countContentLines(after.text),
+            deletions: 0,
+            patch: after.isBinary ? "" : createUnifiedPatch({
+              path,
+              before: "",
+              after: after.text,
+              oldPath: "/dev/null"
+            }),
+            isBinary: after.isBinary,
+            newContent: after.isBinary ? toBase64(after.bytes) : void 0,
+            newSize: after.bytes.length
+          };
+        })
+      );
+      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([
+    git5.resolveRef({ ...repo, ref: qualifyBranchRef(baseRef) }),
+    git5.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
+import git6 from "isomorphic-git";
+async function analyzeMerge(repo, sourceBranch, targetBranch) {
+  assertSafeBranchName(sourceBranch);
+  assertSafeBranchName(targetBranch);
+  try {
+    const [sourceOid, targetOid] = await Promise.all([
+      git6.resolveRef({ ...repo, ref: qualifyBranchRef(sourceBranch) }),
+      git6.resolveRef({ ...repo, ref: qualifyBranchRef(targetBranch) })
+    ]);
+    const isDescendant = await git6.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([
+    git6.resolveRef({ ...repo, ref: `refs/heads/${sourceBranch}` }),
+    git6.resolveRef({ ...repo, ref: `refs/heads/${targetBranch}` })
+  ]);
+  const isFF = await git6.isDescendent({
+    ...repo,
+    oid: sourceOid,
+    ancestor: targetOid
+  });
+  if (!isFF) return null;
+  await git6.writeRef({
+    ...repo,
+    ref: `refs/heads/${targetBranch}`,
+    value: sourceOid,
+    force: true
+  });
+  return { success: true, commitSha: sourceOid };
+}
+export {
+  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,
+  resultKeyPrefixes,
+  upsertTree,
+  writeCommitToBare
+};
+//# sourceMappingURL=ops.js.map