@fern-api/replay 0.6.1 → 0.7.0

package/dist/cli.cjs

@@ -12935,6 +12935,26 @@ var LockfileManager = class {
     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;
@@ -15206,12 +15226,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 ${patchCount} customization(s)`;
+    let fullMessage = message ?? `[fern-replay] Applied customizations`;
     if (patches && patches.length > 0) {
       fullMessage += "\n\nPatches replayed:";
       for (const patch of patches) {
@@ -15302,13 +15322,27 @@ var ReplayService = class {
       this.lockManager.initializeInMemory(record);
     } else {
       this.lockManager.read();
+      const unresolvedPatches = [
+        ...this.lockManager.getUnresolvedPatches(),
+        ...this.lockManager.getResolvingPatches()
+      ];
       this.lockManager.addGeneration(record);
       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);
         }
@@ -15416,6 +15450,12 @@ var ReplayService = class {
     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) {
@@ -15426,10 +15466,8 @@ var ReplayService = class {
     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();
       }
@@ -15477,20 +15515,32 @@ var ReplayService = class {
     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",
@@ -15638,6 +15688,10 @@ var ReplayService = class {
     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);
@@ -15688,6 +15742,55 @@ var ReplayService = class {
     }
     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_node_path4.join)(this.outputDir, fileResult.file);
+        try {
+          const content = (0, import_node_fs2.readFileSync)(filePath, "utf-8");
+          const stripped = this.stripConflictMarkers(content);
+          (0, import_node_fs2.writeFileSync)(filePath, stripped);
+        } catch {
+        }
+      }
+    }
+  }
   readFernignorePatterns() {
     const fernignorePath = (0, import_node_path4.join)(this.outputDir, ".fernignore");
     if (!(0, import_node_fs2.existsSync)(fernignorePath)) return [];
@@ -15722,6 +15825,12 @@ var ReplayService = class {
       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
     };
@@ -16181,17 +16290,82 @@ async function resolve(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;
 }
 
 // src/cli.ts
@@ -16449,14 +16623,23 @@ function printReport(report) {
         }
       }
     }
-    console.log("\nResolve conflicts by editing the marked files, then commit.");
-    console.log("Or run: fern-replay forget <file-pattern>  to remove problematic patches");
+    console.log("\nOr run: fern-replay forget <file-pattern>  to remove problematic patches");
   } else if (report.conflicts.length > 0) {
     console.log("\nConflicts:");
     for (const conflict of report.conflicts) {
       console.log(`  ${conflict.file}: ${conflict.reason ?? "merge conflict"}`);
     }
   }
+  if (report.unresolvedPatches && report.unresolvedPatches.length > 0) {
+    console.log("\nUnresolved Patches (need local resolution):");
+    for (const patch of report.unresolvedPatches) {
+      console.log(`  Patch: ${patch.patchId} - "${patch.patchMessage}"`);
+      for (const file of patch.files) {
+        console.log(`    ${file}`);
+      }
+    }
+    console.log("\nRun 'fern-replay resolve <dir>' on this branch to resolve conflicts.");
+  }
   if (report.warnings && report.warnings.length > 0) {
     console.log("\nWarnings:");
     for (const w of report.warnings) console.log(`  ${w}`);
@@ -16572,6 +16755,17 @@ async function runResolve(dir, flags) {
       case "no-patches":
         console.error("No patches in lockfile. Nothing to resolve.");
         break;
+      case "conflicts-applied":
+        console.log(`Applied ${result.patchesApplied} unresolved patch(es) to working tree.`);
+        console.log(`
+${result.unresolvedFiles.length} file(s) have conflicts:`);
+        for (const f of result.unresolvedFiles) {
+          console.log(`  ${f}`);
+        }
+        console.log(`
+Resolve the conflicts in your editor, then run 'fern-replay resolve ${dir}' again.`);
+        return;
+      // Normal flow, don't exit(1)
       case "unresolved-conflicts":
         console.error("Conflict markers still present in:");
         for (const f of result.unresolvedFiles ?? []) {
@@ -16585,8 +16779,11 @@ async function runResolve(dir, flags) {
     }
     process.exit(1);
   }
+  if (result.patchesResolved) {
+    console.log(`Resolution complete. Updated ${result.patchesResolved} patch(es) in lockfile.`);
+  }
   console.log(`Created [fern-replay] commit: ${result.commitSha?.slice(0, 7)}`);
-  console.log("Conflict resolution complete.");
+  console.log("Push to update the PR.");
 }
 async function main() {
   const { command, dir, flags, pattern } = parseArgs(process.argv);