@fern-api/generator-cli 0.8.0 → 0.9.0

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,11 +614,19 @@ 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;
-    /** GitHub token for clone (read access) */
-    token: string;
+    /** GitHub token for clone (read access). Optional for public repos. */
+    token?: string;
     /** Report what would happen but don't create PR */
     dryRun?: boolean;
     /** Max commits to scan for generation history */
@@ -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.0/node_modules/@fern-api/replay/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
   FERN_BOT_EMAIL: () => FERN_BOT_EMAIL2,
@@ -19797,7 +19797,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 +19842,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 +19868,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);
@@ -20065,30 +20065,136 @@ 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
+    };
+  }
+  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)
+  };
 }
 function reset(outputDir, options) {
   const lockManager = new LockfileManager(outputDir);
@@ -20202,28 +20308,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, 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, 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.0/node_modules/@fern-api/replay/dist/index.js"() {
     "use strict";
     init_esm4();
     import_fs6 = require("fs");
@@ -20457,6 +20588,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 +20690,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 +20704,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 +20774,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 +20803,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();
@@ -20756,7 +20900,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 +20912,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 +20957,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
@@ -20917,7 +21089,7 @@ var init_dist = __esm({
           );
           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,
@@ -20976,7 +21148,7 @@ var init_dist = __esm({
               reason: "missing-content"
             };
           }
-          if (!base || !ours) {
+          if (!base && !useAccumulatorAsMergeBase || !ours) {
             return {
               file: resolvedPath,
               status: "skipped",
@@ -20984,11 +21156,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
@@ -21979,6 +22158,15 @@ CLI Version: ${options.cliVersion}`;
     };
     init_GitClient();
     REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml"];
+    EMPTY_RESULT = {
+      initialized: false,
+      removed: [],
+      remaining: 0,
+      notFound: false,
+      alreadyForgotten: [],
+      totalPatches: 0,
+      warnings: []
+    };
     init_GitClient();
   }
 });
@@ -32328,6 +32516,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 +32671,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({
@@ -32737,11 +32937,14 @@ ${result.errors.map((e) => `  - ${e}`).join("\n")}
         });
       },
       async (argv) => {
-        if (argv.github == null || argv.token == null) {
+        if (argv.github == null) {
+          process.stderr.write("missing required argument; please specify --github flag\n");
+          process.exit(1);
+        }
+        if (argv.token == null) {
           process.stderr.write(
-            "missing required arguments; please specify --github and --token flags\n"
+            "warning: no GitHub token provided. Clone may fail for private repos. Pass --token or set GITHUB_TOKEN.\n"
           );
-          process.exit(1);
         }
         try {
           const result = await replayInit({
@@ -32850,6 +33053,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.0",
+  "version": "0.9.0",
   "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.0",
     "@octokit/rest": "^22.0.1",
     "es-toolkit": "^1.45.1",
     "tmp-promise": "^3.0.3"