@fern-api/generator-cli 0.9.51 → 0.9.53

package/dist/cli.js

@@ -22214,7 +22214,7 @@ var init_diff3 = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/@fern-api+replay@0.19.1/node_modules/@fern-api/replay/dist/index.js
+// ../../node_modules/.pnpm/@fern-api+replay@0.19.2/node_modules/@fern-api/replay/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
   CREDENTIAL_PATTERNS: () => CREDENTIAL_PATTERNS,
@@ -24295,7 +24295,7 @@ function status(outputDir) {
 }
 var import_promises4, import_os, import_path7, import_fs6, import_path8, import_yaml, import_crypto, import_path9, import_promises5, import_os2, import_path10, import_promises6, import_path11, import_promises7, import_path12, import_fs7, import_promises8, import_path13, import_fs8, import_path14, import_promises9, import_os3, import_path15, import_child_process3, import_crypto2, import_fs9, import_path16, import_yaml2, import_crypto3, import_fs10, import_path17, import_fs11, import_promises10, import_path18, __defProp3, __getOwnPropNames3, __esm3, __export3, GitClient_exports, GitClient, init_GitClient, HybridReconstruction_exports, init_HybridReconstruction, PatchApplyTheirs_exports, init_PatchApplyTheirs, CREDENTIAL_PATTERNS, SENSITIVE_FILE_PATTERNS, FERN_BOT_NAME, FERN_BOT_EMAIL, FERN_BOT_LOGIN, FERN_SUPPORT_NAMES, LOCKFILE_HEADER, LockfileNotFoundError, LockfileManager, BINARY_EXTENSIONS, INFRASTRUCTURE_FILES, ReplayDetector, MergeAccumulator, CONFLICT_OPENER, CONFLICT_SEPARATOR, CONFLICT_CLOSER, AUTOVERSION_PLACEHOLDERS, VERSION_TOKEN, VERSION_MASK, ReplayApplicator, ReplayCommitter, FileOwnership, FirstGenerationFlow, SkipApplicationFlow, NoPatchesFlow, NormalRegenerationFlow, ReplayService, FernignoreMigrator, REPLAY_FERNIGNORE_ENTRIES, GITATTRIBUTES_ENTRIES, EMPTY_RESULT;
 var init_dist3 = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.19.1/node_modules/@fern-api/replay/dist/index.js"() {
