@fern-api/generator-cli 0.10.2 → 0.10.3

package/dist/cli.js

@@ -42017,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({
@@ -42054,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({
@@ -42062,7 +42051,8 @@ var AutoVersionStep = class extends BaseStep {
       language,
       mappedMagicVersion,
       previousVersion,
-      analysis
+      analysis,
+      analysisWarning
     });
   }
   /**
@@ -42113,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}.`
@@ -42154,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({
@@ -42162,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
@@ -42175,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);
@@ -42194,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}`);
@@ -42220,6 +42261,7 @@ var AutoVersionStep = class extends BaseStep {
       versionBump: analysis.versionBump,
       prDescription: analysis.prDescription,
       versionBumpReason: analysis.versionBumpReason,
+      analysisWarning,
       commitSha
     };
   }
@@ -42228,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);
@@ -42245,7 +42287,8 @@ var AutoVersionStep = class extends BaseStep {
       version: previousVersion,
       previousVersion,
       versionBump: "NO_CHANGE",
-      commitMessage
+      commitMessage,
+      analysisWarning
     };
   }
   /**
@@ -42253,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(
@@ -42275,7 +42318,8 @@ var AutoVersionStep = class extends BaseStep {
       previousVersion,
       versionBump: analysis.versionBump,
       prDescription: analysis.prDescription,
-      versionBumpReason: analysis.versionBumpReason
+      versionBumpReason: analysis.versionBumpReason,
+      analysisWarning
     };
   }
   /**
@@ -42676,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
@@ -42700,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)) {
@@ -43500,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}`);
@@ -43758,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;
@@ -43782,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.2",
+  "version": "0.10.3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fern-api/fern.git",