@fern-api/generator-cli 0.9.44 → 0.9.46

package/dist/cli.js

@@ -41018,7 +41018,8 @@ var AutoVersioningService = class _AutoVersioningService {
         contentLines.push(line);
       }
     }
-    let processedContent = this.removeVersionChangePairs(contentLines, mappedMagicVersion);
+    let processedContent = this.removeGoModulePathSuffixPairs(contentLines);
+    processedContent = this.removeVersionChangePairs(processedContent, mappedMagicVersion);
     processedContent = this.removeRemainingMagicVersionLines(processedContent, mappedMagicVersion);
     let hasChanges = false;
     for (const line of processedContent) {
@@ -41154,21 +41155,85 @@ var AutoVersioningService = class _AutoVersioningService {
    * so non-Go diffs like API URL version changes are not affected.
    */
   isGoModulePathSuffixChange(minusLine, plusLine) {
-    const minusContent = minusLine.substring(1);
-    const plusContent = plusLine.substring(1);
-    const goModulePathPattern = /"[^"]*(?:github\.com|golang\.org|google\.golang\.org|gopkg\.in)\/[^"]*"/;
-    const goModuleDirectivePattern = /^\s*module\s+(?:github\.com|golang\.org|google\.golang\.org|gopkg\.in)\/\S+/;
-    const hasGoModulePath = goModulePathPattern.test(minusContent) || goModulePathPattern.test(plusContent) || goModuleDirectivePattern.test(minusContent.trim()) || goModuleDirectivePattern.test(plusContent.trim());
-    if (!hasGoModulePath) {
+    const minus = this.analyzeGoModulePathLine(minusLine);
+    const plus = this.analyzeGoModulePathLine(plusLine);
+    if (minus == null || plus == null) {
       return false;
     }
-    const suffixPattern = /\/v\d+(?=\/|"\s*$|$)/g;
-    const minusWithoutSuffix = minusContent.replace(suffixPattern, "");
-    const plusWithoutSuffix = plusContent.replace(suffixPattern, "");
-    if (minusWithoutSuffix !== plusWithoutSuffix) {
+    if (minus.strippedContent !== plus.strippedContent) {
       return false;
     }
-    return /\/v\d+(?=\/|"\s*$|$)/.test(minusContent) || /\/v\d+(?=\/|"\s*$|$)/.test(plusContent);
+    return minus.hasSuffix || plus.hasSuffix;
+  }
+  /**
+   * Removes Go module path `/vN` suffix-only churn from a diff section, regardless of how the
+   * deletion and addition lines are laid out. `removeVersionChangePairs` only removes a deletion
+   * when it can pair it with a *nearby* addition and keeps every line in between — so a diff that
+   * groups all deletions before all additions (as Go import blocks do) leaks the suffix churn for
+   * every line except the first. That churn then reaches the AI diff analyzer, which sees the
+   * previously published `/vN` module path changing on every import and misclassifies a
+   * no-op regeneration as a breaking change (spurious major bump).
+   *
+   * This pass matches each suffix-bearing deletion with any suffix-only-equivalent addition in
+   * the section (by suffix-stripped content) and drops both, so only genuine content changes to
+   * Go module path lines survive.
+   */
+  removeGoModulePathSuffixPairs(lines) {
+    const additions = [];
+    for (let index = 0; index < lines.length; index++) {
+      const line = lines[index];
+      if (line == null || !this.isAdditionLine(line)) {
+        continue;
+      }
+      const info = this.analyzeGoModulePathLine(line);
+      if (info != null) {
+        additions.push({ index, strippedContent: info.strippedContent });
+      }
+    }
+    const removed = /* @__PURE__ */ new Set();
+    const usedAdditions = /* @__PURE__ */ new Set();
+    for (let index = 0; index < lines.length; index++) {
+      const line = lines[index];
+      if (line == null || !this.isDeletionLine(line)) {
+        continue;
+      }
+      const info = this.analyzeGoModulePathLine(line);
+      if (info == null || !info.hasSuffix) {
+        continue;
+      }
+      const match2 = additions.find(
+        (addition) => !usedAdditions.has(addition.index) && addition.strippedContent === info.strippedContent
+      );
+      if (match2 != null) {
+        usedAdditions.add(match2.index);
+        removed.add(index);
+        removed.add(match2.index);
+      }
+    }
+    if (removed.size === 0) {
+      return lines;
+    }
+    return lines.filter((_2, index) => !removed.has(index));
+  }
+  /**
+   * If a diff line (with its leading +/- stripped) references a Go module path — either a quoted
+   * import path or a `module` directive — returns its content with any `/vN` module-version
+   * suffixes removed, plus whether a suffix was present. Returns undefined for non-Go lines so
+   * unrelated diffs (e.g. API URL version segments) are never touched.
+   */
+  analyzeGoModulePathLine(line) {
+    const content = line.substring(1);
+    const goModulePathPattern = /"[^"]*(?:github\.com|golang\.org|google\.golang\.org|gopkg\.in)\/[^"]*"/;
+    const goModuleDirectivePattern = /^\s*module\s+(?:github\.com|golang\.org|google\.golang\.org|gopkg\.in)\/\S+/;
+    const isGoModulePathLine = goModulePathPattern.test(content) || goModuleDirectivePattern.test(content.trim());
+    if (!isGoModulePathLine) {
+      return void 0;
+    }
+    const suffixPattern = /\/v\d+(?=\/|"|$)/g;
+    return {
+      strippedContent: content.replace(suffixPattern, ""),
+      hasSuffix: suffixPattern.test(content)
+    };
   }
   /**
    * Gets the latest semantic version from git tags in the given repository.
@@ -41591,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,
@@ -42014,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,
@@ -42846,11 +43003,16 @@ var GithubStep = class extends BaseStep {
         throw new Error(`Unexpected branch action: ${String(_exhaustive)}`);
       }
     }
+    const createdChangelog = await this.ensureChangelogFile(resolved);
     if (!skipCommit) {
       await this.ensureFernignore();
       this.logger.debug("Committing changes...");
       await repository.commitAllChanges(resolved.commitMessage);
       this.logger.debug(`Committed changes to local copy of GitHub repository at ${this.outputDir}`);
+    } else if (createdChangelog) {
+      this.logger.debug("Committing reconstructed changelog.md on top of the replay commit...");
+      await repository.add("changelog.md");
+      await repository.commit(resolved.commitMessage);
     }
     if (shouldCheckNoDiff(this.config)) {
       const noDiff = await repository.treeHashEquals(`origin/${baseBranch}`);
@@ -42891,7 +43053,20 @@ var GithubStep = class extends BaseStep {
       }
     }
     const headSha = await repository.getHeadSha();
-    const changelogUrl = resolved.changelogEntry ? `https://${remote}/${owner}/${repo}/blob/${headSha}/changelog.md` : void 0;
+    const changelogCommitted = (await repository.listTrackedFiles()).includes("changelog.md");
+    const changelogUrl = resolveChangelogUrl({
+      changelogEntry: resolved.changelogEntry,
+      changelogCommitted,
+      remote,
+      owner,
+      repo,
+      headSha
+    });
+    if (resolved.changelogEntry && !changelogCommitted) {
+      this.logger.warn(
+        'changelog.md is not present in the committed tree; omitting the "See full changelog" link.'
+      );
+    }
     const { prTitle, prBody } = parseCommitMessageForPR(
       resolved.commitMessage,
       resolved.changelogEntry,
@@ -42969,6 +43144,7 @@ var GithubStep = class extends BaseStep {
       this.logger.debug(`Checking out branch ${this.config.branch}`);
       await repository.checkout(this.config.branch);
     }
+    await this.ensureChangelogFile(resolved);
     await this.ensureFernignore();
     this.logger.debug("Committing changes...");
     await repository.commitAllChanges(resolved.commitMessage);
@@ -43010,6 +43186,7 @@ var GithubStep = class extends BaseStep {
       this.logger.debug(`Checking out branch ${this.config.branch}`);
       await repository.checkout(this.config.branch);
     }
+    await this.ensureChangelogFile(resolved);
     await this.ensureFernignore();
     this.logger.debug("Committing changes...");
     await repository.commitAllChanges(resolved.commitMessage);
@@ -43087,6 +43264,33 @@ var GithubStep = class extends BaseStep {
       await (0, import_promises16.writeFile)(fernignorePath, "# Specify files that shouldn't be modified by Fern\n", "utf-8");
     }
   }
+  /**
+   * Guarantees `changelog.md` is present in the output directory whenever a changelog entry
+   * exists for this run, so the file lands in the committed tree that GithubStep pushes and the
+   * "See full changelog" link resolves. AutoVersionStep normally writes this file via
+   * `prependChangelogEntry`; this is a safety net for paths where that write never reached the
+   * directory GithubStep commits (e.g. non-replay self-hosted generation), which previously left
+   * the link pointing at a non-existent blob (404).
+   *
+   * Returns `true` when it created the file, `false` when the file already existed (or there is
+   * no changelog entry to write).
+   */
+  async ensureChangelogFile(resolved) {
+    const entry = resolved.changelogEntry?.trim();
+    if (entry == null || entry.length === 0) {
+      return false;
+    }
+    const changelogPath = (0, import_path24.join)(this.outputDir, "changelog.md");
+    try {
+      await (0, import_promises16.access)(changelogPath);
+      return false;
+    } catch {
+      const version2 = resolved.newVersion ?? resolved.previousVersion;
+      await (0, import_promises16.writeFile)(changelogPath, buildChangelogFileContents(entry, version2), "utf-8");
+      this.logger.debug(`Wrote changelog.md${version2 != null ? ` for ${version2}` : ""}.`);
+      return true;
+    }
+  }
   deriveSkipCommit(replayResult) {
     if (replayResult == null) {
       return false;
@@ -43170,6 +43374,31 @@ function resolveBranchAction({
   }
   return "create-from-head";
 }
+function buildChangelogFileContents(entry, version2) {
+  const trimmed2 = entry.trim();
+  const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const header = version2 != null ? `## [${version2}] - ${now}
+` : `## ${now}
+`;
+  return `# Changelog
+
+${header}${trimmed2}
+
+`;
+}
+function resolveChangelogUrl({
+  changelogEntry,
+  changelogCommitted,
+  remote,
+  owner,
+  repo,
+  headSha
+}) {
+  if (changelogEntry == null || changelogEntry.trim().length === 0 || !changelogCommitted) {
+    return void 0;
+  }
+  return `https://${remote}/${owner}/${repo}/blob/${headSha}/changelog.md`;
+}
 
 // src/pipeline/steps/ReplayStep.ts
 var import_child_process6 = require("child_process");

package/package.json

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