@fern-api/replay 0.8.1 → 0.9.0

package/dist/index.d.cts

@@ -3,6 +3,7 @@ interface GenerationLock {
     generations: GenerationRecord[];
     current_generation: string;
     patches: StoredPatch[];
+    forgotten_hashes?: string[];
     replay_skipped_at?: string;
 }
 interface GenerationRecord {
@@ -137,6 +138,7 @@ declare class LockfileManager {
     updatePatch(patchId: string, updates: Partial<Pick<StoredPatch, "base_generation" | "patch_content" | "content_hash" | "files" | "status">>): void;
     removePatch(patchId: string): void;
     clearPatches(): void;
+    addForgottenHash(hash: string): void;
     getUnresolvedPatches(): StoredPatch[];
     getResolvingPatches(): StoredPatch[];
     markPatchUnresolved(patchId: string): void;
@@ -426,18 +428,43 @@ declare function bootstrap(outputDir: string, options?: BootstrapOptions): Promi
 interface ForgetOptions {
     /** Don't actually remove, just show what would be removed */
     dryRun?: boolean;
+    /** Remove all tracked patches (keep lockfile and generation history) */
+    all?: boolean;
+    /** Specific patch IDs to remove */
+    patchIds?: string[];
+    /** Search pattern: file path, glob, or commit message substring */
+    pattern?: string;
+}
+interface DiffStat {
+    additions: number;
+    deletions: number;
+}
+interface MatchedPatch {
+    id: string;
+    message: string;
+    files: string[];
+    diffstat: DiffStat;
+    status?: "unresolved" | "resolving";
 }
 interface ForgetResult {
-    /** Patches that were (or would be) removed */
-    removed: Array<{
-        id: string;
-        message: string;
-        files: string[];
-    }>;
-    /** True if no patches matched the pattern */
+    /** Whether replay is initialized (lockfile exists) */
+    initialized: boolean;
+    /** Patches that were (or would be in dry-run) removed */
+    removed: MatchedPatch[];
+    /** Number of patches remaining after removal */
+    remaining: number;
+    /** True if a search/pattern was given but nothing matched */
     notFound: boolean;
+    /** Patch IDs that were specified but don't exist (idempotent mode) */
+    alreadyForgotten: string[];
+    /** Total patches before removal */
+    totalPatches: number;
+    /** Warnings (e.g., forgetting patches with conflict markers on disk) */
+    warnings: string[];
+    /** Matching patches for interactive selection (search/no-arg mode only) */
+    matched?: MatchedPatch[];
 }
-declare function forget(outputDir: string, filePattern: string, options?: ForgetOptions): ForgetResult;
+declare function forget(outputDir: string, options?: ForgetOptions): ForgetResult;
 
 interface ResetOptions {
     /** Don't actually delete, just show what would happen */
@@ -480,27 +507,45 @@ declare function resolve(outputDir: string, options?: ResolveOptions): Promise<R
 interface StatusResult {
     /** Whether replay is initialized (lockfile exists) */
     initialized: boolean;
-    /** Tracked customization patches */
-    patches: StatusPatch[];
+    /** Total number of generations tracked */
+    generationCount: number;
     /** Last generation info, if available */
     lastGeneration: StatusGeneration | undefined;
+    /** Tracked customization patches */
+    patches: StatusPatch[];
+    /** Count of patches with "unresolved" or "resolving" status */
+    unresolvedCount: number;
+    /** Exclude patterns from replay.yml */
+    excludePatterns: string[];
 }
 interface StatusPatch {
-    /** Short SHA of the original commit */
-    sha: string;
-    /** Author name (without email) */
-    author: string;
+    /** Patch ID (e.g. "patch-def45678") */
+    id: string;
+    /** "added" if patch_content contains "new file mode", otherwise "modified" */
+    type: "added" | "modified";
     /** Original commit message */
     message: string;
+    /** Author name (without email) */
+    author: string;
+    /** Short SHA of the original commit (7 chars) */
+    sha: string;
     /** Files touched by this patch */
     files: string[];
+    /** Number of files */
+    fileCount: number;
+    /** Patch resolution status, if any */
+    status?: "unresolved" | "resolving";
 }
 interface StatusGeneration {
-    /** Full commit SHA */
+    /** Short commit SHA (7 chars) */
     sha: string;
     /** Generation timestamp */
     timestamp: string;
+    /** CLI version used for generation */
+    cliVersion: string;
+    /** Generator versions (e.g. { "fern-java-sdk": "3.35.0" }) */
+    generatorVersions: Record<string, string>;
 }
 declare function status(outputDir: string): StatusResult;
 
-export { type BootstrapOptions, type BootstrapResult, type CommitInfo, type CommitOptions, type ConflictDetail, type ConflictMetadata, type ConflictReason, type ConflictRegion, type CustomizationsConfig, type DetectionResult, FERN_BOT_EMAIL, FERN_BOT_LOGIN, FERN_BOT_NAME, FernignoreMigrator, type FileResult, type ForgetOptions, type ForgetResult, type GenerationLock, type GenerationRecord, GitClient, LockfileManager, type MergeResult, type MigrationAnalysis, type MigrationResult, type MoveDeclaration, ReplayApplicator, ReplayCommitter, type ReplayConfig, ReplayDetector, type ReplayOptions, type ReplayReport, type ReplayResult, ReplayService, type ResetOptions, type ResetResult, type ResolveOptions, type ResolveResult, type StatusGeneration, type StatusPatch, type StatusResult, type StoredPatch, type UnresolvedPatchInfo, bootstrap, forget, isGenerationCommit, isReplayCommit, isRevertCommit, parseRevertedMessage, parseRevertedSha, reset, resolve, status, threeWayMerge };
+export { type BootstrapOptions, type BootstrapResult, type CommitInfo, type CommitOptions, type ConflictDetail, type ConflictMetadata, type ConflictReason, type ConflictRegion, type CustomizationsConfig, type DetectionResult, type DiffStat, FERN_BOT_EMAIL, FERN_BOT_LOGIN, FERN_BOT_NAME, FernignoreMigrator, type FileResult, type ForgetOptions, type ForgetResult, type GenerationLock, type GenerationRecord, GitClient, LockfileManager, type MatchedPatch, type MergeResult, type MigrationAnalysis, type MigrationResult, type MoveDeclaration, ReplayApplicator, ReplayCommitter, type ReplayConfig, ReplayDetector, type ReplayOptions, type ReplayReport, type ReplayResult, ReplayService, type ResetOptions, type ResetResult, type ResolveOptions, type ResolveResult, type StatusGeneration, type StatusPatch, type StatusResult, type StoredPatch, type UnresolvedPatchInfo, bootstrap, forget, isGenerationCommit, isReplayCommit, isRevertCommit, parseRevertedMessage, parseRevertedSha, reset, resolve, status, threeWayMerge };

package/dist/index.d.ts

@@ -3,6 +3,7 @@ interface GenerationLock {
     generations: GenerationRecord[];
     current_generation: string;
     patches: StoredPatch[];
+    forgotten_hashes?: string[];
     replay_skipped_at?: string;
 }
 interface GenerationRecord {
@@ -137,6 +138,7 @@ declare class LockfileManager {
     updatePatch(patchId: string, updates: Partial<Pick<StoredPatch, "base_generation" | "patch_content" | "content_hash" | "files" | "status">>): void;
     removePatch(patchId: string): void;
     clearPatches(): void;
+    addForgottenHash(hash: string): void;
     getUnresolvedPatches(): StoredPatch[];
     getResolvingPatches(): StoredPatch[];
     markPatchUnresolved(patchId: string): void;
@@ -426,18 +428,43 @@ declare function bootstrap(outputDir: string, options?: BootstrapOptions): Promi
 interface ForgetOptions {
     /** Don't actually remove, just show what would be removed */
     dryRun?: boolean;
+    /** Remove all tracked patches (keep lockfile and generation history) */
+    all?: boolean;
+    /** Specific patch IDs to remove */
+    patchIds?: string[];
+    /** Search pattern: file path, glob, or commit message substring */
+    pattern?: string;
+}
+interface DiffStat {
+    additions: number;
+    deletions: number;
+}
+interface MatchedPatch {
+    id: string;
+    message: string;
+    files: string[];
+    diffstat: DiffStat;
+    status?: "unresolved" | "resolving";
 }
 interface ForgetResult {
-    /** Patches that were (or would be) removed */
-    removed: Array<{
-        id: string;
-        message: string;
-        files: string[];
-    }>;
-    /** True if no patches matched the pattern */
+    /** Whether replay is initialized (lockfile exists) */
+    initialized: boolean;
+    /** Patches that were (or would be in dry-run) removed */
+    removed: MatchedPatch[];
+    /** Number of patches remaining after removal */
+    remaining: number;
+    /** True if a search/pattern was given but nothing matched */
     notFound: boolean;
+    /** Patch IDs that were specified but don't exist (idempotent mode) */
+    alreadyForgotten: string[];
+    /** Total patches before removal */
+    totalPatches: number;
+    /** Warnings (e.g., forgetting patches with conflict markers on disk) */
+    warnings: string[];
+    /** Matching patches for interactive selection (search/no-arg mode only) */
+    matched?: MatchedPatch[];
 }
-declare function forget(outputDir: string, filePattern: string, options?: ForgetOptions): ForgetResult;
+declare function forget(outputDir: string, options?: ForgetOptions): ForgetResult;
 
 interface ResetOptions {
     /** Don't actually delete, just show what would happen */
@@ -480,27 +507,45 @@ declare function resolve(outputDir: string, options?: ResolveOptions): Promise<R
 interface StatusResult {
     /** Whether replay is initialized (lockfile exists) */
     initialized: boolean;
-    /** Tracked customization patches */
-    patches: StatusPatch[];
+    /** Total number of generations tracked */
+    generationCount: number;
     /** Last generation info, if available */
     lastGeneration: StatusGeneration | undefined;
+    /** Tracked customization patches */
+    patches: StatusPatch[];
+    /** Count of patches with "unresolved" or "resolving" status */
+    unresolvedCount: number;
+    /** Exclude patterns from replay.yml */
+    excludePatterns: string[];
 }
 interface StatusPatch {
-    /** Short SHA of the original commit */
-    sha: string;
-    /** Author name (without email) */
-    author: string;
+    /** Patch ID (e.g. "patch-def45678") */
+    id: string;
+    /** "added" if patch_content contains "new file mode", otherwise "modified" */
+    type: "added" | "modified";
     /** Original commit message */
     message: string;
+    /** Author name (without email) */
+    author: string;
+    /** Short SHA of the original commit (7 chars) */
+    sha: string;
     /** Files touched by this patch */
     files: string[];
+    /** Number of files */
+    fileCount: number;
+    /** Patch resolution status, if any */
+    status?: "unresolved" | "resolving";
 }
 interface StatusGeneration {
-    /** Full commit SHA */
+    /** Short commit SHA (7 chars) */
     sha: string;
     /** Generation timestamp */
     timestamp: string;
+    /** CLI version used for generation */
+    cliVersion: string;
+    /** Generator versions (e.g. { "fern-java-sdk": "3.35.0" }) */
+    generatorVersions: Record<string, string>;
 }
 declare function status(outputDir: string): StatusResult;
 
-export { type BootstrapOptions, type BootstrapResult, type CommitInfo, type CommitOptions, type ConflictDetail, type ConflictMetadata, type ConflictReason, type ConflictRegion, type CustomizationsConfig, type DetectionResult, FERN_BOT_EMAIL, FERN_BOT_LOGIN, FERN_BOT_NAME, FernignoreMigrator, type FileResult, type ForgetOptions, type ForgetResult, type GenerationLock, type GenerationRecord, GitClient, LockfileManager, type MergeResult, type MigrationAnalysis, type MigrationResult, type MoveDeclaration, ReplayApplicator, ReplayCommitter, type ReplayConfig, ReplayDetector, type ReplayOptions, type ReplayReport, type ReplayResult, ReplayService, type ResetOptions, type ResetResult, type ResolveOptions, type ResolveResult, type StatusGeneration, type StatusPatch, type StatusResult, type StoredPatch, type UnresolvedPatchInfo, bootstrap, forget, isGenerationCommit, isReplayCommit, isRevertCommit, parseRevertedMessage, parseRevertedSha, reset, resolve, status, threeWayMerge };
+export { type BootstrapOptions, type BootstrapResult, type CommitInfo, type CommitOptions, type ConflictDetail, type ConflictMetadata, type ConflictReason, type ConflictRegion, type CustomizationsConfig, type DetectionResult, type DiffStat, FERN_BOT_EMAIL, FERN_BOT_LOGIN, FERN_BOT_NAME, FernignoreMigrator, type FileResult, type ForgetOptions, type ForgetResult, type GenerationLock, type GenerationRecord, GitClient, LockfileManager, type MatchedPatch, type MergeResult, type MigrationAnalysis, type MigrationResult, type MoveDeclaration, ReplayApplicator, ReplayCommitter, type ReplayConfig, ReplayDetector, type ReplayOptions, type ReplayReport, type ReplayResult, ReplayService, type ResetOptions, type ResetResult, type ResolveOptions, type ResolveResult, type StatusGeneration, type StatusPatch, type StatusResult, type StoredPatch, type UnresolvedPatchInfo, bootstrap, forget, isGenerationCommit, isReplayCommit, isRevertCommit, parseRevertedMessage, parseRevertedSha, reset, resolve, status, threeWayMerge };

package/dist/index.js

@@ -243,6 +243,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");
@@ -339,6 +348,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;
@@ -352,7 +362,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]);
@@ -451,7 +461,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();
@@ -521,6 +531,36 @@ import { mkdir, mkdtemp, readFile, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { dirname as dirname2, extname, join as join2 } from "path";
 import { minimatch } from "minimatch";
+
+// 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/ReplayApplicator.ts
 var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".png",
   ".jpg",
@@ -592,7 +632,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,
@@ -603,6 +644,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 = join2(this.outputDir, fileResult.file);
+            try {
+              const content = await readFile(filePath, "utf-8");
+              const stripped = stripConflictMarkers(content);
+              await writeFile(filePath, stripped);
+            } catch {
+            }
+          }
+        }
+      }
     }
     return results;
   }
