@fern-api/generator-cli 0.6.10 → 0.6.11

package/dist/cli.js

@@ -19568,7 +19568,7 @@ var init_diff3 = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/@fern-api+replay@0.6.2/node_modules/@fern-api/replay/dist/index.js
+// ../../node_modules/.pnpm/@fern-api+replay@0.7.0/node_modules/@fern-api/replay/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
   FERN_BOT_EMAIL: () => FERN_BOT_EMAIL2,
@@ -19891,17 +19891,82 @@ async function resolve7(outputDir, options) {
     return { success: false, reason: "no-patches" };
   }
   const git = new GitClient(outputDir);
+  const unresolvedPatches = lockManager.getUnresolvedPatches();
+  const resolvingPatches = lockManager.getResolvingPatches();
+  if (unresolvedPatches.length > 0) {
+    const applicator = new ReplayApplicator(git, lockManager, outputDir);
+    await applicator.applyPatches(unresolvedPatches);
+    const markerFiles = await findConflictMarkerFiles(git);
+    if (markerFiles.length > 0) {
+      for (const patch of unresolvedPatches) {
+        lockManager.updatePatch(patch.id, { status: "resolving" });
+      }
+      lockManager.save();
+      return {
+        success: false,
+        reason: "conflicts-applied",
+        unresolvedFiles: markerFiles,
+        phase: "applied",
+        patchesApplied: unresolvedPatches.length
+      };
+    }
+  }
   if (options?.checkMarkers !== false) {
-    const markerFiles = await git.exec(["grep", "-l", "<<<<<<<", "--", "."]).catch(() => "");
-    if (markerFiles.trim()) {
-      const files = markerFiles.trim().split("\n").filter(Boolean);
-      return { success: false, reason: "unresolved-conflicts", unresolvedFiles: files };
+    const currentMarkerFiles = await findConflictMarkerFiles(git);
+    if (currentMarkerFiles.length > 0) {
+      return { success: false, reason: "unresolved-conflicts", unresolvedFiles: currentMarkerFiles };
+    }
+  }
+  const patchesToCommit = [...resolvingPatches, ...unresolvedPatches];
+  if (patchesToCommit.length > 0) {
+    const currentGen = lock.current_generation;
+    const detector = new ReplayDetector(git, lockManager, outputDir);
+    let patchesResolved = 0;
+    for (const patch of patchesToCommit) {
+      const diff = await git.exec(["diff", currentGen, "--", ...patch.files]).catch(() => null);
+      if (!diff || !diff.trim()) {
+        lockManager.removePatch(patch.id);
+        continue;
+      }
+      const newContentHash = detector.computeContentHash(diff);
+      const changedFiles = await getChangedFiles(git, currentGen, patch.files);
+      lockManager.markPatchResolved(patch.id, {
+        patch_content: diff,
+        content_hash: newContentHash,
+        base_generation: currentGen,
+        files: changedFiles
+      });
+      patchesResolved++;
     }
+    lockManager.save();
+    const committer2 = new ReplayCommitter(git, outputDir);
+    await committer2.stageAll();
+    const commitSha2 = await committer2.commitReplay(
+      lock.patches.length,
+      lock.patches,
+      "[fern-replay] Resolved conflicts"
+    );
+    return {
+      success: true,
+      commitSha: commitSha2,
+      phase: "committed",
+      patchesResolved
+    };
   }
   const committer = new ReplayCommitter(git, outputDir);
   await committer.stageAll();
   const commitSha = await committer.commitReplay(lock.patches.length, lock.patches);
-  return { success: true, commitSha };
+  return { success: true, commitSha, phase: "committed" };
+}
+async function findConflictMarkerFiles(git) {
+  const output = await git.exec(["grep", "-l", "<<<<<<<", "--", "."]).catch(() => "");
+  return output.trim() ? output.trim().split("\n").filter(Boolean) : [];
+}
+async function getChangedFiles(git, currentGen, files) {
+  const filesOutput = await git.exec(["diff", "--name-only", currentGen, "--", ...files]).catch(() => null);
+  if (!filesOutput || !filesOutput.trim()) return files;
+  const changed = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !f.startsWith(".fern/"));
+  return changed.length > 0 ? changed : files;
 }
 function status(outputDir) {
   const lockManager = new LockfileManager(outputDir);
@@ -19927,7 +19992,7 @@ function status(outputDir) {
 }
 var import_fs6, import_path8, import_yaml, import_crypto, import_promises4, import_os, import_path9, import_fs7, import_path10, import_crypto2, import_fs8, import_path11, import_yaml2, import_crypto3, import_fs9, import_path12, import_fs10, __defProp3, __getOwnPropNames3, __esm3, __export3, GitClient_exports, GitClient, init_GitClient, FERN_BOT_NAME2, FERN_BOT_EMAIL2, FERN_BOT_LOGIN2, FERN_SUPPORT_NAMES, LOCKFILE_HEADER, LockfileManager, INFRASTRUCTURE_FILES, ReplayDetector, BINARY_EXTENSIONS, ReplayApplicator, ReplayCommitter, ReplayService, FernignoreMigrator, REPLAY_FERNIGNORE_ENTRIES;
 var init_dist = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.6.2/node_modules/@fern-api/replay/dist/index.js"() {
+  "../../node_modules/.pnpm/@fern-api+replay@0.7.0/node_modules/@fern-api/replay/dist/index.js"() {
     "use strict";
     init_esm4();
     import_fs6 = require("fs");
@@ -20158,6 +20223,26 @@ var init_dist = __esm({
         this.ensureLoaded();
         this.lock.patches = [];
       }
+      getUnresolvedPatches() {
+        this.ensureLoaded();
+        return this.lock.patches.filter((p) => p.status === "unresolved");
+      }
+      getResolvingPatches() {
+        this.ensureLoaded();
+        return this.lock.patches.filter((p) => p.status === "resolving");
+      }
+      markPatchUnresolved(patchId) {
+        this.updatePatch(patchId, { status: "unresolved" });
+      }
+      markPatchResolved(patchId, updates) {
+        this.ensureLoaded();
+        const patch = this.lock.patches.find((p) => p.id === patchId);
+        if (!patch) {
+          throw new Error(`Patch not found: ${patchId}`);
+        }
+        delete patch.status;
+        Object.assign(patch, updates);
+      }
       getPatches() {
         this.ensureLoaded();
         return this.lock.patches;
@@ -20801,12 +20886,12 @@ CLI Version: ${options.cliVersion}`;
         await this.git.exec(["commit", "-m", fullMessage]);
         return (await this.git.exec(["rev-parse", "HEAD"])).trim();
       }
-      async commitReplay(_patchCount, patches) {
+      async commitReplay(_patchCount, patches, message) {
         await this.stageAll();
         if (!await this.hasStagedChanges()) {
           return (await this.git.exec(["rev-parse", "HEAD"])).trim();
         }
-        let fullMessage = `[fern-replay] Applied customizations`;
+        let fullMessage = message ?? `[fern-replay] Applied customizations`;
         if (patches && patches.length > 0) {
           fullMessage += "\n\nPatches replayed:";
           for (const patch of patches) {
@@ -20896,13 +20981,27 @@ CLI Version: ${options.cliVersion}`;
           this.lockManager.initializeInMemory(record2);
         } else {
           this.lockManager.read();
+          const unresolvedPatches = [
+            ...this.lockManager.getUnresolvedPatches(),
+            ...this.lockManager.getResolvingPatches()
+          ];
           this.lockManager.addGeneration(record2);
           this.lockManager.clearPatches();
+          for (const patch of unresolvedPatches) {
+            this.lockManager.addPatch(patch);
+          }
         }
         this.lockManager.save();
         try {
           const redetectedPatches = await this.detector.detectNewPatches();
           if (redetectedPatches.length > 0) {
+            const redetectedFiles = new Set(redetectedPatches.flatMap((p) => p.files));
+            const currentPatches = this.lockManager.getPatches();
+            for (const patch of currentPatches) {
+              if (patch.status != null && patch.files.some((f) => redetectedFiles.has(f))) {
+                this.lockManager.removePatch(patch.id);
+              }
+            }
             for (const patch of redetectedPatches) {
               this.lockManager.addPatch(patch);
             }
@@ -21010,6 +21109,12 @@ CLI Version: ${options.cliVersion}`;
         let results = [];
         if (newPatches.length > 0) {
           results = await this.applicator.applyPatches(newPatches);
+          this.revertConflictingFiles(results);
+          for (const result of results) {
+            if (result.status === "conflict") {
+              result.patch.status = "unresolved";
+            }
+          }
         }
         const rebaseCounts = await this.rebasePatches(results, genRecord.commit_sha);
         for (const patch of newPatches) {
@@ -21020,10 +21125,8 @@ CLI Version: ${options.cliVersion}`;
         this.lockManager.save();
         if (newPatches.length > 0) {
           if (!options?.stageOnly) {
-            const appliedCount = results.filter((r) => r.status === "applied" || r.status === "conflict").length;
-            if (appliedCount > 0) {
-              await this.committer.commitReplay(appliedCount, newPatches);
-            }
+            const appliedCount = results.filter((r) => r.status === "applied").length;
+            await this.committer.commitReplay(appliedCount, newPatches);
           } else {
             await this.committer.stageAll();
           }
@@ -21071,20 +21174,32 @@ CLI Version: ${options.cliVersion}`;
         const genRecord = await this.committer.createGenerationRecord(commitOpts);
         this.lockManager.addGeneration(genRecord);
         const results = await this.applicator.applyPatches(allPatches);
+        this.revertConflictingFiles(results);
+        for (const result of results) {
+          if (result.status === "conflict") {
+            result.patch.status = "unresolved";
+          }
+        }
         const rebaseCounts = await this.rebasePatches(results, genRecord.commit_sha);
         for (const patch of newPatches) {
           if (!rebaseCounts.absorbedPatchIds.has(patch.id)) {
             this.lockManager.addPatch(patch);
           }
         }
+        for (const result of results) {
+          if (result.status === "conflict") {
+            try {
+              this.lockManager.markPatchUnresolved(result.patch.id);
+            } catch {
+            }
+          }
+        }
         this.lockManager.save();
         if (options?.stageOnly) {
           await this.committer.stageAll();
         } else {
-          const appliedCount = results.filter((r) => r.status === "applied" || r.status === "conflict").length;
-          if (appliedCount > 0) {
-            await this.committer.commitReplay(appliedCount, allPatches);
-          }
+          const appliedCount = results.filter((r) => r.status === "applied").length;
+          await this.committer.commitReplay(appliedCount, allPatches);
         }
         return this.buildReport(
           "normal-regeneration",
@@ -21232,6 +21347,10 @@ CLI Version: ${options.cliVersion}`;
         let conflictAbsorbed = 0;
         let contentRefreshed = 0;
         for (const patch of patches) {
+          if (patch.status != null) {
+            delete patch.status;
+            continue;
+          }
           if (patch.base_generation === currentGen) {
             try {
               const diff = await this.git.exec(["diff", currentGen, "HEAD", "--", ...patch.files]).catch(() => null);
@@ -21282,6 +21401,55 @@ CLI Version: ${options.cliVersion}`;
         }
         return { conflictResolved, conflictAbsorbed, contentRefreshed };
       }
+      /**
+       * Strip conflict markers from file content, keeping the OURS (Generated) side.
+       * Preserves clean patches' non-conflicting changes on shared files.
+       */
+      stripConflictMarkers(content) {
+        const lines = content.split("\n");
+        const result = [];
+        let inConflict = false;
+        let inOurs = false;
+        for (const line of lines) {
+          if (line.startsWith("<<<<<<< ")) {
+            inConflict = true;
+            inOurs = true;
+            continue;
+          }
+          if (inConflict && line === "=======") {
+            inOurs = false;
+            continue;
+          }
+          if (inConflict && line.startsWith(">>>>>>> ")) {
+            inConflict = false;
+            inOurs = false;
+            continue;
+          }
+          if (!inConflict || inOurs) {
+            result.push(line);
+          }
+        }
+        return result.join("\n");
+      }
+      /**
+       * After applyPatches(), strip conflict markers from conflicting files
+       * so only clean content is committed. Keeps the Generated (OURS) side.
+       */
+      revertConflictingFiles(results) {
+        for (const result of results) {
+          if (result.status !== "conflict" || !result.fileResults) continue;
+          for (const fileResult of result.fileResults) {
+            if (fileResult.status !== "conflict") continue;
+            const filePath = (0, import_path10.join)(this.outputDir, fileResult.file);
+            try {
+              const content = (0, import_fs7.readFileSync)(filePath, "utf-8");
+              const stripped = this.stripConflictMarkers(content);
+              (0, import_fs7.writeFileSync)(filePath, stripped);
+            } catch {
+            }
+          }
+        }
+      }
       readFernignorePatterns() {
         const fernignorePath = (0, import_path10.join)(this.outputDir, ".fernignore");
         if (!(0, import_fs7.existsSync)(fernignorePath)) return [];
@@ -21316,6 +21484,12 @@ CLI Version: ${options.cliVersion}`;
           patchesRefreshed: preRebaseCounts && preRebaseCounts.contentRefreshed > 0 ? preRebaseCounts.contentRefreshed : void 0,
           conflicts: conflictResults.flatMap((r) => r.fileResults?.filter((f) => f.status === "conflict") ?? []),
           conflictDetails: conflictDetails.length > 0 ? conflictDetails : void 0,
+          unresolvedPatches: conflictResults.length > 0 ? conflictResults.map((r) => ({
+            patchId: r.patch.id,
+            patchMessage: r.patch.original_message,
+            files: r.patch.files,
+            conflictDetails: r.fileResults?.filter((f) => f.status === "conflict") ?? []
+          })) : void 0,
           wouldApply: options?.dryRun ? patches : void 0,
           warnings: warnings && warnings.length > 0 ? warnings : void 0
         };
@@ -27227,9 +27401,6 @@ async function githubRelease(params) {
   await github.release();
 }
 
-// src/api/generate-readme.ts
-var import_node_stream = require("stream");
-
 // ../../node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/predicate/isLength.mjs
 function isLength(value) {
   return Number.isSafeInteger(value) && value >= 0;
@@ -30048,16 +30219,25 @@ var ReadmeGenerator = class {
     this.apiName = this.readmeConfig.apiName ?? this.organizationPascalCase;
   }
   async generateReadme({ output }) {
+    const writer = new StreamWriter(output);
+    await this.writeReadmeContent({ writer });
+    await writer.end();
+  }
+  async generateReadmeToString() {
+    const writer = new StringWriter();
+    await this.writeReadmeContent({ writer });
+    await writer.end();
+    return writer.toString();
+  }
+  async writeReadmeContent({ writer }) {
     const blocks = await this.generateBlocks();
     const mergedBlocks = await this.mergeBlocks({ blocks });
-    const writer = new StreamWriter(output);
     await this.writeHeader({ writer });
     await this.writeTableOfContents({ writer, blocks: mergedBlocks });
     await this.writeBlocks({
       writer,
       blocks: mergedBlocks
     });
-    await writer.end();
   }
   async generateBlocks() {
     const blocks = [];
@@ -30927,9 +31107,6 @@ async function generateReadmeToStream(params) {
   });
 }
 
-// src/api/generate-reference.ts
-var import_node_stream2 = require("stream");
-
 // src/reference/ReferenceGenerator.ts
 var ReferenceGenerator = class {
   referenceConfig;
@@ -30940,6 +31117,16 @@ var ReferenceGenerator = class {
   }
   async generate({ output }) {
     const writer = new StreamWriter(output);
+    await this.writeReferenceContent({ writer });
+    await writer.end();
+  }
+  async generateToString() {
+    const writer = new StringWriter();
+    await this.writeReferenceContent({ writer });
+    await writer.end();
+    return writer.toString();
+  }
+  async writeReferenceContent({ writer }) {
     await writer.writeLine("# Reference");
     if (this.referenceConfig.rootSection != null) {
       await this.writeRootSection({
@@ -30950,7 +31137,6 @@ var ReferenceGenerator = class {
     for (const section of this.referenceConfig.sections) {
       await this.writeSection({ section, writer });
     }
-    await writer.end();
   }
   async writeRootSection({
     section,
@@ -31090,41 +31276,19 @@ var import_path7 = require("path");
 
 // src/pipeline/github/createReplayBranch.ts
 async function createReplayBranch(repository, branchName, commitMessage, replayConflictInfo, logger) {
-  if (replayConflictInfo?.hasConflicts) {
-    const parentSha = replayConflictInfo.previousGenerationSha;
-    const lockfileRestoreSha = replayConflictInfo.baseBranchHead ?? replayConflictInfo.previousGenerationSha;
-    logger.debug(`Creating divergent PR branch with generation tree (parent: ${parentSha.substring(0, 7)})`);
-    const genTreeHash = await repository.getCommitTreeHash(replayConflictInfo.currentGenerationSha);
-    const syntheticCommitSha = await repository.commitTree(
-      genTreeHash,
-      parentSha,
-      `[fern-generated] ${commitMessage ?? "Update SDK"}`
-    );
-    await repository.createBranchFromCommit(branchName, syntheticCommitSha);
-    try {
-      await repository.restoreFilesFromCommit(lockfileRestoreSha, ".fern/replay.lock");
-      await repository.commitAllChanges(`[fern-generated] ${commitMessage ?? "Update SDK"}`);
-    } catch (error) {
-      logger.debug(
-        `Could not restore lockfile from base branch: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-    return syntheticCommitSha;
-  } else if (replayConflictInfo != null) {
-    const parentSha = replayConflictInfo.previousGenerationSha;
-    logger.debug(`Creating linear PR branch from HEAD (no conflicts)`);
-    await repository.createBranchFromHead(branchName);
-    const genTreeHash = await repository.getCommitTreeHash(replayConflictInfo.currentGenerationSha);
-    const tagCommitSha = await repository.commitTree(
-      genTreeHash,
-      parentSha,
-      `[fern-generated] ${commitMessage ?? "Update SDK"}`
-    );
-    return tagCommitSha;
-  } else {
+  if (replayConflictInfo == null) {
     await repository.createBranchFromHead(branchName);
     return void 0;
   }
+  const parentSha = replayConflictInfo.previousGenerationSha;
+  await repository.createBranchFromHead(branchName);
+  const genTreeHash = await repository.getCommitTreeHash(replayConflictInfo.currentGenerationSha);
+  const tagCommitSha = await repository.commitTree(
+    genTreeHash,
+    parentSha,
+    `[fern-generated] ${commitMessage ?? "Update SDK"}`
+  );
+  return tagCommitSha;
 }
 
 // src/pipeline/github/findExistingUpdatablePR.ts
@@ -31219,11 +31383,11 @@ function formatConflictReason(reason) {
     case "same-line-edit":
       return "The new generation changed the same lines you edited";
     case "new-file-both":
-      return "You and the generator both created this file";
+      return "Both the generator and your customization created this file";
     case "base-generation-mismatch":
-      return "The generated code changed significantly around your edit";
+      return "This customization was from a previous generation";
     case "patch-apply-failed":
-      return "Your change could not be applied to the new generated code";
+      return "The customization could not be applied to the new code";
     default:
       return "Your edit overlaps with changes in the new generation";
   }
@@ -31232,7 +31396,7 @@ function patchDescription(detail) {
   if (detail.patchMessage && detail.patchMessage !== "update") {
     return detail.patchMessage;
   }
-  const firstFile = detail.files[0]?.file;
+  const firstFile = detail.files[0];
   return firstFile != null ? `changes in ${firstFile}` : "customization";
 }
 function formatReplayPrBody(result, options) {
@@ -31241,70 +31405,66 @@ function formatReplayPrBody(result, options) {
   }
   const applied = result.patchesApplied ?? 0;
   const absorbed = result.patchesAbsorbed ?? 0;
-  const conflicts2 = result.patchesWithConflicts ?? 0;
+  const unresolvedPatches = result.unresolvedPatches ?? [];
+  const hasUnresolved = unresolvedPatches.length > 0;
   const preserved = applied - absorbed;
-  if (preserved === 0 && conflicts2 === 0) {
+  if (preserved === 0 && !hasUnresolved) {
     return void 0;
   }
   const parts = [];
-  if (preserved > 0 && conflicts2 === 0) {
+  if (preserved > 0 && !hasUnresolved) {
     parts.push(`\u2705 Customizations automatically preserved in this update.`);
   } else if (preserved > 0) {
+    const totalFiles = unresolvedPatches.reduce((sum, patch) => sum + patch.conflictDetails.length, 0);
     parts.push(
-      `\u2705 Customizations automatically preserved, but ${plural(conflicts2, "file")} ${conflicts2 === 1 ? "needs" : "need"} your attention.`
+      `\u2705 Customizations automatically preserved, but ${plural(totalFiles, "file")} ${totalFiles === 1 ? "needs" : "need"} your attention.`
     );
   }
-  if (conflicts2 > 0) {
-    const allFiles = (result.conflictDetails ?? []).flatMap((d) => d.files);
-    const totalFiles = allFiles.length;
+  if (hasUnresolved) {
+    const totalFiles = unresolvedPatches.reduce((sum, patch) => sum + patch.conflictDetails.length, 0);
     parts.push(`
-### \u26A0\uFE0F Action required: ${plural(totalFiles, "file")} with customization conflicts
+### Action required: ${plural(totalFiles, "file")} with unresolved customization conflicts
 `);
     parts.push(
-      `You previously customized ${totalFiles === 1 ? "a file" : "files"} in this SDK. This generation changed the same code, so your ${totalFiles === 1 ? "edit" : "edits"} couldn't be applied automatically.
-`
-    );
-    parts.push(
-      `> \u26A0\uFE0F **Label guide:** In GitHub's conflict editor, \`<<<<<<< HEAD\` ("Accept current") = new generated code. \`>>>>>>> main\` ("Accept incoming") = your customization.
+      `The new generation changed code you previously customized. Non-conflicting customizations have been applied automatically. The following files need manual resolution:
 `
     );
     parts.push(`| File | Your customization | Why it conflicted |`);
     parts.push(`|------|-------------------|-------------------|`);
-    for (const detail of result.conflictDetails ?? []) {
-      const description = patchDescription(detail);
-      for (const f of detail.files) {
-        parts.push(`| \`${f.file}\` | ${description} | ${formatConflictReason(f.conflictReason)} |`);
+    for (const patch of unresolvedPatches) {
+      const description = patchDescription(patch);
+      for (const file of patch.conflictDetails) {
+        parts.push(`| \`${file.file}\` | ${description} | ${formatConflictReason(file.conflictReason)} |`);
       }
     }
     const branch = options?.branchName ?? "<branch-name>";
+    const repoUri = options?.repoUri;
+    const repoName = repoUri?.split("/").pop() ?? "<repo>";
     parts.push(`
-#### How to fix
-`);
-    parts.push(`**Option A: Resolve in GitHub (recommended for simple conflicts)**
-`);
-    parts.push(`1. Click the **Resolve conflicts** button below`);
-    parts.push(`2. For each file, choose which code to keep:`);
-    parts.push(`   - \`<<<<<<< HEAD\` / "Accept current changes" = **new generated code**`);
-    parts.push(`   - \`>>>>>>> main\` / "Accept incoming changes" = **your customization**`);
-    parts.push(`   - Or manually combine both, then delete the conflict markers`);
-    parts.push(`3. Click **Mark as resolved** for each file, then **Commit merge**
+#### How to resolve
 `);
-    parts.push(`**Option B: Resolve locally**
-`);
-    parts.push(`1. Fetch and check out this branch:`);
-    parts.push(`   \`\`\`sh`);
-    parts.push(`   git fetch origin && git checkout ${branch}`);
-    parts.push(`   \`\`\``);
-    parts.push(`2. Merge the base branch and resolve conflicts in your editor:`);
+    parts.push(`1. Check out this branch:`);
     parts.push(`   \`\`\`sh`);
-    parts.push(`   git merge origin/main`);
+    parts.push(`   git fetch origin && git checkout -b ${branch} origin/${branch}`);
     parts.push(`   \`\`\``);
-    parts.push(`3. Commit and push:`);
-    parts.push(`   \`\`\`sh`);
-    parts.push(`   git add -A && git commit -m "resolve conflicts" && git push`);
-    parts.push(`   \`\`\`
+    if (repoUri != null) {
+      parts.push(`   Or if you don't have the repo cloned:`);
+      parts.push(`   \`\`\`sh`);
+      parts.push(
+        `   git clone https://github.com/${repoUri}.git && cd ${repoName} && git checkout -b ${branch} origin/${branch}`
+      );
+      parts.push(`   \`\`\``);
+    }
+    parts.push(`2. Run: \`fern replay resolve\``);
+    parts.push(`3. Open the conflicting files in your editor \u2014 you'll see standard merge conflict markers`);
+    parts.push(`4. Resolve using your editor's merge tools (VS Code, IntelliJ, etc.)`);
+    parts.push(`5. Run: \`fern replay resolve\` again to finalize`);
+    parts.push(`6. Push your changes
 `);
-    parts.push(`Your resolved changes will be remembered on future SDK generations.`);
+    parts.push(`Your resolved customizations will be remembered on future SDK generations.`);
+    parts.push(
+      `If you merge this PR without resolving, your unresolved customizations will conflict again on the next generation.`
+    );
   }
   return parts.join("\n");
 }
@@ -31440,16 +31600,9 @@ var GithubStep = class extends BaseStep {
         }
       }
     }
-    if (!this.config.previewMode) {
-      const headSha = await repository.getHeadSha();
-      await this.postReplayConflictStatus(octokit, owner, repo, headSha, replayConflictInfo, replayResult);
-      if (isUpdatingExistingPR && existingPR != null) {
-        await this.togglePrDraftState(octokit, existingPR, replayConflictInfo);
-      }
-    }
     const finalCommitMessage = this.config.commitMessage ?? "SDK Generation";
     const { prTitle, prBody } = parseCommitMessageForPR(finalCommitMessage);
-    const replaySection = formatReplayPrBody(replayResult, { branchName: prBranch });
+    const replaySection = formatReplayPrBody(replayResult, { branchName: prBranch, repoUri: this.config.uri });
     const enrichedBody = replaySection != null ? prBody + "\n\n---\n\n" + replaySection : prBody;
     if (isUpdatingExistingPR && existingPR != null) {
       this.logger.info(`Updated existing pull request: ${existingPR.htmlUrl}`);
@@ -31471,7 +31624,6 @@ var GithubStep = class extends BaseStep {
       }
     } else {
       const head = `${owner}:${prBranch}`;
-      const hasConflicts = replayConflictInfo?.hasConflicts === true;
       try {
         const { data: pullRequest } = await octokit.pulls.create({
           owner,
@@ -31479,8 +31631,7 @@ var GithubStep = class extends BaseStep {
           title: prTitle,
           body: enrichedBody,
           head,
-          base: baseBranch,
-          draft: hasConflicts
+          base: baseBranch
         });
         this.logger.info(`Created pull request: ${pullRequest.html_url}`);
         result.prUrl = pullRequest.html_url;
@@ -31494,17 +31645,6 @@ var GithubStep = class extends BaseStep {
         }
       }
     }
-    if (!this.config.previewMode && result.prNumber != null && replayConflictInfo?.hasConflicts === true && replayResult != null) {
-      await this.postWebEditorFallbackComment(
-        octokit,
-        owner,
-        repo,
-        result.prNumber,
-        prBranch,
-        baseBranch,
-        replayResult
-      );
-    }
     return result;
   }
   async executePushMode(repository) {
@@ -31550,198 +31690,17 @@ var GithubStep = class extends BaseStep {
     if (replayResult == null) {
       return void 0;
     }
-    const hasConflicts = (replayResult.patchesWithConflicts ?? 0) > 0;
     const previousGenerationSha = replayResult.previousGenerationSha;
     const currentGenerationSha = replayResult.currentGenerationSha;
     if (previousGenerationSha != null && currentGenerationSha != null) {
       return {
         previousGenerationSha,
-        currentGenerationSha,
-        hasConflicts,
-        baseBranchHead: replayResult.baseBranchHead
+        currentGenerationSha
       };
     }
     return void 0;
   }
-  async togglePrDraftState(octokit, existingPR, replayConflictInfo) {
-    const hasConflicts = replayConflictInfo?.hasConflicts === true;
-    if (hasConflicts && !existingPR.isDraft) {
-      await this.convertPrToDraft(octokit, existingPR.nodeId, existingPR.number);
-    } else if (!hasConflicts && existingPR.isDraft) {
-      await this.markPrReady(octokit, existingPR.nodeId, existingPR.number);
-    }
-  }
-  async convertPrToDraft(octokit, nodeId, prNumber) {
-    try {
-      await octokit.graphql(
-        `mutation($id: ID!) {
-                    convertPullRequestToDraft(input: {pullRequestId: $id}) {
-                        pullRequest { isDraft }
-                    }
-                }`,
-        { id: nodeId }
-      );
-      this.logger.info(`Converted PR #${prNumber} to draft due to replay conflicts`);
-    } catch (error) {
-      this.logger.debug(
-        `Could not convert PR to draft: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  async markPrReady(octokit, nodeId, prNumber) {
-    try {
-      await octokit.graphql(
-        `mutation($id: ID!) {
-                    markPullRequestReadyForReview(input: {pullRequestId: $id}) {
-                        pullRequest { isDraft }
-                    }
-                }`,
-        { id: nodeId }
-      );
-      this.logger.info(`Marked PR #${prNumber} as ready (conflicts resolved)`);
-    } catch (error) {
-      this.logger.debug(`Could not mark PR as ready: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  async postReplayConflictStatus(octokit, owner, repo, sha, replayConflictInfo, replayResult) {
-    if (replayResult == null || !replayResult.executed) {
-      return;
-    }
-    const hasConflicts = replayConflictInfo?.hasConflicts === true;
-    const conflictFileCount = (replayResult.conflictDetails ?? []).reduce(
-      (sum, detail) => sum + detail.files.length,
-      0
-    );
-    const sanitizedName = this.config.generatorName?.replace(/\//g, "--");
-    const context = sanitizedName != null ? `fern / sdk customizations / ${sanitizedName}` : "fern / sdk customizations";
-    try {
-      await octokit.repos.createCommitStatus({
-        owner,
-        repo,
-        sha,
-        state: hasConflicts ? "failure" : "success",
-        context,
-        description: hasConflicts ? `${conflictFileCount} file(s) need manual conflict resolution \u2014 see PR description` : "All customizations applied"
-      });
-      this.logger.debug(`Posted ${hasConflicts ? "failing" : "passing"} commit status (${context})`);
-    } catch (error) {
-      this.logger.debug(
-        `Could not post commit status: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  async postWebEditorFallbackComment(octokit, owner, repo, prNumber, branchName, baseBranch, replayResult) {
-    try {
-      const webEditorLikelyDisabled = await this.isWebEditorLikelyDisabled(
-        octokit,
-        owner,
-        repo,
-        prNumber,
-        replayResult
-      );
-      if (!webEditorLikelyDisabled) {
-        this.logger.debug(`PR #${prNumber}: web conflict editor appears usable, skipping fallback comment`);
-        return;
-      }
-      const comment = buildWebEditorFallbackComment(branchName, baseBranch);
-      await octokit.issues.createComment({
-        owner,
-        repo,
-        issue_number: prNumber,
-        body: comment
-      });
-      this.logger.info(`Posted web-editor fallback comment on PR #${prNumber}`);
-    } catch (error) {
-      this.logger.debug(
-        `Could not post web-editor fallback comment: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  async isWebEditorLikelyDisabled(octokit, owner, repo, prNumber, replayResult) {
-    const conflictDetails = replayResult.conflictDetails ?? [];
-    const allConflictFiles = conflictDetails.flatMap((d) => d.files);
-    const totalConflictFiles = allConflictFiles.length;
-    const hasFileDeletionConflict = allConflictFiles.some((f) => {
-      const status2 = (f.status ?? "").toLowerCase();
-      const reason = (f.conflictReason ?? "").toLowerCase();
-      return status2 === "skipped" || reason.includes("delete") || reason.includes("removed");
-    });
-    if (hasFileDeletionConflict) {
-      this.logger.debug(`PR #${prNumber}: detected file deletion conflict, web editor likely disabled`);
-      return true;
-    }
-    if (totalConflictFiles >= WEB_EDITOR_FILE_THRESHOLD) {
-      this.logger.debug(
-        `PR #${prNumber}: ${totalConflictFiles} conflicting files exceeds threshold (${WEB_EDITOR_FILE_THRESHOLD}), web editor likely disabled`
-      );
-      return true;
-    }
-    const totalHunks = (replayResult.conflicts ?? []).reduce(
-      (sum, fileConflict) => sum + fileConflict.conflicts.length,
-      0
-    );
-    if (totalHunks >= WEB_EDITOR_HUNK_THRESHOLD) {
-      this.logger.debug(
-        `PR #${prNumber}: ${totalHunks} conflict hunks exceeds threshold (${WEB_EDITOR_HUNK_THRESHOLD}), web editor likely disabled`
-      );
-      return true;
-    }
-    const mergeableState = await this.pollMergeableState(octokit, owner, repo, prNumber);
-    if (mergeableState.mergeable === null) {
-      this.logger.debug(`PR #${prNumber}: mergeable state still null after polling, web editor likely disabled`);
-      return true;
-    }
-    return false;
-  }
-  async pollMergeableState(octokit, owner, repo, prNumber) {
-    for (let attempt2 = 0; attempt2 < MERGEABLE_POLL_MAX_ATTEMPTS; attempt2++) {
-      const { data: pr } = await octokit.pulls.get({
-        owner,
-        repo,
-        pull_number: prNumber
-      });
-      if (pr.mergeable != null) {
-        return {
-          mergeable: pr.mergeable,
-          mergeableState: pr.mergeable_state
-        };
-      }
-      if (attempt2 < MERGEABLE_POLL_MAX_ATTEMPTS - 1) {
-        await sleep(MERGEABLE_POLL_DELAY_MS);
-      }
-    }
-    return { mergeable: null, mergeableState: "unknown" };
-  }
 };
-var WEB_EDITOR_FILE_THRESHOLD = 20;
-var WEB_EDITOR_HUNK_THRESHOLD = 50;
-var MERGEABLE_POLL_MAX_ATTEMPTS = 3;
-var MERGEABLE_POLL_DELAY_MS = 1500;
-function buildWebEditorFallbackComment(branchName, baseBranch) {
-  const lines = [
-    `> **Note:** These conflicts may be too complex for GitHub's web editor. To resolve locally:`,
-    `>`,
-    `> 1. Check out this branch:`,
-    `>    \`\`\`sh`,
-    `>    git fetch origin && git checkout ${branchName}`,
-    `>    \`\`\``,
-    `> 2. Merge the base branch:`,
-    `>    \`\`\`sh`,
-    `>    git merge origin/${baseBranch}`,
-    `>    \`\`\``,
-    `> 3. Resolve conflicts in your editor (VS Code, IntelliJ, etc. have built-in merge tools)`,
-    `> 4. Commit and push:`,
-    `>    \`\`\`sh`,
-    `>    git add -A && git commit -m "resolve conflicts" && git push`,
-    `>    \`\`\``,
-    `>`,
-    `> **Label guide:** In your editor's merge view, "current" = new generated code, "incoming" = your customization.`
-  ];
-  return lines.join("\n");
-}
-function sleep(ms) {
-  return new Promise((resolve8) => setTimeout(resolve8, ms));
-}
 
 // src/replay/replay-run.ts
 init_dist();
@@ -31950,8 +31909,7 @@ var ReplayStep = class extends BaseStep {
         flow: "first-generation",
         patchesDetected: 0,
         patchesApplied: 0,
-        patchesWithConflicts: 0,
-        conflicts: []
+        patchesWithConflicts: 0
       };
     }
     const report = result.report;
@@ -31969,22 +31927,12 @@ var ReplayStep = class extends BaseStep {
       patchesRepointed: report.patchesRepointed,
       patchesContentRebased: report.patchesContentRebased,
       patchesKeptAsUserOwned: report.patchesKeptAsUserOwned,
-      conflicts: report.conflicts.map((fileResult) => ({
-        filePath: fileResult.file,
-        conflicts: fileResult.conflicts?.map((conflict) => ({
-          startLine: conflict.startLine,
-          endLine: conflict.endLine,
-          ours: conflict.ours,
-          theirs: conflict.theirs
-        })) ?? []
-      })),
-      conflictDetails: report.conflictDetails?.map((detail) => ({
-        patchId: detail.patchId,
-        patchMessage: detail.patchMessage,
-        reason: detail.reason,
-        files: detail.files.map((f) => ({
+      unresolvedPatches: report.unresolvedPatches?.map((info) => ({
+        patchId: info.patchId,
+        patchMessage: info.patchMessage,
+        files: info.files,
+        conflictDetails: info.conflictDetails.map((f) => ({
           file: f.file,
-          status: f.status,
           conflictReason: f.conflictReason
         }))
       })),
@@ -32248,6 +32196,9 @@ function buildPrBody(result) {
   return lines.join("\n");
 }
 
+// src/replay/replay-resolve.ts
+init_dist();
+
 // src/configuration/loadGitHubConfig.ts
 var import_promises6 = require("fs/promises");
 async function loadGitHubConfig({