@fern-api/replay 0.16.2 → 0.17.4

package/dist/index.d.cts

@@ -101,6 +101,17 @@ interface FileResult {
      * if needed. Empty/undefined when no such lines exist.
      */
     droppedContextLines?: string[];
+    /**
+     * INC-866 silent-loss signal. Set on a `new-file-both` result when BASE was
+     * null because the patch's base-generation tree is unreachable (shallow
+     * clone window too small / pruned history) rather than because the file is
+     * genuinely new. In that state an edited-existing-file customization can be
+     * dropped with no conflict and no error. Surfaced as a ReplayReport warning
+     * (`recordUnreachableBaseWarnings`) so callers/CLI learn the clone window
+     * was insufficient instead of losing the edit silently. Undefined/false in
+     * the benign case.
+     */
+    baseTreeUnreachable?: boolean;
 }
 interface ConflictRegion {
     startLine: number;
@@ -885,6 +896,22 @@ declare class ReplayService {
      */
     /** @internal Used by Flow implementations in `src/flows/`. */
     recordDroppedContextLineWarnings(results: ReplayResult[]): void;
+    /**
+     * 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: ReplayResult[]): void;
     /**
      * After applyPatches(), strip conflict markers from conflicting files
      * so only clean content is committed. Keeps the Generated (OURS) side.

package/dist/index.d.ts

@@ -101,6 +101,17 @@ interface FileResult {
      * if needed. Empty/undefined when no such lines exist.
      */
     droppedContextLines?: string[];
+    /**
+     * INC-866 silent-loss signal. Set on a `new-file-both` result when BASE was
+     * null because the patch's base-generation tree is unreachable (shallow
+     * clone window too small / pruned history) rather than because the file is
+     * genuinely new. In that state an edited-existing-file customization can be
+     * dropped with no conflict and no error. Surfaced as a ReplayReport warning
+     * (`recordUnreachableBaseWarnings`) so callers/CLI learn the clone window
+     * was insufficient instead of losing the edit silently. Undefined/false in
+     * the benign case.
+     */
+    baseTreeUnreachable?: boolean;
 }
 interface ConflictRegion {
     startLine: number;
@@ -885,6 +896,22 @@ declare class ReplayService {
      */
     /** @internal Used by Flow implementations in `src/flows/`. */
     recordDroppedContextLineWarnings(results: ReplayResult[]): void;
+    /**
+     * 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: ReplayResult[]): void;
     /**
      * After applyPatches(), strip conflict markers from conflicting files
      * so only clean content is committed. Keeps the Generated (OURS) side.

package/dist/index.js

@@ -908,6 +908,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() {
@@ -919,6 +935,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 exists = await this.git.commitExists(lastGen.commit_sha);
@@ -1673,16 +1694,20 @@ async function resolveInputs(args) {
   const oursPath = join2(outputDir, resolvedPath);
   const ours = await 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;
+          }
         }
       }
     }
@@ -1694,7 +1719,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
   };
 }
 
@@ -1877,7 +1906,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" };
@@ -1925,17 +1958,19 @@ async function runMergeAndRecord(args) {
     const merged2 = threeWayMerge("", ours, plan.theirs);
     await mkdir(dirname2(oursPath), { recursive: true });
     await 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 mkdir(dirname2(oursPath), { recursive: true });
@@ -3151,6 +3186,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") {
@@ -3306,6 +3342,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") {
@@ -4225,6 +4262,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.