@fern-api/replay 0.11.0 → 0.13.0

package/dist/cli.cjs

@@ -13469,7 +13469,7 @@ var FERN_SUPPORT_NAMES = ["fern-support", "Fern Support"];
 function isGenerationCommit(commit) {
   const isFernSupport = FERN_SUPPORT_NAMES.includes(commit.authorName);
   const isBotAuthor = !isFernSupport && (commit.authorLogin === FERN_BOT_LOGIN || commit.authorEmail === FERN_BOT_EMAIL || commit.authorName === FERN_BOT_NAME);
-  const hasGenerationMarker = commit.message.startsWith("[fern-generated]") || commit.message.startsWith("[fern-replay]") || commit.message.includes("Generated by Fern") || commit.message.includes("\u{1F916} Generated with Fern") || // Squash merge of a Fern-generated PR uses the PR title as commit message.
+  const hasGenerationMarker = commit.message.startsWith("[fern-generated]") || commit.message.startsWith("[fern-replay]") || commit.message.startsWith("[fern-autoversion]") || commit.message.includes("Generated by Fern") || commit.message.includes("\u{1F916} Generated with Fern") || // Squash merge of a Fern-generated PR uses the PR title as commit message.
   // The default PR title is "SDK Generation" (from GithubStep's commitMessage default).
   // GitHub appends "(#N)" for the PR number, e.g. "SDK Generation (#70)".
   commit.message.startsWith("SDK Generation");
@@ -13552,17 +13552,57 @@ var ReplayDetector = class {
     }
     const isAncestor = await this.git.isAncestor(lastGen.commit_sha, "HEAD");
     if (!isAncestor) {
+      return this.detectPatchesViaMergeBase(lastGen, lock);
+    }
+    return this.detectPatchesInRange(lastGen.commit_sha, lastGen, lock);
+  }
+  /**
+   * FER-10201 — Non-linear-history detection via `merge-base(prevGen, HEAD)`.
+   *
+   * After a squash-merge of a Fern-bot PR, `lastGen.commit_sha` (the previous
+   * `[fern-generated]`) is orphaned but still in git's object database. The
+   * merge-base is the commit on main from which the bot's branch was created —
+   * a reachable ancestor of HEAD. Walking that range and classifying each
+   * commit via `isGenerationCommit` mirrors the linear path and eliminates
+   * the bug class where pipeline-driven changes (autoversion, replay,
+   * generation) get bundled as customer customizations.
+   *
+   * Falls through to the legacy composite path when no common ancestor exists
+   * (truly disjoint history — orphan branches with no shared root).
+   */
+  async detectPatchesViaMergeBase(lastGen, lock) {
+    let mergeBase = "";
+    try {
+      mergeBase = (await this.git.exec(["merge-base", lastGen.commit_sha, "HEAD"])).trim();
+    } catch {
+    }
+    if (!mergeBase) {
+      this.warnings.push(
+        `No common ancestor between previous generation ${lastGen.commit_sha.slice(0, 7)} and HEAD. Falling back to composite tree-diff detection.`
+      );
       return this.detectPatchesViaTreeDiff(
         lastGen,
         /* commitKnownMissing */
         false
       );
     }
+    return this.detectPatchesInRange(mergeBase, lastGen, lock);
+  }
+  /**
+   * FER-10201 — Walk `${rangeStart}..HEAD`, classify each commit, emit one
+   * `StoredPatch` per customer commit. Body shared by the linear path
+   * (rangeStart = lastGen.commit_sha) and the merge-base path.
+   *
+   * Patch `base_generation` is always `lastGen.commit_sha` — the
+   * lockfile-tracked reference the applicator uses to fetch base file
+   * content, regardless of where the walk actually started.
+   */
+  async detectPatchesInRange(rangeStart, lastGen, lock) {
     const log = await this.git.exec([
       "log",
       "--first-parent",
       "--format=%H%x00%an%x00%ae%x00%s",
-      `${lastGen.commit_sha}..HEAD`,
+      `${rangeStart}..HEAD`,
       "--",
       this.sdkOutputDir
     ]);
@@ -16546,21 +16586,66 @@ var ReplayService = class {
     this.applicator = new ReplayApplicator(git, this.lockManager, outputDir);
     this.committer = new ReplayCommitter(git, outputDir);
   }
-  async runReplay(options) {
+  /**
+   * Phase 1 of the two-phase replay flow. Runs preGenerationRebase (when applicable),
+   * detects new patches, and creates the `[fern-generated]` commit. Leaves HEAD at
+   * the generation commit (or unchanged for dry-run).
+   *
+   * Does NOT apply patches — the returned handle must be passed to
+   * `applyPreparedReplay()` to complete the run. No disk writes to the lockfile
+   * happen here; lockfile persistence is deferred to phase 2.
+   *
+   * Callers may land additional commits on HEAD between `prepareReplay` and
+   * `applyPreparedReplay` (e.g., `[fern-autoversion]`).
+   */
+  async prepareReplay(options) {
     this.warnings = [];
+    this.detector.warnings.length = 0;
     if (options?.skipApplication) {
-      return this.handleSkipApplication(options);
+      return this._prepareSkipApplication(options);
     }
     const flow = this.determineFlow();
     switch (flow) {
       case "first-generation":
-        return this.handleFirstGeneration(options);
+        return this._prepareFirstGeneration(options);
       case "no-patches":
-        return this.handleNoPatchesRegeneration(options);
+        return this._prepareNoPatchesRegeneration(options);
       case "normal-regeneration":
-        return this.handleNormalRegeneration(options);
+        return this._prepareNormalRegeneration(options);
     }
   }
+  /**
+   * Phase 2 of the two-phase replay flow. Applies patches, rebases them against
+   * the generation, saves the lockfile, and commits `[fern-replay]` (or stages
+   * under `stageOnly`). Operates on HEAD at call time — mid-phase commits are
+   * respected.
+   *
+   * For terminal handles (dry-run, first-gen has no patch work, skip-app does
+   * its own post-commit logic), this returns the precomputed report.
+   */
+  async applyPreparedReplay(prep, options) {
+    if (prep._prepared.terminal) {
+      return prep._prepared.preparedReport;
+    }
+    switch (prep._prepared.flow) {
+      case "first-generation":
+        return this._applyFirstGeneration(prep);
+      case "skip-application":
+        return this._applySkipApplication(prep, options);
+      case "no-patches":
+        return this._applyNoPatchesRegeneration(prep, options);
+      case "normal-regeneration":
+        return this._applyNormalRegeneration(prep, options);
+    }
+  }
+  /**
+   * Backwards-compatible atomic entry point. Composes `prepareReplay` + `applyPreparedReplay`.
+   * Behavior is byte-identical to the pre-split implementation for all existing callers.
+   */
+  async runReplay(options) {
+    const prep = await this.prepareReplay(options);
+    return this.applyPreparedReplay(prep, options);
+  }
   /**
    * Sync the lockfile after a divergent PR was squash-merged.
    * Call this BEFORE runReplay() when the CLI detects a merged divergent PR.
@@ -16634,15 +16719,35 @@ var ReplayService = class {
       throw error;
     }
   }
-  async handleFirstGeneration(options) {
+  firstGenerationReport() {
+    return {
+      flow: "first-generation",
+      patchesDetected: 0,
+      patchesApplied: 0,
+      patchesWithConflicts: 0,
+      patchesSkipped: 0,
+      conflicts: []
+    };
+  }
+  async _prepareFirstGeneration(options) {
     if (options?.dryRun) {
+      const headSha = await this.git.exec(["rev-parse", "HEAD"]).then((s) => s.trim()).catch(() => "");
       return {
         flow: "first-generation",
-        patchesDetected: 0,
-        patchesApplied: 0,
-        patchesWithConflicts: 0,
-        patchesSkipped: 0,
-        conflicts: []
+        previousGenerationSha: null,
+        currentGenerationSha: headSha,
+        baseBranchHead: options.baseBranchHead ?? null,
+        _prepared: {
+          flow: "first-generation",
+          terminal: true,
+          preparedReport: this.firstGenerationReport(),
+          patchesToApply: [],
+          newPatchIds: /* @__PURE__ */ new Set(),
+          detectorWarnings: [],
+          revertedCount: 0,
+          genSha: headSha,
+          optionsSnapshot: options
+        }
       };
     }
     const commitOpts = options ? {
@@ -16652,22 +16757,36 @@ var ReplayService = class {
     } : void 0;
     await this.committer.commitGeneration("Initial SDK generation", commitOpts);
     const genRecord = await this.committer.createGenerationRecord(commitOpts);
-    this.lockManager.initialize(genRecord);
+    this.lockManager.initializeInMemory(genRecord);
     return {
       flow: "first-generation",
-      patchesDetected: 0,
-      patchesApplied: 0,
-      patchesWithConflicts: 0,
-      patchesSkipped: 0,
-      conflicts: []
+      previousGenerationSha: null,
+      currentGenerationSha: genRecord.commit_sha,
+      baseBranchHead: options?.baseBranchHead ?? null,
+      _prepared: {
+        flow: "first-generation",
+        terminal: false,
+        patchesToApply: [],
+        newPatchIds: /* @__PURE__ */ new Set(),
+        detectorWarnings: [],
+        revertedCount: 0,
+        genSha: genRecord.commit_sha,
+        optionsSnapshot: options
+      }
     };
   }
