@fern-api/generator-cli 0.10.1 → 0.10.3

package/dist/cli.js

@@ -21964,257 +21964,7 @@ var require_dist3 = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/node-diff3@3.2.0/node_modules/node-diff3/dist/diff3.mjs
-function LCS(buffer1, buffer2) {
-  let equivalenceClasses = {};
-  for (let j2 = 0; j2 < buffer2.length; j2++) {
-    const item = buffer2[j2];
-    if (equivalenceClasses[item]) {
-      equivalenceClasses[item].push(j2);
-    } else {
-      equivalenceClasses[item] = [j2];
-    }
-  }
-  const NULLRESULT = { buffer1index: -1, buffer2index: -1, chain: null };
-  let candidates = [NULLRESULT];
-  for (let i2 = 0; i2 < buffer1.length; i2++) {
-    const item = buffer1[i2];
-    const buffer2indices = equivalenceClasses[item] || [];
-    let r2 = 0;
-    let c3 = candidates[0];
-    for (let jx = 0; jx < buffer2indices.length; jx++) {
-      const j2 = buffer2indices[jx];
-      let s;
-      for (s = r2; s < candidates.length; s++) {
-        if (candidates[s].buffer2index < j2 && (s === candidates.length - 1 || candidates[s + 1].buffer2index > j2)) {
-          break;
-        }
-      }
-      if (s < candidates.length) {
-        const newCandidate = { buffer1index: i2, buffer2index: j2, chain: candidates[s] };
-        if (r2 === candidates.length) {
-          candidates.push(c3);
-        } else {
-          candidates[r2] = c3;
-        }
-        r2 = s + 1;
-        c3 = newCandidate;
-        if (r2 === candidates.length) {
-          break;
-        }
-      }
-    }
-    candidates[r2] = c3;
-  }
-  return candidates[candidates.length - 1];
-}
-function diffIndices(buffer1, buffer2) {
-  const lcs = LCS(buffer1, buffer2);
-  let result = [];
-  let tail1 = buffer1.length;
-  let tail2 = buffer2.length;
-  for (let candidate = lcs; candidate !== null; candidate = candidate.chain) {
-    const mismatchLength1 = tail1 - candidate.buffer1index - 1;
-    const mismatchLength2 = tail2 - candidate.buffer2index - 1;
-    tail1 = candidate.buffer1index;
-    tail2 = candidate.buffer2index;
-    if (mismatchLength1 || mismatchLength2) {
-      result.push({
-        buffer1: [tail1 + 1, mismatchLength1],
-        buffer1Content: buffer1.slice(tail1 + 1, tail1 + 1 + mismatchLength1),
-        buffer2: [tail2 + 1, mismatchLength2],
-        buffer2Content: buffer2.slice(tail2 + 1, tail2 + 1 + mismatchLength2)
-      });
-    }
-  }
-  result.reverse();
-  return result;
-}
-function diffPatch(buffer1, buffer2) {
-  const lcs = LCS(buffer1, buffer2);
-  let result = [];
-  let tail1 = buffer1.length;
-  let tail2 = buffer2.length;
-  function chunkDescription(buffer, offset, length) {
-    let chunk = [];
-    for (let i2 = 0; i2 < length; i2++) {
-      chunk.push(buffer[offset + i2]);
-    }
-    return {
-      offset,
-      length,
-      chunk
-    };
-  }
-  for (let candidate = lcs; candidate !== null; candidate = candidate.chain) {
-    const mismatchLength1 = tail1 - candidate.buffer1index - 1;
-    const mismatchLength2 = tail2 - candidate.buffer2index - 1;
-    tail1 = candidate.buffer1index;
-    tail2 = candidate.buffer2index;
-    if (mismatchLength1 || mismatchLength2) {
-      result.push({
-        buffer1: chunkDescription(buffer1, candidate.buffer1index + 1, mismatchLength1),
-        buffer2: chunkDescription(buffer2, candidate.buffer2index + 1, mismatchLength2)
-      });
-    }
-  }
-  result.reverse();
-  return result;
-}
-function diff3MergeRegions(a, o2, b3) {
-  let hunks = [];
-  function addHunk(h2, ab) {
-    hunks.push({
-      ab,
-      oStart: h2.buffer1[0],
-      oLength: h2.buffer1[1],
-      abStart: h2.buffer2[0],
-      abLength: h2.buffer2[1]
-    });
-  }
-  diffIndices(o2, a).forEach((item) => addHunk(item, "a"));
-  diffIndices(o2, b3).forEach((item) => addHunk(item, "b"));
-  hunks.sort((x2, y2) => x2.oStart - y2.oStart);
-  let results = [];
-  let currOffset = 0;
-  function advanceTo(endOffset) {
-    if (endOffset > currOffset) {
-      results.push({
-        stable: true,
-        buffer: "o",
-        bufferStart: currOffset,
-        bufferLength: endOffset - currOffset,
-        bufferContent: o2.slice(currOffset, endOffset)
-      });
-      currOffset = endOffset;
-    }
-  }
-  while (hunks.length) {
-    let hunk = hunks.shift();
-    let regionStart = hunk.oStart;
-    let regionEnd = hunk.oStart + hunk.oLength;
-    let regionHunks = [hunk];
-    advanceTo(regionStart);
-    while (hunks.length) {
-      const nextHunk = hunks[0];
-      const nextHunkStart = nextHunk.oStart;
-      if (nextHunkStart > regionEnd)
-        break;
-      regionEnd = Math.max(regionEnd, nextHunkStart + nextHunk.oLength);
-      regionHunks.push(hunks.shift());
-    }
-    if (regionHunks.length === 1) {
-      if (hunk.abLength > 0) {
-        const buffer = hunk.ab === "a" ? a : b3;
-        results.push({
-          stable: true,
-          buffer: hunk.ab,
-          bufferStart: hunk.abStart,
-          bufferLength: hunk.abLength,
-          bufferContent: buffer.slice(hunk.abStart, hunk.abStart + hunk.abLength)
-        });
-      }
-    } else {
-      let bounds = {
-        a: [a.length, -1, o2.length, -1],
-        b: [b3.length, -1, o2.length, -1]
-      };
-      while (regionHunks.length) {
-        hunk = regionHunks.shift();
-        const oStart = hunk.oStart;
-        const oEnd = oStart + hunk.oLength;
-        const abStart = hunk.abStart;
-        const abEnd = abStart + hunk.abLength;
-        let b22 = bounds[hunk.ab];
-        b22[0] = Math.min(abStart, b22[0]);
-        b22[1] = Math.max(abEnd, b22[1]);
-        b22[2] = Math.min(oStart, b22[2]);
-        b22[3] = Math.max(oEnd, b22[3]);
-      }
-      const aStart = bounds.a[0] + (regionStart - bounds.a[2]);
-      const aEnd = bounds.a[1] + (regionEnd - bounds.a[3]);
-      const bStart = bounds.b[0] + (regionStart - bounds.b[2]);
-      const bEnd = bounds.b[1] + (regionEnd - bounds.b[3]);
-      let result = {
-        stable: false,
-        aStart,
-        aLength: aEnd - aStart,
-        aContent: a.slice(aStart, aEnd),
-        oStart: regionStart,
-        oLength: regionEnd - regionStart,
-        oContent: o2.slice(regionStart, regionEnd),
-        bStart,
-        bLength: bEnd - bStart,
-        bContent: b3.slice(bStart, bEnd)
-      };
-      results.push(result);
-    }
-    currOffset = regionEnd;
-  }
-  advanceTo(o2.length);
-  return results;
-}
-function diff3Merge(a, o2, b3, options) {
-  let defaults3 = {
-    excludeFalseConflicts: true,
-    stringSeparator: /\s+/
-  };
-  options = Object.assign(defaults3, options);
-  if (typeof a === "string")
-    a = a.split(options.stringSeparator);
-  if (typeof o2 === "string")
-    o2 = o2.split(options.stringSeparator);
-  if (typeof b3 === "string")
-    b3 = b3.split(options.stringSeparator);
-  let results = [];
-  const regions = diff3MergeRegions(a, o2, b3);
-  let okBuffer = [];
-  function flushOk() {
-    if (okBuffer.length) {
-      results.push({ ok: okBuffer });
-    }
-    okBuffer = [];
-  }
-  function isFalseConflict(a2, b22) {
-    if (a2.length !== b22.length)
-      return false;
-    for (let i2 = 0; i2 < a2.length; i2++) {
-      if (a2[i2] !== b22[i2])
-        return false;
-    }
-    return true;
-  }
-  regions.forEach((region) => {
-    if (region.stable) {
-      okBuffer.push(...region.bufferContent);
-    } else {
-      if (options.excludeFalseConflicts && isFalseConflict(region.aContent, region.bContent)) {
-        okBuffer.push(...region.aContent);
-      } else {
-        flushOk();
-        results.push({
-          conflict: {
-            a: region.aContent,
-            aIndex: region.aStart,
-            o: region.oContent,
-            oIndex: region.oStart,
-            b: region.bContent,
-            bIndex: region.bStart
-          }
-        });
-      }
-    }
-  });
-  flushOk();
-  return results;
-}
-var init_diff3 = __esm({
-  "../../node_modules/.pnpm/node-diff3@3.2.0/node_modules/node-diff3/dist/diff3.mjs"() {
-    "use strict";
-  }
-});
-
-// ../../node_modules/.pnpm/@fern-api+replay@0.19.2/node_modules/@fern-api/replay/dist/index.js
+// ../../node_modules/.pnpm/@fern-api+replay@0.19.3/node_modules/@fern-api/replay/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
   CREDENTIAL_PATTERNS: () => CREDENTIAL_PATTERNS,
