@fern-api/generator-cli 0.9.45 → 0.9.47

package/dist/cli.js

@@ -41355,7 +41355,8 @@ var AutoVersioningService = class _AutoVersioningService {
     }
     await this.addSuffixToGoMod(goModPath, modulePath, suffix);
     await this.addSuffixToGoFiles(workingDirectory, modulePath, suffix);
-    this.logger.info(`Added ${suffix} to Go module path ${modulePath} and all import paths`);
+    await this.addSuffixToMarkdownFiles(workingDirectory, modulePath, suffix);
+    this.logger.info(`Added ${suffix} to Go module path ${modulePath} across imports, headers, and docs`);
   }
   /**
    * Extracts the major version number from a version string.
@@ -41436,15 +41437,16 @@ var AutoVersioningService = class _AutoVersioningService {
     return results;
   }
   /**
-   * Adds a version suffix to import paths in all .go files in the repository.
+   * Adds a version suffix to import paths and embedded module-path string
+   * literals (e.g. the X-Fern-SDK-Name header value) in all .go files.
    */
   async addSuffixToGoFiles(repoRoot, modulePath, suffix) {
     const goFiles = await this.walkDirectory(repoRoot, (filePath) => (0, import_path22.extname)(filePath) === ".go");
     await this.processInParallel(goFiles, (filePath) => this.addSuffixToGoFile(filePath, modulePath, suffix));
   }
   /**
-   * Adds a version suffix to import paths in a single .go file.
-   * Replaces occurrences of the module path with modulePath + suffix in import statements.
+   * Adds a version suffix to import paths and embedded module-path string
+   * literals in a single .go file.
    */
   async addSuffixToGoFile(filePath, modulePath, suffix) {
     const content = await (0, import_promises14.readFile)(filePath, "utf-8");
@@ -41463,13 +41465,10 @@ var AutoVersioningService = class _AutoVersioningService {
         inImportBlock = false;
       }
       const isImportLine = inImportBlock || trimmed2.startsWith('import "') || trimmed2.startsWith('import	"') || /^import\s+\w+\s+"/.test(trimmed2);
-      if (!isImportLine) {
-        continue;
-      }
       if (!line.includes(modulePath)) {
         continue;
       }
-      const newLine = line.replace(`"${modulePath}/`, `"${modulePath}${suffix}/`).replace(`"${modulePath}"`, `"${modulePath}${suffix}"`);
+      const newLine = isImportLine ? line.split(`"${modulePath}/`).join(`"${modulePath}${suffix}/`).split(`"${modulePath}"`).join(`"${modulePath}${suffix}"`) : line.split(`"${modulePath}"`).join(`"${modulePath}${suffix}"`);
       if (newLine !== line) {
         lines[i2] = newLine;
         changed = true;
@@ -41480,6 +41479,45 @@ var AutoVersioningService = class _AutoVersioningService {
       this.logger.debug(`Updated Go imports in ${filePath}`);
     }
   }
+  /**
+   * Adds a version suffix to Go module references in all Markdown files
+   * (e.g. README.md) in the repository, so documented install commands and
+   * import samples resolve to the correct /vN module path when copy-pasted.
+   */
+  async addSuffixToMarkdownFiles(repoRoot, modulePath, suffix) {
+    const markdownFiles = await this.walkDirectory(
+      repoRoot,
+      (filePath) => (0, import_path22.extname)(filePath).toLowerCase() === ".md"
+    );
+    await this.processInParallel(
+      markdownFiles,
+      (filePath) => this.addSuffixToMarkdownFile(filePath, modulePath, suffix)
+    );
+  }
+  /**
+   * Adds a version suffix to Go module references in a single Markdown file.
+   * Rewrites `go get`/`go install` install commands and quoted import paths in
+   * code samples. Web URLs (e.g. `https://pkg.go.dev/<modulePath>`) are left
+   * untouched because the module path there is neither quote-anchored nor
+   * preceded by an install command.
+   */
+  async addSuffixToMarkdownFile(filePath, modulePath, suffix) {
+    const content = await (0, import_promises14.readFile)(filePath, "utf-8");
+    if (!content.includes(modulePath)) {
+      return;
+    }
+    let updated = content.split(`"${modulePath}/`).join(`"${modulePath}${suffix}/`).split(`"${modulePath}"`).join(`"${modulePath}${suffix}"`);
+    const escapedModulePath = modulePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const installCommandPattern = new RegExp(
+      `(go (?:get|install)(?:\\s+-\\S+)*\\s+)${escapedModulePath}(?![\\w./-])`,
+      "g"
+    );
+    updated = updated.replace(installCommandPattern, `$1${modulePath}${suffix}`);
+    if (updated !== content) {
+      await (0, import_promises14.writeFile)(filePath, updated, "utf-8");
+      this.logger.debug(`Updated Go module path in ${filePath}`);
+    }
+  }
   /**
    * Extracts the file path from a diff file section.
    * Parses the "diff --git a/path b/path" header line.
@@ -41656,7 +41694,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 +42118,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.47",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fern-api/fern.git",