finalize doc

jackye1995 · jackye1995 · commit aa1a7e88da60 · 2025-11-04T22:45:55.000-08:00
diff --git a/.github/workflows/create-major-minor-rc.yml b/.github/workflows/create-major-minor-rc.yml
@@ -3,10 +3,6 @@ name: Create Major/Minor Release Candidate
 on:
   workflow_dispatch:
     inputs:
-      version:
-        description: 'Target version (e.g., 1.3.0)'
-        required: true
-        type: string
       dry_run:
         description: 'Dry run (simulate without pushing)'
         required: true
@@ -60,7 +56,7 @@ jobs:
         GITHUB_REPOSITORY: ${{ github.repository }}
         GITHUB_OUTPUT: ${{ github.output }}
       run: |
-        bash ci/create_major_minor_rc.sh "${{ inputs.version }}"
+        bash ci/create_major_minor_rc.sh
 
     - name: Push changes (if not dry run)
       if: ${{ !inputs.dry_run }}
@@ -92,11 +88,11 @@ jobs:
         DISCUSSION_TITLE="[VOTE] Release Candidate ${{ steps.create_rc.outputs.RC_TAG }}"
         DISCUSSION_BODY="## Release Candidate: ${{ steps.create_rc.outputs.RC_TAG }}
 
-        This is the initial release candidate for version **${{ inputs.version }}**.
+        This is the initial release candidate for version **${{ steps.create_rc.outputs.RC_VERSION }}**.
 
         ### Release Information
         - **RC Tag**: ${{ steps.create_rc.outputs.RC_TAG }}
-        - **Target Version**: ${{ inputs.version }}
+        - **Target Version**: ${{ steps.create_rc.outputs.RC_VERSION }}
         - **Release Branch**: ${{ steps.create_rc.outputs.RELEASE_BRANCH }}
         - **Main Version**: ${{ steps.create_rc.outputs.MAIN_VERSION }} (unreleased)
         - **Source Branch**: main (HEAD)
@@ -177,7 +173,7 @@ jobs:
       run: |
         echo "## Major/Minor RC Creation Summary" >> $GITHUB_STEP_SUMMARY
         echo "" >> $GITHUB_STEP_SUMMARY
-        echo "- **Target Version:** ${{ inputs.version }}" >> $GITHUB_STEP_SUMMARY
+        echo "- **Target Version:** ${{ steps.create_rc.outputs.RC_VERSION }}" >> $GITHUB_STEP_SUMMARY
         echo "- **RC Tag:** ${{ steps.create_rc.outputs.RC_TAG }}" >> $GITHUB_STEP_SUMMARY
         echo "- **Release Branch:** ${{ steps.create_rc.outputs.RELEASE_BRANCH }}" >> $GITHUB_STEP_SUMMARY
         echo "- **Release Root Tag:** ${{ steps.create_rc.outputs.RELEASE_ROOT_TAG }}" >> $GITHUB_STEP_SUMMARY
diff --git a/ci/create_major_minor_rc.sh b/ci/create_major_minor_rc.sh
@@ -3,44 +3,98 @@ set -e
 
 # Script to create a major/minor release candidate (RC)
 # Always creates RC from the tip of main branch
-# Usage: create_major_minor_rc.sh <target_version>
-# Example: create_major_minor_rc.sh 1.3.0
+# Checks for breaking changes and bumps major version if needed
+# The version is automatically determined from main branch HEAD
+# Usage: create_major_minor_rc.sh
+# Example: create_major_minor_rc.sh
 