@@ -22633,6 +22383,244 @@ function filterInfrastructureAndSensitiveFiles(rawFilesOutput, fernignorePattern
   const files = nonSensitive.filter((f) => !matchesFernignorePattern(f, fernignorePatterns));
   return { files, sensitiveFiles, fernignoredFiles, infrastructureFiles };
 }
+function LCS(buffer1, buffer2) {
+  const equivalenceClasses = /* @__PURE__ */ new Map();
+  for (let j2 = 0; j2 < buffer2.length; j2++) {
+    const item = buffer2[j2];
+    const indices = equivalenceClasses.get(item);
+    if (indices != null) {
+      indices.push(j2);
+    } else {
+      equivalenceClasses.set(item, [j2]);
+    }
+  }
+  const nullResult = { buffer1index: -1, buffer2index: -1, chain: null };
+  const candidates = [nullResult];
+  for (let i2 = 0; i2 < buffer1.length; i2++) {
+    const item = buffer1[i2];
+    const buffer2indices = equivalenceClasses.get(item) ?? [];
+    let r2 = 0;
+    let c3 = candidates[0];
+    for (let jx = 0; jx < buffer2indices.length; jx++) {
+      const j2 = buffer2indices[jx];
+      let s = candidates.length;
+      let lo = r2;
+      let hi = candidates.length - 1;
+      let found = -1;
+      while (lo <= hi) {
+        const mid = lo + hi >> 1;
+        if (candidates[mid].buffer2index < j2) {
+          found = mid;
+          lo = mid + 1;
+        } else {
+          hi = mid - 1;
+        }
+      }
+      if (found !== -1 && (found === candidates.length - 1 || candidates[found + 1].buffer2index > j2)) {
+        s = found;
+      }
+      if (s < candidates.length) {
+        const newCandidate = { buffer1index: i2, buffer2index: j2, chain: candidates[s] };
+        if (r2 === candidates.length) {
+          candidates.push(c3);
+        } else {
+          candidates[r2] = c3;
+        }
+        r2 = s + 1;
+        c3 = newCandidate;
+        if (r2 === candidates.length) {
+          break;
+        }
+      }
+    }
+    candidates[r2] = c3;
+  }
+  return candidates[candidates.length - 1];
+}
+function diffIndices(buffer1, buffer2) {
+  const lcs = LCS(buffer1, buffer2);
+  const result = [];
+  let tail1 = buffer1.length;
+  let tail2 = buffer2.length;
+  let candidate = lcs;
+  while (candidate !== null) {
+    const mismatchLength1 = tail1 - candidate.buffer1index - 1;
+    const mismatchLength2 = tail2 - candidate.buffer2index - 1;
+    tail1 = candidate.buffer1index;
+    tail2 = candidate.buffer2index;
+    if (mismatchLength1 || mismatchLength2) {
+      result.push({
+        buffer1: [tail1 + 1, mismatchLength1],
+        buffer1Content: buffer1.slice(tail1 + 1, tail1 + 1 + mismatchLength1),
+        buffer2: [tail2 + 1, mismatchLength2],
+        buffer2Content: buffer2.slice(tail2 + 1, tail2 + 1 + mismatchLength2)
+      });
+    }
+    candidate = candidate.chain;
+  }
+  result.reverse();
+  return result;
+}
+function diffPatch(buffer1, buffer2) {
+  const lcs = LCS(buffer1, buffer2);
+  const result = [];
+  let tail1 = buffer1.length;
+  let tail2 = buffer2.length;
+  function chunkDescription(buffer, offset, length) {
+    const chunk = [];
+    for (let i2 = 0; i2 < length; i2++) {
+      chunk.push(buffer[offset + i2]);
+    }
+    return {
+      offset,
+      length,
+      chunk
+    };
+  }
+  let candidate = lcs;
+  while (candidate !== null) {
+    const mismatchLength1 = tail1 - candidate.buffer1index - 1;
+    const mismatchLength2 = tail2 - candidate.buffer2index - 1;
+    tail1 = candidate.buffer1index;
+    tail2 = candidate.buffer2index;
+    if (mismatchLength1 || mismatchLength2) {
+      result.push({
+        buffer1: chunkDescription(buffer1, candidate.buffer1index + 1, mismatchLength1),
+        buffer2: chunkDescription(buffer2, candidate.buffer2index + 1, mismatchLength2)
+      });
+    }
+    candidate = candidate.chain;
+  }
+  result.reverse();
+  return result;
+}
+function diff3MergeRegions(a, o2, b3) {
+  const hunks = [];
+  function addHunk(h2, ab) {
+    hunks.push({
+      ab,
+      oStart: h2.buffer1[0],
+      oLength: h2.buffer1[1],
+      abStart: h2.buffer2[0],
+      abLength: h2.buffer2[1]
+    });
+  }
+  diffIndices(o2, a).forEach((item) => addHunk(item, "a"));
+  diffIndices(o2, b3).forEach((item) => addHunk(item, "b"));
+  hunks.sort((x2, y2) => x2.oStart - y2.oStart);
+  const results = [];
+  let currOffset = 0;
+  function advanceTo(endOffset) {
+    if (endOffset > currOffset) {
+      results.push({
+        stable: true,
+        bufferContent: o2.slice(currOffset, endOffset)
+      });
+      currOffset = endOffset;
+    }
+  }
+  while (hunks.length) {
+    const firstHunk = hunks.shift();
+    if (firstHunk === void 0) break;
+    let hunk = firstHunk;
+    const regionStart = hunk.oStart;
+    let regionEnd = hunk.oStart + hunk.oLength;
+    const regionHunks = [hunk];
+    advanceTo(regionStart);
+    while (hunks.length) {
+      const nextHunk = hunks[0];
+      const nextHunkStart = nextHunk.oStart;
+      if (nextHunkStart > regionEnd) break;
+      regionEnd = Math.max(regionEnd, nextHunkStart + nextHunk.oLength);
+      const next = hunks.shift();
+      if (next === void 0) break;
+      regionHunks.push(next);
+    }
+    if (regionHunks.length === 1) {
+      if (hunk.abLength > 0) {
+        const buffer = hunk.ab === "a" ? a : b3;
+        results.push({
+          stable: true,
+          bufferContent: buffer.slice(hunk.abStart, hunk.abStart + hunk.abLength)
+        });
+      }
+    } else {
+      const bounds = {
+        a: [a.length, -1, o2.length, -1],
+        b: [b3.length, -1, o2.length, -1]
+      };
+      while (regionHunks.length) {
+        const next = regionHunks.shift();
+        if (next === void 0) break;
+        hunk = next;
+        const oStart = hunk.oStart;
+        const oEnd = oStart + hunk.oLength;
+        const abStart = hunk.abStart;
+        const abEnd = abStart + hunk.abLength;
+        const bound = bounds[hunk.ab];
+        bound[0] = Math.min(abStart, bound[0]);
+        bound[1] = Math.max(abEnd, bound[1]);
+        bound[2] = Math.min(oStart, bound[2]);
+        bound[3] = Math.max(oEnd, bound[3]);
+      }
+      const aStart = bounds.a[0] + (regionStart - bounds.a[2]);
+      const aEnd = bounds.a[1] + (regionEnd - bounds.a[3]);
+      const bStart = bounds.b[0] + (regionStart - bounds.b[2]);
+      const bEnd = bounds.b[1] + (regionEnd - bounds.b[3]);
+      results.push({
+        stable: false,
+        aStart,
+        aContent: a.slice(aStart, aEnd),
+        oStart: regionStart,
+        oContent: o2.slice(regionStart, regionEnd),
+        bStart,
+        bContent: b3.slice(bStart, bEnd)
+      });
+    }
+    currOffset = regionEnd;
+  }
+  advanceTo(o2.length);
+  return results;
+}
+function diff3Merge(a, o2, b3) {
+  const regions = diff3MergeRegions(a, o2, b3);
+  const results = [];
+  let okBuffer = [];
+  function flushOk() {
+    if (okBuffer.length) {
+      results.push({ ok: okBuffer });
+    }
+    okBuffer = [];
+  }
+  function isFalseConflict(left2, right2) {
+    if (left2.length !== right2.length) return false;
+    for (let i2 = 0; i2 < left2.length; i2++) {
+      if (left2[i2] !== right2[i2]) return false;
+    }
+    return true;
+  }
+  regions.forEach((region) => {
+    if (region.stable) {
+      okBuffer.push(...region.bufferContent);
+    } else if (isFalseConflict(region.aContent, region.bContent)) {
+      okBuffer.push(...region.aContent);
+    } else {
+      flushOk();
+      results.push({
+        conflict: {
+          a: region.aContent,
+          aIndex: region.aStart,
+          o: region.oContent,
+          oIndex: region.oStart,
+          b: region.bContent,
+          bIndex: region.bStart
+        }
+      });
+    }
+  });
+  flushOk();
+  return results;
+}
 function threeWayMerge(base, ours, theirs) {
   const baseLines = base.split("\n");
   const oursLines = ours.split("\n");
@@ -24295,7 +24283,7 @@ function status(outputDir) {
 }
 var import_promises4, import_os, import_path7, import_fs6, import_path8, import_yaml, import_crypto, import_path9, import_promises5, import_os2, import_path10, import_promises6, import_path11, import_promises7, import_path12, import_fs7, import_promises8, import_path13, import_fs8, import_path14, import_promises9, import_os3, import_path15, import_child_process3, import_crypto2, import_fs9, import_path16, import_yaml2, import_crypto3, import_fs10, import_path17, import_fs11, import_promises10, import_path18, __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, AUTOVERSION_PLACEHOLDERS, VERSION_TOKEN, VERSION_MASK, 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.19.2/node_modules/@fern-api/replay/dist/index.js"() {
+  "../../node_modules/.pnpm/@fern-api+replay@0.19.3/node_modules/@fern-api/replay/dist/index.js"() {
     "use strict";
     init_esm4();
     import_promises4 = require("fs/promises");
@@ -24308,7 +24296,6 @@ var init_dist3 = __esm({
     import_crypto = require("crypto");
     init_esm3();
     import_path9 = require("path");
-    init_diff3();
     import_promises5 = require("fs/promises");
     import_os2 = require("os");
     import_path10 = require("path");
@@ -42030,36 +42017,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({
@@ -42067,7 +42042,8 @@ var AutoVersionStep = class extends BaseStep {
         language,
         mappedMagicVersion,
         previousVersion,
-        reason: "FAI returned NO_CHANGE"
+        reason: "FAI returned NO_CHANGE",
+        analysisWarning
       });
     }
     return await this.finalizeWithBump({
@@ -42075,7 +42051,8 @@ var AutoVersionStep = class extends BaseStep {
       language,
       mappedMagicVersion,
       previousVersion,
-      analysis
+      analysis,
+      analysisWarning
     });
   }
   /**
@@ -42126,38 +42103,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}.`
@@ -42167,7 +42130,8 @@ var AutoVersionStep = class extends BaseStep {
         language,
         mappedMagicVersion,
         previousVersion,
-        reason: "FAI returned NO_CHANGE"
+        reason: "FAI returned NO_CHANGE",
+        analysisWarning
       });
     }
     return await this.finalizeWithBumpNonReplay({
@@ -42175,9 +42139,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
@@ -42188,7 +42215,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);
@@ -42207,11 +42234,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}`);
@@ -42233,6 +42261,7 @@ var AutoVersionStep = class extends BaseStep {
       versionBump: analysis.versionBump,
       prDescription: analysis.prDescription,
       versionBumpReason: analysis.versionBumpReason,
+      analysisWarning,
       commitSha
     };
   }
@@ -42241,7 +42270,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);
@@ -42258,7 +42287,8 @@ var AutoVersionStep = class extends BaseStep {
       version: previousVersion,
       previousVersion,
       versionBump: "NO_CHANGE",
-      commitMessage
+      commitMessage,
+      analysisWarning
     };
   }
   /**
@@ -42266,7 +42296,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(
@@ -42288,7 +42318,8 @@ var AutoVersionStep = class extends BaseStep {
       previousVersion,
       versionBump: analysis.versionBump,
       prDescription: analysis.prDescription,
-      versionBumpReason: analysis.versionBumpReason
+      versionBumpReason: analysis.versionBumpReason,
+      analysisWarning
     };
   }
   /**
@@ -42689,6 +42720,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
@@ -42713,7 +42806,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)) {
@@ -43513,6 +43609,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}`);
@@ -43771,9 +43868,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;
@@ -43795,7 +43908,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.1",
+  "version": "0.10.3",
   "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.19.2",
+    "@fern-api/replay": "0.19.3",
     "@octokit/rest": "^22.0.1",
     "es-toolkit": "^1.45.1",
     "semver": "^7.6.3",