git-fs-s3 0.7.0 → 0.9.0

package/dist/ops.js

@@ -1,28 +1,116 @@
+import {
+  parseLooseObjectPath
+} from "./chunk-ZB6GNJ2J.js";
 import {
   assertBranchExists,
   assertSafeBranchName,
   createBranchFrom,
   deleteBranchByName,
+  encodePack,
   listBranches,
-  resolveLooseRefFast
-} from "./chunk-XNSZTA4Y.js";
+  resolveLooseRefFast,
+  storePack
+} from "./chunk-HBOJR5D3.js";
 import {
+  GitInvalidRequestError,
   GitObjectNotFoundError,
   GitPathNotFoundError,
   GitRefNotFoundError,
-  decodeUtf8,
-  hasNullByte,
+  inflate,
+  isSafeTreePath,
   qualifyBranchRef,
-  readBlobContent,
-  toBase64
-} from "./chunk-FIFWOMPM.js";
+  readBlobContent
+} from "./chunk-PASVUPKR.js";
 
 // src/ops/commit.ts
 import git2 from "isomorphic-git";
 
+// src/ops/packed-writes.ts
+var OBJECT_TYPES = /* @__PURE__ */ new Set(["commit", "tree", "blob", "tag"]);
+function parseLooseObject(raw) {
+  const nul = raw.indexOf(0);
+  const header = new TextDecoder().decode(raw.subarray(0, nul));
+  const [type, size] = header.split(" ");
+  const content = raw.slice(nul + 1);
+  if (!OBJECT_TYPES.has(type) || Number(size) !== content.length) {
+    throw new Error(`packed writes: malformed object header "${header}"`);
+  }
+  return { type, content };
+}
+function fileStat(size) {
+  const epoch = /* @__PURE__ */ new Date(0);
+  return {
+    type: "file",
+    mode: 33188,
+    size,
+    ino: 0,
+    mtimeMs: 0,
+    ctimeMs: 0,
+    uid: 0,
+    gid: 0,
+    dev: 0,
+    mtime: epoch,
+    ctime: epoch,
+    isFile: () => true,
+    isDirectory: () => false,
+    isSymbolicLink: () => false
+  };
+}
+async function withPackedWrites(repo, fn) {
+  const base = repo.fs.promises;
+  const pending = /* @__PURE__ */ new Map();
+  async function flush() {
+    if (pending.size === 0) return;
+    const objects = await Promise.all(
+      [...pending.values()].map(
+        async (deflated) => parseLooseObject(await inflate(deflated))
+      )
+    );
+    await storePack(repo, await encodePack(objects));
+    pending.clear();
+  }
+  const promises = new Proxy(base, {
+    get(target, property, receiver) {
+      switch (property) {
+        case "writeFile":
+          return async (path, data, options) => {
+            if (parseLooseObjectPath(path) !== null && typeof data !== "string") {
+              pending.set(path, new Uint8Array(data));
+              return;
+            }
+            await flush();
+            return target.writeFile(path, data, options);
+          };
+        case "readFile":
+          return async (path, options) => {
+            const data = pending.get(path);
+            if (data === void 0) return target.readFile(path, options);
+            return data;
+          };
+        case "stat":
+        case "lstat":
+          return async (path) => {
+            const data = pending.get(path);
+            if (data !== void 0) return fileStat(data.length);
+            return target[property](path);
+          };
+        default: {
+          const value = Reflect.get(target, property, receiver);
+          return typeof value === "function" ? value.bind(target) : value;
+        }
+      }
+    }
+  });
+  const packedRepo = { ...repo, fs: { promises } };
+  const result = await fn(packedRepo);
+  await flush();
+  return result;
+}
+
 // src/ops/tree.ts
 import git from "isomorphic-git";
 var joinPath = (prefix, name) => prefix ? `${prefix.replace(/\/+$/, "")}/${name}` : name;
