@fern-api/generator-cli 0.10.2 → 0.10.4

package/dist/cli.js

@@ -18618,10 +18618,10 @@ var require_resolve_block_map = __commonJS({
       let offset = bm.offset;
       let commentEnd = null;
       for (const collItem of bm.items) {
-        const { start, key, sep: sep3, value } = collItem;
+        const { start, key, sep: sep4, value } = collItem;
         const keyProps = resolveProps.resolveProps(start, {
           indicator: "explicit-key-ind",
-          next: key ?? sep3?.[0],
+          next: key ?? sep4?.[0],
           offset,
           onError: onError2,
           parentIndent: bm.indent,
@@ -18635,7 +18635,7 @@ var require_resolve_block_map = __commonJS({
             else if ("indent" in key && key.indent !== bm.indent)
               onError2(offset, "BAD_INDENT", startColMsg);
           }
-          if (!keyProps.anchor && !keyProps.tag && !sep3) {
+          if (!keyProps.anchor && !keyProps.tag && !sep4) {
             commentEnd = keyProps.end;
             if (keyProps.comment) {
               if (map.comment)
@@ -18659,7 +18659,7 @@ var require_resolve_block_map = __commonJS({
         ctx.atKey = false;
         if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
           onError2(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
-        const valueProps = resolveProps.resolveProps(sep3 ?? [], {
+        const valueProps = resolveProps.resolveProps(sep4 ?? [], {
           indicator: "map-value-ind",
           next: value,
           offset: keyNode.range[2],
@@ -18675,7 +18675,7 @@ var require_resolve_block_map = __commonJS({
             if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024)
               onError2(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key");
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError2) : composeEmptyNode(ctx, offset, sep3, null, valueProps, onError2);
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError2) : composeEmptyNode(ctx, offset, sep4, null, valueProps, onError2);
           if (ctx.schema.compat)
             utilFlowIndentCheck.flowIndentCheck(bm.indent, value, onError2);
           offset = valueNode.range[2];
@@ -18766,7 +18766,7 @@ var require_resolve_end = __commonJS({
       let comment = "";
       if (end) {
         let hasSpace = false;
-        let sep3 = "";
+        let sep4 = "";
         for (const token of end) {
           const { source, type } = token;
           switch (type) {
@@ -18780,13 +18780,13 @@ var require_resolve_end = __commonJS({
               if (!comment)
                 comment = cb;
               else
-                comment += sep3 + cb;
-              sep3 = "";
+                comment += sep4 + cb;
+              sep4 = "";
               break;
             }
             case "newline":
               if (comment)
-                sep3 += source;
+                sep4 += source;
               hasSpace = true;
               break;
             default:
@@ -18829,18 +18829,18 @@ var require_resolve_flow_collection = __commonJS({
       let offset = fc.offset + fc.start.source.length;
       for (let i2 = 0; i2 < fc.items.length; ++i2) {
         const collItem = fc.items[i2];
-        const { start, key, sep: sep3, value } = collItem;
+        const { start, key, sep: sep4, value } = collItem;
         const props = resolveProps.resolveProps(start, {
           flow: fcName,
           indicator: "explicit-key-ind",
-          next: key ?? sep3?.[0],
+          next: key ?? sep4?.[0],
           offset,
           onError: onError2,
           parentIndent: fc.indent,
           startOnNewline: false
         });
         if (!props.found) {
-          if (!props.anchor && !props.tag && !sep3 && !value) {
+          if (!props.anchor && !props.tag && !sep4 && !value) {
             if (i2 === 0 && props.comma)
               onError2(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
             else if (i2 < fc.items.length - 1)
@@ -18894,8 +18894,8 @@ var require_resolve_flow_collection = __commonJS({
             }
           }
         }
-        if (!isMap && !sep3 && !props.found) {
-          const valueNode = value ? composeNode(ctx, value, props, onError2) : composeEmptyNode(ctx, props.end, sep3, null, props, onError2);
+        if (!isMap && !sep4 && !props.found) {
+          const valueNode = value ? composeNode(ctx, value, props, onError2) : composeEmptyNode(ctx, props.end, sep4, null, props, onError2);
           coll.items.push(valueNode);
           offset = valueNode.range[2];
           if (isBlock(value))
@@ -18907,7 +18907,7 @@ var require_resolve_flow_collection = __commonJS({
           if (isBlock(key))
             onError2(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
           ctx.atKey = false;
-          const valueProps = resolveProps.resolveProps(sep3 ?? [], {
+          const valueProps = resolveProps.resolveProps(sep4 ?? [], {
             flow: fcName,
             indicator: "map-value-ind",
             next: value,
@@ -18918,8 +18918,8 @@ var require_resolve_flow_collection = __commonJS({
           });
           if (valueProps.found) {
             if (!isMap && !props.found && ctx.options.strict) {
-              if (sep3)
-                for (const st of sep3) {
+              if (sep4)
+                for (const st of sep4) {
                   if (st === valueProps.found)
                     break;
                   if (st.type === "newline") {
@@ -18936,7 +18936,7 @@ var require_resolve_flow_collection = __commonJS({
             else
               onError2(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError2) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep3, null, valueProps, onError2) : null;
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError2) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep4, null, valueProps, onError2) : null;
           if (valueNode) {
             if (isBlock(value))
               onError2(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
@@ -19116,7 +19116,7 @@ var require_resolve_block_scalar = __commonJS({
           chompStart = i2 + 1;
       }
       let value = "";
-      let sep3 = "";
+      let sep4 = "";
       let prevMoreIndented = false;
       for (let i2 = 0; i2 < contentStart; ++i2)
         value += lines[i2][0].slice(trimIndent) + "\n";
@@ -19133,24 +19133,24 @@ var require_resolve_block_scalar = __commonJS({
           indent = "";
         }
         if (type === Scalar.Scalar.BLOCK_LITERAL) {
-          value += sep3 + indent.slice(trimIndent) + content;
-          sep3 = "\n";
+          value += sep4 + indent.slice(trimIndent) + content;
+          sep4 = "\n";
         } else if (indent.length > trimIndent || content[0] === "	") {
-          if (sep3 === " ")
-            sep3 = "\n";
-          else if (!prevMoreIndented && sep3 === "\n")
-            sep3 = "\n\n";
-          value += sep3 + indent.slice(trimIndent) + content;
-          sep3 = "\n";
+          if (sep4 === " ")
+            sep4 = "\n";
+          else if (!prevMoreIndented && sep4 === "\n")
+            sep4 = "\n\n";
+          value += sep4 + indent.slice(trimIndent) + content;
+          sep4 = "\n";
           prevMoreIndented = true;
         } else if (content === "") {
-          if (sep3 === "\n")
+          if (sep4 === "\n")
             value += "\n";
           else
-            sep3 = "\n";
+            sep4 = "\n";
         } else {
-          value += sep3 + content;
-          sep3 = " ";
+          value += sep4 + content;
+          sep4 = " ";
           prevMoreIndented = false;
         }
       }
@@ -19332,25 +19332,25 @@ var require_resolve_flow_scalar = __commonJS({
       if (!match2)
         return source;
       let res = match2[1];
-      let sep3 = " ";
+      let sep4 = " ";
       let pos = first2.lastIndex;
       line.lastIndex = pos;
       while (match2 = line.exec(source)) {
         if (match2[1] === "") {
-          if (sep3 === "\n")
-            res += sep3;
+          if (sep4 === "\n")
+            res += sep4;
           else
-            sep3 = "\n";
+            sep4 = "\n";
         } else {
-          res += sep3 + match2[1];
-          sep3 = " ";
+          res += sep4 + match2[1];
+          sep4 = " ";
         }
         pos = line.lastIndex;
       }
       const last2 = /[ \t]*(.*)/sy;
       last2.lastIndex = pos;
       match2 = last2.exec(source);
-      return res + sep3 + (match2?.[1] ?? "");
+      return res + sep4 + (match2?.[1] ?? "");
     }
     function doubleQuotedValue(source, onError2) {
       let res = "";
@@ -20157,14 +20157,14 @@ var require_cst_stringify = __commonJS({
         }
       }
     }
-    function stringifyItem({ start, key, sep: sep3, value }) {
+    function stringifyItem({ start, key, sep: sep4, value }) {
       let res = "";
       for (const st of start)
         res += st.source;
       if (key)
         res += stringifyToken(key);
-      if (sep3)
-        for (const st of sep3)
+      if (sep4)
+        for (const st of sep4)
           res += st.source;
       if (value)
         res += stringifyToken(value);
@@ -21314,18 +21314,18 @@ var require_parser = __commonJS({
         if (this.type === "map-value-ind") {
           const prev = getPrevProps(this.peek(2));
           const start = getFirstKeyStartProps(prev);
-          let sep3;
+          let sep4;
           if (scalar.end) {
-            sep3 = scalar.end;
-            sep3.push(this.sourceToken);
+            sep4 = scalar.end;
+            sep4.push(this.sourceToken);
             delete scalar.end;
           } else
-            sep3 = [this.sourceToken];
+            sep4 = [this.sourceToken];
           const map = {
             type: "block-map",
             offset: scalar.offset,
             indent: scalar.indent,
-            items: [{ start, key: scalar, sep: sep3 }]
+            items: [{ start, key: scalar, sep: sep4 }]
           };
           this.onKeyLine = true;
           this.stack[this.stack.length - 1] = map;
@@ -21478,15 +21478,15 @@ var require_parser = __commonJS({
                 } else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
                   const start2 = getFirstKeyStartProps(it.start);
                   const key = it.key;
-                  const sep3 = it.sep;
-                  sep3.push(this.sourceToken);
+                  const sep4 = it.sep;
+                  sep4.push(this.sourceToken);
                   delete it.key;
                   delete it.sep;
                   this.stack.push({
                     type: "block-map",
                     offset: this.offset,
                     indent: this.indent,
-                    items: [{ start: start2, key, sep: sep3 }]
+                    items: [{ start: start2, key, sep: sep4 }]
                   });
                 } else if (start.length > 0) {
                   it.sep = it.sep.concat(start, this.sourceToken);
@@ -21680,13 +21680,13 @@ var require_parser = __commonJS({
             const prev = getPrevProps(parent);
             const start = getFirstKeyStartProps(prev);
             fixFlowSeqItems(fc);
-            const sep3 = fc.end.splice(1, fc.end.length);
-            sep3.push(this.sourceToken);
+            const sep4 = fc.end.splice(1, fc.end.length);
+            sep4.push(this.sourceToken);
             const map = {
               type: "block-map",
               offset: fc.offset,
               indent: fc.indent,
-              items: [{ start, key: fc, sep: sep3 }]
+              items: [{ start, key: fc, sep: sep4 }]
             };
             this.onKeyLine = true;
             this.stack[this.stack.length - 1] = map;
@@ -36523,6 +36523,11 @@ function escape3(string2) {
   return escape2(toString(string2));
 }
 
+// ../../node_modules/.pnpm/es-toolkit@1.45.1/node_modules/es-toolkit/dist/string/escapeRegExp.mjs
+function escapeRegExp(str) {
+  return str.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
+
 // ../../node_modules/.pnpm/es-toolkit@1.45.1/node_modules/es-toolkit/dist/string/snakeCase.mjs
 function snakeCase(str) {
   const words$1 = words(str);
@@ -40740,6 +40745,9 @@ function countFilesInDiff(diffContent) {
 function formatSizeKB(charLength) {
   return (charLength / 1024).toFixed(1);
 }
+function magicVersionRegExp(mappedMagicVersion) {
+  return new RegExp(`(?<![0-9.])${escapeRegExp(mappedMagicVersion)}(?![0-9A-Za-z-]|\\.[0-9A-Za-z])`, "g");
+}
 var EXCLUDED_DIRECTORIES = /* @__PURE__ */ new Set([
   // Version control
   ".git",
@@ -41524,7 +41532,10 @@ var AutoVersioningService = class _AutoVersioningService {
    */
   async replaceMagicVersion(workingDirectory, mappedMagicVersion, finalVersion) {
     this.logger.debug(`Replacing placeholder version ${mappedMagicVersion} with final version: ${finalVersion}`);
-    const files = await this.walkDirectory(workingDirectory, () => true);
+    const allFiles = await this.walkDirectory(workingDirectory, () => true);
+    const fernignoredFiles = await this.getFernignoredFiles(workingDirectory, allFiles);
+    const files = allFiles.filter((filePath) => !fernignoredFiles.has(filePath));
+    const magicVersionPattern = magicVersionRegExp(mappedMagicVersion);
     const replaceInFile = async (filePath) => {
       if (await this.isBinaryFile(filePath)) {
         return false;
@@ -41533,7 +41544,10 @@ var AutoVersioningService = class _AutoVersioningService {
       if (!content.includes(mappedMagicVersion)) {
         return false;
       }
-      const updated = content.split(mappedMagicVersion).join(finalVersion);
+      const updated = content.replace(magicVersionPattern, () => finalVersion);
+      if (updated === content) {
+        return false;
+      }
       await (0, import_promises15.writeFile)(filePath, updated, "utf-8");
       return true;
     };
@@ -41638,6 +41652,28 @@ var AutoVersioningService = class _AutoVersioningService {
       this.logger.debug(`Updated go.mod: added ${suffix} to module path`);
     }
   }
+  /**
+   * Files protected by `.fernignore` hold customer-owned content, so the placeholder
+   * must never be rewritten inside them (e.g. docs that mention `0.0.0-fern-placeholder`).
+   */
+  async getFernignoredFiles(workingDirectory, files) {
+    const fernignorePath = (0, import_path23.join)(workingDirectory, ".fernignore");
+    let fernignoreContent;
+    try {
+      fernignoreContent = await (0, import_promises15.readFile)(fernignorePath, "utf-8");
+    } catch {
+      return /* @__PURE__ */ new Set();
+    }
+    const relativePaths = new Map(
+      files.map((filePath) => [(0, import_path23.relative)(workingDirectory, filePath).split(import_path23.sep).join("/"), filePath])
+    );
+    return /* @__PURE__ */ new Set([
+      fernignorePath,
+      ...expandFernignorePatterns(fernignoreContent, [...relativePaths.keys()]).map(
+        (relativePath) => relativePaths.get(relativePath) ?? relativePath
+      )
+    ]);
+  }
   /**
    * Recursively walks a directory and returns all file paths matching a filter.
    */
@@ -42017,36 +42053,24 @@ var AutoVersionStep = class extends BaseStep {
       });
     }
     if (cleanedBytes > MAX_RAW_DIFF_BYTES) {
-      this.logger.warn(
-        `AutoVersionStep: diff too large for FAI (${formatSizeKB(cleanedBytes)}KB, limit ${formatSizeKB(MAX_RAW_DIFF_BYTES)}KB). Falling back to PATCH.`
-      );
+      const warning = `diff too large for FAI (${formatSizeKB(cleanedBytes)}KB, limit ${formatSizeKB(MAX_RAW_DIFF_BYTES)}KB)`;
+      this.logger.warn(`AutoVersionStep: ${warning}. Falling back to PATCH.`);
       return await this.finalizeWithBump({
         service,
         language,
         mappedMagicVersion,
         previousVersion,
-        analysis: { versionBump: "PATCH", message: this.brandMessage("SDK regeneration") }
+        analysis: this.fallbackPatchAnalysis(),
+        analysisWarning: warning
       });
     }
-    let analysis;
-    try {
-      if (this.config.ai == null && this.config.fernToken != null) {
-        analysis = await this.analyzeViaFaiService(cleanedDiff, language, previousVersion);
-      } else {
-        const chunks = service.chunkDiff(cleanedDiff, MAX_AI_DIFF_BYTES);
-        const cappedChunks = chunks.slice(0, MAX_CHUNKS);
-        const skippedChunks = chunks.length - cappedChunks.length;
-        if (chunks.length > 1) {
-          this.logger.info(
-            `AutoVersionStep: split diff into ${chunks.length} chunks` + (skippedChunks > 0 ? ` (capped at ${MAX_CHUNKS}, skipping ${skippedChunks})` : "")
-          );
-        }
-        analysis = cappedChunks.length <= 1 ? await this.analyzeSingle(cleanedDiff, language, previousVersion) : await this.analyzeChunks(cappedChunks, language, previousVersion);
-      }
-    } catch (error) {
-      this.logger.warn(`AutoVersionStep: FAI analysis failed (${String(error)}); falling back to PATCH bump.`);
-      analysis = { versionBump: "PATCH", message: this.brandMessage("SDK regeneration") };
-    }
+    const { analysis, analysisWarning } = await this.analyze({
+      service,
+      cleanedDiff,
+      language,
+      previousVersion,
+      label: "AutoVersionStep"
+    });
     if (analysis == null) {
       this.logger.info(`AutoVersionStep: FAI returned NO_CHANGE; rewriting placeholder to ${previousVersion}.`);
       return await this.finalizeNoChange({
@@ -42054,7 +42078,8 @@ var AutoVersionStep = class extends BaseStep {
         language,
         mappedMagicVersion,
         previousVersion,
-        reason: "FAI returned NO_CHANGE"
+        reason: "FAI returned NO_CHANGE",
+        analysisWarning
       });
     }
     return await this.finalizeWithBump({
@@ -42062,7 +42087,8 @@ var AutoVersionStep = class extends BaseStep {
       language,
       mappedMagicVersion,
       previousVersion,
-      analysis
+      analysis,
+      analysisWarning
     });
   }
   /**
@@ -42113,38 +42139,24 @@ var AutoVersionStep = class extends BaseStep {
       });
     }
     if (cleanedBytes > MAX_RAW_DIFF_BYTES) {
-      this.logger.warn(
-        `AutoVersionStep (non-replay): diff too large (${formatSizeKB(cleanedBytes)}KB). Falling back to PATCH.`
-      );
+      const warning = `diff too large for FAI (${formatSizeKB(cleanedBytes)}KB, limit ${formatSizeKB(MAX_RAW_DIFF_BYTES)}KB)`;
+      this.logger.warn(`AutoVersionStep (non-replay): ${warning}. Falling back to PATCH.`);
       return await this.finalizeWithBumpNonReplay({
         service,
         language,
         mappedMagicVersion,
         previousVersion,
-        analysis: { versionBump: "PATCH", message: this.brandMessage("SDK regeneration") }
+        analysis: this.fallbackPatchAnalysis(),
+        analysisWarning: warning
       });
     }
-    let analysis;
-    try {
-      if (this.config.ai == null && this.config.fernToken != null) {
-        analysis = await this.analyzeViaFaiService(cleanedDiff, language, previousVersion);
-      } else {
-        const chunks = service.chunkDiff(cleanedDiff, MAX_AI_DIFF_BYTES);
-        const cappedChunks = chunks.slice(0, MAX_CHUNKS);
-        const skippedChunks = chunks.length - cappedChunks.length;
-        if (chunks.length > 1) {
-          this.logger.info(
-            `AutoVersionStep (non-replay): split diff into ${chunks.length} chunks` + (skippedChunks > 0 ? ` (capped at ${MAX_CHUNKS}, skipping ${skippedChunks})` : "")
-          );
-        }
-        analysis = cappedChunks.length <= 1 ? await this.analyzeSingle(cleanedDiff, language, previousVersion) : await this.analyzeChunks(cappedChunks, language, previousVersion);
-      }
-    } catch (error) {
-      this.logger.warn(
-        `AutoVersionStep (non-replay): FAI analysis failed (${String(error)}); falling back to PATCH bump.`
-      );
-      analysis = { versionBump: "PATCH", message: this.brandMessage("SDK regeneration") };
-    }
+    const { analysis, analysisWarning } = await this.analyze({
+      service,
+      cleanedDiff,
+      language,
+      previousVersion,
+      label: "AutoVersionStep (non-replay)"
+    });
     if (analysis == null) {
       this.logger.info(
         `AutoVersionStep (non-replay): FAI returned NO_CHANGE; rewriting placeholder to ${previousVersion}.`
@@ -42154,7 +42166,8 @@ var AutoVersionStep = class extends BaseStep {
         language,
         mappedMagicVersion,
         previousVersion,
-        reason: "FAI returned NO_CHANGE"
+        reason: "FAI returned NO_CHANGE",
+        analysisWarning
       });
     }
     return await this.finalizeWithBumpNonReplay({
@@ -42162,9 +42175,72 @@ var AutoVersionStep = class extends BaseStep {
       language,
       mappedMagicVersion,
       previousVersion,
-      analysis
+      analysis,
+      analysisWarning
     });
   }
+  fallbackPatchAnalysis() {
+    return { versionBump: "PATCH", message: this.brandMessage("SDK regeneration") };
+  }
+  /**
+   * Runs FAI analysis over the cleaned diff. Never throws: when analysis cannot be
+   * obtained at all, returns a PATCH fallback together with an `analysisWarning`
+   * describing why, so callers can surface it in the step result / PR body instead
+   * of shipping a silent PATCH for what may be a breaking change.
+   */
+  async analyze(params) {
+    const { service, cleanedDiff, language, previousVersion, label } = params;
+    const chunks = service.chunkDiff(cleanedDiff, MAX_AI_DIFF_BYTES);
+    const cappedChunks = chunks.slice(0, MAX_CHUNKS);
+    const skippedChunks = chunks.length - cappedChunks.length;
+    const logSplit = () => {
+      if (chunks.length > 1) {
+        this.logger.info(
+          `${label}: split diff into ${chunks.length} chunks` + (skippedChunks > 0 ? ` (capped at ${MAX_CHUNKS}, skipping ${skippedChunks})` : "")
+        );
+      }
+    };
+    try {
+      if (this.config.ai == null && this.config.fernToken != null) {
+        try {
+          return { analysis: await this.analyzeViaFaiService(cleanedDiff, language, previousVersion) };
+        } catch (error) {
+          if (cappedChunks.length <= 1) {
+            throw error;
+          }
+          this.logger.warn(
+            `${label}: FAI analysis of the full diff failed (${String(error)}); retrying in ${cappedChunks.length} chunks.`
+          );
+          logSplit();
+          const chunked = await this.analyzeChunksViaFaiService(
+            cappedChunks,
+            language,
+            previousVersion,
+            label
+          );
+          const warnings = [chunked.analysisWarning];
+          if (skippedChunks > 0) {
+            warnings.push(
+              `${skippedChunks} of ${chunks.length} diff chunks were not analyzed (capped at ${MAX_CHUNKS})`
+            );
+          }
+          const analysisWarning = warnings.filter(hasText).join("; ");
+          return {
+            analysis: chunked.analysis,
+            analysisWarning: analysisWarning.length > 0 ? analysisWarning : void 0
+          };
+        }
+      }
+      logSplit();
+      return {
+        analysis: cappedChunks.length <= 1 ? await this.analyzeSingle(cleanedDiff, language, previousVersion) : await this.analyzeChunks(cappedChunks, language, previousVersion)
+      };
+    } catch (error) {
+      const warning = `FAI analysis failed (${String(error)})`;
+      this.logger.warn(`${label}: ${warning}; falling back to PATCH bump.`);
+      return { analysis: this.fallbackPatchAnalysis(), analysisWarning: warning };
+    }
+  }
   /**
    * Terminal path for runs that determine no semver bump is needed. The
    * current working tree still contains `0.0.0-fern-placeholder` from this
@@ -42175,7 +42251,7 @@ var AutoVersionStep = class extends BaseStep {
    * `[fern-autoversion]` so the replay + github steps see a stable base.
    */
   async finalizeNoChange(params) {
-    const { service, language, mappedMagicVersion, previousVersion, reason } = params;
+    const { service, language, mappedMagicVersion, previousVersion, reason, analysisWarning } = params;
     if (!isValidSemver(previousVersion)) {
       const errorMessage = `AutoVersionStep: resolved previousVersion ${JSON.stringify(previousVersion)} is not a valid semver string. Refusing to rewrite placeholder to avoid shell injection.`;
       this.logger.error(errorMessage);
@@ -42194,11 +42270,12 @@ var AutoVersionStep = class extends BaseStep {
       previousVersion,
       versionBump: "NO_CHANGE",
       commitMessage,
-      commitSha
+      commitSha,
+      analysisWarning
     };
   }
   async finalizeWithBump(params) {
-    const { service, language, mappedMagicVersion, previousVersion } = params;
+    const { service, language, mappedMagicVersion, previousVersion, analysisWarning } = params;
     const analysis = this.withChangelogFallback(params.analysis);
     const newVersion = incrementVersion(previousVersion, analysis.versionBump);
     this.logger.info(`AutoVersionStep: ${analysis.versionBump} bump: ${previousVersion} \u2192 ${newVersion}`);
@@ -42220,6 +42297,7 @@ var AutoVersionStep = class extends BaseStep {
       versionBump: analysis.versionBump,
       prDescription: analysis.prDescription,
       versionBumpReason: analysis.versionBumpReason,
+      analysisWarning,
       commitSha
     };
   }
@@ -42228,7 +42306,7 @@ var AutoVersionStep = class extends BaseStep {
    * `previousVersion` but does NOT commit — GithubStep handles the commit.
    */
   async finalizeNoChangeNonReplay(params) {
-    const { service, language, mappedMagicVersion, previousVersion, reason } = params;
+    const { service, language, mappedMagicVersion, previousVersion, reason, analysisWarning } = params;
     if (!isValidSemver(previousVersion)) {
       const errorMessage = `AutoVersionStep: resolved previousVersion ${JSON.stringify(previousVersion)} is not a valid semver string. Refusing to rewrite placeholder to avoid shell injection.`;
       this.logger.error(errorMessage);
@@ -42245,7 +42323,8 @@ var AutoVersionStep = class extends BaseStep {
       version: previousVersion,
       previousVersion,
       versionBump: "NO_CHANGE",
-      commitMessage
+      commitMessage,
+      analysisWarning
     };
   }
   /**
@@ -42253,7 +42332,7 @@ var AutoVersionStep = class extends BaseStep {
    * the bumped version but does NOT commit — GithubStep handles the commit.
    */
   async finalizeWithBumpNonReplay(params) {
-    const { service, language, mappedMagicVersion, previousVersion } = params;
+    const { service, language, mappedMagicVersion, previousVersion, analysisWarning } = params;
     const analysis = this.withChangelogFallback(params.analysis);
     const newVersion = incrementVersion(previousVersion, analysis.versionBump);
     this.logger.info(
@@ -42275,7 +42354,8 @@ var AutoVersionStep = class extends BaseStep {
       previousVersion,
       versionBump: analysis.versionBump,
       prDescription: analysis.prDescription,
-      versionBumpReason: analysis.versionBumpReason
+      versionBumpReason: analysis.versionBumpReason,
+      analysisWarning
     };
   }
   /**
@@ -42676,6 +42756,68 @@ ${body}` : `${COMMIT_MARKER} ${subject}`;
       };
     }
   }
+  /**
+   * Chunked retry for the hosted FAI path. Each chunk is analyzed independently;
+   * chunks whose request fails are skipped as long as at least one chunk succeeds,
+   * and the partial coverage is reported via `analysisWarning` so the PR is flagged
+   * and never automerged. Results are aggregated with the same max-bump rule as the
+   * BAML path; entries are joined rather than consolidated (no hosted rollup endpoint).
+   */
+  async analyzeChunksViaFaiService(chunks, language, previousVersion, label) {
+    const chunkAnalyses = [];
+    let attemptedChunks = 0;
+    let failedChunks = 0;
+    let lastError;
+    for (let i2 = 0; i2 < chunks.length; i2++) {
+      const chunk = chunks[i2];
+      if (!chunk) {
+        continue;
+      }
+      attemptedChunks++;
+      let analysis;
+      try {
+        analysis = await this.analyzeViaFaiService(chunk, language, previousVersion);
+      } catch (error) {
+        failedChunks++;
+        lastError = error;
+        this.logger.warn(
+          `${label}: FAI analysis of chunk ${i2 + 1}/${chunks.length} failed (${String(error)}).`
+        );
+        continue;
+      }
+      if (analysis == null) {
+        continue;
+      }
+      chunkAnalyses.push(analysis);
+    }
+    if (failedChunks > 0 && failedChunks === attemptedChunks) {
+      throw new Error(`all ${attemptedChunks} FAI chunk requests failed; last error: ${String(lastError)}`);
+    }
+    const analysisWarning = failedChunks > 0 ? `${failedChunks} of ${attemptedChunks} FAI chunk requests failed; last error: ${String(lastError)}` : void 0;
+    if (chunkAnalyses.length === 0) {
+      return { analysis: null, analysisWarning };
+    }
+    const { bestBump, bestMessage, bestVersionBumpReason, changelogEntries, usedBumpReasonAsEntry } = aggregateChunkAnalyses(chunkAnalyses);
+    if (usedBumpReasonAsEntry) {
+      this.logger.warn(
+        `${label}: no chunk produced a changelog entry for the ${bestBump} bump; using its version bump reason instead.`
+      );
+    }
+    if (analysisWarning != null) {
+      this.logger.warn(`${label}: ${analysisWarning}; the ${bestBump} bump is based on the remaining chunks.`);
+    }
+    const prDescriptions = chunkAnalyses.filter((analysis) => analysis.versionBump === bestBump && hasText(analysis.prDescription)).map((analysis) => analysis.prDescription?.trim() ?? "");
+    return {
+      analysis: {
+        versionBump: bestBump,
+        message: bestMessage,
+        changelogEntry: changelogEntries.length > 0 ? changelogEntries.join("\n\n") : void 0,
+        prDescription: prDescriptions.length > 0 ? prDescriptions.join("\n\n") : void 0,
+        versionBumpReason: bestVersionBumpReason
+      },
+      analysisWarning
+    };
+  }
   /**
    * Calls the hosted FAI service (`/sdks/analyze-commit-diff`) with the fern token.
    * Used when no BAML `ai` config is supplied (remote generation via fiddle). FAI
@@ -42700,7 +42842,10 @@ ${body}` : `${COMMIT_MARKER} ${subject}`;
     });
     if (!response.ok) {
       const body = await response.text().catch(() => "");
-      throw new Error(`FAI analyze-commit-diff failed with status ${response.status}: ${body.slice(0, 500)}`);
+      if (body.length > 0) {
+        this.logger.debug(`AutoVersionStep: FAI analyze-commit-diff response body: ${body.slice(0, 500)}`);
+      }
+      throw new Error(`FAI analyze-commit-diff failed with status ${response.status}`);
     }
     const parsed = await response.json();
     if (!isFaiAnalyzeResponse(parsed)) {
@@ -43500,6 +43645,7 @@ var GithubStep = class extends BaseStep {
     );
     const replaySection = formatReplayPrBody(replayResult, { branchName: prBranch, repoUri: this.config.uri });
     let enrichedBody = replaySection != null ? prBody + "\n\n---\n\n" + replaySection : prBody;
+    enrichedBody = appendAutoVersionWarning(enrichedBody, resolved.analysisWarning);
     enrichedBody = enrichPrBodyForAutomation(enrichedBody, this.config, resolved);
     if (isUpdatingExistingPR && existingPR != null) {
       this.logger.info(`Updated existing pull request: ${existingPR.htmlUrl}`);
@@ -43758,9 +43904,25 @@ function resolvePrFields(config, autoVersion) {
     newVersion: config.newVersion ?? autoVersion?.version,
     versionBump: config.versionBump ?? autoVersion?.versionBump,
     hasBreakingChanges: config.hasBreakingChanges ?? autoVersionBreaking,
-    breakingChangesSummary: config.breakingChangesSummary ?? autoVersion?.prDescription
+    breakingChangesSummary: config.breakingChangesSummary ?? autoVersion?.prDescription,
+    analysisWarning: autoVersion?.analysisWarning
   };
 }
+function appendAutoVersionWarning(body, analysisWarning) {
+  if (analysisWarning == null || analysisWarning.trim().length === 0) {
+    return body;
+  }
+  const reason = analysisWarning.replace(/[`\s]+/g, " ").trim().slice(0, 300);
+  return body + `
+
+---
+
+## \u26A0\uFE0F Version bump not verified
+
+Automatic version analysis was unavailable or incomplete for this generation, so the version bump and changelog may understate the changes (a **PATCH** bump with no changelog is applied when no analysis is available). If this change is breaking or adds features, adjust the version and changelog before merging.
+
+Reason: \`${reason}\``;
+}
 function enrichPrBodyForAutomation(body, config, breaking = {}) {
   if (!config.automationMode) {
     return body;
@@ -43782,7 +43944,8 @@ _Fern Run ID: \`${config.runId}\`_`;
 }
 function shouldEnableAutomerge(config, breaking = {}) {
   const hasBreakingChanges = breaking.hasBreakingChanges ?? config.hasBreakingChanges;
-  return config.automationMode === true && config.autoMerge === true && hasBreakingChanges !== true;
+  const analysisUnavailable = breaking.analysisWarning != null && breaking.analysisWarning.length > 0;
+  return config.automationMode === true && config.autoMerge === true && hasBreakingChanges !== true && !analysisUnavailable;
 }
 function shouldCheckNoDiff(config) {
   return config.skipIfNoDiff === true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fern-api/generator-cli",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fern-api/fern.git",