@@ -621,7 +689,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
@@ -753,7 +821,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,
@@ -812,7 +880,7 @@ var ReplayApplicator = class {
           reason: "missing-content"
         };
       }
-      if (!base || !ours) {
+      if (!base && !useAccumulatorAsMergeBase || !ours) {
         return {
           file: resolvedPath,
           status: "skipped",
@@ -820,11 +888,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 = dirname2(oursPath);
       await mkdir(outDir, { recursive: true });
       await writeFile(oursPath, merged.content);
-      if (effective_theirs && base) {
+      if (effective_theirs) {
         this.fileTheirsAccumulator.set(resolvedPath, {
           content: effective_theirs,
           baseGeneration: patch.base_generation
@@ -1067,36 +1142,6 @@ import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync
 import { join as join3 } from "path";
 import { minimatch as minimatch2 } from "minimatch";
 init_GitClient();
-
-// 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;
   detector;
@@ -2064,30 +2109,145 @@ function computeContentHash(patchContent) {
 
 // src/commands/forget.ts
 import { minimatch as minimatch4 } from "minimatch";
-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 || minimatch4(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 || minimatch4(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)
+  };
 }
 
 // src/commands/reset.ts
@@ -2209,24 +2369,49 @@ 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
+  };
 }
 export {
   FERN_BOT_EMAIL,