+var BLOB_MODES = /* @__PURE__ */ new Set(["100644", "100755", "120000"]);
 async function upsertTree(repo, treeOid, entries) {
   const existing = treeOid ? (await git.readTree({ ...repo, oid: treeOid })).tree : [];
   const byName = new Map(existing.map((e) => [e.path, e]));
@@ -40,8 +128,12 @@ async function upsertTree(repo, treeOid, entries) {
     }
   }
   for (const [name, blobOid] of direct) {
+    const current = byName.get(name);
+    if (current && current.type !== "blob") {
+      throw new GitInvalidRequestError(`"${name}" is a directory, not a file`);
+    }
     byName.set(name, {
-      mode: "100644",
+      mode: current && BLOB_MODES.has(current.mode) ? current.mode : "100644",
       path: name,
       oid: blobOid,
       type: "blob"
@@ -50,7 +142,10 @@ async function upsertTree(repo, treeOid, entries) {
   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;
+      if (entry && entry.type !== "tree") {
+        throw new GitInvalidRequestError(`"${dir}" is a file, not a directory`);
+      }
+      const subtreeOid = entry?.oid;
       const newOid = await upsertTree(repo, subtreeOid, subEntries);
       return [dir, newOid];
     })
@@ -61,20 +156,34 @@ async function upsertTree(repo, treeOid, entries) {
   return git.writeTree({ ...repo, tree: Array.from(byName.values()) });
 }
 async function deleteFromTree(repo, treeOid, filePath) {
+  const result = await deleteFromSubtree(repo, treeOid, filePath, filePath);
+  return result ?? git.writeTree({ ...repo, tree: [] });
+}
+async function deleteFromSubtree(repo, treeOid, filePath, fullPath) {
   const existing = (await git.readTree({ ...repo, oid: treeOid })).tree;
   const byName = new Map(existing.map((e) => [e.path, e]));
   const slash = filePath.indexOf("/");
+  const name = slash === -1 ? filePath : filePath.slice(0, slash);
+  const entry = byName.get(name);
   if (slash === -1) {
-    byName.delete(filePath);
+    if (entry?.type !== "blob") {
+      throw new GitPathNotFoundError(`No such file: ${fullPath}`);
+    }
+    byName.delete(name);
   } 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 });
+    if (entry?.type !== "tree") {
+      throw new GitPathNotFoundError(`No such file: ${fullPath}`);
     }
+    const newOid = await deleteFromSubtree(
+      repo,
+      entry.oid,
+      filePath.slice(slash + 1),
+      fullPath
+    );
+    if (newOid === null) byName.delete(name);
+    else byName.set(name, { ...entry, oid: newOid });
   }
+  if (byName.size === 0) return null;
   return git.writeTree({ ...repo, tree: Array.from(byName.values()) });
 }
 async function findTreeEntry(repo, rootTreeOid, treePath) {
@@ -123,6 +232,9 @@ function authorNow(name, email) {
 }
 async function writeCommitToBare(repo, options) {
   assertSafeBranchName(options.branch);
+  return withPackedWrites(repo, (packed) => writeCommit(packed, options));
+}
+async function writeCommit(repo, options) {
   let parentOid;
   let parentTreeOid;
   try {
@@ -137,7 +249,7 @@ async function writeCommitToBare(repo, options) {
       throw err;
     }
   }
-  const treeOid = await options.buildTree(parentTreeOid);
+  const treeOid = await options.buildTree(parentTreeOid, repo);
   const commitOid = await git2.writeCommit({
     ...repo,
     commit: {
@@ -156,34 +268,50 @@ async function writeCommitToBare(repo, options) {
   });
   return commitOid;
 }
-function commitFilesToBare(repo, options) {
+async function commitFilesToBare(repo, options) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const file of options.files) {
+    if (!isSafeTreePath(file.path)) {
+      throw new GitInvalidRequestError(`Invalid file path: ${file.path}`);
+    }
+    if (paths.has(file.path)) {
+      throw new GitInvalidRequestError(`Duplicate file path: ${file.path}`);
+    }
+    paths.add(file.path);
+  }
+  if (paths.size === 0) {
+    throw new GitInvalidRequestError("A commit needs at least one file");
+  }
   return writeCommitToBare(repo, {
     branch: options.branch,
     message: options.message,
     author: options.author,
-    buildTree: async (parentTreeOid) => {
+    buildTree: async (parentTreeOid, writeRepo) => {
       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 git2.writeBlob({ ...repo, blob: content });
+          const oid = await git2.writeBlob({ ...writeRepo, blob: content });
           blobs.set(file.path, oid);
         })
       );
-      return upsertTree(repo, parentTreeOid, blobs);
+      return upsertTree(writeRepo, parentTreeOid, blobs);
     }
   });
 }
