@fern-api/replay 0.14.1 → 0.15.0

package/dist/index.cjs

@@ -3551,6 +3551,66 @@ var ReplayService = class {
     }
     return snapshot;
   }
+  /**
+   * FER-10203: returns true when a `[fern-autoversion]` commit between
+   * `fromSha` and `toSha` touched any of the patch's `files`. Re-classifies
+   * each grep match via `isGenerationCommit` so a customer commit that
+   * merely quotes the marker in its body doesn't false-positive.
+   */
+  async hasAutoversionContamination(fromSha, toSha, files) {
+    if (files.length === 0) return false;
+    const log = await this.git.exec([
+      "log",
+      `${fromSha}..${toSha}`,
+      "--grep=\\[fern-autoversion\\]",
+      "--extended-regexp",
+      "--format=%H%x09%aN%x09%ae%x09%s",
+      "--",
+      ...files
+    ]).catch(() => "");
+    if (!log.trim()) return false;
+    for (const line of log.trim().split("\n")) {
+      const [sha, authorName, authorEmail, message] = line.split("	");
+      if (sha == null) continue;
+      if (isGenerationCommit({
+        sha,
+        authorName: authorName ?? "",
+        authorEmail: authorEmail ?? "",
+        message: message ?? ""
+      })) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * FER-10203: rebuild patch_content from `theirs_snapshot` (captured at
+   * detection time, predates pipeline content) rather than a HEAD-relative
+   * diff. Returns `null` when snapshot is missing or doesn't cover every
+   * file in `patch.files` — caller leaves the patch unchanged.
+   */
+  async computeSnapshotBasedPatchDiff(patch, currentGen) {
+    if (!patch.theirs_snapshot) return null;
+    if (Object.keys(patch.theirs_snapshot).length === 0) return null;
+    for (const file of patch.files) {
+      if (patch.theirs_snapshot[file] == null) return null;
+    }
+    const fragments = [];
+    for (const file of patch.files) {
+      const theirsContent = patch.theirs_snapshot[file];
+      const oursContent = await this.git.showFile(currentGen, file).catch(() => null);
+      if (oursContent == null) {
+        fragments.push(synthesizeNewFileDiff(file, theirsContent));
+        continue;
+      }
+      if (oursContent === theirsContent) continue;
+      const fileDiff = await unifiedDiff(oursContent, theirsContent, file);
+      if (fileDiff.trim()) {
+        fragments.push(fileDiff);
+      }
+    }
+    return fragments.join("");
+  }
   /**
    * Read THEIRS snapshot from a git tree-ish (commit, branch, or tree).
    * Used when the diff that produced `patch_content` was relative to that
@@ -3816,6 +3876,41 @@ var ReplayService = class {
       }
       if (patch.base_generation === currentGen) {
         try {
+          const contaminated = await this.hasAutoversionContamination(
+            currentGen,
+            "HEAD",
+            patch.files
+          );
+          if (contaminated) {
+            const snapshotDiff = await this.computeSnapshotBasedPatchDiff(
+              patch,
+              currentGen
+            );
+            if (snapshotDiff === null) continue;
+            if (!snapshotDiff.trim()) {
+              if (await allPatchFilesUserOwned(patch)) continue;
+              this.lockManager.removePatch(patch.id);
+              contentRefreshed++;
+              continue;
+            }
+            const snapHasStaleMarkers = snapshotDiff.split("\n").some(
+              (l) => l.startsWith("+<<<<<<< Generated") || l.startsWith("+>>>>>>> Your customization")
+            );
+            if (snapHasStaleMarkers) continue;
+            const isProtectedSnap = patch.files.some(
+              (file) => file === ".fernignore" || fernignorePatterns.some((p) => file === p || (0, import_minimatch2.minimatch)(file, p))
+            );
+            if (isProtectedSnap) continue;
+            const snapHash = this.detector.computeContentHash(snapshotDiff);
+            if (snapHash !== patch.content_hash) {
+              this.lockManager.updatePatch(patch.id, {
+                patch_content: snapshotDiff,
+                content_hash: snapHash
+              });
+              contentRefreshed++;
+            }
+            continue;
+          }
           const ppResult = await computePerPatchDiffWithFallback(
             patch,
             (f) => this.git.showFile(currentGen, f),
@@ -3867,6 +3962,42 @@ var ReplayService = class {
       try {
         const markerFiles = await this.git.exec(["grep", "-l", "<<<<<<< Generated", "HEAD", "--", ...patch.files]).catch(() => "");
         if (markerFiles.trim()) continue;
+        const contaminated = await this.hasAutoversionContamination(
+          currentGen,
+          "HEAD",
+          patch.files
+        );
+        if (contaminated) {
+          const snapshotDiff = await this.computeSnapshotBasedPatchDiff(
+            patch,
+            currentGen
+          );
+          if (snapshotDiff === null) continue;
+          if (!snapshotDiff.trim()) {
+            if (await allPatchFilesUserOwned(patch)) {
+              try {
+                this.lockManager.updatePatch(patch.id, { base_generation: currentGen });
+              } catch {
+              }
+              continue;
+            }
+            this.lockManager.removePatch(patch.id);
+            conflictAbsorbed++;
+            continue;
+          }
+          const snapHasStaleMarkers = snapshotDiff.split("\n").some(
+            (l) => l.startsWith("+<<<<<<< Generated") || l.startsWith("+>>>>>>> Your customization")
+          );
+          if (snapHasStaleMarkers) continue;
+          const snapHash = this.detector.computeContentHash(snapshotDiff);
+          this.lockManager.updatePatch(patch.id, {
+            base_generation: currentGen,
+            patch_content: snapshotDiff,
+            content_hash: snapHash
+          });
+          conflictResolved++;
+          continue;
+        }
         const ppResult = await computePerPatchDiffWithFallback(
           patch,
           (f) => this.git.showFile(currentGen, f),