@fern-api/generator-cli 0.9.52 → 0.9.54

package/dist/cli.js

@@ -41162,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;
@@ -41366,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
@@ -41758,11 +41843,20 @@ var SEMVER_PATTERN = /^(v)?(\d+)\.(\d+)\.(\d+)(?:-([\w.-]+))?(?:\+([\w.-]+))?$/;
 function isValidSemver(version2) {
   return SEMVER_PATTERN.test(version2);
 }
+function isPlaceholderVersion(version2) {
+  const withoutPrefix = version2.startsWith("v") ? version2.slice(1) : version2;
+  return withoutPrefix === MAGIC_VERSION || withoutPrefix.startsWith(`${MAGIC_VERSION}.`) || withoutPrefix === MAGIC_VERSION_PYTHON || withoutPrefix.startsWith(`${MAGIC_VERSION_PYTHON}.`);
+}
 function incrementVersion(currentVersion, versionBump) {
   const matcher = currentVersion.match(SEMVER_PATTERN);
   if (!matcher) {
     throw new AutoVersioningException("Invalid semantic version format: " + currentVersion);
   }
+  if (isPlaceholderVersion(currentVersion)) {
+    throw new AutoVersioningException(
+      "Refusing to increment the magic placeholder version: " + currentVersion + ". A real previous version must be resolved first."
+    );
+  }
   const prefix = matcher[1] ?? "";
   const versionWithoutPrefix = currentVersion.slice(prefix.length);
   const preRelease = matcher[5];
@@ -41833,7 +41927,8 @@ var AutoVersionStep = class extends BaseStep {
   }
   async handleFirstGeneration(params) {
     const { service, language, mappedMagicVersion, commit } = params;
-    const initialVersion = this.config.baseVersion ?? (mappedMagicVersion.startsWith("v") ? "v0.0.1" : "0.0.1");
+    const configuredBaseVersion = this.usableVersion(this.config.baseVersion, "baseVersion");
+    const initialVersion = configuredBaseVersion ?? (mappedMagicVersion.startsWith("v") ? "v0.0.1" : "0.0.1");
     if (!isValidSemver(initialVersion)) {
       const errorMessage = `AutoVersionStep: baseVersion ${JSON.stringify(initialVersion)} is not a valid semver string (expected e.g. "1.2.3" or "v1.2.3"). Refusing to run.`;
       this.logger.error(errorMessage);
@@ -42167,14 +42262,18 @@ var AutoVersionStep = class extends BaseStep {
    */
   async resolvePreviousVersionNonReplay(params) {
     const { service, rawDiff, mappedMagicVersion, baseVersion } = params;
-    if (baseVersion != null && isValidSemver(baseVersion)) {
+    const usableBaseVersion = this.usableVersion(baseVersion, "baseVersion");
+    if (usableBaseVersion != null && isValidSemver(usableBaseVersion)) {
       this.logger.debug(
-        `AutoVersionStep (non-replay): previous version from pipeline baseVersion: ${baseVersion}`
+        `AutoVersionStep (non-replay): previous version from pipeline baseVersion: ${usableBaseVersion}`
       );
-      return this.normalizeVersionPrefix(baseVersion, mappedMagicVersion);
+      return this.normalizeVersionPrefix(usableBaseVersion, mappedMagicVersion);
     }
     try {
-      const extracted = service.extractPreviousVersion(rawDiff, mappedMagicVersion);
+      const extracted = this.usableVersion(
+        service.extractPreviousVersion(rawDiff, mappedMagicVersion) ?? void 0,
+        "diff"
+      );
       if (extracted != null) {
         this.logger.debug(`AutoVersionStep (non-replay): previous version from diff: ${extracted}`);
         return extracted;
@@ -42185,12 +42284,15 @@ var AutoVersionStep = class extends BaseStep {
       }
       this.logger.info("AutoVersionStep (non-replay): magic version not in diff; trying metadata + git tags.");
     }
-    const metadataVersion = this.readVersionFromMetadataAtHead();
+    const metadataVersion = this.usableVersion(this.readVersionFromMetadataAtHead(), "metadata.json");
     if (metadataVersion != null) {
       return this.normalizeVersionPrefix(metadataVersion, mappedMagicVersion);
     }
     try {
-      const tagVersion = await service.getLatestVersionFromGitTags(this.outputDir);
+      const tagVersion = this.usableVersion(
+        await service.getLatestVersionFromGitTags(this.outputDir) ?? void 0,
+        "git tags"
+      );
       if (tagVersion != null) {
         return this.normalizeVersionPrefix(tagVersion, mappedMagicVersion);
       }
@@ -42201,12 +42303,16 @@ var AutoVersionStep = class extends BaseStep {
   }
   async resolvePreviousVersion(params) {
     const { service, rawDiff, mappedMagicVersion, baseVersion } = params;
-    if (baseVersion != null && isValidSemver(baseVersion)) {
-      this.logger.debug(`AutoVersionStep: previous version from pipeline baseVersion: ${baseVersion}`);
-      return this.normalizeVersionPrefix(baseVersion, mappedMagicVersion);
+    const usableBaseVersion = this.usableVersion(baseVersion, "baseVersion");
+    if (usableBaseVersion != null && isValidSemver(usableBaseVersion)) {
+      this.logger.debug(`AutoVersionStep: previous version from pipeline baseVersion: ${usableBaseVersion}`);
+      return this.normalizeVersionPrefix(usableBaseVersion, mappedMagicVersion);
     }
     try {
-      const extracted = service.extractPreviousVersion(rawDiff, mappedMagicVersion);
+      const extracted = this.usableVersion(
+        service.extractPreviousVersion(rawDiff, mappedMagicVersion) ?? void 0,
+        "diff"
+      );
       if (extracted != null) {
         this.logger.debug(`AutoVersionStep: previous version from diff: ${extracted}`);
         return extracted;
@@ -42217,12 +42323,15 @@ var AutoVersionStep = class extends BaseStep {
       }
       this.logger.info("AutoVersionStep: magic version not found in diff; falling back to metadata + git tags.");
     }
-    const metadataVersion = await this.readVersionFromMetadata();
+    const metadataVersion = this.usableVersion(await this.readVersionFromMetadata(), "metadata.json");
     if (metadataVersion != null) {
       return this.normalizeVersionPrefix(metadataVersion, mappedMagicVersion);
     }
     try {
-      const tagVersion = await service.getLatestVersionFromGitTags(this.outputDir);
+      const tagVersion = this.usableVersion(
+        await service.getLatestVersionFromGitTags(this.outputDir) ?? void 0,
+        "git tags"
+      );
       if (tagVersion != null) {
         return this.normalizeVersionPrefix(tagVersion, mappedMagicVersion);
       }
@@ -42244,6 +42353,27 @@ var AutoVersionStep = class extends BaseStep {
       return void 0;
     }
   }
+  /**
+   * Drops candidate previous versions that are the magic placeholder. SDK repos
+   * that derive their published version at release time keep the placeholder
+   * committed, so every resolution source (baseVersion, diff extraction,
+   * metadata.json, git tags) can hand back the sentinel; incrementing it would
+   * emit a mutated placeholder such as `0.0.0-fern-placeholder.0` instead of a
+   * real version. Returning undefined lets the caller fall through to the next
+   * source, and ultimately to the first-generation path.
+   */
+  usableVersion(version2, source) {
+    if (version2 == null) {
+      return void 0;
+    }
+    if (isPlaceholderVersion(version2)) {
+      this.logger.info(
+        `AutoVersionStep: ignoring placeholder version ${version2} from ${source}; trying the next previous-version source.`
+      );
+      return void 0;
+    }
+    return version2;
+  }
   normalizeVersionPrefix(version2, mappedMagicVersion) {
     const stripped = version2.startsWith("v") ? version2.slice(1) : version2;
     return mappedMagicVersion.startsWith("v") ? `v${stripped}` : stripped;

package/package.json

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