@fern-api/replay 0.8.0 → 0.9.0

package/dist/cli.cjs

@@ -751,7 +751,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;
@@ -759,22 +759,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;
         }
       };
     }
@@ -1817,10 +1817,10 @@ function mergeTask(customArgs) {
     }
   };
 }
-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,
@@ -3659,7 +3659,7 @@ var init_esm = __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,
@@ -3667,7 +3667,7 @@ var init_esm = __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)
               });
@@ -4214,7 +4214,7 @@ var init_esm = __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) {
@@ -4223,9 +4223,9 @@ var init_esm = __esm({
             if (line.charAt(0) === "R") {
               line += NULL + (lines[i++] || "");
             }
-            splitLine(status, line);
+            splitLine(status2, line);
           }
-          return status;
+          return status2;
         };
       }
     });
@@ -4514,15 +4514,15 @@ var init_esm = __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
@@ -12846,6 +12846,7 @@ var require_brace_expansion = __commonJS({
 // src/cli.ts
 var import_node_path7 = require("path");
 var import_node_fs6 = require("fs");
+var import_node_readline = require("readline");
 init_GitClient();
 
 // src/LockfileManager.ts
@@ -12938,6 +12939,15 @@ var LockfileManager = class {
     this.ensureLoaded();
     this.lock.patches = [];
   }
+  addForgottenHash(hash) {
+    this.ensureLoaded();
+    if (!this.lock.forgotten_hashes) {
+      this.lock.forgotten_hashes = [];
+    }
+    if (!this.lock.forgotten_hashes.includes(hash)) {
+      this.lock.forgotten_hashes.push(hash);
+    }
+  }
   getUnresolvedPatches() {
     this.ensureLoaded();
     return this.lock.patches.filter((p) => p.status === "unresolved");
@@ -13013,7 +13023,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})\./);
@@ -13065,6 +13075,7 @@ var ReplayDetector = class {
     }
     const commits = this.parseGitLog(log);
     const newPatches = [];
