@fern-api/replay 0.16.1 → 0.17.4

package/dist/cli.cjs

@@ -14979,6 +14979,15 @@ function parseRevertedMessage(subject) {
 
 // src/ReplayDetector.ts
 var INFRASTRUCTURE_FILES = /* @__PURE__ */ new Set([".fernignore"]);
+function matchesFernignorePattern(filePath, patterns) {
+  if (patterns.length === 0) return false;
+  return patterns.some((p) => {
+    if (filePath === p) return true;
+    if (minimatch(filePath, p)) return true;
+    if (!p.includes("*") && !p.includes("?") && filePath.startsWith(p + "/")) return true;
+    return false;
+  });
+}
 function parsePatchFileHeaders(patchContent) {
   const results = [];
   let currentPath = null;
@@ -15019,21 +15028,25 @@ async function capturePatchSnapshot(git, files, treeish) {
   }
   return snapshot;
 }
-function filterInfrastructureAndSensitiveFiles(rawFilesOutput) {
+function filterInfrastructureAndSensitiveFiles(rawFilesOutput, fernignorePatterns) {
   const allFiles = rawFilesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
   const sensitiveFiles = allFiles.filter((f) => isSensitiveFile(f));
-  const files = allFiles.filter((f) => !isSensitiveFile(f));
-  return { files, sensitiveFiles };
+  const nonSensitive = allFiles.filter((f) => !isSensitiveFile(f));
+  const fernignoredFiles = nonSensitive.filter((f) => matchesFernignorePattern(f, fernignorePatterns));
+  const files = nonSensitive.filter((f) => !matchesFernignorePattern(f, fernignorePatterns));
+  return { files, sensitiveFiles, fernignoredFiles };
 }
 var ReplayDetector = class {
   git;
   lockManager;
   sdkOutputDir;
+  fernignorePatterns;
   warnings = [];
-  constructor(git, lockManager, sdkOutputDir) {
+  constructor(git, lockManager, sdkOutputDir, fernignorePatterns = []) {
     this.git = git;
     this.lockManager = lockManager;
     this.sdkOutputDir = sdkOutputDir;
+    this.fernignorePatterns = fernignorePatterns;
   }
   /**
    * Derive the previous-generation SHA from git history instead of trusting
@@ -15068,6 +15081,22 @@ var ReplayDetector = class {
         return commit.sha;
       }
     }
+    let fullLog;
+    try {
+      fullLog = await this.git.exec([
+        "log",
+        "--no-merges",
+        "--format=%H%x00%an%x00%ae%x00%s",
+        "HEAD"
+      ]);
+    } catch {
+      return null;
+    }
+    for (const commit of this.parseGitLog(fullLog)) {
+      if (isGenerationBoundary(commit)) {
+        return commit.sha;
+      }
+    }
     return null;
   }
   async detectNewPatches() {
@@ -15079,6 +15108,11 @@ var ReplayDetector = class {
     }
     const lastGen = this.getLastGeneration(lock);
     if (!lastGen) {
+      if (lock.current_generation) {
+        this.warnings.push(
+          `No generation boundary found in git history and the lockfile's recorded generation (${lock.current_generation.slice(0, 7)}) matches no entry in its generation records. Customer customizations may differ from the last known generation and could be lost on the next regeneration. Run \`fern-replay bootstrap --force\` to re-initialize tracking.`
+        );
+      }
       return { patches: [], revertedPatchIds: [] };
     }
     const exists2 = await this.git.commitExists(lastGen.commit_sha);
@@ -15140,22 +15174,30 @@ var ReplayDetector = class {
         continue;
       }
       const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
-      const { files, sensitiveFiles } = filterInfrastructureAndSensitiveFiles(filesOutput);
+      const { files, sensitiveFiles, fernignoredFiles } = filterInfrastructureAndSensitiveFiles(
+        filesOutput,
+        this.fernignorePatterns
+      );
       if (sensitiveFiles.length > 0) {
         this.warnings.push(
           `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveFiles.join(", ")}. These files will not be tracked by replay.`
         );
-        if (files.length > 0) {
-          const parentSha = parents[0];
-          if (parentSha) {
-            try {
-              patchContent = await this.git.exec(["diff", parentSha, commit.sha, "--", ...files]);
-            } catch {
-              continue;
-            }
-            if (!patchContent.trim()) continue;
-            contentHash = this.computeContentHash(patchContent);
+      }
+      if (fernignoredFiles.length > 0) {
+        this.warnings.push(
+          `.fernignore-protected file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${fernignoredFiles.join(", ")}. These files are managed by .fernignore, not Replay.`
+        );
+      }
+      if ((sensitiveFiles.length > 0 || fernignoredFiles.length > 0) && files.length > 0) {
+        const parentSha = parents[0];
+        if (parentSha) {
+          try {
+            patchContent = await this.git.exec(["diff", parentSha, commit.sha, "--", ...files]);
+          } catch {
+            continue;
           }
+          if (!patchContent.trim()) continue;
+          contentHash = this.computeContentHash(patchContent);
         }
       }
       if (files.length === 0) {
@@ -15354,12 +15396,20 @@ var ReplayDetector = class {
       resolvedBaseGeneration = fallback;
     }
     const filesOutput = await this.git.exec(["diff", "--name-only", diffBase, "HEAD"]);
-    const { files, sensitiveFiles } = filterInfrastructureAndSensitiveFiles(filesOutput);
+    const { files, sensitiveFiles, fernignoredFiles } = filterInfrastructureAndSensitiveFiles(
+      filesOutput,
+      this.fernignorePatterns
+    );
     if (sensitiveFiles.length > 0) {
       this.warnings.push(
         `Sensitive file(s) excluded from composite patch: ${sensitiveFiles.join(", ")}. These files will not be tracked by replay.`
       );
     }
+    if (fernignoredFiles.length > 0) {
+      this.warnings.push(
+        `.fernignore-protected file(s) excluded from composite patch: ${fernignoredFiles.join(", ")}. These files are managed by .fernignore, not Replay.`
+      );
+    }
     if (files.length === 0) return { patches: [], revertedPatchIds: [] };
     const diff = await this.git.exec(["diff", diffBase, "HEAD", "--", ...files]);
     if (!diff.trim()) return { patches: [], revertedPatchIds: [] };
@@ -15442,23 +15492,31 @@ var ReplayDetector = class {
         continue;
       }
       const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
-      const { files, sensitiveFiles } = filterInfrastructureAndSensitiveFiles(filesOutput);
+      const { files, sensitiveFiles, fernignoredFiles } = filterInfrastructureAndSensitiveFiles(
+        filesOutput,
+        this.fernignorePatterns
+      );
       if (sensitiveFiles.length > 0) {
         this.warnings.push(
           `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveFiles.join(", ")}. These files will not be tracked by replay.`
         );
-        if (files.length > 0) {
-          if (parents.length === 0) {
-            continue;
-          }
-          try {
-            patchContent = await this.git.exec(["diff", parents[0], commit.sha, "--", ...files]);
-          } catch {
-            continue;
-          }
-          if (!patchContent.trim()) continue;
-          contentHash = this.computeContentHash(patchContent);
+      }
+      if (fernignoredFiles.length > 0) {
+        this.warnings.push(
+          `.fernignore-protected file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${fernignoredFiles.join(", ")}. These files are managed by .fernignore, not Replay.`
+        );
+      }
+      if ((sensitiveFiles.length > 0 || fernignoredFiles.length > 0) && files.length > 0) {
+        if (parents.length === 0) {
+          continue;
+        }
+        try {
+          patchContent = await this.git.exec(["diff", parents[0], commit.sha, "--", ...files]);
+        } catch {
+          continue;
         }
+        if (!patchContent.trim()) continue;
+        contentHash = this.computeContentHash(patchContent);
       }
       if (files.length === 0) {
         continue;
@@ -15675,16 +15733,20 @@ async function resolveInputs(args) {
   const oursPath = (0, import_node_path4.join)(outputDir, resolvedPath);
   const ours = await (0, import_promises.readFile)(oursPath, "utf-8").catch(() => null);
   let ghostTheirs = null;
-  if (!base && ours && !renameSourcePath) {
+  let baseTreeUnreachable = false;
+  if (!base && !renameSourcePath) {
     const treeReachable = await isTreeReachable(baseGen.tree_hash);
     if (!treeReachable) {
-      const fileDiff = extractFileDiff2(patch.patch_content, filePath);
-      if (fileDiff) {
-        const { reconstructFromGhostPatch: reconstructFromGhostPatch2 } = await Promise.resolve().then(() => (init_HybridReconstruction(), HybridReconstruction_exports));
-        const result = reconstructFromGhostPatch2(fileDiff, ours);
-        if (result) {
-          base = result.base;
-          ghostTheirs = result.theirs;
+      baseTreeUnreachable = true;
+      if (ours) {
+        const fileDiff = extractFileDiff2(patch.patch_content, filePath);
+        if (fileDiff) {
+          const { reconstructFromGhostPatch: reconstructFromGhostPatch2 } = await Promise.resolve().then(() => (init_HybridReconstruction(), HybridReconstruction_exports));
+          const result = reconstructFromGhostPatch2(fileDiff, ours);
+          if (result) {
+            base = result.base;
+            ghostTheirs = result.theirs;
+          }
         }
       }
     }
@@ -15696,7 +15758,11 @@ async function resolveInputs(args) {
     ours,
     oursPath,
     renameSourcePath,
-    ghostTheirs
+    ghostTheirs,
+    // Only meaningful when ghost reconstruction did NOT recover a base; if it
+    // did, `base` is non-null and the merge proceeds normally. We still set
+    // the flag truthfully (the tree IS unreachable) so Phase 3 can decide.
+    baseTreeUnreachable
   };
 }
 
@@ -16262,7 +16328,11 @@ async function buildMergePlan(args) {
     return { kind: "new-file-only-user", theirs: effective_theirs };
   }
   if (base == null && ours != null && effective_theirs != null && !useAccumulatorAsMergeBase) {
-    return { kind: "new-file-both", theirs: effective_theirs };
+    return {
+      kind: "new-file-both",
+      theirs: effective_theirs,
+      ...inputs.baseTreeUnreachable ? { baseTreeUnreachable: true } : {}
+    };
   }
   if (effective_theirs == null) {
     return { kind: "skipped", reason: "missing-content" };
@@ -16310,17 +16380,19 @@ async function runMergeAndRecord(args) {
     const merged2 = threeWayMerge("", ours, plan.theirs);
     await (0, import_promises2.mkdir)((0, import_node_path5.dirname)(oursPath), { recursive: true });
     await (0, import_promises2.writeFile)(oursPath, merged2.content);
+    const unreachableFlag = plan.baseTreeUnreachable ? { baseTreeUnreachable: true } : {};
     if (merged2.hasConflicts) {
       return {
         file: resolvedPath,
         status: "conflict",
         conflicts: merged2.conflicts,
         conflictReason: "new-file-both",
-        conflictMetadata: metadata
+        conflictMetadata: metadata,
+        ...unreachableFlag
       };
     }
     accumulator.recordMerge(resolvedPath, merged2.content, patch.base_generation);
-    return { file: resolvedPath, status: "merged" };
+    return { file: resolvedPath, status: "merged", ...unreachableFlag };
   }
   const merged = threeWayMerge(plan.mergeBase, ours, plan.theirs);
   await (0, import_promises2.mkdir)((0, import_node_path5.dirname)(oursPath), { recursive: true });
@@ -17528,6 +17600,7 @@ var NoPatchesFlow = class {
       results = await this.service.applicator.applyPatches(newPatches);
       this.service._lastApplyResults = results;
       this.service.recordDroppedContextLineWarnings(results);
+      this.service.recordUnreachableBaseWarnings(results);
       this.service.revertConflictingFiles(results);
       for (const result of results) {
         if (result.status === "conflict") {
@@ -17683,6 +17756,7 @@ var NormalRegenerationFlow = class {
     const results = await this.service.applicator.applyPatches(allPatches);
     this.service._lastApplyResults = results;
     this.service.recordDroppedContextLineWarnings(results);
+    this.service.recordUnreachableBaseWarnings(results);
     this.service.revertConflictingFiles(results);
     for (const result of results) {
       if (result.status === "conflict") {
@@ -17785,7 +17859,8 @@ var ReplayService = class {
     this.git = git;
     this.outputDir = outputDir;
     this.lockManager = new LockfileManager(outputDir);
-    this.detector = new ReplayDetector(git, this.lockManager, outputDir);
+    const fernignorePatterns = this.readFernignorePatterns();
+    this.detector = new ReplayDetector(git, this.lockManager, outputDir, fernignorePatterns);
     this.applicator = new ReplayApplicator(git, this.lockManager, outputDir);
     this.committer = new ReplayCommitter(git, outputDir);
     this.fileOwnership = new FileOwnership(git);
@@ -17805,8 +17880,60 @@ var ReplayService = class {
   async prepareReplay(options) {
     this.warnings = [];
     this.detector.warnings.length = 0;
+    this.cleanseLegacyFernignoreEntries();
     return this.selectFlow(options).prepare(options);
   }
+  /**
+   * ADR 0002 migration step. Strips `.fernignore`-matched entries from
+   * `patch.files`, `patch.theirs_snapshot` keys, and `diff --git` sections
+   * in `patch.patch_content` for every patch in the lockfile. Patches that
+   * end up with no surviving files are removed entirely.
+   *
+   * Idempotent: a second run is a no-op because the first run already
+   * matches the contract. Per-patch try/catch ensures one bad patch does
+   * not block the rest. Each affected patch emits a warning naming the
+   * stripped paths. `patch_content` is left untouched if no parseable
+   * `diff --git` headers are found (fail-safe for exotic legacy formats).
+   */
+  cleanseLegacyFernignoreEntries() {
+    const patterns = this.readFernignorePatterns();
+    if (patterns.length === 0) return;
+    if (!this.lockManager.exists()) return;
+    this.lockManager.read();
+    let lockfileMutated = false;
+    const patches = this.lockManager.getPatches();
+    for (const patch of patches) {
+      try {
+        const result = computeLegacyFernignoreCleanse(
+          patch,
+          patterns,
+          (content) => this.detector.computeContentHash(content)
+        );
+        if (result.unchanged) continue;
+        if (result.remove) {
+          this.lockManager.removePatch(patch.id);
+          this.warnings.push(
+            `Cleansed legacy patch ${patch.id}: all referenced files match .fernignore \u2014 patch removed. Customer's on-disk content for those files is preserved by .fernignore. (ADR 0002: .fernignore-protected files are not tracked by Replay.)`
+          );
+        } else {
+          this.lockManager.updatePatch(patch.id, {
+            files: result.files,
+            patch_content: result.patch_content,
+            content_hash: result.content_hash,
+            ...result.theirs_snapshot !== void 0 ? { theirs_snapshot: result.theirs_snapshot } : {}
+          });
+          this.warnings.push(
+            `Cleansed legacy patch ${patch.id}: stripped .fernignore-matched entries (${result.strippedPaths.join(", ")}). Customer's on-disk content for those files is preserved by .fernignore. (ADR 0002.)`
+          );
+        }
+        lockfileMutated = true;
+      } catch {
+      }
+    }
+    if (lockfileMutated) {
+      this.lockManager.save();
+    }
+  }
   /**
    * Phase 2 of the two-phase replay flow. Applies patches, rebases them against
    * the generation, saves the lockfile, and commits `[fern-replay]` (or stages
@@ -18549,6 +18676,37 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
       }
     }
   }
+  /**
+   * After applyPatches(), surface a warning for each (patch × file) where a
+   * customization's BASE could not be read because the patch's
+   * base-generation tree is unreachable in this clone (shallow-clone window
+   * too small / pruned history). In that state the merge pipeline falls
+   * through to `new-file-both` and the customer's edit can be dropped with NO
+   * conflict and NO error — the INC-866 silent-loss class. This converts that
+   * silence into an explicit, actionable warning naming the file and the
+   * likely cause (insufficient clone window).
+   *
+   * Mirrors `recordDroppedContextLineWarnings`'s "surface, never silently
+   * drop" contract. De-duplicated per file path so a single insufficient
+   * window doesn't spam one warning per touched file repeatedly.
+   */
+  /** @internal Used by Flow implementations in `src/flows/`. */
+  recordUnreachableBaseWarnings(results) {
+    const warned = /* @__PURE__ */ new Set();
+    for (const result of results) {
+      if (!result.fileResults) continue;
+      for (const fr of result.fileResults) {
+        if (!fr.baseTreeUnreachable) continue;
+        if (warned.has(fr.file)) continue;
+        warned.add(fr.file);
+        const base = fr.conflictMetadata?.baseGeneration;
+        const baseRef = base ? ` (base generation ${base.slice(0, 7)})` : "";
+        this.warnings.push(
+          `${fr.file}: could not read the prior generation's version of this file${baseRef} because that generation's tree is outside the clone window (insufficient shallow-clone depth or pruned history). The customization was treated as a new file, which can drop your edits silently. Re-run with the prior generation in the clone window \u2014 e.g. \`git fetch --shallow-since=<date just before the prior [fern-generated] commit>\` or \`git fetch --unshallow\` \u2014 then re-run replay.`
+        );
+      }
+    }
+  }
   /**
    * After applyPatches(), strip conflict markers from conflicting files
    * so only clean content is committed. Keeps the Generated (OURS) side.
@@ -18667,6 +18825,93 @@ function computeCommitBuckets(results, absorbedPatchIds, patchesPassedToCommit)
   }
   return { applied, unresolved, absorbed };
 }
+function computeLegacyFernignoreCleanse(patch, fernignorePatterns, computeContentHash2) {
+  const matchesFernignore = (filePath) => fernignorePatterns.some((p) => {
+    if (filePath === p) return true;
+    if (minimatch(filePath, p)) return true;
+    if (!p.includes("*") && !p.includes("?") && filePath.startsWith(p + "/")) return true;
+    return false;
+  });
+  const strippedFromFiles = patch.files.filter(matchesFernignore);
+  const survivingFiles = patch.files.filter((f) => !matchesFernignore(f));
+  let survivingSnapshot = void 0;
+  let snapshotChanged = false;
+  if (patch.theirs_snapshot) {
+    survivingSnapshot = {};
+    for (const [key, value] of Object.entries(patch.theirs_snapshot)) {
+      if (matchesFernignore(key)) {
+        snapshotChanged = true;
+      } else {
+        survivingSnapshot[key] = value;
+      }
+    }
+  }
+  const { stripped: patchContentStripped, content: newPatchContent, strippedSectionPaths } = stripFernignoreDiffSections(patch.patch_content, matchesFernignore);
+  const unchanged = strippedFromFiles.length === 0 && !snapshotChanged && !patchContentStripped;
+  if (unchanged) {
+    return {
+      unchanged: true,
+      remove: false,
+      files: patch.files,
+      patch_content: patch.patch_content,
+      content_hash: patch.content_hash,
+      theirs_snapshot: patch.theirs_snapshot,
+      strippedPaths: []
+    };
+  }
+  const strippedPaths = Array.from(/* @__PURE__ */ new Set([...strippedFromFiles, ...strippedSectionPaths]));
+  if (survivingFiles.length === 0 || newPatchContent.trim() === "") {
+    return {
+      unchanged: false,
+      remove: true,
+      files: [],
+      patch_content: "",
+      content_hash: "",
+      strippedPaths
+    };
+  }
+  const newContentHash = patchContentStripped ? computeContentHash2(newPatchContent) : patch.content_hash;
+  return {
+    unchanged: false,
+    remove: false,
+    files: survivingFiles,
+    patch_content: newPatchContent,
+    content_hash: newContentHash,
+    ...survivingSnapshot !== void 0 ? { theirs_snapshot: survivingSnapshot } : {},
+    strippedPaths
+  };
+}
+function stripFernignoreDiffSections(patchContent, matchesFernignore) {
+  const lines = patchContent.split("\n");
+  const sectionStarts = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("diff --git ")) {
+      const match2 = line.match(/^diff --git a\/(.+?) b\/(.+?)$/);
+      const path2 = match2 ? match2[2] : null;
+      sectionStarts.push({ idx: i, path: path2 });
+    }
+  }
+  if (sectionStarts.length === 0) {
+    return { stripped: false, content: patchContent, strippedSectionPaths: [] };
+  }
+  const preamble = lines.slice(0, sectionStarts[0].idx);
+  const newLines = [...preamble];
+  const strippedSectionPaths = [];
+  let stripped = false;
+  for (let i = 0; i < sectionStarts.length; i++) {
+    const section = sectionStarts[i];
+    const next = sectionStarts[i + 1];
+    const endIdx = next ? next.idx : lines.length;
+    if (section.path !== null && matchesFernignore(section.path)) {
+      stripped = true;
+      strippedSectionPaths.push(section.path);
+      continue;
+    }
+    newLines.push(...lines.slice(section.idx, endIdx));
+  }
+  return { stripped, content: newLines.join("\n"), strippedSectionPaths };
+}
 
 // src/FernignoreMigrator.ts
 var import_node_crypto2 = require("crypto");