-TARGET_VERSION=${1:?"Error: target version required (e.g., 1.3.0)"}
-TAG_PREFIX=${2:-"v"}
+TAG_PREFIX=${1:-"v"}
 
 readonly SELF_DIR=$(cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
 
-echo "Creating major/minor RC for version ${TARGET_VERSION} from main HEAD"
-
-# Parse major.minor from target version
-MAJOR=$(echo "${TARGET_VERSION}" | cut -d. -f1)
-MINOR=$(echo "${TARGET_VERSION}" | cut -d. -f2)
-RELEASE_BRANCH="release/v${MAJOR}.${MINOR}"
-
-echo "Will create release branch: ${RELEASE_BRANCH}"
-
-# Check if main is at beta.0, bump to beta.1 first
 git checkout main
 MAIN_VERSION=$(grep '^version = ' Cargo.toml | head -n1 | cut -d'"' -f2)
 echo "Main branch current version: ${MAIN_VERSION}"
 
-if [[ "${MAIN_VERSION}" =~ -beta\.0$ ]]; then
-    echo "Main is at beta.0, bumping to beta.1 first"
-    bump-my-version bump -vv prerelease_num
+# Extract the base version from main (remove beta suffix if present)
+if [[ "${MAIN_VERSION}" =~ ^([0-9]+)\.([0-9]+)\.([0-9]+)(-beta\.([0-9]+))?$ ]]; then
+    CURR_MAJOR="${BASH_REMATCH[1]}"
+    CURR_MINOR="${BASH_REMATCH[2]}"
+    CURR_PATCH="${BASH_REMATCH[3]}"
+    BASE_VERSION="${CURR_MAJOR}.${CURR_MINOR}.${CURR_PATCH}"
+else
+    echo "ERROR: Cannot parse version from main branch: ${MAIN_VERSION}"
+    exit 1
+fi
+
+echo "Current base version on main: ${BASE_VERSION}"
+
+# Check for existing release-root tag to find comparison base
+CURR_RELEASE_ROOT_TAG="release-root/${BASE_VERSION}-beta.N"
+
+if git rev-parse "${CURR_RELEASE_ROOT_TAG}" >/dev/null 2>&1; then
+    echo "Found release root tag: ${CURR_RELEASE_ROOT_TAG}"
+    COMPARE_TAG="${CURR_RELEASE_ROOT_TAG}"
+    COMPARE_COMMIT=$(git rev-parse "${CURR_RELEASE_ROOT_TAG}")
+    echo "Will compare against: ${COMPARE_TAG} (commit: ${COMPARE_COMMIT})"
+else
+    echo "No release root tag found for current version series"
+    COMPARE_TAG=""
+fi
 
-    git add -A
-    git commit -m "chore: bump to beta.1 for preview release"
+# Check for breaking changes
+BREAKING_CHANGES="false"
+if [ -n "${COMPARE_TAG}" ]; then
+    if [ -x "${SELF_DIR}/check_breaking_changes.py" ]; then
+        if python3 "${SELF_DIR}/check_breaking_changes.py" --detect-only "${COMPARE_TAG}" "HEAD"; then
+            echo "No breaking changes detected"
+            BREAKING_CHANGES="false"
+        else
+            echo "Breaking changes detected"
+            BREAKING_CHANGES="true"
+        fi
+    fi
 fi
 
+# Determine RC version based on breaking changes
+if [ "${BREAKING_CHANGES}" = "true" ]; then
+    # If breaking changes, check if we need to bump major
+    # Extract the base RC version from the release-root tag message
+    # This is the RC version we're comparing against (stays constant across major bumps)
+    TAG_MESSAGE=$(git tag -l --format='%(contents)' "${CURR_RELEASE_ROOT_TAG}")
+    BASE_RC_VERSION=$(echo "${TAG_MESSAGE}" | head -n1 | sed 's/Base: //')
+    BASE_RC_MAJOR=$(echo "${BASE_RC_VERSION}" | cut -d. -f1 | sed 's/^v//')
+
+    echo "Base RC version: ${BASE_RC_VERSION} (major: ${BASE_RC_MAJOR})"
+
+    if [ "${CURR_MAJOR}" -gt "${BASE_RC_MAJOR}" ]; then
+        echo "Major version already bumped from ${BASE_RC_MAJOR} to ${CURR_MAJOR}"
+        RC_VERSION="${BASE_VERSION}-rc.0"
+    else
+        echo "Breaking changes require major version bump"
+        RC_MAJOR=$((CURR_MAJOR + 1))
+        RC_VERSION="${RC_MAJOR}.0.0-rc.0"
+    fi
+else
+    # No breaking changes, use current base version
+    RC_VERSION="${BASE_VERSION}-rc.0"
+fi
+
+echo "Creating RC version: ${RC_VERSION}"
+
+# Parse RC version for release branch
+RC_MAJOR=$(echo "${RC_VERSION}" | cut -d. -f1)
+RC_MINOR=$(echo "${RC_VERSION}" | cut -d. -f2)
+RELEASE_BRANCH="release/v${RC_MAJOR}.${RC_MINOR}"
+
+echo "Will create release branch: ${RELEASE_BRANCH}"
+
 # Create release branch from main HEAD
 echo "Creating release branch ${RELEASE_BRANCH} from main HEAD"
 git checkout -b "${RELEASE_BRANCH}"
 
-# Set version to target-rc.1
-RC_VERSION="${TARGET_VERSION}-rc.1"
+# Set version to RC version
 echo "Setting version to ${RC_VERSION}"
-
 bump-my-version bump -vv --new-version "${RC_VERSION}" --no-tag patch
 
 # Commit the RC version
@@ -58,32 +112,13 @@ echo "Successfully created RC tag: ${RC_TAG} on branch ${RELEASE_BRANCH}"
 echo "Bumping main to next version beta.0"
 git checkout main
 
-# Get current version on main
-CURRENT_MAIN_VERSION=$(grep '^version = ' Cargo.toml | head -n1 | cut -d'"' -f2)
-echo "Current main version: ${CURRENT_MAIN_VERSION}"
-
-# Parse current version
-CURR_MAJOR=$(echo "${CURRENT_MAIN_VERSION}" | cut -d. -f1 | sed 's/-beta.*//')
-CURR_MINOR=$(echo "${CURRENT_MAIN_VERSION}" | cut -d. -f2)
-CURR_PATCH=$(echo "${CURRENT_MAIN_VERSION}" | cut -d. -f3 | cut -d- -f1)
-
-# Determine next version - just increment based on what we have
-# Breaking change detection will happen during beta publish
-if [ "${CURR_PATCH}" != "0" ]; then
-    # If on a patch version, bump to next minor
-    NEXT_MINOR=$((CURR_MINOR + 1))
-    NEXT_VERSION="${CURR_MAJOR}.${NEXT_MINOR}.0-beta.0"
-elif [ "${CURR_MINOR}" -gt "0" ]; then
-    # On minor version, bump to next minor
-    NEXT_MINOR=$((CURR_MINOR + 1))
-    NEXT_VERSION="${CURR_MAJOR}.${NEXT_MINOR}.0-beta.0"
-else
-    # On major.0.0, bump to next major
-    NEXT_MAJOR=$((CURR_MAJOR + 1))
-    NEXT_VERSION="${NEXT_MAJOR}.0.0-beta.0"
-fi
+# Determine next version for main based on RC version
+# Always bump minor from the RC version
+NEXT_MAJOR="${RC_MAJOR}"
+NEXT_MINOR=$((RC_MINOR + 1))
+NEXT_VERSION="${NEXT_MAJOR}.${NEXT_MINOR}.0-beta.0"
 
-echo "Bumping main to ${NEXT_VERSION} (unreleased, will be adjusted during beta publish)"
+echo "Bumping main to ${NEXT_VERSION} (unreleased)"
 
 bump-my-version bump -vv --new-version "${NEXT_VERSION}" --no-tag patch
 
diff --git a/ci/publish_beta.sh b/ci/publish_beta.sh
@@ -51,9 +51,12 @@ if [[ "${BRANCH}" == "main" ]] && [[ "${CURRENT_VERSION}" =~ -beta\.[0-9]+$ ]];
         echo "Release root tag ${CURR_RELEASE_ROOT_TAG} not found"
         echo "Treating as major version bump (no comparison base)"
 
+        # Store current commit before bumping version
+        PREV_COMMIT=$(git rev-parse HEAD)
+
         NEXT_MAJOR=$((CURR_MAJOR + 1))
-        NEXT_BETA=$((CURR_BETA + 1))
-        NEXT_VERSION="${NEXT_MAJOR}.0.0-beta.${NEXT_BETA}"
+        # Reset to beta.1 for new major version
+        NEXT_VERSION="${NEXT_MAJOR}.0.0-beta.1"
         echo "Bumping to ${NEXT_VERSION} (no release root found)"
 
         echo "Updating version from ${CURRENT_VERSION} to ${NEXT_VERSION}"
@@ -64,6 +67,19 @@ if [[ "${BRANCH}" == "main" ]] && [[ "${CURRENT_VERSION}" =~ -beta\.[0-9]+$ ]];
 
         CURRENT_VERSION="${NEXT_VERSION}"
 
+        # Create release-root tag for the new major version series
+        # Point it to the commit before the version bump
+        # Use the previous version as the base (this is what we're comparing against)
+        NEW_RELEASE_ROOT_TAG="release-root/${NEXT_VERSION}-beta.N"
+        echo "Creating release root tag ${NEW_RELEASE_ROOT_TAG} at commit ${PREV_COMMIT}"
+        # Extract previous base version (without beta suffix)
+        PREV_BASE_VERSION=$(echo "${CURRENT_VERSION}" | sed 's/-beta\.[0-9]*$//')
+        # Decrement major to get what the "RC" would have been
+        PREV_MAJOR=$((NEXT_MAJOR - 1))
+        BASE_RC_VERSION="${PREV_MAJOR}.${CURR_MINOR}.${CURR_PATCH}-rc.0"
+        git tag -a "${NEW_RELEASE_ROOT_TAG}" "${PREV_COMMIT}" -m "Base: ${BASE_RC_VERSION}
+Release root for ${NEXT_VERSION}-beta.N series (created during major bump)"
+
         # Create beta tag
         BETA_TAG="${TAG_PREFIX}${CURRENT_VERSION}"
         echo "Creating beta tag: ${BETA_TAG}"
@@ -72,6 +88,7 @@ if [[ "${BRANCH}" == "main" ]] && [[ "${CURRENT_VERSION}" =~ -beta\.[0-9]+$ ]];
         echo "Successfully published beta release: ${BETA_TAG}"
         echo "BETA_TAG=${BETA_TAG}" >> $GITHUB_OUTPUT 2>/dev/null || true
         echo "BETA_VERSION=${CURRENT_VERSION}" >> $GITHUB_OUTPUT 2>/dev/null || true
+        echo "RELEASE_ROOT_TAG=${NEW_RELEASE_ROOT_TAG}" >> $GITHUB_OUTPUT 2>/dev/null || true
         exit 0
     fi
 
@@ -94,6 +111,7 @@ if [[ "${BRANCH}" == "main" ]] && [[ "${CURRENT_VERSION}" =~ -beta\.[0-9]+$ ]];
         if [ "${BREAKING_CHANGES}" = "true" ]; then
             # Extract the base RC version from the release-root tag message
             # Format: "Base: X.Y.Z-rc.N\nRelease root for..."
+            # This is the RC version we're comparing against (stays constant across major bumps)
             TAG_MESSAGE=$(git tag -l --format='%(contents)' "${CURR_RELEASE_ROOT_TAG}")
             BASE_RC_VERSION=$(echo "${TAG_MESSAGE}" | head -n1 | sed 's/Base: //')
             BASE_VERSION=$(echo "${BASE_RC_VERSION}" | sed 's/-rc\.[0-9]*$//')
@@ -109,9 +127,8 @@ if [[ "${BRANCH}" == "main" ]] && [[ "${CURRENT_VERSION}" =~ -beta\.[0-9]+$ ]];
             else
                 echo "Breaking changes detected since ${BASE_VERSION}, bumping major version"
                 NEXT_MAJOR=$((CURR_MAJOR + 1))
-                # Increment beta number
-                NEXT_BETA=$((CURR_BETA + 1))
-                NEXT_VERSION="${NEXT_MAJOR}.0.0-beta.${NEXT_BETA}"
+                # Reset to beta.1 for new major version
+                NEXT_VERSION="${NEXT_MAJOR}.0.0-beta.1"
                 echo "Bumping to ${NEXT_VERSION}"
 
                 echo "Updating version from ${CURRENT_VERSION} to ${NEXT_VERSION}"
diff --git a/release_process.md b/release_process.md
