@fern-api/generator-cli 0.8.1 → 0.9.1

package/dist/api.d.ts

@@ -1,5 +1,5 @@
-import { BootstrapResult, ResolveResult, ReplayReport } from '@fern-api/replay';
-export { ConflictDetail, ReplayReport, ResolveResult } from '@fern-api/replay';
+import { ForgetOptions, ForgetResult, BootstrapResult, ResolveResult, ReplayReport, StatusResult } from '@fern-api/replay';
+export { ConflictDetail, DiffStat, ForgetOptions, ForgetResult, MatchedPatch, ReplayReport, ResolveResult, StatusGeneration, StatusPatch, StatusResult } from '@fern-api/replay';
 import fs from 'fs';
 
 /**
@@ -614,6 +614,14 @@ declare function formatReplayPrBody(result: ReplayStepResult | undefined, option
     repoUri?: string;
 }): string | undefined;
 
+interface ReplayForgetParams {
+    /** Directory containing the SDK (where .fern/replay.lock lives) */
+    outputDir: string;
+    /** Options controlling which patches to forget */
+    options?: ForgetOptions;
+}
+declare function replayForget(params: ReplayForgetParams): ForgetResult;
+
 interface ReplayInitParams {
     /** GitHub repo URI (e.g., "fern-demo/fern-replay-testbed-java-sdk") */
     githubRepo: string;
@@ -699,4 +707,10 @@ interface ReplayRunResult {
 }
 declare function replayRun(params: ReplayRunParams): Promise<ReplayRunResult>;
 
-export { type BootstrapLogEntry, type GenerateReadmeParams, type GenerateReadmeToStreamParams, type GenerateReferenceParams, type GenerateReferenceToStreamParams, type GithubPrParams, type GithubPushParams, type GithubReleaseParams, type GithubStepConfig, type GithubStepResult, type PipelineConfig, type PipelineContext, type PipelineLogger, type PipelineResult, PostGenerationPipeline, type ReplayInitParams, type ReplayInitResult, type ReplayResolveParams, type ReplayRunParams, type ReplayRunResult, type ReplayStepResult, consolePipelineLogger, formatBootstrapSummary, formatReplayPrBody, generateReadme, generateReadmeToStream, generateReference, generateReferenceToStream, githubPr, githubPush, githubRelease, logReplaySummary, replayInit, replayResolve, replayRun };
+interface ReplayStatusParams {
+    /** Directory containing the SDK (where .fern/replay.lock lives) */
+    outputDir: string;
+}
+declare function replayStatus(params: ReplayStatusParams): StatusResult;
+
+export { type BootstrapLogEntry, type GenerateReadmeParams, type GenerateReadmeToStreamParams, type GenerateReferenceParams, type GenerateReferenceToStreamParams, type GithubPrParams, type GithubPushParams, type GithubReleaseParams, type GithubStepConfig, type GithubStepResult, type PipelineConfig, type PipelineContext, type PipelineLogger, type PipelineResult, PostGenerationPipeline, type ReplayForgetParams, type ReplayInitParams, type ReplayInitResult, type ReplayResolveParams, type ReplayRunParams, type ReplayRunResult, type ReplayStatusParams, type ReplayStepResult, consolePipelineLogger, formatBootstrapSummary, formatReplayPrBody, generateReadme, generateReadmeToStream, generateReference, generateReferenceToStream, githubPr, githubPush, githubRelease, logReplaySummary, replayForget, replayInit, replayResolve, replayRun, replayStatus };

package/dist/api.js

@@ -844,7 +844,7 @@ var require_dist2 = __commonJS({
     function deferred2() {
       let done;
       let fail;
-      let status = "pending";
+      let status2 = "pending";
       const promise = new Promise((_done, _fail) => {
         done = _done;
         fail = _fail;
@@ -852,22 +852,22 @@ var require_dist2 = __commonJS({
       return {
         promise,
         done(result) {
-          if (status === "pending") {
-            status = "resolved";
+          if (status2 === "pending") {
+            status2 = "resolved";
             done(result);
           }
         },
         fail(error) {
-          if (status === "pending") {
-            status = "rejected";
+          if (status2 === "pending") {
+            status2 = "rejected";
             fail(error);
           }
         },
         get fulfilled() {
-          return status !== "pending";
+          return status2 !== "pending";
         },
         get status() {
-          return status;
+          return status2;
         }
       };
     }
@@ -892,9 +892,11 @@ __export(api_exports2, {
   githubPush: () => githubPush,
   githubRelease: () => githubRelease,
   logReplaySummary: () => logReplaySummary,
+  replayForget: () => replayForget,
   replayInit: () => replayInit,
   replayResolve: () => replayResolve,
-  replayRun: () => replayRun
+  replayRun: () => replayRun,
+  replayStatus: () => replayStatus
 });
 module.exports = __toCommonJS(api_exports2);
 
@@ -2827,7 +2829,7 @@ var init_parse_diff_summary = __esm({
     nameStatusParser = [
       new LineParser(
         /([ACDMRTUXB])([0-9]{0,3})\t(.[^\t]*)(\t(.[^\t]*))?$/,
-        (result, [status, similarity, from, _to, to]) => {
+        (result, [status2, similarity, from, _to, to]) => {
           result.changed++;
           result.files.push({
             file: to ?? from,
@@ -2835,7 +2837,7 @@ var init_parse_diff_summary = __esm({
             insertions: 0,
             deletions: 0,
             binary: false,
-            status: orVoid(isDiffNameStatus(status) && status),
+            status: orVoid(isDiffNameStatus(status2) && status2),
             from: orVoid(!!to && from !== to && from),
             similarity: asNumber(similarity)
           });
@@ -3361,10 +3363,10 @@ var init_merge = __esm({
     init_task();
   }
 });
-function pushResultPushedItem(local, remote, status) {
-  const deleted = status.includes("deleted");
-  const tag = status.includes("tag") || /^refs\/tags/.test(local);
-  const alreadyUpdated = !status.includes("new");
+function pushResultPushedItem(local, remote, status2) {
+  const deleted = status2.includes("deleted");
+  const tag = status2.includes("tag") || /^refs\/tags/.test(local);
+  const alreadyUpdated = !status2.includes("new");
   return {
     deleted,
     tag,
@@ -3678,7 +3680,7 @@ var init_StatusSummary = __esm({
     ]);
     parseStatusSummary = function(text) {
       const lines = text.split(NULL);
-      const status = new StatusSummary();
+      const status2 = new StatusSummary();
       for (let i = 0, l = lines.length; i < l; ) {
         let line = lines[i++].trim();
         if (!line) {
@@ -3687,9 +3689,9 @@ var init_StatusSummary = __esm({
         if (line.charAt(0) === "R") {
           line += NULL + (lines[i++] || "");
         }
-        splitLine(status, line);
+        splitLine(status2, line);
       }
-      return status;
+      return status2;
     };
   }
 });
@@ -4116,15 +4118,15 @@ var init_BranchSummary = __esm({
         this.current = "";
         this.detached = false;
       }
-      push(status, detached, name, commit, label) {
-        if (status === "*") {
+      push(status2, detached, name, commit, label) {
+        if (status2 === "*") {
           this.detached = detached;
           this.current = name;
         }
         this.all.push(name);
         this.branches[name] = {
-          current: status === "*",
-          linkedWorkTree: status === "+",
+          current: status2 === "*",
+          linkedWorkTree: status2 === "+",
           name,
           commit,
           label
@@ -10488,8 +10490,14 @@ var PostGenerationPipeline = class {
   }
 };
 
-// src/replay/replay-init.ts
+// src/replay/replay-forget.ts
 var import_replay2 = require("@fern-api/replay");
+function replayForget(params) {
+  return (0, import_replay2.forget)(params.outputDir, params.options);
+}
+
+// src/replay/replay-init.ts
+var import_replay3 = require("@fern-api/replay");
 var import_fs4 = require("fs");
 var import_path6 = require("path");
 var import_tmp_promise2 = __toESM(require("tmp-promise"));
@@ -10502,7 +10510,7 @@ async function replayInit(params) {
     installationToken: token,
     targetDirectory: repoPath
   });
-  const bootstrapResult = await (0, import_replay2.bootstrap)(repoPath, {
+  const bootstrapResult = await (0, import_replay3.bootstrap)(repoPath, {
     dryRun,
     fernignoreAction: "skip",
     maxCommitsToScan: params.maxCommitsToScan,
@@ -10635,12 +10643,18 @@ function buildPrBody(result) {
 }
 
 // src/replay/replay-resolve.ts
-var import_replay3 = require("@fern-api/replay");
+var import_replay4 = require("@fern-api/replay");
 async function replayResolve(params) {
-  return (0, import_replay3.resolve)(params.outputDir, {
+  return (0, import_replay4.resolve)(params.outputDir, {
     checkMarkers: params.checkMarkers
   });
 }
+
+// src/replay/replay-status.ts
+var import_replay5 = require("@fern-api/replay");
+function replayStatus(params) {
+  return (0, import_replay5.status)(params.outputDir);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PostGenerationPipeline,
@@ -10655,7 +10669,9 @@ async function replayResolve(params) {
   githubPush,
   githubRelease,
   logReplaySummary,
+  replayForget,
   replayInit,
   replayResolve,
-  replayRun
+  replayRun,
+  replayStatus
 });

package/dist/cli.js

@@ -19759,7 +19759,7 @@ var init_diff3 = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/@fern-api+replay@0.8.0/node_modules/@fern-api/replay/dist/index.js
+// ../../node_modules/.pnpm/@fern-api+replay@0.9.1/node_modules/@fern-api/replay/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
   FERN_BOT_EMAIL: () => FERN_BOT_EMAIL2,
@@ -19784,6 +19784,241 @@ __export(dist_exports, {
   status: () => status,
   threeWayMerge: () => threeWayMerge
 });
+function parseHunks(fileDiff) {
+  const lines = fileDiff.split("\n");
+  const hunks = [];
+  let currentHunk = null;
+  for (const line of lines) {
+    const headerMatch = line.match(
+      /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/
+    );
+    if (headerMatch) {
+      if (currentHunk) {
+        hunks.push(currentHunk);
+      }
+      currentHunk = {
+        oldStart: parseInt(headerMatch[1], 10),
+        oldCount: headerMatch[2] != null ? parseInt(headerMatch[2], 10) : 1,
+        newStart: parseInt(headerMatch[3], 10),
+        newCount: headerMatch[4] != null ? parseInt(headerMatch[4], 10) : 1,
+        lines: []
+      };
+      continue;
+    }
+    if (!currentHunk) continue;
+    if (line.startsWith("diff --git") || line.startsWith("index ") || line.startsWith("---") || line.startsWith("+++") || line.startsWith("old mode") || line.startsWith("new mode") || line.startsWith("similarity index") || line.startsWith("rename from") || line.startsWith("rename to") || line.startsWith("new file mode") || line.startsWith("deleted file mode")) {
+      continue;
+    }
+    if (line === "\") {
+      continue;
+    }
+    if (line.startsWith("-")) {
+      currentHunk.lines.push({ type: "remove", content: line.slice(1) });
+    } else if (line.startsWith("+")) {
+      currentHunk.lines.push({ type: "add", content: line.slice(1) });
+    } else if (line.startsWith(" ") || line === "") {
+      currentHunk.lines.push({
+        type: "context",
+        content: line.startsWith(" ") ? line.slice(1) : line
+      });
+    }
+  }
+  if (currentHunk) {
+    hunks.push(currentHunk);
+  }
+  return hunks;
+}
+function extractLeadingContext(hunk) {
+  const result = [];
+  for (const line of hunk.lines) {
+    if (line.type !== "context") break;
+    result.push(line.content);
+  }
+  return result;
+}
+function extractTrailingContext(hunk) {
+  const result = [];
+  for (let i = hunk.lines.length - 1; i >= 0; i--) {
+    if (hunk.lines[i].type !== "context") break;
+    result.unshift(hunk.lines[i].content);
+  }
+  return result;
+}
+function countOursLinesBeforeTrailing(hunk) {
+  let count = 0;
+  const trailingStart = findTrailingContextStart(hunk);
+  for (let i = 0; i < trailingStart; i++) {
+    if (hunk.lines[i].type === "context") count++;
+  }
+  return count;
+}
+function findTrailingContextStart(hunk) {
+  let i = hunk.lines.length - 1;
+  while (i >= 0 && hunk.lines[i].type === "context") {
+    i--;
+  }
+  return i + 1;
+}
+function matchesAt(needle, haystack, offset) {
+  for (let i = 0; i < needle.length; i++) {
+    if (haystack[offset + i] !== needle[i]) return false;
+  }
+  return true;
+}
+function findContextInOurs(contextLines, oursLines, minIndex, hint) {
+  const SEARCH_WINDOW = 200;
+  const maxStart = oursLines.length - contextLines.length;
+  const clampedHint = Math.max(minIndex, Math.min(hint, maxStart));
+  if (clampedHint >= minIndex && clampedHint <= maxStart) {
+    if (matchesAt(contextLines, oursLines, clampedHint)) {
+      return clampedHint;
+    }
+  }
+  for (let delta = 1; delta <= SEARCH_WINDOW; delta++) {
+    for (const sign of [1, -1]) {
+      const idx = clampedHint + delta * sign;
+      if (idx < minIndex || idx > maxStart) continue;
+      if (matchesAt(contextLines, oursLines, idx)) {
+        return idx;
+      }
+    }
+  }
+  return -1;
+}
+function computeOursSpan(hunk, oursLines, oursOffset) {
+  const leading = extractLeadingContext(hunk);
+  const trailing = extractTrailingContext(hunk);
+  if (trailing.length === 0) {
+    const contextCount2 = hunk.lines.filter(
+      (l) => l.type === "context"
+    ).length;
+    return Math.min(contextCount2, oursLines.length - oursOffset);
+  }
+  const searchStart = oursOffset + leading.length;
+  for (let i = searchStart; i <= oursLines.length - trailing.length; i++) {
+    if (matchesAt(trailing, oursLines, i)) {
+      return i + trailing.length - oursOffset;
+    }
+  }
+  const contextCount = hunk.lines.filter(
+    (l) => l.type === "context"
+  ).length;
+  return Math.min(contextCount, oursLines.length - oursOffset);
+}
+function locateHunksInOurs(hunks, oursLines) {
+  const located = [];
+  let minOursIndex = 0;
+  for (const hunk of hunks) {
+    const contextLines = extractLeadingContext(hunk);
+    let oursOffset;
+    if (contextLines.length > 0) {
+      const found = findContextInOurs(
+        contextLines,
+        oursLines,
+        minOursIndex,
+        hunk.newStart - 1
+      );
+      if (found === -1) {
+        const trailingContext = extractTrailingContext(hunk);
+        if (trailingContext.length > 0) {
+          const trailingFound = findContextInOurs(
+            trailingContext,
+            oursLines,
+            minOursIndex,
+            hunk.newStart - 1
+          );
+          if (trailingFound === -1) return null;
+          const nonTrailingCount = countOursLinesBeforeTrailing(hunk);
+          oursOffset = trailingFound - nonTrailingCount;
+          if (oursOffset < minOursIndex) return null;
+        } else {
+          return null;
+        }
+      } else {
+        oursOffset = found;
+      }
+    } else if (hunk.oldStart === 1 && hunk.oldCount === 0) {
+      oursOffset = 0;
+    } else {
+      oursOffset = Math.max(hunk.newStart - 1, minOursIndex);
+    }
+    const oursSpan = computeOursSpan(hunk, oursLines, oursOffset);
+    located.push({ hunk, oursOffset, oursSpan });
+    minOursIndex = oursOffset + oursSpan;
+  }
+  return located;
+}
+function assembleHybrid(locatedHunks, oursLines) {
+  const baseLines = [];
+  const theirsLines = [];
+  let oursCursor = 0;
+  for (const { hunk, oursOffset, oursSpan } of locatedHunks) {
+    if (oursOffset > oursCursor) {
+      const gapLines = oursLines.slice(oursCursor, oursOffset);
+      baseLines.push(...gapLines);
+      theirsLines.push(...gapLines);
+    }
+    for (const line of hunk.lines) {
+      switch (line.type) {
+        case "context":
+          baseLines.push(line.content);
+          theirsLines.push(line.content);
+          break;
+        case "remove":
+          baseLines.push(line.content);
+          break;
+        case "add":
+          theirsLines.push(line.content);
+          break;
+      }
+    }
+    oursCursor = oursOffset + oursSpan;
+  }
+  if (oursCursor < oursLines.length) {
+    const gapLines = oursLines.slice(oursCursor);
+    baseLines.push(...gapLines);
+    theirsLines.push(...gapLines);
+  }
+  return {
+    base: baseLines.join("\n"),
+    theirs: theirsLines.join("\n")
+  };
+}
+function reconstructFromGhostPatch(fileDiff, ours) {
+  const hunks = parseHunks(fileDiff);
+  if (hunks.length === 0) {
+    return null;
+  }
+  const isPureAddition = hunks.every(
+    (h) => h.oldCount === 0 && h.lines.every((l) => l.type !== "remove")
+  );
+  if (isPureAddition) {
+    return null;
+  }
+  const isPureDeletion = hunks.every(
+    (h) => h.newCount === 0 && h.lines.every((l) => l.type !== "add")
+  );
+  if (isPureDeletion) {
+    const baseLines = [];
+    for (const hunk of hunks) {
+      for (const line of hunk.lines) {
+        if (line.type === "context" || line.type === "remove") {
+          baseLines.push(line.content);
+        }
+      }
+    }
+    return {
+      base: baseLines.join("\n"),
+      theirs: ""
+    };
+  }
+  const oursLines = ours.split("\n");
+  const located = locateHunksInOurs(hunks, oursLines);
+  if (!located) {
+    return null;
+  }
+  return assembleHybrid(located, oursLines);
+}
 function isGenerationCommit(commit) {
   const isFernSupport = FERN_SUPPORT_NAMES.includes(commit.authorName);
   const isBotAuthor = !isFernSupport && (commit.authorLogin === FERN_BOT_LOGIN2 || commit.authorEmail === FERN_BOT_EMAIL2 || commit.authorName === FERN_BOT_NAME2);
@@ -19797,7 +20032,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 match2 = fullBody.match(/This reverts commit ([0-9a-f]{40})\./);
@@ -19842,14 +20077,6 @@ function threeWayMerge(base, ours, theirs) {
     conflicts: conflicts2
   };
 }
-function isBinaryFile(filePath) {
-  const ext2 = (0, import_path9.extname)(filePath).toLowerCase();
-  return BINARY_EXTENSIONS.has(ext2);
-}
-function isDiffLineForFile(diffLine, filePath) {
-  const match2 = diffLine.match(/^diff --git a\/.+ b\/(.+)$/);
-  return match2 !== null && match2[1] === filePath;
-}
 function stripConflictMarkers(content) {
   const lines = content.split("\n");
   const result = [];
@@ -19876,6 +20103,14 @@ function stripConflictMarkers(content) {
   }
   return result.join("\n");
 }
+function isBinaryFile(filePath) {
+  const ext2 = (0, import_path9.extname)(filePath).toLowerCase();
+  return BINARY_EXTENSIONS.has(ext2);
+}
+function isDiffLineForFile(diffLine, filePath) {
+  const match2 = diffLine.match(/^diff --git a\/.+ b\/(.+)$/);
+  return match2 !== null && match2[1] === filePath;
+}
 async function bootstrap(outputDir, options) {
   const git = new GitClient(outputDir);
   const lockManager = new LockfileManager(outputDir);
@@ -19957,6 +20192,7 @@ async function bootstrap(outputDir, options) {
   }
   lockManager.save();
   const fernignoreUpdated = ensureFernignoreEntries(outputDir);
+  ensureGitattributesEntries(outputDir);
   if (migrator.fernignoreExists() && fernignorePatterns.length > 0) {
     const action = options?.fernignoreAction ?? "skip";
     if (action === "migrate") {
@@ -20061,34 +20297,162 @@ function ensureFernignoreEntries(outputDir) {
   (0, import_fs9.writeFileSync)(fernignorePath, content, "utf-8");
   return true;
 }
+function ensureGitattributesEntries(outputDir) {
+  const gitattributesPath = (0, import_path12.join)(outputDir, ".gitattributes");
+  let content = "";
+  if ((0, import_fs9.existsSync)(gitattributesPath)) {
+    content = (0, import_fs9.readFileSync)(gitattributesPath, "utf-8");
+  }
+  const lines = content.split("\n");
+  const toAdd = [];
+  for (const entry of GITATTRIBUTES_ENTRIES) {
+    if (!lines.some((line) => line.trim() === entry)) {
+      toAdd.push(entry);
+    }
+  }
+  if (toAdd.length === 0) {
+    return;
+  }
+  if (content && !content.endsWith("\n")) {
+    content += "\n";
+  }
+  content += toAdd.join("\n") + "\n";
+  (0, import_fs9.writeFileSync)(gitattributesPath, content, "utf-8");
+}
 function computeContentHash(patchContent) {
   const normalized = patchContent.split("\n").filter((line) => !line.startsWith("From ") && !line.startsWith("index ") && !line.startsWith("Date: ")).join("\n");
   return `sha256:${(0, import_crypto3.createHash)("sha256").update(normalized).digest("hex")}`;
 }
-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 || minimatch(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;
+}
+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 || minimatch(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
+    };
   }
-  return { removed, notFound: false };
+  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 {
+    initialized: true,
+    removed: [],
+    remaining: totalPatches,
+    notFound: totalPatches === 0,
+    alreadyForgotten: [],
+    totalPatches,
+    warnings: [],
+    matched: lock.patches.map(toMatchedPatch)
+  };
 }
 function reset(outputDir, options) {
   const lockManager = new LockfileManager(outputDir);
@@ -20202,28 +20566,53 @@ 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
+  };
 }
-var import_fs6, import_path8, import_yaml, import_crypto, import_promises4, import_os, import_path9, import_fs7, import_path10, import_crypto2, import_fs8, import_path11, import_yaml2, import_crypto3, import_fs9, import_path12, import_fs10, __defProp3, __getOwnPropNames3, __esm3, __export3, GitClient_exports, GitClient, init_GitClient, FERN_BOT_NAME2, FERN_BOT_EMAIL2, FERN_BOT_LOGIN2, FERN_SUPPORT_NAMES, LOCKFILE_HEADER, LockfileManager, INFRASTRUCTURE_FILES, ReplayDetector, BINARY_EXTENSIONS, ReplayApplicator, ReplayCommitter, ReplayService, FernignoreMigrator, REPLAY_FERNIGNORE_ENTRIES;
+var import_fs6, import_path8, import_yaml, import_crypto, import_promises4, import_os, import_path9, import_fs7, import_path10, import_crypto2, import_fs8, import_path11, import_yaml2, import_crypto3, import_fs9, import_path12, import_fs10, __defProp3, __getOwnPropNames3, __esm3, __export3, GitClient_exports, GitClient, init_GitClient, HybridReconstruction_exports, init_HybridReconstruction, FERN_BOT_NAME2, FERN_BOT_EMAIL2, FERN_BOT_LOGIN2, FERN_SUPPORT_NAMES, LOCKFILE_HEADER, LockfileManager, INFRASTRUCTURE_FILES, ReplayDetector, BINARY_EXTENSIONS, ReplayApplicator, ReplayCommitter, ReplayService, FernignoreMigrator, REPLAY_FERNIGNORE_ENTRIES, GITATTRIBUTES_ENTRIES, EMPTY_RESULT;
 var init_dist = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.8.0/node_modules/@fern-api/replay/dist/index.js"() {
+  "../../node_modules/.pnpm/@fern-api+replay@0.9.1/node_modules/@fern-api/replay/dist/index.js"() {
     "use strict";
     init_esm4();
     import_fs6 = require("fs");
@@ -20357,6 +20746,14 @@ var init_dist = __esm({
               return false;
             }
           }
+          async treeExists(treeHash) {
+            try {
+              const type = await this.exec(["cat-file", "-t", treeHash]);
+              return type.trim() === "tree";
+            } catch {
+              return false;
+            }
+          }
           async getCommitBody(commitSha) {
             return this.exec(["log", "-1", "--format=%B", commitSha]);
           }
@@ -20366,6 +20763,18 @@ var init_dist = __esm({
         };
       }
     });
+    HybridReconstruction_exports = {};
+    __export3(HybridReconstruction_exports, {
+      assembleHybrid: () => assembleHybrid,
+      locateHunksInOurs: () => locateHunksInOurs,
+      parseHunks: () => parseHunks,
+      reconstructFromGhostPatch: () => reconstructFromGhostPatch
+    });
+    init_HybridReconstruction = __esm3({
+      "src/HybridReconstruction.ts"() {
+        "use strict";
+      }
+    });
     init_GitClient();
     FERN_BOT_NAME2 = "fern-api";
     FERN_BOT_EMAIL2 = "115122769+fern-api[bot]@users.noreply.github.com";
@@ -20457,6 +20866,15 @@ var init_dist = __esm({
         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");
@@ -20550,6 +20968,7 @@ var init_dist = __esm({
         }
         const commits = this.parseGitLog(log);
         const newPatches = [];
+        const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
         for (const commit of commits) {
           if (isGenerationCommit(commit)) {
             continue;
@@ -20563,7 +20982,7 @@ var init_dist = __esm({
           }
           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]);
@@ -20633,6 +21052,9 @@ var init_dist = __esm({
               revertIndicesToRemove.add(idx);
             }
           }
+          if (!matchedExisting && !matchedNew) {
+            revertIndicesToRemove.add(i);
+          }
         }
         const filteredPatches = newPatches.filter((_, i) => !revertIndicesToRemove.has(i));
         return { patches: filteredPatches, revertedPatchIds: [...revertedPatchIdSet] };
@@ -20659,7 +21081,7 @@ var init_dist = __esm({
         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();
@@ -20739,6 +21161,7 @@ var init_dist = __esm({
       lockManager;
       outputDir;
       renameCache = /* @__PURE__ */ new Map();
+      treeExistsCache = /* @__PURE__ */ new Map();
       fileTheirsAccumulator = /* @__PURE__ */ new Map();
       constructor(git, lockManager, outputDir) {
         this.git = git;
@@ -20756,7 +21179,8 @@ var init_dist = __esm({
       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,
@@ -20767,6 +21191,33 @@ var init_dist = __esm({
           }
           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 = (0, import_path9.join)(this.outputDir, fileResult.file);
+                try {
+                  const content = await (0, import_promises4.readFile)(filePath, "utf-8");
+                  const stripped = stripConflictMarkers(content);
+                  await (0, import_promises4.writeFile)(filePath, stripped);
+                } catch {
+                }
+              }
+            }
+          }
         }
         return results;
       }
@@ -20785,7 +21236,7 @@ var init_dist = __esm({
             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
@@ -20907,17 +21358,36 @@ var init_dist = __esm({
           }
           const oursPath = (0, import_path9.join)(this.outputDir, resolvedPath);
           const ours = await (0, import_promises4.readFile)(oursPath, "utf-8").catch(() => null);
-          let theirs = await this.applyPatchToContent(
-            base,
-            patch.patch_content,
-            filePath,
-            tempGit,
-            tempDir,
-            renameSourcePath
-          );
+          let ghostReconstructed = false;
+          let theirs = null;
+          if (!base && ours && !renameSourcePath) {
+            const treeReachable = await this.isTreeReachable(baseGen.tree_hash);
+            if (!treeReachable) {
+              const fileDiff = this.extractFileDiff(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;
+                  theirs = result.theirs;
+                  ghostReconstructed = true;
+                }
+              }
+            }
+          }
+          if (!ghostReconstructed) {
+            theirs = await this.applyPatchToContent(
+              base,
+              patch.patch_content,
+              filePath,
+              tempGit,
+              tempDir,
+              renameSourcePath
+            );
+          }
           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,
@@ -20947,13 +21417,13 @@ var init_dist = __esm({
               baseMismatchSkipped = true;
             }
           }
-          if (!base && !ours && effective_theirs) {
+          if (base == null && !ours && effective_theirs) {
             const outDir2 = (0, import_path9.dirname)(oursPath);
             await (0, import_promises4.mkdir)(outDir2, { recursive: true });
             await (0, import_promises4.writeFile)(oursPath, effective_theirs);
             return { file: resolvedPath, status: "merged", reason: "new-file" };
           }
-          if (!base && ours && effective_theirs) {
+          if (base == null && ours && effective_theirs) {
             const merged2 = threeWayMerge("", ours, effective_theirs);
             const outDir2 = (0, import_path9.dirname)(oursPath);
             await (0, import_promises4.mkdir)(outDir2, { recursive: true });
@@ -20976,7 +21446,7 @@ var init_dist = __esm({
               reason: "missing-content"
             };
           }
-          if (!base || !ours) {
+          if (base == null && !useAccumulatorAsMergeBase || !ours) {
             return {
               file: resolvedPath,
               status: "skipped",
@@ -20984,11 +21454,18 @@ var init_dist = __esm({
             };
           }
           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 = (0, import_path9.dirname)(oursPath);
           await (0, import_promises4.mkdir)(outDir, { recursive: true });
           await (0, import_promises4.writeFile)(oursPath, merged.content);
-          if (effective_theirs && base) {
+          if (effective_theirs) {
             this.fileTheirsAccumulator.set(resolvedPath, {
               content: effective_theirs,
               baseGeneration: patch.base_generation
@@ -21012,6 +21489,14 @@ var init_dist = __esm({
           };
         }
       }
+      async isTreeReachable(treeHash) {
+        let result = this.treeExistsCache.get(treeHash);
+        if (result === void 0) {
+          result = await this.git.treeExists(treeHash);
+          this.treeExistsCache.set(treeHash, result);
+        }
+        return result;
+      }
       isExcluded(patch) {
         const config = this.lockManager.getCustomizationsConfig();
         if (!config.exclude) return false;
@@ -21978,7 +22463,17 @@ CLI Version: ${options.cliVersion}`;
       }
     };
     init_GitClient();
-    REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml"];
+    REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml", ".gitattributes"];
+    GITATTRIBUTES_ENTRIES = [".fern/replay.lock linguist-generated=true"];
+    EMPTY_RESULT = {
+      initialized: false,
+      removed: [],
+      remaining: 0,
+      notFound: false,
+      alreadyForgotten: [],
+      totalPatches: 0,
+      warnings: []
+    };
     init_GitClient();
   }
 });
@@ -32328,6 +32823,12 @@ var PostGenerationPipeline = class {
   }
 };
 
+// src/replay/replay-forget.ts
+init_dist();
+function replayForget(params) {
+  return forget(params.outputDir, params.options);
+}
+
 // src/replay/replay-init.ts
 init_dist();
 var import_fs13 = require("fs");
@@ -32477,6 +32978,12 @@ function buildPrBody(result) {
 // src/replay/replay-resolve.ts
 init_dist();
 
+// src/replay/replay-status.ts
+init_dist();
+function replayStatus(params) {
+  return status(params.outputDir);
+}
+
 // src/configuration/loadGitHubConfig.ts
 var import_promises6 = require("fs/promises");
 async function loadGitHubConfig({
@@ -32853,6 +33360,84 @@ Bootstrap complete! Lockfile saved to ${outputDir}/.fern/replay.lock
         } catch (error) {
           const errorMessage = extractErrorMessage(error);
           process.stderr.write(`Bootstrap failed: ${errorMessage}
+`);
+          process.exit(1);
+        }
+      }
+    ).command(
+      "status [directory]",
+      false,
+      // hidden from --help
+      (subYargs) => {
+        return subYargs.positional("directory", {
+          type: "string",
+          default: ".",
+          description: "SDK directory containing .fern/replay.lock"
+        });
+      },
+      (argv) => {
+        try {
+          const outputDir = resolve(cwd(), argv.directory ?? ".");
+          const result = replayStatus({ outputDir });
+          process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+          process.exit(0);
+        } catch (error) {
+          const errorMessage = extractErrorMessage(error);
+          process.stderr.write(`Replay status failed: ${errorMessage}
+`);
+          process.exit(1);
+        }
+      }
+    ).command(
+      "forget [args..]",
+      false,
+      // hidden from --help
+      (subYargs) => {
+        return subYargs.positional("args", {
+          type: "string",
+          array: true,
+          description: "Patch IDs or search pattern"
+        }).option("dry-run", {
+          type: "boolean",
+          default: false,
+          description: "Show what would be removed without actually removing"
+        }).option("all", {
+          type: "boolean",
+          default: false,
+          description: "Remove all tracked patches"
+        }).option("pattern", {
+          type: "string",
+          description: "Search pattern (file path, glob, or commit message substring)"
+        });
+      },
+      (argv) => {
+        try {
+          const outputDir = resolve(cwd(), ".");
+          const args = argv.args ?? [];
+          const dryRun = argv["dry-run"];
+          let result;
+          if (argv.all) {
+            result = replayForget({ outputDir, options: { all: true, dryRun } });
+          } else if (argv.pattern) {
+            result = replayForget({ outputDir, options: { pattern: argv.pattern, dryRun } });
+          } else if (args.length > 0) {
+            const allPatchIds = args.every((a) => a.startsWith("patch-"));
+            if (allPatchIds) {
+              result = replayForget({ outputDir, options: { patchIds: args, dryRun } });
+            } else {
+              result = replayForget({
+                outputDir,
+                options: { pattern: args[0], dryRun }
+              });
+            }
+          } else {
+            result = replayForget({ outputDir, options: { dryRun } });
+          }
+          process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+          process.exit(0);
+        } catch (error) {
+          const errorMessage = extractErrorMessage(error);
+          process.stderr.write(`Replay forget failed: ${errorMessage}
 `);
           process.exit(1);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fern-api/generator-cli",
-  "version": "0.8.1",
+  "version": "0.9.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fern-api/fern.git",
@@ -22,7 +22,7 @@
     "**"
   ],
   "dependencies": {
-    "@fern-api/replay": "^0.8.0",
+    "@fern-api/replay": "^0.9.1",
     "@octokit/rest": "^22.0.1",
     "es-toolkit": "^1.45.1",
     "tmp-promise": "^3.0.3"