@fern-api/replay 0.8.0 → 0.9.0

package/dist/index.js

@@ -142,7 +142,7 @@ function isReplayCommit(commit) {
   return commit.message.startsWith("[fern-replay]");
 }
 function isRevertCommit(message) {
-  return message.startsWith('Revert "');
+  return /^Revert ".+"$/.test(message);
 }
 function parseRevertedSha(fullBody) {
   const match = fullBody.match(/This reverts commit ([0-9a-f]{40})\./);
@@ -243,6 +243,15 @@ var LockfileManager = class {
     this.ensureLoaded();
     this.lock.patches = [];
   }
+  addForgottenHash(hash) {
+    this.ensureLoaded();
+    if (!this.lock.forgotten_hashes) {
+      this.lock.forgotten_hashes = [];
+    }
+    if (!this.lock.forgotten_hashes.includes(hash)) {
+      this.lock.forgotten_hashes.push(hash);
+    }
+  }
   getUnresolvedPatches() {
     this.ensureLoaded();
     return this.lock.patches.filter((p) => p.status === "unresolved");
@@ -339,6 +348,7 @@ var ReplayDetector = class {
     }
     const commits = this.parseGitLog(log);
     const newPatches = [];
+    const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
     for (const commit of commits) {
       if (isGenerationCommit(commit)) {
         continue;
@@ -352,7 +362,7 @@ var ReplayDetector = class {
       }
       const patchContent = await this.git.formatPatch(commit.sha);
       const contentHash = this.computeContentHash(patchContent);
-      if (lock.patches.find((p) => p.content_hash === contentHash)) {
+      if (lock.patches.find((p) => p.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
         continue;
       }
       const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
@@ -422,6 +432,9 @@ var ReplayDetector = class {
           revertIndicesToRemove.add(idx);
         }
       }
+      if (!matchedExisting && !matchedNew) {
+        revertIndicesToRemove.add(i);
+      }
     }
     const filteredPatches = newPatches.filter((_, i) => !revertIndicesToRemove.has(i));
     return { patches: filteredPatches, revertedPatchIds: [...revertedPatchIdSet] };
@@ -448,7 +461,7 @@ var ReplayDetector = class {
     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)) {
+    if (lock.patches.some((p) => p.content_hash === contentHash) || (lock.forgotten_hashes ?? []).includes(contentHash)) {
       return { patches: [], revertedPatchIds: [] };
     }
     const headSha = (await this.git.exec(["rev-parse", "HEAD"])).trim();
@@ -518,6 +531,36 @@ import { mkdir, mkdtemp, readFile, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { dirname as dirname2, extname, join as join2 } from "path";
 import { minimatch } from "minimatch";
+
+// 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/ReplayApplicator.ts
 var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".png",
   ".jpg",
@@ -589,7 +632,8 @@ var ReplayApplicator = class {
   async applyPatches(patches) {
     this.resetAccumulator();
     const results = [];
-    for (const patch of patches) {
+    for (let i = 0; i < patches.length; i++) {
+      const patch = patches[i];
       if (this.isExcluded(patch)) {
         results.push({
           patch,
@@ -600,6 +644,33 @@ var ReplayApplicator = class {
       }
       const result = await this.applyPatchWithFallback(patch);
       results.push(result);
+      if (result.status === "conflict" && result.fileResults) {
+        const laterFiles = /* @__PURE__ */ new Set();
+        for (let j = i + 1; j < patches.length; j++) {
+          for (const f of patches[j].files) {
+            laterFiles.add(f);
+          }
+        }
+        const resolvedToOriginal = /* @__PURE__ */ new Map();
+        if (result.resolvedFiles) {
+          for (const [orig, resolved] of Object.entries(result.resolvedFiles)) {
+            resolvedToOriginal.set(resolved, orig);
+          }
+        }
+        for (const fileResult of result.fileResults) {
+          if (fileResult.status !== "conflict") continue;
+          const originalPath = resolvedToOriginal.get(fileResult.file) ?? fileResult.file;
+          if (laterFiles.has(fileResult.file) || laterFiles.has(originalPath)) {
+            const filePath = join2(this.outputDir, fileResult.file);
+            try {
+              const content = await readFile(filePath, "utf-8");
+              const stripped = stripConflictMarkers(content);
+              await writeFile(filePath, stripped);
+            } catch {
+            }
+          }
+        }
+      }
     }
     return results;
   }
@@ -618,7 +689,7 @@ var ReplayApplicator = class {
         const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
         const base = await this.git.showFile(baseGen.tree_hash, filePath);
         const theirs = await this.applyPatchToContent(base, patch.patch_content, filePath, tempGit, tempDir);
-        if (theirs && base) {
+        if (theirs) {
           this.fileTheirsAccumulator.set(resolvedPath, {
             content: theirs,
             baseGeneration: patch.base_generation
@@ -750,7 +821,7 @@ var ReplayApplicator = class {
       );
       let useAccumulatorAsMergeBase = false;
       const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
-      if (!theirs && base && accumulatorEntry) {
+      if (!theirs && accumulatorEntry) {
         theirs = await this.applyPatchToContent(
           accumulatorEntry.content,
           patch.patch_content,
@@ -809,7 +880,7 @@ var ReplayApplicator = class {
           reason: "missing-content"
         };
       }
-      if (!base || !ours) {
+      if (!base && !useAccumulatorAsMergeBase || !ours) {
         return {
           file: resolvedPath,
           status: "skipped",
@@ -817,11 +888,18 @@ var ReplayApplicator = class {
         };
       }
       const mergeBase = useAccumulatorAsMergeBase && accumulatorEntry ? accumulatorEntry.content : base;
+      if (mergeBase == null) {
+        return {
+          file: resolvedPath,
+          status: "skipped",
+          reason: "missing-content"
+        };
+      }
       const merged = threeWayMerge(mergeBase, ours, effective_theirs);
       const outDir = dirname2(oursPath);
       await mkdir(outDir, { recursive: true });
       await writeFile(oursPath, merged.content);
-      if (effective_theirs && base) {
+      if (effective_theirs) {
         this.fileTheirsAccumulator.set(resolvedPath, {
           content: effective_theirs,
           baseGeneration: patch.base_generation
@@ -1064,36 +1142,6 @@ import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync
 import { join as join3 } from "path";
 import { minimatch as minimatch2 } from "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;
@@ -2061,30 +2109,145 @@ function computeContentHash(patchContent) {
 
 // src/commands/forget.ts
 import { minimatch as minimatch4 } from "minimatch";
-function forget(outputDir, filePattern, options) {
+function parseDiffStat(patchContent) {
+  let additions = 0;
+  let deletions = 0;
+  let inDiffHunk = false;
+  for (const line of patchContent.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      inDiffHunk = true;
+      continue;
+    }
+    if (!inDiffHunk) continue;
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      additions++;
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      deletions++;
+    }
+  }
+  return { additions, deletions };
+}
+function toMatchedPatch(patch) {
+  return {
+    id: patch.id,
+    message: patch.original_message,
+    files: patch.files,
+    diffstat: parseDiffStat(patch.patch_content),
+    ...patch.status ? { status: patch.status } : {}
+  };
+}
+function matchesPatch(patch, pattern) {
+  const fileMatch = patch.files.some(
+    (file) => file === pattern || minimatch4(file, pattern)
+  );
+  if (fileMatch) return true;
+  return patch.original_message.toLowerCase().includes(pattern.toLowerCase());
+}
+function buildWarnings(patches) {
+  const warnings = [];
+  for (const patch of patches) {
+    if (patch.status === "resolving") {
+      warnings.push(
+        `patch ${patch.id} has conflict markers in these files: ${patch.files.join(", ")}. Run \`git checkout -- <files>\` to restore the generated versions.`
+      );
+    } else if (patch.status === "unresolved") {
+      warnings.push(
+        `patch ${patch.id} had unresolved conflicts (files: ${patch.files.join(", ")}).`
+      );
+    }
+  }
+  return warnings;
+}
+var EMPTY_RESULT = {
+  initialized: false,
+  removed: [],
+  remaining: 0,
+  notFound: false,
+  alreadyForgotten: [],
+  totalPatches: 0,
+  warnings: []
+};
+function forget(outputDir, options) {
   const lockManager = new LockfileManager(outputDir);
   if (!lockManager.exists()) {
-    return { removed: [], notFound: true };
+    return { ...EMPTY_RESULT };
   }
   const lock = lockManager.read();
-  const matchingPatches = lock.patches.filter(
-    (patch) => patch.files.some((file) => file === filePattern || minimatch4(file, filePattern))
-  );
-  if (matchingPatches.length === 0) {
-    return { removed: [], notFound: true };
+  const totalPatches = lock.patches.length;
+  if (options?.all) {
+    const removed = lock.patches.map(toMatchedPatch);
+    const warnings = buildWarnings(lock.patches);
+    if (!options.dryRun) {
+      for (const patch of lock.patches) {
+        lockManager.addForgottenHash(patch.content_hash);
+      }
+      lockManager.clearPatches();
+      lockManager.save();
+    }
+    return {
+      initialized: true,
+      removed,
+      remaining: 0,
+      notFound: false,
+      alreadyForgotten: [],
+      totalPatches,
+      warnings
+    };
   }
-  const removed = matchingPatches.map((p) => ({
-    id: p.id,
-    message: p.original_message,
-    files: p.files
-  }));
-  if (!options?.dryRun) {
-    for (const patch of matchingPatches) {
-      lockManager.removePatch(patch.id);
+  if (options?.patchIds && options.patchIds.length > 0) {
+    const removed = [];
+    const alreadyForgotten = [];
+    const patchesToRemove = [];
+    for (const id of options.patchIds) {
+      const patch = lock.patches.find((p) => p.id === id);
+      if (patch) {
+        removed.push(toMatchedPatch(patch));
+        patchesToRemove.push(patch);
+      } else {
+        alreadyForgotten.push(id);
+      }
     }
-    lockManager.save();
+    const warnings = buildWarnings(patchesToRemove);
+    if (!options.dryRun) {
+      for (const patch of patchesToRemove) {
+        lockManager.addForgottenHash(patch.content_hash);
+        lockManager.removePatch(patch.id);
+      }
+      lockManager.save();
+    }
+    return {
+      initialized: true,
+      removed,
+      remaining: totalPatches - removed.length,
+      notFound: removed.length === 0 && alreadyForgotten.length > 0,
+      alreadyForgotten,
+      totalPatches,
+      warnings
+    };
+  }
+  if (options?.pattern) {
+    const matched = lock.patches.filter((p) => matchesPatch(p, options.pattern)).map(toMatchedPatch);
+    return {
+      initialized: true,
+      removed: [],
+      remaining: totalPatches,
+      notFound: matched.length === 0,
+      alreadyForgotten: [],
+      totalPatches,
+      warnings: [],
+      matched
+    };
   }
-  return { removed, notFound: false };
+  return {
+    initialized: true,
+    removed: [],
+    remaining: totalPatches,
+    notFound: totalPatches === 0,
+    alreadyForgotten: [],
+    totalPatches,
+    warnings: [],
+    matched: lock.patches.map(toMatchedPatch)
+  };
 }
 
 // src/commands/reset.ts
@@ -2206,24 +2369,49 @@ async function getChangedFiles(git, currentGen, files) {
 function status(outputDir) {
   const lockManager = new LockfileManager(outputDir);
   if (!lockManager.exists()) {
-    return { initialized: false, patches: [], lastGeneration: void 0 };
+    return {
+      initialized: false,
+      generationCount: 0,
+      lastGeneration: void 0,
+      patches: [],
+      unresolvedCount: 0,
+      excludePatterns: []
+    };
   }
   const lock = lockManager.read();
   const patches = lock.patches.map((patch) => ({
-    sha: patch.original_commit.slice(0, 7),
-    author: patch.original_author.split("<")[0]?.trim() ?? "unknown",
+    id: patch.id,
+    type: patch.patch_content.includes("new file mode") ? "added" : "modified",
     message: patch.original_message,
-    files: patch.files
+    author: patch.original_author.split("<")[0]?.trim() || "unknown",
+    sha: patch.original_commit.slice(0, 7),
+    files: patch.files,
+    fileCount: patch.files.length,
+    ...patch.status ? { status: patch.status } : {}
   }));
+  const unresolvedCount = lock.patches.filter(
+    (p) => p.status === "unresolved" || p.status === "resolving"
+  ).length;
   let lastGeneration;
   const lastGen = lock.generations.find((g) => g.commit_sha === lock.current_generation);
   if (lastGen) {
     lastGeneration = {
-      sha: lastGen.commit_sha,
-      timestamp: lastGen.timestamp
+      sha: lastGen.commit_sha.slice(0, 7),
+      timestamp: lastGen.timestamp,
+      cliVersion: lastGen.cli_version,
+      generatorVersions: lastGen.generator_versions
     };
   }
-  return { initialized: true, patches, lastGeneration };
+  const config = lockManager.getCustomizationsConfig();
+  const excludePatterns = config.exclude ?? [];
+  return {
+    initialized: true,
+    generationCount: lock.generations.length,
+    lastGeneration,
+    patches,
+    unresolvedCount,
+    excludePatterns
+  };
 }
 export {
   FERN_BOT_EMAIL,