@fern-api/replay 0.6.2 → 0.8.0

package/dist/index.cjs

@@ -133,6 +133,9 @@ var init_GitClient = __esm({
           return false;
         }
       }
+      async getCommitBody(commitSha) {
+        return this.exec(["log", "-1", "--format=%B", commitSha]);
+      }
       getRepoPath() {
         return this.repoPath;
       }
@@ -157,6 +160,9 @@ __export(index_exports, {
   forget: () => forget,
   isGenerationCommit: () => isGenerationCommit,
   isReplayCommit: () => isReplayCommit,
+  isRevertCommit: () => isRevertCommit,
+  parseRevertedMessage: () => parseRevertedMessage,
+  parseRevertedSha: () => parseRevertedSha,
   reset: () => reset,
   resolve: () => resolve,
   status: () => status,
@@ -182,6 +188,17 @@ function isGenerationCommit(commit) {
 function isReplayCommit(commit) {
   return commit.message.startsWith("[fern-replay]");
 }
+function isRevertCommit(message) {
+  return message.startsWith('Revert "');
+}
+function parseRevertedSha(fullBody) {
+  const match = fullBody.match(/This reverts commit ([0-9a-f]{40})\./);
+  return match?.[1];
+}
+function parseRevertedMessage(subject) {
+  const match = subject.match(/^Revert "(.+)"$/);
+  return match?.[1];
+}
 
 // src/LockfileManager.ts
 var import_node_fs = require("fs");
@@ -273,6 +290,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;
@@ -324,14 +361,14 @@ var ReplayDetector = class {
     const lock = this.lockManager.read();
     const lastGen = this.getLastGeneration(lock);
     if (!lastGen) {
-      return [];
+      return { patches: [], revertedPatchIds: [] };
     }
     const exists = await this.git.commitExists(lastGen.commit_sha);
     if (!exists) {
       this.warnings.push(
         `Generation commit ${lastGen.commit_sha.slice(0, 7)} not found in git history. Skipping new patch detection. Existing lockfile patches will still be applied.`
       );
-      return [];
+      return { patches: [], revertedPatchIds: [] };
     }
     const isAncestor = await this.git.isAncestor(lastGen.commit_sha, "HEAD");
     if (!isAncestor) {
@@ -345,7 +382,7 @@ var ReplayDetector = class {
       this.sdkOutputDir
     ]);
     if (!log.trim()) {
-      return [];
+      return { patches: [], revertedPatchIds: [] };
     }
     const commits = this.parseGitLog(log);
     const newPatches = [];
@@ -381,7 +418,60 @@ var ReplayDetector = class {
         patch_content: patchContent
       });
     }
-    return newPatches.reverse();
+    newPatches.reverse();
+    const revertedPatchIdSet = /* @__PURE__ */ new Set();
+    const revertIndicesToRemove = /* @__PURE__ */ new Set();
+    for (let i = 0; i < newPatches.length; i++) {
+      const patch = newPatches[i];
+      if (!isRevertCommit(patch.original_message)) continue;
+      let body = "";
+      try {
+        body = await this.git.getCommitBody(patch.original_commit);
+      } catch {
+      }
+      const revertedSha = parseRevertedSha(body);
+      const revertedMessage = parseRevertedMessage(patch.original_message);
+      let matchedExisting = false;
+      if (revertedSha) {
+        const existing = lock.patches.find((p) => p.original_commit === revertedSha);
+        if (existing) {
+          revertedPatchIdSet.add(existing.id);
+          revertIndicesToRemove.add(i);
+          matchedExisting = true;
+        }
+      }
+      if (!matchedExisting && revertedMessage) {
+        const existing = lock.patches.find((p) => p.original_message === revertedMessage);
+        if (existing) {
+          revertedPatchIdSet.add(existing.id);
+          revertIndicesToRemove.add(i);
+          matchedExisting = true;
+        }
+      }
+      if (matchedExisting) continue;
+      let matchedNew = false;
+      if (revertedSha) {
+        const idx = newPatches.findIndex(
+          (p, j) => j !== i && !revertIndicesToRemove.has(j) && p.original_commit === revertedSha
+        );
+        if (idx !== -1) {
+          revertIndicesToRemove.add(i);
+          revertIndicesToRemove.add(idx);
+          matchedNew = true;
+        }
+      }
+      if (!matchedNew && revertedMessage) {
+        const idx = newPatches.findIndex(
+          (p, j) => j !== i && !revertIndicesToRemove.has(j) && p.original_message === revertedMessage
+        );
+        if (idx !== -1) {
+          revertIndicesToRemove.add(i);
+          revertIndicesToRemove.add(idx);
+        }
+      }
+    }
+    const filteredPatches = newPatches.filter((_, i) => !revertIndicesToRemove.has(i));
+    return { patches: filteredPatches, revertedPatchIds: [...revertedPatchIdSet] };
   }
   /**
    * Compute content hash for deduplication.
@@ -392,31 +482,34 @@ var ReplayDetector = class {
     const normalized = patchContent.split("\n").filter((line) => !line.startsWith("From ") && !line.startsWith("index ") && !line.startsWith("Date: ")).join("\n");
     return `sha256:${(0, import_node_crypto.createHash)("sha256").update(normalized).digest("hex")}`;
   }
-  /** Detect patches via tree diff for non-linear history. Returns a composite patch. */
+  /**
+   * Detect patches via tree diff for non-linear history. Returns a composite patch.
+   * Revert reconciliation is skipped here because tree-diff produces a single composite
+   * patch from the aggregate diff — individual revert commits are not distinguishable.
+   */
   async detectPatchesViaTreeDiff(lastGen) {
     const filesOutput = await this.git.exec(["diff", "--name-only", lastGen.commit_sha, "HEAD"]);
     const files = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
-    if (files.length === 0) return [];
+    if (files.length === 0) return { patches: [], revertedPatchIds: [] };
     const diff = await this.git.exec(["diff", lastGen.commit_sha, "HEAD", "--", ...files]);
-    if (!diff.trim()) return [];
+    if (!diff.trim()) return { patches: [], revertedPatchIds: [] };
     const contentHash = this.computeContentHash(diff);
     const lock = this.lockManager.read();
     if (lock.patches.some((p) => p.content_hash === contentHash)) {
-      return [];
+      return { patches: [], revertedPatchIds: [] };
     }
     const headSha = (await this.git.exec(["rev-parse", "HEAD"])).trim();
-    return [
-      {
-        id: `patch-composite-${headSha.slice(0, 8)}`,
-        content_hash: contentHash,
-        original_commit: headSha,
-        original_message: "Customer customizations (composite)",
-        original_author: "composite",
-        base_generation: lastGen.commit_sha,
-        files,
-        patch_content: diff
-      }
-    ];
+    const compositePatch = {
+      id: `patch-composite-${headSha.slice(0, 8)}`,
+      content_hash: contentHash,
+      original_commit: headSha,
+      original_message: "Customer customizations (composite)",
+      original_author: "composite",
+      base_generation: lastGen.commit_sha,
+      files,
+      patch_content: diff
+    };
+    return { patches: [compositePatch], revertedPatchIds: [] };
   }
   parseGitLog(log) {
     return log.trim().split("\n").map((line) => {
@@ -973,12 +1066,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) {
@@ -1018,6 +1111,36 @@ var import_node_fs2 = require("fs");
 var import_node_path3 = require("path");
 var import_minimatch2 = require("minimatch");
 init_GitClient();
+
+// src/conflict-utils.ts
+function 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");
+}
+
+// src/ReplayService.ts
 var ReplayService = class {
   git;
   detector;
@@ -1073,13 +1196,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();
+      const { patches: 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);
         }
@@ -1162,7 +1299,7 @@ var ReplayService = class {
     };
   }
   async handleNoPatchesRegeneration(options) {
-    const newPatches = await this.detector.detectNewPatches();
+    const { patches: newPatches, revertedPatchIds } = await this.detector.detectNewPatches();
     const warnings = [...this.detector.warnings];
     if (options?.dryRun) {
       return {
@@ -1171,11 +1308,18 @@ var ReplayService = class {
         patchesApplied: 0,
         patchesWithConflicts: 0,
         patchesSkipped: 0,
+        patchesReverted: revertedPatchIds.length,
         conflicts: [],
         wouldApply: newPatches,
         warnings: warnings.length > 0 ? warnings : void 0
       };
     }
+    for (const id of revertedPatchIds) {
+      try {
+        this.lockManager.removePatch(id);
+      } catch {
+      }
+    }
     const commitOpts = options ? {
       cliVersion: options.cliVersion ?? "unknown",
       generatorVersions: options.generatorVersions ?? {},
@@ -1187,6 +1331,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,20 +1347,18 @@ 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();
       }
     }
-    return this.buildReport("no-patches", newPatches, results, options, warnings, rebaseCounts);
+    return this.buildReport("no-patches", newPatches, results, options, warnings, rebaseCounts, void 0, revertedPatchIds.length);
   }
   async handleNormalRegeneration(options) {
     if (options?.dryRun) {
       const existingPatches2 = this.lockManager.getPatches();
-      const newPatches2 = await this.detector.detectNewPatches();
+      const { patches: newPatches2, revertedPatchIds: dryRunReverted } = await this.detector.detectNewPatches();
       const warnings2 = [...this.detector.warnings];
       const allPatches2 = [...existingPatches2, ...newPatches2];
       return {
@@ -1219,13 +1367,19 @@ var ReplayService = class {
         patchesApplied: 0,
         patchesWithConflicts: 0,
         patchesSkipped: 0,
+        patchesReverted: dryRunReverted.length,
         conflicts: [],
         wouldApply: allPatches2,
         warnings: warnings2.length > 0 ? warnings2 : void 0
       };
     }
     let existingPatches = this.lockManager.getPatches();
+    const preRebasePatchIds = new Set(existingPatches.map((p) => p.id));
     const preRebaseCounts = await this.preGenerationRebase(existingPatches);
+    const postRebasePatchIds = new Set(this.lockManager.getPatches().map((p) => p.id));
+    const removedByPreRebase = existingPatches.filter(
+      (p) => preRebasePatchIds.has(p.id) && !postRebasePatchIds.has(p.id)
+    );
     existingPatches = this.lockManager.getPatches();
     const seenHashes = /* @__PURE__ */ new Set();
     for (const p of existingPatches) {
@@ -1236,8 +1390,28 @@ var ReplayService = class {
       }
     }
     existingPatches = this.lockManager.getPatches();
-    const newPatches = await this.detector.detectNewPatches();
+    let { patches: newPatches, revertedPatchIds } = await this.detector.detectNewPatches();
     const warnings = [...this.detector.warnings];
+    if (removedByPreRebase.length > 0) {
+      const removedOriginalCommits = new Set(removedByPreRebase.map((p) => p.original_commit));
+      const removedOriginalMessages = new Set(removedByPreRebase.map((p) => p.original_message));
+      newPatches = newPatches.filter((p) => {
+        if (removedOriginalCommits.has(p.original_commit)) return false;
+        if (isRevertCommit(p.original_message)) {
+          const revertedMsg = parseRevertedMessage(p.original_message);
+          if (revertedMsg && removedOriginalMessages.has(revertedMsg)) return false;
+        }
+        return true;
+      });
+    }
+    for (const id of revertedPatchIds) {
+      try {
+        this.lockManager.removePatch(id);
+      } catch {
+      }
+    }
+    const revertedSet = new Set(revertedPatchIds);
+    existingPatches = existingPatches.filter((p) => !revertedSet.has(p.id));
     const allPatches = [...existingPatches, ...newPatches];
     const commitOpts = options ? {
       cliVersion: options.cliVersion ?? "unknown",
@@ -1248,20 +1422,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",
@@ -1270,7 +1456,8 @@ var ReplayService = class {
       options,
       warnings,
       rebaseCounts,
-      preRebaseCounts
+      preRebaseCounts,
+      revertedPatchIds.length
     );
   }
   /**
@@ -1409,6 +1596,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,12 +1650,31 @@ var ReplayService = class {
     }
     return { conflictResolved, conflictAbsorbed, contentRefreshed };
   }
+  /**
+   * 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 = 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 [];
     return (0, import_node_fs2.readFileSync)(fernignorePath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   }
-  buildReport(flow, patches, results, options, warnings, rebaseCounts, preRebaseCounts) {
+  buildReport(flow, patches, results, options, warnings, rebaseCounts, preRebaseCounts, patchesReverted) {
     const conflictResults = results.filter((r) => r.status === "conflict");
     const conflictDetails = conflictResults.map((r) => {
       const conflictFiles = r.fileResults?.filter((f) => f.status === "conflict") ?? [];
@@ -1489,10 +1699,17 @@ var ReplayService = class {
       patchesRepointed: rebaseCounts && rebaseCounts.repointed > 0 ? rebaseCounts.repointed : void 0,
       patchesContentRebased: rebaseCounts && rebaseCounts.contentRebased > 0 ? rebaseCounts.contentRebased : void 0,
       patchesKeptAsUserOwned: rebaseCounts && rebaseCounts.keptAsUserOwned > 0 ? rebaseCounts.keptAsUserOwned : void 0,
+      patchesReverted: patchesReverted && patchesReverted > 0 ? patchesReverted : void 0,
       patchesConflictResolved: preRebaseCounts && preRebaseCounts.conflictResolved + preRebaseCounts.conflictAbsorbed > 0 ? preRebaseCounts.conflictResolved + preRebaseCounts.conflictAbsorbed : void 0,
       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
     };
@@ -1529,7 +1746,7 @@ var FernignoreMigrator = class {
   async analyzeMigration() {
     const patterns = this.readFernignorePatterns();
     const detector = new ReplayDetector(this.git, this.lockManager, this.outputDir);
-    const patches = await detector.detectNewPatches();
+    const { patches } = await detector.detectNewPatches();
     const trackedByBoth = [];
     const fernignoreOnly = [];
     const commitsOnly = [];
@@ -1654,7 +1871,7 @@ var FernignoreMigrator = class {
   async migrate() {
     const analysis = await this.analyzeMigration();
     const detector = new ReplayDetector(this.git, this.lockManager, this.outputDir);
-    const patches = await detector.detectNewPatches();
+    const { patches } = await detector.detectNewPatches();
     const warnings = [];
     let patchesCreated = 0;
     for (const patch of patches) {
@@ -1954,17 +2171,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
@@ -2006,6 +2288,9 @@ function status(outputDir) {
   forget,
   isGenerationCommit,
   isReplayCommit,
+  isRevertCommit,
+  parseRevertedMessage,
+  parseRevertedSha,
   reset,
   resolve,
   status,