@fern-api/generator-cli 0.9.36 → 0.9.37

package/dist/cli.js

@@ -41181,32 +41181,30 @@ var AutoVersionStep = class extends BaseStep {
   name = "autoVersion";
   async execute(context) {
     const prepared = context.previousStepResults.generationCommit?.preparedReplay;
-    if (!prepared) {
-      this.logger.info(
-        "AutoVersionStep: no replay preparation available (replay uninitialized or prepare failed); skipping."
-      );
-      return { executed: true, success: true };
-    }
-    if (prepared.flow === "skip-application") {
-      this.logger.info("AutoVersionStep: replay flow is skip-application; skipping autoversion.");
-      return { executed: true, success: true };
-    }
-    const language = this.config.language;
-    const mappedMagicVersion = mapMagicVersionForLanguage(MAGIC_VERSION, language);
-    const service = new AutoVersioningService({ logger: this.toTaskLogger() });
-    if (prepared.previousGenerationSha == null) {
-      return await this.handleFirstGeneration({ service, language, mappedMagicVersion });
+    if (prepared) {
+      if (prepared.flow === "skip-application") {
+        this.logger.info("AutoVersionStep: replay flow is skip-application; skipping autoversion.");
+        return { executed: true, success: true };
+      }
+      const language = this.config.language;
+      const mappedMagicVersion = mapMagicVersionForLanguage(MAGIC_VERSION, language);
+      const service = new AutoVersioningService({ logger: this.toTaskLogger() });
+      if (prepared.previousGenerationSha == null) {
+        return await this.handleFirstGeneration({ service, language, mappedMagicVersion, commit: true });
+      }
+      return await this.handleNormalFlow({
+        prepared,
+        service,
+        language,
+        mappedMagicVersion,
+        previousGenerationSha: prepared.previousGenerationSha
+      });
     }
-    return await this.handleNormalFlow({
-      prepared,
-      service,
-      language,
-      mappedMagicVersion,
-      previousGenerationSha: prepared.previousGenerationSha
-    });
+    this.logger.info("AutoVersionStep: running in non-replay mode (git diff HEAD).");
+    return await this.handleNonReplayFlow();
   }
   async handleFirstGeneration(params) {
-    const { service, language, mappedMagicVersion } = params;
+    const { service, language, mappedMagicVersion, commit } = params;
     const initialVersion = this.config.baseVersion ?? (mappedMagicVersion.startsWith("v") ? "v0.0.1" : "0.0.1");
     if (!isValidSemver(initialVersion)) {
       const errorMessage = `AutoVersionStep: baseVersion ${JSON.stringify(initialVersion)} is not a valid semver string (expected e.g. "1.2.3" or "v1.2.3"). Refusing to run to avoid shell injection into the placeholder-rewrite step.`;
@@ -41223,7 +41221,7 @@ var AutoVersionStep = class extends BaseStep {
       await service.addGoMajorVersionSuffix(this.outputDir, initialVersion);
     }
     const commitMessage = this.brandMessage("Initial SDK generation");
-    const commitSha = this.commitAutoversion(commitMessage);
+    const commitSha = commit ? this.commitAutoversion(commitMessage) : void 0;
     return {
       executed: true,
       success: true,
@@ -41242,7 +41240,7 @@ var AutoVersionStep = class extends BaseStep {
       baseVersion: this.config.baseVersion
     });
     if (previousVersion == null) {
-      return await this.handleFirstGeneration({ service, language, mappedMagicVersion });
+      return await this.handleFirstGeneration({ service, language, mappedMagicVersion, commit: true });
     }
     if (rawDiff.trim().length === 0) {
       this.logger.info(
@@ -41323,6 +41321,106 @@ var AutoVersionStep = class extends BaseStep {
       analysis
     });
   }
+  /**
+   * Non-replay autoversion: diffs HEAD (committed SDK) vs the working tree
+   * (freshly generated files). Does NOT commit — GithubStep will commit all
+   * changes (including the rewritten placeholder) in a single generation commit.
+   */
+  async handleNonReplayFlow() {
+    const language = this.config.language;
+    const mappedMagicVersion = mapMagicVersionForLanguage(MAGIC_VERSION, language);
+    const service = new AutoVersioningService({ logger: this.toTaskLogger() });
+    const rawDiff = this.gitDiffHead();
+    const previousVersion = await this.resolvePreviousVersionNonReplay({
+      service,
+      rawDiff,
+      mappedMagicVersion,
+      baseVersion: this.config.baseVersion
+    });
+    if (previousVersion == null) {
+      return await this.handleFirstGeneration({ service, language, mappedMagicVersion, commit: false });
+    }
+    if (rawDiff.trim().length === 0) {
+      this.logger.info(`AutoVersionStep: empty diff (non-replay); rewriting placeholder to ${previousVersion}.`);
+      return await this.finalizeNoChangeNonReplay({
+        service,
+        language,
+        mappedMagicVersion,
+        previousVersion,
+        reason: "no diff between generations"
+      });
+    }
+    const cleanedDiff = service.cleanDiffForAI(rawDiff, mappedMagicVersion);
+    const rawBytes = Buffer.byteLength(rawDiff, "utf-8");
+    const cleanedBytes = Buffer.byteLength(cleanedDiff, "utf-8");
+    this.logger.debug(
+      `AutoVersionStep (non-replay): raw=${formatSizeKB(rawBytes)}KB (${countFilesInDiff(rawDiff)} files), cleaned=${formatSizeKB(cleanedBytes)}KB (${countFilesInDiff(cleanedDiff)} files)`
+    );
+    if (cleanedDiff.trim().length === 0) {
+      this.logger.info(
+        `AutoVersionStep: cleaned diff empty (non-replay); rewriting placeholder to ${previousVersion}.`
+      );
+      return await this.finalizeNoChangeNonReplay({
+        service,
+        language,
+        mappedMagicVersion,
+        previousVersion,
+        reason: "no semantic changes"
+      });
+    }
+    if (cleanedBytes > MAX_RAW_DIFF_BYTES) {
+      this.logger.warn(
+        `AutoVersionStep (non-replay): diff too large (${formatSizeKB(cleanedBytes)}KB). Falling back to PATCH.`
+      );
+      return await this.finalizeWithBumpNonReplay({
+        service,
+        language,
+        mappedMagicVersion,
+        previousVersion,
+        analysis: { versionBump: "PATCH", message: this.brandMessage("SDK regeneration") }
+      });
+    }
+    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") };
+    }
+    if (analysis == null) {
+      this.logger.info(
+        `AutoVersionStep (non-replay): FAI returned NO_CHANGE; rewriting placeholder to ${previousVersion}.`
+      );
+      return await this.finalizeNoChangeNonReplay({
+        service,
+        language,
+        mappedMagicVersion,
+        previousVersion,
+        reason: "FAI returned NO_CHANGE"
+      });
+    }
+    return await this.finalizeWithBumpNonReplay({
+      service,
+      language,
+      mappedMagicVersion,
+      previousVersion,
+      analysis
+    });
+  }
   /**
    * Terminal path for runs that determine no semver bump is needed. The
    * current working tree still contains `0.0.0-fern-placeholder` from this
@@ -41380,6 +41478,98 @@ var AutoVersionStep = class extends BaseStep {
       commitSha
     };
   }
+  /**
+   * Non-replay variant of finalizeNoChange. Rewrites the placeholder to
+   * `previousVersion` but does NOT commit — GithubStep handles the commit.
+   */
+  async finalizeNoChangeNonReplay(params) {
+    const { service, language, mappedMagicVersion, previousVersion, reason } = 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);
+      return { executed: true, success: false, errorMessage };
+    }
+    await service.replaceMagicVersion(this.outputDir, mappedMagicVersion, previousVersion);
+    if (language === "go") {
+      await service.addGoMajorVersionSuffix(this.outputDir, previousVersion);
+    }
+    const commitMessage = this.brandMessage(`SDK regeneration (no semver change: ${reason})`);
+    return {
+      executed: true,
+      success: true,
+      version: previousVersion,
+      previousVersion,
+      versionBump: "NO_CHANGE",
+      commitMessage
+    };
+  }
+  /**
+   * Non-replay variant of finalizeWithBump. Rewrites the placeholder to
+   * the bumped version but does NOT commit — GithubStep handles the commit.
+   */
+  async finalizeWithBumpNonReplay(params) {
+    const { service, language, mappedMagicVersion, previousVersion, analysis } = params;
+    const newVersion = incrementVersion(previousVersion, analysis.versionBump);
+    this.logger.info(
+      `AutoVersionStep (non-replay): ${analysis.versionBump} bump: ${previousVersion} \u2192 ${newVersion}`
+    );
+    await service.replaceMagicVersion(this.outputDir, mappedMagicVersion, newVersion);
+    if (language === "go") {
+      await service.addGoMajorVersionSuffix(this.outputDir, newVersion);
+    }
+    if (analysis.changelogEntry && analysis.changelogEntry.trim().length > 0) {
+      await this.prependChangelogEntry({ version: newVersion, entry: analysis.changelogEntry });
+    }
+    return {
+      executed: true,
+      success: true,
+      version: newVersion,
+      commitMessage: analysis.message,
+      changelogEntry: analysis.changelogEntry,
+      previousVersion,
+      versionBump: analysis.versionBump,
+      prDescription: analysis.prDescription,
+      versionBumpReason: analysis.versionBumpReason
+    };
+  }
+  /**
+   * Resolves the previous version for non-replay mode. Reads HEAD:.fern/metadata.json
+   * (not HEAD~1, since no generation commit exists yet) as the primary fallback.
+   */
+  async resolvePreviousVersionNonReplay(params) {
+    const { service, rawDiff, mappedMagicVersion, baseVersion } = params;
+    if (baseVersion != null && isValidSemver(baseVersion)) {
+      this.logger.debug(
+        `AutoVersionStep (non-replay): previous version from pipeline baseVersion: ${baseVersion}`
+      );
+      return this.normalizeVersionPrefix(baseVersion, mappedMagicVersion);
+    }
+    try {
+      const extracted = service.extractPreviousVersion(rawDiff, mappedMagicVersion);
+      if (extracted != null) {
+        this.logger.debug(`AutoVersionStep (non-replay): previous version from diff: ${extracted}`);
+        return extracted;
+      }
+    } catch (error) {
+      if (!(error instanceof AutoVersioningException) || !error.magicVersionAbsent) {
+        throw error;
+      }
+      this.logger.info("AutoVersionStep (non-replay): magic version not in diff; trying metadata + git tags.");
+    }
+    const metadataVersion = this.readVersionFromMetadataAtHead();
+    if (metadataVersion != null) {
+      return this.normalizeVersionPrefix(metadataVersion, mappedMagicVersion);
+    }
+    try {
+      const tagVersion = await service.getLatestVersionFromGitTags(this.outputDir);
+      if (tagVersion != null) {
+        return this.normalizeVersionPrefix(tagVersion, mappedMagicVersion);
+      }
+    } catch (error) {
+      this.logger.debug(`AutoVersionStep (non-replay): git-tags fallback failed (${String(error)}); ignoring.`);
+    }
+    return null;
+  }
   async resolvePreviousVersion(params) {
     const { service, rawDiff, mappedMagicVersion, baseVersion } = params;
     if (baseVersion != null && isValidSemver(baseVersion)) {
@@ -41429,6 +41619,42 @@ var AutoVersionStep = class extends BaseStep {
     const stripped = version2.startsWith("v") ? version2.slice(1) : version2;
     return mappedMagicVersion.startsWith("v") ? `v${stripped}` : stripped;
   }
+  /**
+   * Reads the sdkVersion from the committed (HEAD) .fern/metadata.json.
+   * Used by the non-replay path where no generation commit exists yet,
+   * so HEAD is the unmodified SDK repository.
+   */
+  readVersionFromMetadataAtHead() {
+    try {
+      const output = (0, import_child_process4.execFileSync)("git", ["show", "HEAD:.fern/metadata.json"], {
+        cwd: this.outputDir,
+        encoding: "utf-8",
+        stdio: "pipe"
+      });
+      const parsed = JSON.parse(output);
+      return parsed.sdkVersion ?? void 0;
+    } catch (error) {
+      this.logger.debug(`AutoVersionStep: failed to read HEAD:.fern/metadata.json (${String(error)})`);
+      return void 0;
+    }
+  }
+  /**
+   * Computes a diff between HEAD (committed SDK) and the working tree (new
+   * generation). Marks untracked files as intent-to-add so they appear in
+   * the diff, matching LocalTaskHandler.generateDiffFile() behavior.
+   */
+  gitDiffHead() {
+    (0, import_child_process4.execFileSync)("git", ["add", "-N", "."], {
+      cwd: this.outputDir,
+      stdio: "pipe"
+    });
+    return (0, import_child_process4.execFileSync)("git", ["diff", "HEAD", "--", ".", ":(exclude).fern/metadata.json"], {
+      cwd: this.outputDir,
+      encoding: "utf-8",
+      stdio: "pipe",
+      maxBuffer: 256 * 1024 * 1024
+    });
+  }
   gitDiff(from, to) {
     return (0, import_child_process4.execFileSync)("git", ["diff", from, to, "--", ".", ":(exclude).fern/metadata.json"], {
       cwd: this.outputDir,
@@ -42903,10 +43129,6 @@ var PostGenerationPipeline = class {
       );
       replayEnabled = false;
     }
-    if (autoVersionEnabled && !replayEnabled) {
-      this.logger.warn("AutoVersion requires Replay to be enabled. Disabling AutoVersion for this run.");
-      autoVersionEnabled = false;
-    }
     if (replayEnabled && config.replay != null) {
       this.steps.push(
         new GenerationCommitStep(

package/package.json

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