+  async _applyFirstGeneration(_prep) {
+    this.lockManager.save();
+    return this.firstGenerationReport();
+  }
   /**
-   * Skip-application mode: commit the generation and update the lockfile
-   * but don't detect or apply patches. Sets a marker so the next normal
-   * run skips revert detection in preGenerationRebase().
+   * Skip-application mode phase 1: commit the generation and update the
+   * in-memory lockfile, but don't detect or apply patches. Sets a marker
+   * so the next normal run skips revert detection in preGenerationRebase().
+   *
+   * Disk save is deferred to `_applySkipApplication`.
    */
-  async handleSkipApplication(options) {
+  async _prepareSkipApplication(options) {
     const commitOpts = options ? {
       cliVersion: options.cliVersion ?? "unknown",
       generatorVersions: options.generatorVersions ?? {},
@@ -16676,8 +16795,10 @@ var ReplayService = class {
     await this.committer.commitGeneration("Update SDK (replay skipped)", commitOpts);
     await this.cleanupStaleConflictMarkers();
     const genRecord = await this.committer.createGenerationRecord(commitOpts);
+    let previousGenerationSha = null;
     try {
-      this.lockManager.read();
+      const lock = this.lockManager.read();
+      previousGenerationSha = lock.current_generation ?? null;
       this.lockManager.addGeneration(genRecord);
     } catch (error) {
       if (error instanceof LockfileNotFoundError) {
@@ -16687,6 +16808,24 @@ var ReplayService = class {
       }
     }
     this.lockManager.setReplaySkippedAt((/* @__PURE__ */ new Date()).toISOString());
+    return {
+      flow: "skip-application",
+      previousGenerationSha,
+      currentGenerationSha: genRecord.commit_sha,
+      baseBranchHead: options?.baseBranchHead ?? null,
+      _prepared: {
+        flow: "skip-application",
+        terminal: false,
+        patchesToApply: [],
+        newPatchIds: /* @__PURE__ */ new Set(),
+        detectorWarnings: [],
+        revertedCount: 0,
+        genSha: genRecord.commit_sha,
+        optionsSnapshot: options
+      }
+    };
+  }
+  async _applySkipApplication(_prep, options) {
     this.lockManager.save();
     const credentialWarnings = [...this.lockManager.warnings];
     if (!options?.stageOnly) {
@@ -16704,12 +16843,14 @@ var ReplayService = class {
       warnings: credentialWarnings.length > 0 ? credentialWarnings : void 0
     };
   }
-  async handleNoPatchesRegeneration(options) {
+  async _prepareNoPatchesRegeneration(options) {
+    const preLock = this.lockManager.read();
+    const previousGenerationSha = preLock.current_generation ?? null;
     let { patches: newPatches, revertedPatchIds } = await this.detector.detectNewPatches();
     const detectorWarnings = [...this.detector.warnings];
     if (options?.dryRun) {
       const dryRunWarnings = [...detectorWarnings, ...this.warnings];
-      return {
+      const preparedReport = {
         flow: "no-patches",
         patchesDetected: newPatches.length,
         patchesApplied: 0,
@@ -16720,9 +16861,26 @@ var ReplayService = class {
         wouldApply: newPatches,
         warnings: dryRunWarnings.length > 0 ? dryRunWarnings : void 0
       };
+      const headSha = await this.git.exec(["rev-parse", "HEAD"]).then((s) => s.trim()).catch(() => "");
+      return {
+        flow: "no-patches",
+        previousGenerationSha,
+        currentGenerationSha: headSha,
+        baseBranchHead: options.baseBranchHead ?? null,
+        _prepared: {
+          flow: "no-patches",
+          terminal: true,
+          preparedReport,
+          patchesToApply: [],
+          newPatchIds: /* @__PURE__ */ new Set(),
+          detectorWarnings,
+          revertedCount: revertedPatchIds.length,
+          genSha: headSha,
+          optionsSnapshot: options
+        }
+      };
     }
     {
-      const preLock = this.lockManager.read();
       const preCurrentGen = preLock.current_generation;
       const uniqueFiles = [...new Set(newPatches.flatMap((p) => p.files))];
       const absorbedFiles = /* @__PURE__ */ new Set();
@@ -16753,6 +16911,27 @@ var ReplayService = class {
     await this.cleanupStaleConflictMarkers();
     const genRecord = await this.committer.createGenerationRecord(commitOpts);
     this.lockManager.addGeneration(genRecord);
+    return {
+      flow: "no-patches",
+      previousGenerationSha,
+      currentGenerationSha: genRecord.commit_sha,
+      baseBranchHead: options?.baseBranchHead ?? null,
+      _prepared: {
+        flow: "no-patches",
+        terminal: false,
+        patchesToApply: newPatches,
+        newPatchIds: new Set(newPatches.map((p) => p.id)),
+        detectorWarnings,
+        revertedCount: revertedPatchIds.length,
+        genSha: genRecord.commit_sha,
+        optionsSnapshot: options
+      }
+    };
+  }
+  async _applyNoPatchesRegeneration(prep, options) {
+    const newPatches = prep._prepared.patchesToApply;
+    const detectorWarnings = prep._prepared.detectorWarnings;
+    const genSha = prep._prepared.genSha;
     let results = [];
     if (newPatches.length > 0) {
       results = await this.applicator.applyPatches(newPatches);
@@ -16764,7 +16943,7 @@ var ReplayService = class {
         }
       }
     }
-    const rebaseCounts = await this.rebasePatches(results, genRecord.commit_sha);
+    const rebaseCounts = await this.rebasePatches(results, genSha);
     for (const patch of newPatches) {
       if (!rebaseCounts.absorbedPatchIds.has(patch.id)) {
         this.lockManager.addPatch(patch);
@@ -16781,15 +16960,26 @@ var ReplayService = class {
       }
     }
     const warnings = [...detectorWarnings, ...this.warnings];
-    return this.buildReport("no-patches", newPatches, results, options, warnings, rebaseCounts, void 0, revertedPatchIds.length);
+    return this.buildReport(
+      "no-patches",
+      newPatches,
+      results,
+      prep._prepared.optionsSnapshot,
+      warnings,
+      rebaseCounts,
+      void 0,
+      prep._prepared.revertedCount
+    );
   }
-  async handleNormalRegeneration(options) {
+  async _prepareNormalRegeneration(options) {
+    const preLock = this.lockManager.read();
+    const previousGenerationSha = preLock.current_generation ?? null;
     if (options?.dryRun) {
       const existingPatches2 = this.lockManager.getPatches();
       const { patches: newPatches2, revertedPatchIds: dryRunReverted } = await this.detector.detectNewPatches();
-      const warnings2 = [...this.detector.warnings, ...this.warnings];
+      const warnings = [...this.detector.warnings, ...this.warnings];
       const allPatches2 = [...existingPatches2, ...newPatches2];
-      return {
+      const preparedReport = {
         flow: "normal-regeneration",
         patchesDetected: allPatches2.length,
         patchesApplied: 0,
@@ -16798,7 +16988,25 @@ var ReplayService = class {
         patchesReverted: dryRunReverted.length,
         conflicts: [],
         wouldApply: allPatches2,
-        warnings: warnings2.length > 0 ? warnings2 : void 0
+        warnings: warnings.length > 0 ? warnings : void 0
+      };
+      const headSha = await this.git.exec(["rev-parse", "HEAD"]).then((s) => s.trim()).catch(() => "");
+      return {
+        flow: "normal-regeneration",
+        previousGenerationSha,
+        currentGenerationSha: headSha,
+        baseBranchHead: options.baseBranchHead ?? null,
+        _prepared: {
+          flow: "normal-regeneration",
+          terminal: true,
+          preparedReport,
+          patchesToApply: [],
+          newPatchIds: /* @__PURE__ */ new Set(),
+          detectorWarnings: [...this.detector.warnings],
+          revertedCount: dryRunReverted.length,
+          genSha: headSha,
+          optionsSnapshot: options
+        }
       };
     }
     let existingPatches = this.lockManager.getPatches();
@@ -16850,6 +17058,29 @@ var ReplayService = class {
     await this.cleanupStaleConflictMarkers();
     const genRecord = await this.committer.createGenerationRecord(commitOpts);
     this.lockManager.addGeneration(genRecord);
+    return {
+      flow: "normal-regeneration",
+      previousGenerationSha,
+      currentGenerationSha: genRecord.commit_sha,
+      baseBranchHead: options?.baseBranchHead ?? null,
+      _prepared: {
+        flow: "normal-regeneration",
+        terminal: false,
+        patchesToApply: allPatches,
+        newPatchIds: new Set(newPatches.map((p) => p.id)),
+        preRebaseCounts,
+        detectorWarnings,
+        revertedCount: revertedPatchIds.length,
+        genSha: genRecord.commit_sha,
+        optionsSnapshot: options
+      }
+    };
+  }
+  async _applyNormalRegeneration(prep, options) {
+    const allPatches = prep._prepared.patchesToApply;
+    const newPatchIds = prep._prepared.newPatchIds;
+    const detectorWarnings = prep._prepared.detectorWarnings;
+    const genSha = prep._prepared.genSha;
     const results = await this.applicator.applyPatches(allPatches);
     this._lastApplyResults = results;
     this.revertConflictingFiles(results);
@@ -16858,7 +17089,8 @@ var ReplayService = class {
         result.patch.status = "unresolved";
       }
     }
-    const rebaseCounts = await this.rebasePatches(results, genRecord.commit_sha);
+    const rebaseCounts = await this.rebasePatches(results, genSha);
+    const newPatches = allPatches.filter((p) => newPatchIds.has(p.id));
     for (const patch of newPatches) {
       if (!rebaseCounts.absorbedPatchIds.has(patch.id)) {
         this.lockManager.addPatch(patch);
@@ -16885,11 +17117,11 @@ var ReplayService = class {
       "normal-regeneration",
       allPatches,
       results,
-      options,
+      prep._prepared.optionsSnapshot,
       warnings,
       rebaseCounts,
-      preRebaseCounts,
-      revertedPatchIds.length
+      prep._prepared.preRebaseCounts,
+      prep._prepared.revertedCount
     );
   }
   /**