@fern-api/generator-cli 0.9.43 → 0.9.45

package/dist/api.js

@@ -6168,6 +6168,26 @@ var ClonedRepository = class _ClonedRepository {
     const result = await this.git.raw(["rev-parse", `${commitSha}^{tree}`]);
     return result.trim();
   }
+  async getCommitMessage(commitSha) {
+    await this.git.cwd(this.clonePath);
+    const result = await this.git.raw(["log", "-1", "--format=%B", commitSha]);
+    return result.replace(/\n$/, "");
+  }
+  async getCommitParents(commitSha) {
+    await this.git.cwd(this.clonePath);
+    const result = await this.git.raw(["rev-list", "--parents", "-n", "1", commitSha]);
+    const parts = result.trim().split(/\s+/);
+    return parts.slice(1);
+  }
+  /**
+   * Returns the SHAs of commits reachable from HEAD but not from any remote-tracking ref,
+   * ordered oldest-first. These are the commits created locally that have not been pushed.
+   */
+  async getLocalOnlyCommits() {
+    await this.git.cwd(this.clonePath);
+    const result = await this.git.raw(["rev-list", "--reverse", "HEAD", "--not", "--remotes=origin"]);
+    return result.trim().split("\n").filter((line) => line.length > 0);
+  }
   /**
    * Returns true if the working tree has uncommitted changes (staged or unstaged).
    */

package/dist/cli.js

@@ -32254,6 +32254,26 @@ var ClonedRepository = class _ClonedRepository {
     const result = await this.git.raw(["rev-parse", `${commitSha}^{tree}`]);
     return result.trim();
   }
+  async getCommitMessage(commitSha) {
+    await this.git.cwd(this.clonePath);
+    const result = await this.git.raw(["log", "-1", "--format=%B", commitSha]);
+    return result.replace(/\n$/, "");
+  }
+  async getCommitParents(commitSha) {
+    await this.git.cwd(this.clonePath);
+    const result = await this.git.raw(["rev-list", "--parents", "-n", "1", commitSha]);
+    const parts = result.trim().split(/\s+/);
+    return parts.slice(1);
+  }
+  /**
+   * Returns the SHAs of commits reachable from HEAD but not from any remote-tracking ref,
+   * ordered oldest-first. These are the commits created locally that have not been pushed.
+   */
+  async getLocalOnlyCommits() {
+    await this.git.cwd(this.clonePath);
+    const result = await this.git.raw(["rev-list", "--reverse", "HEAD", "--not", "--remotes=origin"]);
+    return result.trim().split("\n").filter((line) => line.length > 0);
+  }
   /**
    * Returns true if the working tree has uncommitted changes (staged or unstaged).
    */
@@ -40998,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) {
@@ -41134,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.
@@ -42461,6 +42546,7 @@ ${prBody}`;
 
 // src/pipeline/github/pushSignedCommit.ts
 var MAX_CONCURRENT_PUSH_RETRIES = 3;
+var MAX_SIGNED_CHAIN_LENGTH = 20;
 async function pushSignedCommit({
   repository,
   octokit,
@@ -42475,25 +42561,19 @@ async function pushSignedCommit({
   const tempRef = `refs/temp/fern-${Date.now()}`;
   let tempRefPushed = false;
   try {
-    let [localHeadSha, treeSha, message, parents] = await Promise.all([
-      repository.getHeadSha(),
-      repository.getHeadTreeHash(),
-      repository.getHeadCommitMessage(),
-      repository.getHeadParents()
-    ]);
+    let localHeadSha = await repository.getHeadSha();
     await repository.pushObjectToRef(localHeadSha, tempRef);
     tempRefPushed = true;
     for (let attempt2 = 0; attempt2 < MAX_CONCURRENT_PUSH_RETRIES; attempt2++) {
-      const identityFields = author != null ? { author, committer: author } : {};
-      const { data: signedCommit } = await octokit.git.createCommit({
+      const signedSha = await signLocalCommitChain({
+        repository,
+        octokit,
         owner,
         repo,
-        message,
-        tree: treeSha,
-        parents,
-        ...identityFields
+        localHeadSha,
+        author,
+        logger
       });
-      const signedSha = signedCommit.sha;
       try {
         await upsertBranchRef({ octokit, owner, repo, branch, sha: signedSha, force });
         logger.debug(`Updated refs/heads/${branch} to signed commit ${signedSha}`);
@@ -42508,12 +42588,7 @@ async function pushSignedCommit({
             `Non-fast-forward on refs/heads/${branch} (attempt ${attempt2 + 1}/${MAX_CONCURRENT_PUSH_RETRIES}); rebasing locally and retrying.`
           );
           await repository.pullWithRebase(branch);
-          [localHeadSha, treeSha, message, parents] = await Promise.all([
-            repository.getHeadSha(),
-            repository.getHeadTreeHash(),
-            repository.getHeadCommitMessage(),
-            repository.getHeadParents()
-          ]);
+          localHeadSha = await repository.getHeadSha();
           await repository.pushObjectToRef(localHeadSha, tempRef, { force: true });
         } else {
           throw err;
@@ -42533,6 +42608,49 @@ async function pushSignedCommit({
     }
   }
 }
+async function signLocalCommitChain({
+  repository,
+  octokit,
+  owner,
+  repo,
+  localHeadSha,
+  author,
+  logger
+}) {
+  let chain = await repository.getLocalOnlyCommits();
+  if (chain.length === 0 || chain[chain.length - 1] !== localHeadSha) {
+    chain = [localHeadSha];
+  } else if (chain.length > MAX_SIGNED_CHAIN_LENGTH) {
+    logger.warn(
+      `Local commit chain has ${chain.length} commits (limit ${MAX_SIGNED_CHAIN_LENGTH}); signing HEAD only.`
+    );
+    chain = [localHeadSha];
+  }
+  const identityFields = author != null ? { author, committer: author } : {};
+  const signedShaByLocalSha = /* @__PURE__ */ new Map();
+  let signedSha = localHeadSha;
+  for (const sha of chain) {
+    const [treeSha, message, parents] = await Promise.all([
+      repository.getCommitTreeHash(sha),
+      repository.getCommitMessage(sha),
+      repository.getCommitParents(sha)
+    ]);
+    const { data: signedCommit } = await octokit.git.createCommit({
+      owner,
+      repo,
+      message,
+      tree: treeSha,
+      parents: parents.map((parent) => signedShaByLocalSha.get(parent) ?? parent),
+      ...identityFields
+    });
+    signedShaByLocalSha.set(sha, signedCommit.sha);
+    signedSha = signedCommit.sha;
+  }
+  if (chain.length > 1) {
+    logger.debug(`Signed ${chain.length} local commits via the GitHub API`);
+  }
+  return signedSha;
+}
 async function upsertBranchRef({
   octokit,
   owner,
@@ -42793,11 +42911,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}`);
@@ -42838,7 +42961,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,
@@ -42916,6 +43052,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);
@@ -42957,6 +43094,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);
@@ -43034,6 +43172,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;
@@ -43117,6 +43282,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.43",
+  "version": "0.9.45",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fern-api/fern.git",