@fern-api/generator-cli 0.9.45 → 0.9.46

package/dist/cli.js

@@ -41656,7 +41656,8 @@ var AutoVersionStep = class extends BaseStep {
   }
   async handleNormalFlow(params) {
     const { prepared, service, language, mappedMagicVersion, previousGenerationSha } = params;
-    const rawDiff = this.gitDiff(previousGenerationSha, prepared.currentGenerationSha);
+    const diffBase = this.resolveReachableGenerationBase(previousGenerationSha, prepared.currentGenerationSha);
+    const rawDiff = diffBase != null ? this.safeGitDiff(diffBase, prepared.currentGenerationSha) : "";
     const previousVersion = await this.resolvePreviousVersion({
       service,
       rawDiff,
@@ -42079,6 +42080,97 @@ var AutoVersionStep = class extends BaseStep {
       maxBuffer: 256 * 1024 * 1024
     });
   }
+  /**
+   * Resolves a reachable base commit for the autoversion diff.
+   *
+   * `recordedSha` (the previous generation from replay.lock) is preferred when it exists
+   * in this clone. When it doesn't — e.g. the signed-commit push recreated the
+   * [fern-generated] commit under a new SHA, or the branch was squash-merged — we re-anchor
+   * on the most recent reachable [fern-generated] commit in history. Returns null when no
+   * generation baseline is reachable at all, in which case the caller resolves the previous
+   * version from metadata/git-tags and still rewrites the placeholder.
+   */
+  resolveReachableGenerationBase(recordedSha, currentGenerationSha) {
+    if (this.commitExists(recordedSha)) {
+      return recordedSha;
+    }
+    this.logger.warn(
+      `AutoVersionStep: recorded previous generation ${recordedSha.slice(0, 7)} is unreachable in this clone; deriving the baseline from history.`
+    );
+    const derived = this.findPreviousGenerationFromHistory(currentGenerationSha);
+    if (derived != null) {
+      this.logger.info(`AutoVersionStep: re-anchored autoversion baseline on ${derived.slice(0, 7)}.`);
+      return derived;
+    }
+    this.logger.warn(
+      "AutoVersionStep: no reachable [fern-generated] baseline found; falling back to metadata/git-tags."
+    );
+    return null;
+  }
+  commitExists(sha) {
+    if (!/^[0-9a-f]{7,40}$/.test(sha)) {
+      return false;
+    }
+    try {
+      (0, import_child_process4.execFileSync)("git", ["cat-file", "-e", `${sha}^{commit}`], {
+        cwd: this.outputDir,
+        stdio: "pipe"
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Walks first-parent history from the current generation commit and returns the most
+   * recent prior [fern-generated] commit — the reachable equivalent of replay.lock's
+   * recorded baseline. Mirrors @fern-api/replay's `findPreviousGenerationFromHistory`.
+   */
+  findPreviousGenerationFromHistory(currentGenerationSha) {
+    const start = this.commitExists(currentGenerationSha) ? currentGenerationSha : "HEAD";
+    let log;
+    try {
+      log = (0, import_child_process4.execFileSync)("git", ["log", "--first-parent", "--format=%H%x00%s", start], {
+        cwd: this.outputDir,
+        encoding: "utf-8",
+        stdio: "pipe",
+        maxBuffer: 64 * 1024 * 1024
+      });
+    } catch (error) {
+      this.logger.debug(`AutoVersionStep: git log history walk failed (${String(error)}); no baseline derived.`);
+      return null;
+    }
+    for (const line of log.split("\n")) {
+      if (line.trim().length === 0) {
+        continue;
+      }
+      const [sha, subject = ""] = line.split("\0");
+      if (sha == null || sha === currentGenerationSha) {
+        continue;
+      }
+      if (subject.startsWith("[fern-generated]")) {
+        return sha;
+      }
+    }
+    return null;
+  }
+  /**
+   * `gitDiff` that degrades to an empty diff instead of throwing. Both endpoints are
+   * expected to be reachable (the base is resolved via resolveReachableGenerationBase and
+   * `to` is this run's freshly-created HEAD), but we never want a `git diff` failure to
+   * abort autoversion and leave the magic placeholder in the shipped SDK — the empty diff
+   * routes version resolution to baseVersion/metadata/git-tags, which still rewrites it.
+   */
+  safeGitDiff(from, to) {
+    try {
+      return this.gitDiff(from, to);
+    } catch (error) {
+      this.logger.warn(
+        `AutoVersionStep: git diff ${from.slice(0, 7)}..${to.slice(0, 7)} failed (${error instanceof Error ? error.message : String(error)}); proceeding with an empty diff.`
+      );
+      return "";
+    }
+  }
   gitDiff(from, to) {
     return (0, import_child_process4.execFileSync)("git", ["diff", from, to, "--", ".", ":(exclude).fern/metadata.json"], {
       cwd: this.outputDir,

package/package.json

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