@fern-api/generator-cli 0.9.35 → 0.9.37

package/dist/cli.js

@@ -3822,9 +3822,9 @@ var init_esm3 = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/tmp@0.2.5/node_modules/tmp/lib/tmp.js
+// ../../node_modules/.pnpm/tmp@0.2.6/node_modules/tmp/lib/tmp.js
 var require_tmp = __commonJS({
-  "../../node_modules/.pnpm/tmp@0.2.5/node_modules/tmp/lib/tmp.js"(exports2, module2) {
+  "../../node_modules/.pnpm/tmp@0.2.6/node_modules/tmp/lib/tmp.js"(exports2, module2) {
     "use strict";
     var fs3 = require("fs");
     var os = require("os");
@@ -4075,13 +4075,20 @@ var require_tmp = __commonJS({
       ].join("");
       return path5.join(tmpDir, opts.dir, name);
     }
+    function _assertPath(path6) {
+      if (path6.includes("..")) {
+        throw new Error("Relative value not allowed");
+      }
+      return path6;
+    }
     function _assertOptionsBase(options) {
       if (!_isUndefined(options.name)) {
         const name = options.name;
         if (path5.isAbsolute(name)) throw new Error(`name option must not contain an absolute path, found "${name}".`);
         const basename2 = path5.basename(name);
-        if (basename2 === ".." || basename2 === "." || basename2 !== name)
+        if (basename2 === ".." || basename2 === "." || basename2 !== name) {
           throw new Error(`name option must not contain a path, found "${name}".`);
+        }
       }
       if (!_isUndefined(options.template) && !options.template.match(TEMPLATE_PATTERN)) {
         throw new Error(`Invalid template, found "${options.template}".`);
@@ -4094,15 +4101,16 @@ var require_tmp = __commonJS({
       options.detachDescriptor = !!options.detachDescriptor;
       options.discardDescriptor = !!options.discardDescriptor;
       options.unsafeCleanup = !!options.unsafeCleanup;
-      options.prefix = _isUndefined(options.prefix) ? "" : options.prefix;
-      options.postfix = _isUndefined(options.postfix) ? "" : options.postfix;
+      options.prefix = _isUndefined(options.prefix) ? "" : _assertPath(options.prefix);
+      options.postfix = _isUndefined(options.postfix) ? "" : _assertPath(options.postfix);
+      options.template = _isUndefined(options.template) ? void 0 : _assertPath(options.template);
     }
     function _getRelativePath(option, name, tmpDir, cb) {
       if (_isUndefined(name)) return cb(null);
       _resolvePath(name, tmpDir, function(err, resolvedPath) {
         if (err) return cb(err);
         const relativePath = path5.relative(tmpDir, resolvedPath);
-        if (!resolvedPath.startsWith(tmpDir)) {
+        if (relativePath.startsWith("..") || path5.isAbsolute(relativePath)) {
           return cb(new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath}".`));
         }
         cb(null, relativePath);
@@ -4112,7 +4120,7 @@ var require_tmp = __commonJS({
       if (_isUndefined(name)) return;
       const resolvedPath = _resolvePathSync(name, tmpDir);
       const relativePath = path5.relative(tmpDir, resolvedPath);
-      if (!resolvedPath.startsWith(tmpDir)) {
+      if (relativePath.startsWith("..") || path5.isAbsolute(relativePath)) {
         throw new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath}".`);
       }
       return relativePath;
@@ -41173,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.`;
@@ -41215,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,
@@ -41234,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(
@@ -41278,17 +41284,21 @@ var AutoVersionStep = class extends BaseStep {
         analysis: { versionBump: "PATCH", message: this.brandMessage("SDK regeneration") }
       });
     }
-    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})` : "")
-      );
-    }
     let analysis;
     try {
-      analysis = cappedChunks.length <= 1 ? await this.analyzeSingle(cleanedDiff, language, previousVersion) : await this.analyzeChunks(cappedChunks, language, previousVersion);
+      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") };
@@ -41311,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
@@ -41368,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)) {
@@ -41417,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,
@@ -41568,6 +41806,47 @@ ${newBlock}${remainder}`;
       };
     }
   }
+  /**
+   * 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
+   * handles chunking, parallelism, and retries server-side. Returns null on
+   * NO_CHANGE; throws on transport/HTTP errors so the caller's PATCH fallback applies.
+   */
+  async analyzeViaFaiService(cleanedDiff, language, previousVersion) {
+    const baseUrl = this.config.faiBaseUrl ?? "https://fai.buildwithfern.com";
+    const response = await fetch(`${baseUrl}/sdks/analyze-commit-diff`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.config.fernToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        diff: cleanedDiff,
+        language,
+        previous_version: previousVersion,
+        prior_changelog: this.config.priorChangelog ?? void 0,
+        spec_commit_message: this.config.specCommitMessage ?? void 0
+      })
+    });
+    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)}`);
+    }
+    const parsed = await response.json();
+    if (!isFaiAnalyzeResponse(parsed)) {
+      throw new Error("FAI analyze-commit-diff returned an unexpected response shape");
+    }
+    if (parsed.version_bump === "NO_CHANGE") {
+      return null;
+    }
+    return {
+      versionBump: parsed.version_bump,
+      message: this.brandMessage(parsed.message),
+      changelogEntry: nonEmpty(parsed.changelog_entry),
+      prDescription: nonEmpty(parsed.pr_description),
+      versionBumpReason: nonEmpty(parsed.version_bump_reason)
+    };
+  }
   /**
    * Dynamically imports @fern-api/cli-ai only when autoversion actually needs to
    * call FAI. The package is ESM-only with extensionless internal imports, so
@@ -41609,6 +41888,20 @@ ${newBlock}${remainder}`;
     return adapter;
   }
 };
+var FAI_VERSION_BUMPS = ["MAJOR", "MINOR", "PATCH", "NO_CHANGE"];
+function isFaiAnalyzeResponse(value) {
+  if (typeof value !== "object" || value == null) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.message === "string" && typeof candidate.version_bump === "string" && FAI_VERSION_BUMPS.includes(candidate.version_bump) && isStringOrAbsent(candidate.changelog_entry) && isStringOrAbsent(candidate.pr_description) && isStringOrAbsent(candidate.version_bump_reason);
+}
+function isStringOrAbsent(value) {
+  return value == null || typeof value === "string";
+}
+function nonEmpty(value) {
+  return value != null && value.trim().length > 0 ? value : void 0;
+}
 
 // src/pipeline/steps/GenerationCommitStep.ts
 var import_child_process5 = require("child_process");
@@ -42836,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.35",
+  "version": "0.9.37",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fern-api/fern.git",