@fern-api/generator-cli 0.9.42 → 0.9.44

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).
    */
@@ -40448,7 +40468,7 @@ var consolePipelineLogger = {
 };
 
 // src/pipeline/PostGenerationPipeline.ts
-var import_child_process6 = require("child_process");
+var import_child_process7 = require("child_process");
 
 // src/pipeline/github/constants.ts
 var FERN_BOT_NAME2 = "fern-api";
@@ -42461,6 +42481,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 +42496,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 +42523,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 +42543,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,
@@ -43119,6 +43172,7 @@ function resolveBranchAction({
 }
 
 // src/pipeline/steps/ReplayStep.ts
+var import_child_process6 = require("child_process");
 var ReplayStep = class extends BaseStep {
   constructor(outputDir, logger, config, cliVersion, generatorVersions) {
     super(outputDir, logger);
@@ -43159,17 +43213,21 @@ var ReplayStep = class extends BaseStep {
         patchesWithConflicts: 0
       };
     }
+    const stageOnly = this.config.stageOnly ?? false;
     const result = prepared != null ? await replayApply(prepared, {
-      stageOnly: this.config.stageOnly ?? false,
+      stageOnly,
       logger: this.logger
     }) : await replayRun({
       outputDir: this.outputDir,
       cliVersion: this.cliVersion,
       generatorVersions: this.generatorVersions,
-      stageOnly: this.config.stageOnly ?? false,
+      stageOnly,
       skipApplication: this.config.skipApplication,
       logger: this.logger
     });
+    if (!stageOnly) {
+      this.commitLockfileIfUncommitted();
+    }
     if (result.failureReason != null) {
       return {
         executed: true,
@@ -43233,6 +43291,44 @@ var ReplayStep = class extends BaseStep {
       warnings: report.warnings
     };
   }
+  /**
+   * Commits `.fern/replay.lock` when replay saved the lockfile to disk but
+   * didn't create a `[fern-replay]` commit (e.g. no-patches flow with zero
+   * new patches). Without this, `skipCommit = true` in GithubStep drops the
+   * lockfile advance, freezing `previousGenerationSha` across runs.
+   */
+  commitLockfileIfUncommitted() {
+    try {
+      const status2 = (0, import_child_process6.execFileSync)("git", ["status", "--porcelain", "--", ".fern/replay.lock"], {
+        cwd: this.outputDir,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      if (status2.length === 0) {
+        return;
+      }
+      (0, import_child_process6.execFileSync)("git", ["add", "--", ".fern/replay.lock"], {
+        cwd: this.outputDir,
+        stdio: "pipe"
+      });
+      (0, import_child_process6.execFileSync)(
+        "git",
+        [
+          "-c",
+          `user.name=${FERN_BOT_NAME2}`,
+          "-c",
+          `user.email=${FERN_BOT_EMAIL2}`,
+          "commit",
+          "-m",
+          "[fern-replay] advance lockfile"
+        ],
+        { cwd: this.outputDir, stdio: "pipe" }
+      );
+      this.logger.debug("ReplayStep: committed uncommitted lockfile advance.");
+    } catch (error) {
+      this.logger.debug("ReplayStep: failed to commit lockfile advance: " + String(error));
+    }
+  }
 };
 
 // ../cli/generation/local-generation/docker-utils/lib/runDocker.js
@@ -43567,8 +43663,8 @@ var PostGenerationPipeline = class {
   async run() {
     if (this.config.github?.enabled) {
       try {
-        (0, import_child_process6.execFileSync)("git", ["config", "user.name", FERN_BOT_NAME2], { cwd: this.config.outputDir });
-        (0, import_child_process6.execFileSync)("git", ["config", "user.email", FERN_BOT_EMAIL2], { cwd: this.config.outputDir });
+        (0, import_child_process7.execFileSync)("git", ["config", "user.name", FERN_BOT_NAME2], { cwd: this.config.outputDir });
+        (0, import_child_process7.execFileSync)("git", ["config", "user.email", FERN_BOT_EMAIL2], { cwd: this.config.outputDir });
       } catch {
       }
     }

package/package.json

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