+  "../../node_modules/.pnpm/@fern-api+replay@0.19.2/node_modules/@fern-api/replay/dist/index.js"() {
     "use strict";
     init_esm4();
     import_promises4 = require("fs/promises");
@@ -26248,7 +26248,9 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
       }
       async prepare(options) {
         const preLock = this.service.lockManager.read();
-        const previousGenerationSha = preLock.current_generation ?? null;
+        const previousGenerationSha = await this.service.resolveReachablePreviousGeneration(
+          preLock.current_generation ?? null
+        );
         let { patches: newPatches, revertedPatchIds } = await this.service.detector.detectNewPatches();
         const detectorWarnings = [...this.service.detector.warnings];
         const detectorDegraded = [...this.service.detector.degradedReasons];
@@ -26384,7 +26386,9 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
       }
       async prepare(options) {
         const preLock = this.service.lockManager.read();
-        const previousGenerationSha = preLock.current_generation ?? null;
+        const previousGenerationSha = await this.service.resolveReachablePreviousGeneration(
+          preLock.current_generation ?? null
+        );
         if (options?.dryRun) {
           const existingPatches2 = this.service.lockManager.getPatches();
           const { patches: newPatches2, revertedPatchIds: dryRunReverted } = await this.service.detector.detectNewPatches();
@@ -26613,6 +26617,37 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
         this.committer = new ReplayCommitter(git, outputDir);
         this.fileOwnership = new FileOwnership(git);
       }
+      /**
+       * Resolve the previous-generation SHA to export on
+       * `ReplayPreparation.previousGenerationSha`.
+       *
+       * `current_generation` is the SHA of a LOCALLY-created `[fern-generated]` commit.
+       * generator-cli's signed-commit push (`pushSignedCommit`) recreates that commit under a
+       * new remote SHA, and a squash-merge collapses it away, so the recorded value can be
+       * unreachable in a later clone (org "Natural": autoVersion then diffed against a phantom
+       * baseline and silently reported NO_CHANGE — or, pre-a38bbc6, shipped
+       * `0.0.0-fern-placeholder`). Consumers (generator-cli's autoVersion) diff against this
+       * baseline, so it MUST resolve to a real commit.
+       *
+       * Prefer the recorded SHA while it still resolves — the healthy case, and the pristine
+       * prior `[fern-generated]` tree. Otherwise re-anchor on the most recent reachable
+       * generation boundary in first-parent history: the SAME value the detector already
+       * derives for its own scan boundary (`findPreviousGenerationFromHistory`, whose
+       * `isGenerationBoundary` matches squash-merge subjects like `SDK Generation (#N)`). Fall
+       * back to the recorded SHA only when no boundary is reachable at all — no worse than the
+       * prior behavior. ADR 0002 (generator-cli) allows replay to expose this reconciled value;
+       * the consumer stays independently resilient.
+       *
+       * MUST be called before the new `[fern-generated]` commit is created, while HEAD is still
+       * the pre-generation (customer) state, so the walk anchors on the PREVIOUS generation.
+       */
+      async resolveReachablePreviousGeneration(recordedSha) {
+        if (recordedSha != null && await this.git.commitExists(recordedSha)) {
+          return recordedSha;
+        }
+        const derived = await this.detector.findPreviousGenerationFromHistory();
+        return derived ?? recordedSha;
+      }
       /**
        * Phase 1 of the two-phase replay flow. Runs preGenerationRebase (when applicable),
        * detects new patches, and creates the `[fern-generated]` commit. Leaves HEAD at
@@ -41127,6 +41162,7 @@ var AutoVersioningService = class _AutoVersioningService {
       }
     }
     let processedContent = this.removeGoModulePathSuffixPairs(contentLines);
+    processedContent = this.removeGoExplicitFieldBitConstantPairs(processedContent);
     processedContent = this.removeVersionChangePairs(processedContent, mappedMagicVersion);
     processedContent = this.removeRemainingMagicVersionLines(processedContent, mappedMagicVersion);
     let hasChanges = false;
@@ -41331,6 +41367,90 @@ var AutoVersioningService = class _AutoVersioningService {
       hasSuffix: suffixPattern.test(content)
     };
   }
+  /**
+   * Removes Go `explicitFields` bit-constant reindexing churn from a diff section.
+   *
+   * The Go SDK tracks which optional fields were explicitly set via a per-struct `big.Int`
+   * bitmask. For each struct property it generates a private constant whose value is a single
+   * bit at the property's positional index, e.g.
+   *
+   *     var (
+   *         entityFieldGeoShape   = big.NewInt(1 << 3)
+   *         entityFieldGeoDetails = big.NewInt(1 << 4)
+   *     )
+   *
+   * Inserting a new field earlier in the struct shifts every following constant's bit index by
+   * one, producing a deletion/addition pair per field that differs only by the integer:
+   *
+   *     -    entityFieldGeoShape = big.NewInt(1 << 3)
+   *     +    entityFieldGeoShape = big.NewInt(1 << 4)
+   *
+   * This is a purely mechanical artifact of the field addition: the bit is assigned and read
+   * within the same generated version (the wire format is name-based JSON, not bit position),
+   * so shifting it is not observable to consumers. Left in the diff, the AI analyzer reads the
+   * shifted bit positions as a serialization-compatibility break and misclassifies an additive
+   * change as a spurious MAJOR bump. The genuinely new field, its own new bit constant, and its
+   * setter are all pure additions with no matching deletion, so they survive this pass and the
+   * AI still sees (and correctly classifies) the field addition as MINOR.
+   */
+  removeGoExplicitFieldBitConstantPairs(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.analyzeGoBitConstantLine(line);
+      if (info != null) {
+        additions.push({ index, normalized: info.normalized });
+      }
+    }
+    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.analyzeGoBitConstantLine(line);
+      if (info == null) {
+        continue;
+      }
+      const match2 = additions.find(
+        (addition) => !usedAdditions.has(addition.index) && addition.normalized === info.normalized
+      );
+      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) is a generated Go `explicitFields`
+   * bit constant — `<name> = big.NewInt(1 << N)` or the >=63 form
+   * `<name> = big.NewInt(0).Lsh(big.NewInt(1), N)` — returns a normalized key with the bit
+   * index removed so a deletion and its reindexed addition compare equal. Requiring the exact
+   * `big.NewInt` bit-shift shape keeps this from matching ordinary integer assignments.
+   */
+  analyzeGoBitConstantLine(line) {
+    const content = line.substring(1);
+    const shiftMatch = content.match(/^(\s*)([A-Za-z_][A-Za-z0-9_]*)\s*=\s*big\.NewInt\(1\s*<<\s*\d+\)\s*$/);
+    if (shiftMatch?.[2] != null) {
+      return { normalized: `${shiftMatch[2]}=big.NewInt(1<<#)` };
+    }
+    const lshMatch = content.match(
+      /^(\s*)([A-Za-z_][A-Za-z0-9_]*)\s*=\s*big\.NewInt\(0\)\.Lsh\(big\.NewInt\(1\),\s*\d+\)\s*$/
+    );
+    if (lshMatch?.[2] != null) {
+      return { normalized: `${lshMatch[2]}=big.NewInt(0).Lsh(big.NewInt(1),#)` };
+    }
+    return void 0;
+  }
   /**
    * Gets the latest semantic version from git tags in the given repository.
    * Used as a fallback when the magic version is not embedded in any generated file

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fern-api/generator-cli",
-  "version": "0.9.51",
+  "version": "0.9.53",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fern-api/fern.git",
@@ -23,7 +23,7 @@
   ],
   "dependencies": {
     "@boundaryml/baml": "^0.219.0",
-    "@fern-api/replay": "0.19.1",
+    "@fern-api/replay": "0.19.2",
     "@octokit/rest": "^22.0.1",
     "es-toolkit": "^1.45.1",
     "semver": "^7.6.3",