+    const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
     for (const commit of commits) {
       if (isGenerationCommit(commit)) {
         continue;
@@ -13078,7 +13089,7 @@ var ReplayDetector = class {
       }
       const patchContent = await this.git.formatPatch(commit.sha);
       const contentHash = this.computeContentHash(patchContent);
-      if (lock.patches.find((p) => p.content_hash === contentHash)) {
+      if (lock.patches.find((p) => p.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
         continue;
       }
       const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
@@ -13148,6 +13159,9 @@ var ReplayDetector = class {
           revertIndicesToRemove.add(idx);
         }
       }
+      if (!matchedExisting && !matchedNew) {
+        revertIndicesToRemove.add(i);
+      }
     }
     const filteredPatches = newPatches.filter((_, i) => !revertIndicesToRemove.has(i));
     return { patches: filteredPatches, revertedPatchIds: [...revertedPatchIdSet] };
@@ -13174,7 +13188,7 @@ var ReplayDetector = class {
     if (!diff.trim()) return { patches: [], revertedPatchIds: [] };
     const contentHash = this.computeContentHash(diff);
     const lock = this.lockManager.read();
-    if (lock.patches.some((p) => p.content_hash === contentHash)) {
+    if (lock.patches.some((p) => p.content_hash === contentHash) || (lock.forgotten_hashes ?? []).includes(contentHash)) {
       return { patches: [], revertedPatchIds: [] };
     }
     const headSha = (await this.git.exec(["rev-parse", "HEAD"])).trim();
@@ -14543,6 +14557,34 @@ var import_promises = require("fs/promises");
 var import_node_os = require("os");
 var import_node_path3 = require("path");
 
+// src/conflict-utils.ts
+function stripConflictMarkers(content) {
+  const lines = content.split("\n");
+  const result = [];
+  let inConflict = false;
+  let inOurs = false;
+  for (const line of lines) {
+    if (line.startsWith("<<<<<<< ")) {
+      inConflict = true;
+      inOurs = true;
+      continue;
+    }
+    if (inConflict && line === "=======") {
+      inOurs = false;
+      continue;
+    }
+    if (inConflict && line.startsWith(">>>>>>> ")) {
+      inConflict = false;
+      inOurs = false;
+      continue;
+    }
+    if (!inConflict || inOurs) {
+      result.push(line);
+    }
+  }
+  return result.join("\n");
+}
+
 // node_modules/node-diff3/dist/diff3.mjs
 function LCS(buffer1, buffer2) {
   let equivalenceClasses = {};
@@ -14866,7 +14908,8 @@ var ReplayApplicator = class {
   async applyPatches(patches) {
     this.resetAccumulator();
     const results = [];
-    for (const patch of patches) {
+    for (let i = 0; i < patches.length; i++) {
+      const patch = patches[i];
       if (this.isExcluded(patch)) {
         results.push({
           patch,
@@ -14877,6 +14920,33 @@ var ReplayApplicator = class {
       }
       const result = await this.applyPatchWithFallback(patch);
       results.push(result);
+      if (result.status === "conflict" && result.fileResults) {
+        const laterFiles = /* @__PURE__ */ new Set();
+        for (let j = i + 1; j < patches.length; j++) {
+          for (const f of patches[j].files) {
+            laterFiles.add(f);
+          }
+        }
+        const resolvedToOriginal = /* @__PURE__ */ new Map();
+        if (result.resolvedFiles) {
+          for (const [orig, resolved] of Object.entries(result.resolvedFiles)) {
+            resolvedToOriginal.set(resolved, orig);
+          }
+        }
+        for (const fileResult of result.fileResults) {
+          if (fileResult.status !== "conflict") continue;
+          const originalPath = resolvedToOriginal.get(fileResult.file) ?? fileResult.file;
+          if (laterFiles.has(fileResult.file) || laterFiles.has(originalPath)) {
+            const filePath = (0, import_node_path3.join)(this.outputDir, fileResult.file);
+            try {
+              const content = await (0, import_promises.readFile)(filePath, "utf-8");
+              const stripped = stripConflictMarkers(content);
+              await (0, import_promises.writeFile)(filePath, stripped);
+            } catch {
+            }
+          }
+        }
+      }
     }
     return results;
   }
@@ -14895,7 +14965,7 @@ var ReplayApplicator = class {
         const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
         const base = await this.git.showFile(baseGen.tree_hash, filePath);
         const theirs = await this.applyPatchToContent(base, patch.patch_content, filePath, tempGit, tempDir);
-        if (theirs && base) {
+        if (theirs) {
           this.fileTheirsAccumulator.set(resolvedPath, {
             content: theirs,
             baseGeneration: patch.base_generation
@@ -15027,7 +15097,7 @@ var ReplayApplicator = class {
       );
       let useAccumulatorAsMergeBase = false;
       const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
-      if (!theirs && base && accumulatorEntry) {
+      if (!theirs && accumulatorEntry) {
         theirs = await this.applyPatchToContent(
           accumulatorEntry.content,
           patch.patch_content,
@@ -15086,7 +15156,7 @@ var ReplayApplicator = class {
           reason: "missing-content"
         };
       }
-      if (!base || !ours) {
+      if (!base && !useAccumulatorAsMergeBase || !ours) {
         return {
           file: resolvedPath,
           status: "skipped",
@@ -15094,11 +15164,18 @@ var ReplayApplicator = class {
         };
       }
       const mergeBase = useAccumulatorAsMergeBase && accumulatorEntry ? accumulatorEntry.content : base;
+      if (mergeBase == null) {
+        return {
+          file: resolvedPath,
+          status: "skipped",
+          reason: "missing-content"
+        };
+      }
       const merged = threeWayMerge(mergeBase, ours, effective_theirs);
       const outDir = (0, import_node_path3.dirname)(oursPath);
       await (0, import_promises.mkdir)(outDir, { recursive: true });
       await (0, import_promises.writeFile)(oursPath, merged.content);
-      if (effective_theirs && base) {
+      if (effective_theirs) {
         this.fileTheirsAccumulator.set(resolvedPath, {
           content: effective_theirs,
           baseGeneration: patch.base_generation
@@ -15336,34 +15413,6 @@ CLI Version: ${options.cliVersion}`;
   }
 };
 
-// src/conflict-utils.ts
-function stripConflictMarkers(content) {
-  const lines = content.split("\n");
-  const result = [];
-  let inConflict = false;
-  let inOurs = false;
-  for (const line of lines) {
-    if (line.startsWith("<<<<<<< ")) {
-      inConflict = true;
-      inOurs = true;
-      continue;
-    }
-    if (inConflict && line === "=======") {
-      inOurs = false;
-      continue;
-    }
-    if (inConflict && line.startsWith(">>>>>>> ")) {
-      inConflict = false;
-      inOurs = false;
-      continue;
-    }
-    if (!inConflict || inOurs) {
-      result.push(line);
-    }
-  }
-  return result.join("\n");
-}
-
 // src/ReplayService.ts
 var ReplayService = class {
   git;
@@ -16330,30 +16379,145 @@ function computeContentHash(patchContent) {
 }
 
 // src/commands/forget.ts
-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;
+}
+var EMPTY_RESULT = {
+  initialized: false,
+  removed: [],
+  remaining: 0,
+  notFound: false,
+  alreadyForgotten: [],
+  totalPatches: 0,
+  warnings: []
+};
+function forget(outputDir, options) {
   const lockManager = new LockfileManager(outputDir);
   if (!lockManager.exists()) {
-    return { removed: [], notFound: true };
+    return { ...EMPTY_RESULT };
   }
   const lock = lockManager.read();
-  const matchingPatches = lock.patches.filter(
-    (patch) => patch.files.some((file) => file === filePattern || 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)
+  };
 }
 
 // src/commands/reset.ts
@@ -16471,6 +16635,55 @@ async function getChangedFiles(git, currentGen, files) {
   return changed.length > 0 ? changed : files;
 }
 
+// src/commands/status.ts
+function status(outputDir) {
+  const lockManager = new LockfileManager(outputDir);
+  if (!lockManager.exists()) {
+    return {
+      initialized: false,
+      generationCount: 0,
+      lastGeneration: void 0,
+      patches: [],
+      unresolvedCount: 0,
+      excludePatterns: []
+    };
+  }
+  const lock = lockManager.read();
+  const patches = lock.patches.map((patch) => ({
+    id: patch.id,
+    type: patch.patch_content.includes("new file mode") ? "added" : "modified",
+    message: patch.original_message,
+    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.slice(0, 7),
+      timestamp: lastGen.timestamp,
+      cliVersion: lastGen.cli_version,
+      generatorVersions: lastGen.generator_versions
+    };
+  }
+  const config = lockManager.getCustomizationsConfig();
+  const excludePatterns = config.exclude ?? [];
+  return {
+    initialized: true,
+    generationCount: lock.generations.length,
+    lastGeneration,
+    patches,
+    unresolvedCount,
+    excludePatterns
+  };
+}
+
 // src/cli.ts
 var COMMANDS = ["bootstrap", "status", "detect", "replay", "migrate", "forget", "reset", "resolve"];
 function usage() {
@@ -16482,7 +16695,7 @@ Commands:
   detect      Detect new customization patches (dry-run)
   replay      Run full replay (detect + apply patches)
   migrate     Analyze .fernignore migration
-  forget      Remove specific patches by file pattern
+  forget      Remove specific patches (by ID, search, or --all)
   reset       Remove all Replay state (nuclear option)
   resolve     Finish replay after manually resolving conflicts
 
@@ -16492,6 +16705,8 @@ Options:
   --no-check        Skip conflict marker check (resolve command only)
   --migrate-fernignore  Move untrackable .fernignore patterns to replay.yml
   --max-commits <n>     Max commits to scan (default: 500)
+  --all               Remove all tracked patches (forget only)
+  --yes, -y           Skip interactive selection/confirmation (forget only)
 
 Examples:
   fern-replay bootstrap ./my-sdk
@@ -16501,8 +16716,9 @@ Examples:
   fern-replay detect ./my-sdk
   fern-replay replay ./my-sdk --dry-run
   fern-replay migrate ./my-sdk
+  fern-replay forget ./my-sdk patch-def45678
   fern-replay forget ./my-sdk "src/utils/retry.ts"
-  fern-replay forget ./my-sdk "src/legacy/**" --dry-run
+  fern-replay forget ./my-sdk --all
   fern-replay reset ./my-sdk
   fern-replay reset ./my-sdk --dry-run`);
 }
@@ -16527,7 +16743,7 @@ function parseArgs(argv) {
     process.exit(1);
   }
   const flags = {};
-  let pattern;
+  const positionals = [];
   for (let i = 2; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--dry-run") {
@@ -16542,11 +16758,17 @@ function parseArgs(argv) {
       flags.force = true;
     } else if (arg === "--no-check") {
       flags.noCheck = true;
-    } else if (!arg.startsWith("--") && !pattern) {
-      pattern = arg;
+    } else if (arg === "--verbose" || arg === "-v") {
+      flags.verbose = true;
+    } else if (arg === "--all") {
+      flags.all = true;
+    } else if (arg === "--yes" || arg === "-y") {
+      flags.yes = true;
+    } else if (!arg.startsWith("--")) {
+      positionals.push(arg);
     }
   }
-  return { command, dir: (0, import_node_path7.resolve)(dir), flags, pattern };
+  return { command, dir: (0, import_node_path7.resolve)(dir), flags, positionals };
 }
 async function runBootstrap(dir, flags) {
   const dryRun = !!flags.dryRun;
@@ -16599,43 +16821,67 @@ async function runBootstrap(dir, flags) {
     for (const w of result.warnings) console.log(`  ${w}`);
   }
 }
-async function runStatus(dir) {
-  const lockManager = new LockfileManager(dir);
-  if (!lockManager.exists()) {
-    console.log("Replay is not initialized. Run 'fern-replay bootstrap <dir>' first.");
+async function runStatus(dir, flags) {
+  const result = status(dir);
+  const verbose = !!flags.verbose;
+  if (!result.initialized) {
+    console.log("Replay is not initialized. Run 'fern replay init' to get started.");
     return;
   }
-  const lock = lockManager.read();
-  const lastGen = lock.generations.find((g) => g.commit_sha === lock.current_generation);
-  console.log(`Replay Status: ${dir}
-`);
-  console.log(`Generations: ${lock.generations.length}`);
-  if (lastGen) {
-    console.log(`Last generation: ${lastGen.commit_sha.slice(0, 7)} (${lastGen.timestamp})`);
-    console.log(`  CLI: ${lastGen.cli_version}`);
-    if (Object.keys(lastGen.generator_versions).length > 0) {
-      for (const [name, ver] of Object.entries(lastGen.generator_versions)) {
+  console.log("Replay: initialized");
+  if (result.lastGeneration) {
+    const gen = result.lastGeneration;
+    if (verbose) {
+      console.log(`Last generation: ${gen.sha} (${gen.timestamp})`);
+      console.log(`  CLI: ${gen.cliVersion}`);
+      for (const [name, ver] of Object.entries(gen.generatorVersions)) {
         console.log(`  ${name}: ${ver}`);
       }
+      console.log(`Generations tracked: ${result.generationCount}`);
+    } else {
+      const genVersions = Object.entries(gen.generatorVersions);
+      const versionSuffix = genVersions.length > 0 ? `, ${genVersions[0][0]}@${genVersions[0][1]}` : "";
+      console.log(`Last generation: ${gen.sha} (${gen.timestamp}${versionSuffix})`);
     }
   }
+  if (result.patches.length === 0) {
+    console.log("\nNo customizations tracked. Edit SDK files and commit \u2014 Replay will detect them on next generation.");
+    return;
+  }
+  const unresolvedSuffix = result.unresolvedCount > 0 ? `, ${result.unresolvedCount} unresolved` : "";
   console.log(`
-Patches: ${lock.patches.length}`);
-  if (lock.patches.length > 0) {
-    for (const patch of lock.patches) {
-      const type = patch.patch_content.includes("new file mode") ? "added" : "modified";
-      console.log(`  ${patch.id} [${type}] "${patch.original_message.slice(0, 50)}"`);
-      console.log(`    by ${patch.original_author} (${patch.original_commit.slice(0, 7)})`);
+Patches: ${result.patches.length} tracked${unresolvedSuffix}`);
+  if (verbose) {
+    for (const patch of result.patches) {
+      const prefix = patch.status ? "\u26A0 " : "  ";
+      console.log(`
+${prefix}${patch.id}  [${patch.type}]  "${patch.message}"`);
+      console.log(`    by ${patch.author} (${patch.sha})`);
       for (const f of patch.files) {
         console.log(`    ${f}`);
       }
+      if (patch.status) {
+        console.log("    Run `fern replay resolve` to fix.");
+      }
+    }
+    if (result.excludePatterns.length > 0) {
+      console.log("\nExclude patterns (from replay.yml):");
+      for (const p of result.excludePatterns) {
+        console.log(`  ${p}`);
+      }
+    }
+  } else {
+    console.log("");
+    const maxDisplay = 10;
+    const displayPatches = result.patches.slice(0, maxDisplay);
+    for (const patch of displayPatches) {
+      const prefix = patch.status ? "\u26A0 " : "  ";
+      const filesLabel = patch.fileCount === 1 ? "1 file" : `${patch.fileCount} files`;
+      console.log(`${prefix}${patch.id}  "${patch.message}"  ${filesLabel}`);
+    }
+    if (result.patches.length > maxDisplay) {
+      console.log(`  ... and ${result.patches.length - maxDisplay} more`);
     }
-  }
-  const config = lockManager.getCustomizationsConfig();
-  if (config.exclude && config.exclude.length > 0) {
-    console.log(`
-Exclude patterns: ${config.exclude.length}`);
-    for (const p of config.exclude) console.log(`  ${p}`);
   }
 }
 async function runDetect(dir) {
@@ -16804,32 +17050,155 @@ Unprotected customizations (${analysis.commitsOnly.length}):`);
     console.log("Run: fern-replay bootstrap <dir>");
   }
 }
-async function runForget(dir, flags, pattern) {
-  if (!pattern) {
-    console.error("Usage: fern-replay forget <sdk-dir> <file-pattern>");
-    console.error("Example: fern-replay forget ./my-sdk src/utils/retry.ts");
-    process.exit(1);
+function formatDiffStat(patch) {
+  return `+${patch.diffstat.additions} -${patch.diffstat.deletions}`;
+}
+function formatPatchLine(index, patch) {
+  const status2 = patch.status ? ` [${patch.status}]` : "";
+  const filesStr = patch.files.join(", ");
+  return `  [${index}]  ${patch.id}  "${patch.message}"  ${formatDiffStat(patch)}  ${filesStr}${status2}`;
+}
+function printForgetWarnings(warnings) {
+  for (const w of warnings) {
+    console.log(`Warning: ${w}`);
   }
+}
+function promptLine(question) {
+  const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+}
+function parseSelection(input, max) {
+  const trimmed2 = input.trim().toLowerCase();
+  if (trimmed2 === "all") return "all";
+  if (trimmed2 === "none" || trimmed2 === "") return "none";
+  const nums = [];
+  for (const part of trimmed2.split(",")) {
+    const n = parseInt(part.trim(), 10);
+    if (isNaN(n) || n < 1 || n > max) return null;
+    if (!nums.includes(n)) nums.push(n);
+  }
+  return nums.length > 0 ? nums : null;
+}
+async function runForget(dir, flags, positionals) {
   const dryRun = !!flags.dryRun;
-  console.log(`Forgetting patches matching: ${pattern}`);
-  if (dryRun) console.log("(dry-run mode)");
-  const result = forget(dir, pattern, { dryRun });
-  if (result.notFound) {
-    console.log("No patches found matching that pattern.");
+  const yes = !!flags.yes;
+  const all = !!flags.all;
+  const isPatchIdMode = positionals.length > 0 && positionals.every((a) => a.startsWith("patch-"));
+  const pattern = !isPatchIdMode && positionals.length > 0 ? positionals[0] : void 0;
+  const patchIds = isPatchIdMode ? positionals : void 0;
+  if (all) {
+    const preview = forget(dir, { all: true, dryRun: true });
+    if (!preview.initialized) {
+      console.log("Replay is not initialized. Run 'fern replay init' to get started.");
+      process.exit(1);
+    }
+    if (preview.totalPatches === 0) {
+      console.log("No patches tracked. Nothing to remove.");
+      return;
+    }
+    if (!dryRun && !yes) {
+      console.log(`WARNING: This will remove all ${preview.totalPatches} tracked patches.`);
+      console.log("Affected files will be overwritten on next generation.");
+      console.log("Replay will remain initialized and detect new customizations.\n");
+      const confirm = await promptLine("Proceed? [y/N] ");
+      if (confirm.toLowerCase() !== "y") {
+        console.log("Aborted.");
+        return;
+      }
+    }
+    const finalResult = dryRun ? preview : forget(dir, { all: true });
+    printForgetWarnings(finalResult.warnings);
+    const verb2 = dryRun ? "Would remove" : "Removed";
+    console.log(`${verb2} ${finalResult.removed.length} patches. ${finalResult.remaining} patches remaining.`);
     return;
   }
-  console.log(`
-${dryRun ? "Would remove" : "Removed"} ${result.removed.length} patch(es):
-`);
-  for (const patch of result.removed) {
-    console.log(`  ${patch.id}: "${patch.message.slice(0, 50)}"`);
-    for (const f of patch.files) {
-      console.log(`    ${f}`);
+  if (isPatchIdMode && patchIds) {
+    const result2 = forget(dir, { patchIds, dryRun });
+    if (!result2.initialized) {
+      console.log("Replay is not initialized. Run 'fern replay init' to get started.");
+      process.exit(1);
+    }
+    if (result2.alreadyForgotten.length > 0 && result2.removed.length === 0) {
+      for (const id of result2.alreadyForgotten) {
+        console.log(`${id} is not tracked. Nothing to remove.`);
+      }
+      return;
     }
+    printForgetWarnings(result2.warnings);
+    if (result2.alreadyForgotten.length > 0) {
+      for (const id of result2.alreadyForgotten) {
+        console.log(`${id} is not tracked (skipped).`);
+      }
+    }
+    const verb2 = dryRun ? "Would remove" : "Removed";
+    if (result2.removed.length === 1) {
+      const p = result2.removed[0];
+      console.log(`${verb2} 1 patch: "${p.message}" (${p.files.length} files)`);
+    } else {
+      console.log(`${verb2} ${result2.removed.length} patches.`);
+    }
+    console.log(`${result2.remaining} patches remaining.`);
+    return;
   }
-  if (!dryRun) {
-    console.log("\nNext generation will restore pure generated code for these files.");
+  const searchResult = pattern ? forget(dir, { pattern }) : forget(dir);
+  if (!searchResult.initialized) {
+    console.log("Replay is not initialized. Run 'fern replay init' to get started.");
+    process.exit(1);
+  }
+  const matches = searchResult.matched ?? [];
+  if (matches.length === 0) {
+    if (pattern) {
+      console.log(`No patches found matching "${pattern}". Run 'fern replay status -v' to see all tracked patches.`);
+    } else {
+      console.log("No patches tracked. Nothing to remove.");
+    }
+    return;
+  }
+  if (pattern) {
+    console.log(`Found ${matches.length} patch(es) matching "${pattern}":
+`);
+  } else {
+    console.log("All tracked patches:\n");
   }
+  for (let i = 0; i < matches.length; i++) {
+    console.log(formatPatchLine(i + 1, matches[i]));
+  }
+  if (!process.stdin.isTTY && !yes) {
+    console.error("\nError: Interactive selection required. Use patch IDs directly or add --yes to remove all matches.");
+    process.exit(1);
+  }
+  let selectedIds;
+  if (yes) {
+    selectedIds = matches.map((m) => m.id);
+  } else {
+    console.log();
+    const input = await promptLine("Remove which? (comma-separated numbers, 'all', or 'none'): ");
+    const selection = parseSelection(input, matches.length);
+    if (selection === "none" || selection === null) {
+      if (selection === null) console.log("Invalid selection.");
+      console.log("Aborted.");
+      return;
+    }
+    selectedIds = selection === "all" ? matches.map((m) => m.id) : selection.map((i) => matches[i - 1].id);
+    console.log(`
+This will remove ${selectedIds.length} patch(es). Affected files will be overwritten on next generation.`);
+    const confirm = await promptLine("Proceed? [y/N] ");
+    if (confirm.toLowerCase() !== "y") {
+      console.log("Aborted.");
+      return;
+    }
+  }
+  const result = forget(dir, { patchIds: selectedIds, dryRun });
+  printForgetWarnings(result.warnings);
+  const verb = dryRun ? "Would remove" : "Removed";
+  console.log(`
+${verb} ${result.removed.length} patch(es).`);
+  console.log(`${result.remaining} patches remaining.`);
 }
 async function runReset(dir, flags) {
   const dryRun = !!flags.dryRun;
@@ -16895,7 +17264,7 @@ Resolve the conflicts in your editor, then run 'fern-replay resolve ${dir}' agai
   console.log("Push to update the PR.");
 }
 async function main() {
-  const { command, dir, flags, pattern } = parseArgs(process.argv);
+  const { command, dir, flags, positionals } = parseArgs(process.argv);
   if (!(0, import_node_fs6.existsSync)(dir)) {
     console.error(`Directory not found: ${dir}`);
     process.exit(1);
@@ -16905,7 +17274,7 @@ async function main() {
       await runBootstrap(dir, flags);
       break;
     case "status":
-      await runStatus(dir);
+      await runStatus(dir, flags);
       break;
     case "detect":
       await runDetect(dir);
@@ -16917,7 +17286,7 @@ async function main() {
       await runMigrate(dir);
       break;
     case "forget":
-      await runForget(dir, flags, pattern);
+      await runForget(dir, flags, positionals);
       break;
     case "reset":
       await runReset(dir, flags);