@fern-api/generator-cli 0.9.33 → 0.9.35

package/dist/cli.js

@@ -22126,7 +22126,7 @@ var init_diff3 = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/@fern-api+replay@0.16.1/node_modules/@fern-api/replay/dist/index.js
+// ../../node_modules/.pnpm/@fern-api+replay@0.16.2/node_modules/@fern-api/replay/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
   CREDENTIAL_PATTERNS: () => CREDENTIAL_PATTERNS,
@@ -22437,13 +22437,13 @@ function isSensitiveFile(filePath) {
   return SENSITIVE_FILE_PATTERNS.some((re) => re.test(filePath));
 }
 function scanForCredentials(content) {
-  const matches = [];
+  const matches2 = [];
   for (const { name, re } of CREDENTIAL_PATTERNS) {
     if (re.test(content)) {
-      matches.push(name);
+      matches2.push(name);
     }
   }
-  return matches;
+  return matches2;
 }
 function isGenerationCommit(commit) {
   const isFernSupport = FERN_SUPPORT_NAMES.includes(commit.authorName);
@@ -22485,6 +22485,15 @@ function isBinaryFile(filePath) {
   const ext2 = (0, import_path9.extname)(filePath).toLowerCase();
   return BINARY_EXTENSIONS.has(ext2);
 }
+function matchesFernignorePattern(filePath, patterns) {
+  if (patterns.length === 0) return false;
+  return patterns.some((p2) => {
+    if (filePath === p2) return true;
+    if (minimatch(filePath, p2)) return true;
+    if (!p2.includes("*") && !p2.includes("?") && filePath.startsWith(p2 + "/")) return true;
+    return false;
+  });
+}
 function parsePatchFileHeaders(patchContent) {
   const results = [];
   let currentPath = null;
@@ -22525,11 +22534,13 @@ async function capturePatchSnapshot(git, files, treeish) {
   }
   return snapshot;
 }
-function filterInfrastructureAndSensitiveFiles(rawFilesOutput) {
+function filterInfrastructureAndSensitiveFiles(rawFilesOutput, fernignorePatterns) {
   const allFiles = rawFilesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
   const sensitiveFiles = allFiles.filter((f) => isSensitiveFile(f));
-  const files = allFiles.filter((f) => !isSensitiveFile(f));
-  return { files, sensitiveFiles };
+  const nonSensitive = allFiles.filter((f) => !isSensitiveFile(f));
+  const fernignoredFiles = nonSensitive.filter((f) => matchesFernignorePattern(f, fernignorePatterns));
+  const files = nonSensitive.filter((f) => !matchesFernignorePattern(f, fernignorePatterns));
+  return { files, sensitiveFiles, fernignoredFiles };
 }
 function threeWayMerge(base, ours, theirs) {
   const baseLines = base.split("\n");
@@ -23375,6 +23386,93 @@ function computeCommitBuckets(results, absorbedPatchIds, patchesPassedToCommit)
   }
   return { applied, unresolved, absorbed };
 }
+function computeLegacyFernignoreCleanse(patch, fernignorePatterns, computeContentHash2) {
+  const matchesFernignore = (filePath) => fernignorePatterns.some((p2) => {
+    if (filePath === p2) return true;
+    if (minimatch(filePath, p2)) return true;
+    if (!p2.includes("*") && !p2.includes("?") && filePath.startsWith(p2 + "/")) return true;
+    return false;
+  });
+  const strippedFromFiles = patch.files.filter(matchesFernignore);
+  const survivingFiles = patch.files.filter((f) => !matchesFernignore(f));
+  let survivingSnapshot = void 0;
+  let snapshotChanged = false;
+  if (patch.theirs_snapshot) {
+    survivingSnapshot = {};
+    for (const [key, value] of Object.entries(patch.theirs_snapshot)) {
+      if (matchesFernignore(key)) {
+        snapshotChanged = true;
+      } else {
+        survivingSnapshot[key] = value;
+      }
+    }
+  }
+  const { stripped: patchContentStripped, content: newPatchContent, strippedSectionPaths } = stripFernignoreDiffSections(patch.patch_content, matchesFernignore);
+  const unchanged = strippedFromFiles.length === 0 && !snapshotChanged && !patchContentStripped;
+  if (unchanged) {
+    return {
+      unchanged: true,
+      remove: false,
+      files: patch.files,
+      patch_content: patch.patch_content,
+      content_hash: patch.content_hash,
+      theirs_snapshot: patch.theirs_snapshot,
+      strippedPaths: []
+    };
+  }
+  const strippedPaths = Array.from(/* @__PURE__ */ new Set([...strippedFromFiles, ...strippedSectionPaths]));
+  if (survivingFiles.length === 0 || newPatchContent.trim() === "") {
+    return {
+      unchanged: false,
+      remove: true,
+      files: [],
+      patch_content: "",
+      content_hash: "",
+      strippedPaths
+    };
+  }
+  const newContentHash = patchContentStripped ? computeContentHash2(newPatchContent) : patch.content_hash;
+  return {
+    unchanged: false,
+    remove: false,
+    files: survivingFiles,
+    patch_content: newPatchContent,
+    content_hash: newContentHash,
+    ...survivingSnapshot !== void 0 ? { theirs_snapshot: survivingSnapshot } : {},
+    strippedPaths
+  };
+}
+function stripFernignoreDiffSections(patchContent, matchesFernignore) {
+  const lines = patchContent.split("\n");
+  const sectionStarts = [];
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    const line = lines[i2];
+    if (line.startsWith("diff --git ")) {
+      const match2 = line.match(/^diff --git a\/(.+?) b\/(.+?)$/);
+      const path5 = match2 ? match2[2] : null;
+      sectionStarts.push({ idx: i2, path: path5 });
+    }
+  }
+  if (sectionStarts.length === 0) {
+    return { stripped: false, content: patchContent, strippedSectionPaths: [] };
+  }
+  const preamble = lines.slice(0, sectionStarts[0].idx);
+  const newLines = [...preamble];
+  const strippedSectionPaths = [];
+  let stripped = false;
+  for (let i2 = 0; i2 < sectionStarts.length; i2++) {
+    const section = sectionStarts[i2];
+    const next = sectionStarts[i2 + 1];
+    const endIdx = next ? next.idx : lines.length;
+    if (section.path !== null && matchesFernignore(section.path)) {
+      stripped = true;
+      strippedSectionPaths.push(section.path);
+      continue;
+    }
+    newLines.push(...lines.slice(section.idx, endIdx));
+  }
+  return { stripped, content: newLines.join("\n"), strippedSectionPaths };
+}
 async function bootstrap(outputDir, options) {
   const git = new GitClient(outputDir);
   const lockManager = new LockfileManager(outputDir);
@@ -23958,7 +24056,7 @@ function status(outputDir) {
 }
 var import_promises3, import_os, import_path7, import_fs6, import_path8, import_yaml, import_crypto, import_path9, import_promises4, import_os2, import_path10, import_promises5, import_path11, import_promises6, import_path12, import_fs7, import_promises7, import_path13, import_promises8, import_os3, import_path14, import_child_process3, import_crypto2, import_fs8, import_path15, import_yaml2, import_crypto3, import_fs9, import_path16, import_fs10, import_promises9, import_path17, __defProp3, __getOwnPropNames3, __esm3, __export3, GitClient_exports, GitClient, init_GitClient, HybridReconstruction_exports, init_HybridReconstruction, PatchApplyTheirs_exports, init_PatchApplyTheirs, CREDENTIAL_PATTERNS, SENSITIVE_FILE_PATTERNS, FERN_BOT_NAME, FERN_BOT_EMAIL, FERN_BOT_LOGIN, FERN_SUPPORT_NAMES, LOCKFILE_HEADER, LockfileNotFoundError, LockfileManager, BINARY_EXTENSIONS, INFRASTRUCTURE_FILES, ReplayDetector, MergeAccumulator, CONFLICT_OPENER, CONFLICT_SEPARATOR, CONFLICT_CLOSER, ReplayApplicator, ReplayCommitter, FileOwnership, FirstGenerationFlow, SkipApplicationFlow, NoPatchesFlow, NormalRegenerationFlow, ReplayService, FernignoreMigrator, REPLAY_FERNIGNORE_ENTRIES, GITATTRIBUTES_ENTRIES, EMPTY_RESULT;
 var init_dist3 = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.16.1/node_modules/@fern-api/replay/dist/index.js"() {
+  "../../node_modules/.pnpm/@fern-api+replay@0.16.2/node_modules/@fern-api/replay/dist/index.js"() {
     "use strict";
     init_esm4();
     import_promises3 = require("fs/promises");
@@ -23969,6 +24067,7 @@ var init_dist3 = __esm({
     init_esm3();
     import_yaml = __toESM(require_dist3(), 1);
     import_crypto = require("crypto");
+    init_esm3();
     import_path9 = require("path");
     init_diff3();
     import_promises4 = require("fs/promises");
@@ -24451,11 +24550,13 @@ var init_dist3 = __esm({
       git;
       lockManager;
       sdkOutputDir;
+      fernignorePatterns;
       warnings = [];
-      constructor(git, lockManager, sdkOutputDir) {
+      constructor(git, lockManager, sdkOutputDir, fernignorePatterns = []) {
         this.git = git;
         this.lockManager = lockManager;
         this.sdkOutputDir = sdkOutputDir;
+        this.fernignorePatterns = fernignorePatterns;
       }
       /**
        * Derive the previous-generation SHA from git history instead of trusting
@@ -24562,22 +24663,30 @@ var init_dist3 = __esm({
             continue;
           }
           const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
-          const { files, sensitiveFiles } = filterInfrastructureAndSensitiveFiles(filesOutput);
+          const { files, sensitiveFiles, fernignoredFiles } = filterInfrastructureAndSensitiveFiles(
+            filesOutput,
+            this.fernignorePatterns
+          );
           if (sensitiveFiles.length > 0) {
             this.warnings.push(
               `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveFiles.join(", ")}. These files will not be tracked by replay.`
             );
-            if (files.length > 0) {
-              const parentSha = parents[0];
-              if (parentSha) {
-                try {
-                  patchContent = await this.git.exec(["diff", parentSha, commit.sha, "--", ...files]);
-                } catch {
-                  continue;
-                }
-                if (!patchContent.trim()) continue;
-                contentHash = this.computeContentHash(patchContent);
+          }
+          if (fernignoredFiles.length > 0) {
+            this.warnings.push(
+              `.fernignore-protected file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${fernignoredFiles.join(", ")}. These files are managed by .fernignore, not Replay.`
+            );
+          }
+          if ((sensitiveFiles.length > 0 || fernignoredFiles.length > 0) && files.length > 0) {
+            const parentSha = parents[0];
+            if (parentSha) {
+              try {
+                patchContent = await this.git.exec(["diff", parentSha, commit.sha, "--", ...files]);
+              } catch {
+                continue;
               }
+              if (!patchContent.trim()) continue;
+              contentHash = this.computeContentHash(patchContent);
             }
           }
           if (files.length === 0) {
@@ -24776,12 +24885,20 @@ var init_dist3 = __esm({
           resolvedBaseGeneration = fallback;
         }
         const filesOutput = await this.git.exec(["diff", "--name-only", diffBase, "HEAD"]);
-        const { files, sensitiveFiles } = filterInfrastructureAndSensitiveFiles(filesOutput);
+        const { files, sensitiveFiles, fernignoredFiles } = filterInfrastructureAndSensitiveFiles(
+          filesOutput,
+          this.fernignorePatterns
+        );
         if (sensitiveFiles.length > 0) {
           this.warnings.push(
             `Sensitive file(s) excluded from composite patch: ${sensitiveFiles.join(", ")}. These files will not be tracked by replay.`
           );
         }
+        if (fernignoredFiles.length > 0) {
+          this.warnings.push(
+            `.fernignore-protected file(s) excluded from composite patch: ${fernignoredFiles.join(", ")}. These files are managed by .fernignore, not Replay.`
+          );
+        }
         if (files.length === 0) return { patches: [], revertedPatchIds: [] };
         const diff = await this.git.exec(["diff", diffBase, "HEAD", "--", ...files]);
         if (!diff.trim()) return { patches: [], revertedPatchIds: [] };
@@ -24864,23 +24981,31 @@ var init_dist3 = __esm({
             continue;
           }
           const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
-          const { files, sensitiveFiles } = filterInfrastructureAndSensitiveFiles(filesOutput);
+          const { files, sensitiveFiles, fernignoredFiles } = filterInfrastructureAndSensitiveFiles(
+            filesOutput,
+            this.fernignorePatterns
+          );
           if (sensitiveFiles.length > 0) {
             this.warnings.push(
               `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveFiles.join(", ")}. These files will not be tracked by replay.`
             );
-            if (files.length > 0) {
-              if (parents.length === 0) {
-                continue;
-              }
-              try {
-                patchContent = await this.git.exec(["diff", parents[0], commit.sha, "--", ...files]);
-              } catch {
-                continue;
-              }
-              if (!patchContent.trim()) continue;
-              contentHash = this.computeContentHash(patchContent);
+          }
+          if (fernignoredFiles.length > 0) {
+            this.warnings.push(
+              `.fernignore-protected file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${fernignoredFiles.join(", ")}. These files are managed by .fernignore, not Replay.`
+            );
+          }
+          if ((sensitiveFiles.length > 0 || fernignoredFiles.length > 0) && files.length > 0) {
+            if (parents.length === 0) {
+              continue;
+            }
+            try {
+              patchContent = await this.git.exec(["diff", parents[0], commit.sha, "--", ...files]);
+            } catch {
+              continue;
             }
+            if (!patchContent.trim()) continue;
+            contentHash = this.computeContentHash(patchContent);
           }
           if (files.length === 0) {
             continue;
@@ -26097,7 +26222,8 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
         this.git = git;
         this.outputDir = outputDir;
         this.lockManager = new LockfileManager(outputDir);
-        this.detector = new ReplayDetector(git, this.lockManager, outputDir);
+        const fernignorePatterns = this.readFernignorePatterns();
+        this.detector = new ReplayDetector(git, this.lockManager, outputDir, fernignorePatterns);
         this.applicator = new ReplayApplicator(git, this.lockManager, outputDir);
         this.committer = new ReplayCommitter(git, outputDir);
         this.fileOwnership = new FileOwnership(git);
@@ -26117,8 +26243,60 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
       async prepareReplay(options) {
         this.warnings = [];
         this.detector.warnings.length = 0;
+        this.cleanseLegacyFernignoreEntries();
         return this.selectFlow(options).prepare(options);
       }
+      /**
+       * ADR 0002 migration step. Strips `.fernignore`-matched entries from
+       * `patch.files`, `patch.theirs_snapshot` keys, and `diff --git` sections
+       * in `patch.patch_content` for every patch in the lockfile. Patches that
+       * end up with no surviving files are removed entirely.
+       *
+       * Idempotent: a second run is a no-op because the first run already
+       * matches the contract. Per-patch try/catch ensures one bad patch does
+       * not block the rest. Each affected patch emits a warning naming the
+       * stripped paths. `patch_content` is left untouched if no parseable
+       * `diff --git` headers are found (fail-safe for exotic legacy formats).
+       */
+      cleanseLegacyFernignoreEntries() {
+        const patterns = this.readFernignorePatterns();
+        if (patterns.length === 0) return;
+        if (!this.lockManager.exists()) return;
+        this.lockManager.read();
+        let lockfileMutated = false;
+        const patches = this.lockManager.getPatches();
+        for (const patch of patches) {
+          try {
+            const result = computeLegacyFernignoreCleanse(
+              patch,
+              patterns,
+              (content) => this.detector.computeContentHash(content)
+            );
+            if (result.unchanged) continue;
+            if (result.remove) {
+              this.lockManager.removePatch(patch.id);
+              this.warnings.push(
+                `Cleansed legacy patch ${patch.id}: all referenced files match .fernignore \u2014 patch removed. Customer's on-disk content for those files is preserved by .fernignore. (ADR 0002: .fernignore-protected files are not tracked by Replay.)`
+              );
+            } else {
+              this.lockManager.updatePatch(patch.id, {
+                files: result.files,
+                patch_content: result.patch_content,
+                content_hash: result.content_hash,
+                ...result.theirs_snapshot !== void 0 ? { theirs_snapshot: result.theirs_snapshot } : {}
+              });
+              this.warnings.push(
+                `Cleansed legacy patch ${patch.id}: stripped .fernignore-matched entries (${result.strippedPaths.join(", ")}). Customer's on-disk content for those files is preserved by .fernignore. (ADR 0002.)`
+              );
+            }
+            lockfileMutated = true;
+          } catch {
+          }
+        }
+        if (lockfileMutated) {
+          this.lockManager.save();
+        }
+      }
       /**
        * Phase 2 of the two-phase replay flow. Applies patches, rebases them against
        * the generation, saves the lockfile, and commits `[fern-replay]` (or stages
@@ -31413,6 +31591,11 @@ var ClonedRepository = class _ClonedRepository {
     }
     await this.git.raw([...args, ...Array.isArray(files) ? files : [files]]);
   }
+  async listTrackedFiles() {
+    await this.git.cwd(this.clonePath);
+    const result = await this.git.raw(["ls-tree", "-r", "HEAD", "--name-only"]);
+    return result.split("\n").filter((line) => line.length > 0);
+  }
   async restoreFilesFromCommit(commitSha, files) {
     await this.git.cwd(this.clonePath);
     const fileList = Array.isArray(files) ? files : [files];
@@ -31835,6 +32018,20 @@ async function cloneRepository({ githubRepository, installationToken, targetDire
   });
 }
 
+// ../commons/github/lib/expandFernignorePatterns.js
+init_esm3();
+function expandFernignorePatterns(fernignoreContent, candidatePaths) {
+  const patterns = fernignoreContent.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+  return candidatePaths.filter((candidate) => patterns.some((pattern) => matches(candidate, pattern)));
+}
+function matches(candidate, pattern) {
+  const normalized = pattern.endsWith("/") ? pattern.slice(0, -1) : pattern;
+  if (minimatch(candidate, normalized, { dot: true, nonegate: true })) {
+    return true;
+  }
+  return candidate === normalized || candidate.startsWith(normalized + "/");
+}
+
 // ../../node_modules/.pnpm/universal-user-agent@7.0.3/node_modules/universal-user-agent/index.js
 function getUserAgent() {
   if (typeof navigator === "object" && "userAgent" in navigator) {
@@ -32051,11 +32248,11 @@ function removeNonChars(variableName) {
   return variableName.replace(/(?:^\W+)|(?:(?<!\W)\W+$)/g, "").split(/,/);
 }
 function extractUrlVariableNames(url) {
-  const matches = url.match(urlVariableRegex);
-  if (!matches) {
+  const matches2 = url.match(urlVariableRegex);
+  if (!matches2) {
     return [];
   }
-  return matches.map(removeNonChars).reduce((a, b3) => a.concat(b3), []);
+  return matches2.map(removeNonChars).reduce((a, b3) => a.concat(b3), []);
 }
 function omit(object2, keysToOmit) {
   const result = { __proto__: null };
@@ -32498,8 +32695,8 @@ async function fetchWrapper(requestOptions) {
     data: ""
   };
   if ("deprecation" in responseHeaders) {
-    const matches = responseHeaders.link && responseHeaders.link.match(/<([^<>]+)>; rel="deprecation"/);
-    const deprecationLink = matches && matches.pop();
+    const matches2 = responseHeaders.link && responseHeaders.link.match(/<([^<>]+)>; rel="deprecation"/);
+    const deprecationLink = matches2 && matches2.pop();
     log.warn(
       `[@octokit/request] "${requestOptions.method} ${requestOptions.url}" is deprecated. It is scheduled to be removed on ${responseHeaders.sunset}${deprecationLink ? `. See ${deprecationLink}` : ""}`
     );
@@ -35583,15 +35780,8 @@ var GitHub = class {
     if (fernignore === void 0) {
       return [];
     }
-    const fernignoreLines = fernignore.split("\n");
-    const fernignoreFiles = [];
-    for (const line of fernignoreLines) {
-      const trimmedLine = line.trim();
-      if (!trimmedLine.startsWith("#") && trimmedLine.length > 0 && await repository.fileExists({ relativeFilePath: trimmedLine })) {
-        fernignoreFiles.push(trimmedLine);
-      }
-    }
-    return fernignoreFiles;
+    const tracked = await repository.listTrackedFiles();
+    return expandFernignorePatterns(fernignore, tracked);
   }
   async restoreFiles(repository, files) {
     if (files.length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fern-api/generator-cli",
-  "version": "0.9.33",
+  "version": "0.9.35",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fern-api/fern.git",
@@ -23,7 +23,7 @@
   ],
   "dependencies": {
     "@boundaryml/baml": "^0.219.0",
-    "@fern-api/replay": "0.16.1",
+    "@fern-api/replay": "0.16.2",
     "@octokit/rest": "^22.0.1",
     "es-toolkit": "^1.45.1",
     "semver": "^7.6.3",