@fern-api/replay 0.6.1 → 0.7.0

package/dist/index.cjs

@@ -273,6 +273,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;
@@ -973,12 +993,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) {
@@ -1073,13 +1093,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);
         }
@@ -1187,6 +1221,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) {
@@ -1197,10 +1237,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();
       }
@@ -1248,20 +1286,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",
@@ -1409,6 +1459,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);
@@ -1459,6 +1513,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_path3.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_path3.join)(this.outputDir, ".fernignore");
     if (!(0, import_node_fs2.existsSync)(fernignorePath)) return [];
@@ -1493,6 +1596,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
     };
@@ -1954,17 +2063,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/commands/status.ts