-function deleteFileFromBare(repo, options) {
+async function deleteFileFromBare(repo, options) {
+  if (!isSafeTreePath(options.filePath)) {
+    throw new GitInvalidRequestError(`Invalid file path: ${options.filePath}`);
+  }
   return writeCommitToBare(repo, {
     branch: options.branch,
     message: options.message,
     author: options.author,
-    buildTree: async (parentTreeOid) => {
+    buildTree: async (parentTreeOid, writeRepo) => {
       if (!parentTreeOid) {
-        throw new Error(`Branch ${options.branch} is empty`);
+        throw new GitPathNotFoundError(`Branch ${options.branch} is empty`);
       }
-      return deleteFromTree(repo, parentTreeOid, options.filePath);
+      return deleteFromTree(writeRepo, parentTreeOid, options.filePath);
     }
   });
 }
@@ -201,36 +329,49 @@ function resultKeyPrefixes(gitdir) {
   return [
     `commitlog:${gitdir}:`,
     `tree:${gitdir}:`,
-    `commits:${gitdir}:`,
     `last-commits:${gitdir}:`,
     `file-history:${gitdir}:`
   ];
 }
 
 // src/ops/history.ts
+var HISTORY_WALK_DEPTH = 400;
+function summarizeCommit(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()
+  };
+}
+var isNotFound = (err) => err?.code === "NotFoundError";
 function wrapMissingObject(promise, context) {
   return promise.catch((err) => {
-    if (err?.code === "NotFoundError") {
+    if (isNotFound(err)) {
       throw new GitObjectNotFoundError(
-        `Git data for ${context} is missing from storage. The repository may need to be re-pushed to repair it.`
+        `Git data for ${context} is missing from storage`
       );
     }
     throw err;
   });
 }
-var isNotFound = (err) => err?.code === "NotFoundError";
-async function resolveCommit(repo, ref) {
-  const oid = await git3.resolveRef({ ...repo, ref: qualifyBranchRef(ref) }).catch((err) => {
-    if (isNotFound(err)) {
+async function resolveRefOid(repo, ref) {
+  try {
+    return await git3.resolveRef({ ...repo, ref: qualifyBranchRef(ref) });
+  } catch (err) {
+    if (isNotFound(err))
       throw new GitRefNotFoundError(`Ref ${ref} does not exist`);
-    }
     throw err;
-  });
-  const result = await wrapMissingObject(
+  }
+}
+async function resolveCommit(repo, ref) {
+  const oid = await resolveRefOid(repo, ref);
+  const { commit } = await wrapMissingObject(
     git3.readCommit({ ...repo, oid }),
     `${repo.gitdir} commit ${oid}`
   );
-  return { oid, commit: result.commit };
+  return { oid, commit };
 }
 async function getBlob(repo, sha) {
   const { blob } = await wrapMissingObject(
@@ -240,9 +381,7 @@ async function getBlob(repo, sha) {
   return blob;
 }
 async function getFileContent(repo, filePath, ref, hooks) {
-  if (hooks?.prefetch) {
-    await runStep(hooks, "prefetch", hooks.prefetch);
-  }
+  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(
@@ -265,39 +404,28 @@ async function getCommit(repo, 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;
   const depth = options.depth ?? 50;
-  let headSha;
-  if (options.knownHeadSha) {
-    headSha = options.knownHeadSha;
-  } else {
+  let headSha = options.knownHeadSha;
+  if (headSha === void 0) {
     try {
-      headSha = await git3.resolveRef({ ...repo, ref: qualifyBranchRef(ref) });
+      headSha = await resolveRefOid(repo, ref);
     } catch (err) {
-      if (isNotFound(err)) return [];
+      if (err instanceof GitRefNotFoundError) 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})`
-    );
+  const fullyWalked = cached?.at(-1)?.commit.parent.length === 0;
+  if (cached && (cached.length >= depth || fullyWalked)) {
+    hooks?.onNote?.(`getCommitLog: cache hit ${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(
+  hooks?.onNote?.(`getCommitLog: cache miss ${cacheKey} (depth=${depth})`);
+  if (hooks?.prefetch) await runStep(hooks, "prefetch", hooks.prefetch);
+  const log = await wrapMissingObject(
     runStep(
       hooks,
       `git.log ${ref} depth=${depth}`,
@@ -305,25 +433,16 @@ async function getCommitLog(repo, options, hooks) {
     ),
     `${repo.gitdir}@${ref} history`
   );
-  const result = commits.map((commit) => ({
-    oid: commit.oid,
-    commit: commit.commit,
-    payload: commit.payload || ""
+  const result = log.map(({ oid, commit, payload }) => ({
+    oid,
+    commit,
+    payload: 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;
   const treePath = options.treePath ?? "";
@@ -331,227 +450,143 @@ async function getTreeFromRef(repo, options, hooks) {
   const cacheKey = `tree:${repo.gitdir}:${headSha}:${treePath}`;
   const cached = hooks?.resultCache?.get(cacheKey);
   if (cached) {
-    hooks?.onNote?.(`getTreeFromRef: result-cache HIT for ${cacheKey}`);
+    hooks?.onNote?.(`getTreeFromRef: cache hit ${cacheKey}`);
     return cached;
   }
-  hooks?.onNote?.(`getTreeFromRef: result-cache MISS for ${cacheKey}`);
-  if (hooks?.prefetch) {
-    await runStep(hooks, "prefetch", hooks.prefetch);
-  }
+  hooks?.onNote?.(`getTreeFromRef: cache miss ${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
+  const dir = treePath ? await wrapMissingObject(
+    runStep(
+      hooks,
+      `findTreeEntry ${treePath}`,
+      () => findTreeEntry(repo, commit.tree, treePath)
+    ),
+    context
+  ) : { path: "", type: "tree", oid: commit.tree };
+  if (!dir) {
+    throw new GitPathNotFoundError(
+      `Path "${treePath}" does not exist at ${ref}`
     );
   }
+  const result = dir.type === "tree" ? await wrapMissingObject(
+    runStep(
+      hooks,
+      `listTreeEntries ${treePath || "/"}`,
+      () => listTreeEntries(repo, dir.oid, dir.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 git3.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(
+  const log = await getCommitLog(
     repo,
-    { ref: options.ref, depth: limit + skip, knownHeadSha: headSha },
+    { ref: options.ref, depth: limit + skip },
     hooks
   );
-  const result = all.slice(skip, skip + limit);
-  if (cacheKey) hooks?.resultCache?.set(cacheKey, result);
-  return result;
+  return log.slice(skip, skip + limit);
 }
 
 // src/ops/diff.ts
 var MAX_DIFF_TEXT_BYTES = 1024 * 1024;
-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();
+  if (lines.at(-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,
+function unifiedPatch(path, before, after) {
+  const body = createTwoFilesPatch(
+    before ? `a/${path}` : "/dev/null",
+    after ? `b/${path}` : "/dev/null",
+    before?.text ?? "",
+    after?.text ?? "",
     "",
     "",
     { 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
-  };
+  return `diff --git a/${path} b/${path}
+${body}`;
 }
-function buildDiffFile(path, status, before, after) {
+function buildDiffFile(path, before, after) {
   const kind = before?.isBinary || after?.isBinary ? "binary" : Math.max(before?.bytes.length ?? 0, after?.bytes.length ?? 0) > MAX_DIFF_TEXT_BYTES ? "too-large" : "text";
   const isText = kind === "text";
   return {
     path,
-    status,
+    status: !before ? "added" : !after ? "deleted" : "modified",
     kind,
     additions: isText && after ? countContentLines(after.text) : 0,
     deletions: isText && before ? countContentLines(before.text) : 0,
-    patch: isText ? createUnifiedPatch({
-      path,
-      before: before?.text ?? "",
-      after: after?.text ?? "",
-      oldPath: before ? void 0 : "/dev/null",
-      newPath: after ? void 0 : "/dev/null"
-    }) : "",
+    patch: isText ? unifiedPatch(path, before, after) : "",
     oldSize: before?.bytes.length,
     newSize: after?.bytes.length
   };
 }
-async function walkTreeDiff(repo, oldOid, newOid) {
+async function diffTrees(repo, oldTreeOid, newTreeOid) {
+  const readSide = async (entry) => {
+    if (!entry || await entry.type() !== "blob") return null;
+    const { blob } = await git4.readBlob({ ...repo, oid: await entry.oid() });
+    return readBlobContent(blob);
+  };
+  const trees = oldTreeOid ? [git4.TREE({ ref: oldTreeOid }), git4.TREE({ ref: newTreeOid })] : [git4.TREE({ ref: newTreeOid })];
   const changes = await git4.walk({
     ...repo,
-    trees: [git4.TREE({ ref: oldOid }), git4.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 git4.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 git4.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("")
+    trees,
+    map: async (filepath, entries) => {
+      const [oldEntry, newEntry] = oldTreeOid ? [entries[0] ?? null, entries[1] ?? null] : [null, entries[0] ?? null];
+      const [oldType, newType] = await Promise.all([
+        oldEntry?.type(),
+        newEntry?.type()
       ]);
-      if (oidA !== oidB) {
-        const [{ blob: blobA }, { blob: blobB }] = await Promise.all([
-          git4.readBlob({ ...repo, oid: oidA }),
-          git4.readBlob({ ...repo, oid: oidB })
+      if (oldType !== "blob" && newType !== "blob") return void 0;
+      if (oldEntry && newEntry && oldType === newType) {
+        const [oldOid, newOid] = await Promise.all([
+          oldEntry.oid(),
+          newEntry.oid()
         ]);
-        const before = detectBlobContent(blobA);
-        const after = detectBlobContent(blobB);
-        return buildDiffFile(filepath, "modified", before, after);
+        if (oldOid === newOid) return void 0;
       }
-      return null;
+      const [before, after] = await Promise.all([
+        readSide(oldEntry),
+        readSide(newEntry)
+      ]);
+      return before || after ? buildDiffFile(filepath, before, after) : void 0;
     }
   });
-  return (changes ?? []).filter(
-    (c) => c !== null && c !== void 0
-  );
+  const files = (changes ?? []).filter((file) => !!file);
+  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 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 git4.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 git4.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}`);
-  }
+  const { commit } = await getCommit(repo, commitSha);
+  const parent = commit.parent[0];
+  const parentTree = parent ? (await getCommit(repo, parent)).commit.tree : null;
+  return diffTrees(repo, parentTree, commit.tree);
 }
 async function getDiffBetweenRefs(repo, baseRef, compareRef) {
-  const [baseOid, compareOid] = await Promise.all([
-    git4.resolveRef({ ...repo, ref: qualifyBranchRef(baseRef) }),
-    git4.resolveRef({ ...repo, ref: qualifyBranchRef(compareRef) })
+  const [base, compare] = await Promise.all([
+    resolveCommit(repo, baseRef),
+    resolveCommit(repo, compareRef)
   ]);
-  const files = await walkTreeDiff(repo, baseOid, compareOid);
-  return summarizeDiff(files);
+  const [mergeBase] = await git4.findMergeBase({
+    ...repo,
+    oids: [base.oid, compare.oid]
+  });
+  const baseTree = mergeBase === void 0 ? null : mergeBase === base.oid ? base.commit.tree : (await getCommit(repo, mergeBase)).commit.tree;
+  return diffTrees(repo, baseTree, compare.commit.tree);
 }
 
 // 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;
@@ -602,7 +637,7 @@ async function getFileHistory(repo, options, hooks) {
         parentCommit ? resolveOid(parentCommit.commit.tree) : Promise.resolve(null)
       ]);
       if (oid !== parentOid) {
-        entries.push(toEntry(commit));
+        entries.push(summarizeCommit(commit));
         if (entries.length >= limit) {
           truncated = i < commits.length - 1;
           break outer;
@@ -616,20 +651,10 @@ async function getFileHistory(repo, options, hooks) {
 }
 
 // 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 depth = options.depth ?? HISTORY_WALK_DEPTH;
   const commits = await runStep(
     hooks,
     `getCommitLog depth=${depth}`,
@@ -709,7 +734,7 @@ async function getLastCommitsForTree(repo, options, hooks) {
       );
       for (const name of remaining) {
         if (childByName.get(name) !== parentChildByName.get(name)) {
-          result[name] = toLastCommitInfo(commit);
+          result[name] = summarizeCommit(commit);
         }
       }
       for (const name of Object.keys(result)) {
@@ -734,7 +759,7 @@ async function analyzeMerge(repo, sourceBranch, targetBranch) {
       git5.resolveRef({ ...repo, ref: qualifyBranchRef(sourceBranch) }),
       git5.resolveRef({ ...repo, ref: qualifyBranchRef(targetBranch) })
     ]);
-    const isDescendant = await git5.isDescendent({
+    const isDescendant = sourceOid === targetOid || await git5.isDescendent({
       ...repo,
       oid: sourceOid,
       ancestor: targetOid
@@ -764,6 +789,9 @@ async function fastForwardMerge(repo, sourceBranch, targetBranch) {
     git5.resolveRef({ ...repo, ref: `refs/heads/${sourceBranch}` }),
     git5.resolveRef({ ...repo, ref: `refs/heads/${targetBranch}` })
   ]);
+  if (sourceOid === targetOid || await git5.isDescendent({ ...repo, oid: targetOid, ancestor: sourceOid })) {
+    return { success: true, commitSha: targetOid };
+  }
   const isFF = await git5.isDescendent({
     ...repo,
     oid: sourceOid,
@@ -800,7 +828,6 @@ export {
   getCommitLog,
   getDiffBetweenRefs,
   getFileContent,
-  getFileFromRef,
   getFileHistory,
   getLastCommitsForTree,
   getTreeFromRef,
@@ -809,7 +836,9 @@ export {
   resolveCommit,
   resolveLooseRefFast,
   resultKeyPrefixes,
+  summarizeCommit,
   upsertTree,
+  withPackedWrites,
   writeCommitToBare
 };
 //# sourceMappingURL=ops.js.map