@fern-api/replay 0.10.2 → 0.10.4

package/dist/index.d.cts

@@ -173,6 +173,13 @@ declare class ReplayDetector {
      * so rebased commits with same content produce the same hash.
      */
     computeContentHash(patchContent: string): string;
+    /**
+     * Create a single composite patch for a merge commit by diffing the merge
+     * commit against its first parent. This captures the net change of the
+     * entire merged branch as one patch, eliminating accumulator chaining and
+     * zero-net-change ghost conflicts.
+     */
+    private createMergeCompositePatch;
     /**
      * Detect patches via tree diff for non-linear history. Returns a composite patch.
      * Revert reconciliation is skipped here because tree-diff produces a single composite

package/dist/index.d.ts

@@ -173,6 +173,13 @@ declare class ReplayDetector {
      * so rebased commits with same content produce the same hash.
      */
     computeContentHash(patchContent: string): string;
+    /**
+     * Create a single composite patch for a merge commit by diffing the merge
+     * commit against its first parent. This captures the net change of the
+     * entire merged branch as one patch, eliminating accumulator chaining and
+     * zero-net-change ghost conflicts.
+     */
+    private createMergeCompositePatch;
     /**
      * Detect patches via tree diff for non-linear history. Returns a composite patch.
      * Revert reconciliation is skipped here because tree-diff produces a single composite

package/dist/index.js

@@ -613,6 +613,7 @@ var ReplayDetector = class {
     }
     const log = await this.git.exec([
       "log",
+      "--first-parent",
       "--format=%H%x00%an%x00%ae%x00%s",
       `${lastGen.commit_sha}..HEAD`,
       "--",
@@ -628,11 +629,20 @@ var ReplayDetector = class {
       if (isGenerationCommit(commit)) {
         continue;
       }
-      const parents = await this.git.getCommitParents(commit.sha);
-      if (parents.length > 1) {
+      if (lock.patches.find((p) => p.original_commit === commit.sha)) {
         continue;
       }
-      if (lock.patches.find((p) => p.original_commit === commit.sha)) {
+      const parents = await this.git.getCommitParents(commit.sha);
+      if (parents.length > 1) {
+        const compositePatch = await this.createMergeCompositePatch({
+          mergeCommit: commit,
+          firstParent: parents[0],
+          lastGen,
+          lock
+        });
+        if (compositePatch) {
+          newPatches.push(compositePatch);
+        }
         continue;
       }
       let patchContent;
@@ -731,6 +741,46 @@ var ReplayDetector = class {
     const normalized = patchContent.split("\n").filter((line) => !line.startsWith("From ") && !line.startsWith("index ") && !line.startsWith("Date: ")).join("\n");
     return `sha256:${createHash("sha256").update(normalized).digest("hex")}`;
   }
+  /**
+   * Create a single composite patch for a merge commit by diffing the merge
+   * commit against its first parent. This captures the net change of the
+   * entire merged branch as one patch, eliminating accumulator chaining and
+   * zero-net-change ghost conflicts.
+   */
+  async createMergeCompositePatch(input) {
+    const { mergeCommit, firstParent, lastGen, lock } = input;
+    const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
+    const filesOutput = await this.git.exec([
+      "diff",
+      "--name-only",
+      firstParent,
+      mergeCommit.sha
+    ]);
+    const files = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
+    if (files.length === 0) return null;
+    const diff = await this.git.exec([
+      "diff",
+      firstParent,
+      mergeCommit.sha,
+      "--",
+      ...files
+    ]);
+    if (!diff.trim()) return null;
+    const contentHash = this.computeContentHash(diff);
+    if (lock.patches.some((p) => p.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
+      return null;
+    }
+    return {
+      id: `patch-merge-${mergeCommit.sha.slice(0, 8)}`,
+      content_hash: contentHash,
+      original_commit: mergeCommit.sha,
+      original_message: mergeCommit.message,
+      original_author: `${mergeCommit.authorName} <${mergeCommit.authorEmail}>`,
+      base_generation: lastGen.commit_sha,
+      files,
+      patch_content: diff
+    };
+  }
   /**
    * Detect patches via tree diff for non-linear history. Returns a composite patch.
    * Revert reconciliation is skipped here because tree-diff produces a single composite