@fern-api/replay 0.7.0 → 0.8.1

package/dist/cli.cjs

@@ -5335,6 +5335,9 @@ var init_GitClient = __esm({
           return false;
         }
       }
+      async getCommitBody(commitSha) {
+        return this.exec(["log", "-1", "--format=%B", commitSha]);
+      }
       getRepoPath() {
         return this.repoPath;
       }
@@ -13009,6 +13012,17 @@ function isGenerationCommit(commit) {
 function isReplayCommit(commit) {
   return commit.message.startsWith("[fern-replay]");
 }
+function isRevertCommit(message) {
+  return /^Revert ".+"$/.test(message);
+}
+function parseRevertedSha(fullBody) {
+  const match2 = fullBody.match(/This reverts commit ([0-9a-f]{40})\./);
+  return match2?.[1];
+}
+function parseRevertedMessage(subject) {
+  const match2 = subject.match(/^Revert "(.+)"$/);
+  return match2?.[1];
+}
 
 // src/ReplayDetector.ts
 var INFRASTRUCTURE_FILES = /* @__PURE__ */ new Set([".fernignore"]);
@@ -13026,14 +13040,14 @@ var ReplayDetector = class {
     const lock = this.lockManager.read();
     const lastGen = this.getLastGeneration(lock);
     if (!lastGen) {
-      return [];
+      return { patches: [], revertedPatchIds: [] };
     }
     const exists2 = await this.git.commitExists(lastGen.commit_sha);
     if (!exists2) {
       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) {
@@ -13047,7 +13061,7 @@ var ReplayDetector = class {
       this.sdkOutputDir
     ]);
     if (!log.trim()) {
-      return [];
+      return { patches: [], revertedPatchIds: [] };
     }
     const commits = this.parseGitLog(log);
     const newPatches = [];
@@ -13083,7 +13097,63 @@ 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);
+        }
+      }
+      if (!matchedExisting && !matchedNew) {
+        revertIndicesToRemove.add(i);
+      }
+    }
+    const filteredPatches = newPatches.filter((_, i) => !revertIndicesToRemove.has(i));
+    return { patches: filteredPatches, revertedPatchIds: [...revertedPatchIdSet] };
   }
   /**
    * Compute content hash for deduplication.
@@ -13094,31 +13164,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) => {
@@ -15266,6 +15339,34 @@ CLI Version: ${options.cliVersion}`;
   }
 };
 
+// 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;
@@ -15334,7 +15435,7 @@ var ReplayService = class {
     }
     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();
@@ -15425,7 +15526,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 {
@@ -15434,11 +15535,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 ?? {},
@@ -15472,12 +15580,12 @@ var ReplayService = class {
         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 {
@@ -15486,13 +15594,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) {
@@ -15503,8 +15617,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",
@@ -15549,7 +15683,8 @@ var ReplayService = class {
       options,
       warnings,
       rebaseCounts,
-      preRebaseCounts
+      preRebaseCounts,
+      revertedPatchIds.length
     );
   }
   /**
@@ -15742,36 +15877,6 @@ 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.
@@ -15784,7 +15889,7 @@ var ReplayService = class {
         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);
+          const stripped = stripConflictMarkers(content);
           (0, import_node_fs2.writeFileSync)(filePath, stripped);
         } catch {
         }
@@ -15796,7 +15901,7 @@ var ReplayService = class {
     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") ?? [];
@@ -15821,6 +15926,7 @@ 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") ?? []),
@@ -15866,7 +15972,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 = [];
@@ -15991,7 +16097,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) {
@@ -16544,11 +16650,14 @@ async function runDetect(dir) {
   lockManager.read();
   const git = new GitClient(dir);
   const detector = new ReplayDetector(git, lockManager, dir);
-  const patches = await detector.detectNewPatches();
+  const { patches, revertedPatchIds } = await detector.detectNewPatches();
   if (detector.warnings.length > 0) {
     for (const w of detector.warnings) console.log(`Warning: ${w}`);
     console.log();
   }
+  if (revertedPatchIds.length > 0) {
+    console.log(`Reverted patches: ${revertedPatchIds.length}`);
+  }
   console.log(`Detected ${patches.length} new patch(es) since last generation:
 `);
   if (patches.length === 0) {
@@ -16590,6 +16699,9 @@ function printReport(report) {
   if (report.patchesKeptAsUserOwned) {
     console.log(`Patches kept (user-owned files): ${report.patchesKeptAsUserOwned}`);
   }
+  if (report.patchesReverted) {
+    console.log(`Patches reverted by user: ${report.patchesReverted}`);
+  }
   if (report.patchesPartiallyApplied) {
     console.log(`Patches partially applied: ${report.patchesPartiallyApplied}`);
   }