From bb4e39f78f3c5e20bf5e01b0ec0f1f64dfdc30b9 Mon Sep 17 00:00:00 2001
From: "blink-so[bot]" <211532188+blink-so[bot]@users.noreply.github.com>
Date: Thu, 5 Jun 2025 17:01:05 +0000
Subject: [PATCH 01/10] feat: extract version bump logic into reusable script

- Add .github/scripts/version-bump.sh with extracted logic from PR #137
- Add version-check.yaml workflow to verify module versions are updated
- Add version-bump.yaml workflow that uses the script for label-triggered bumps
- Update CONTRIBUTING.md with instructions on using the version bump script
- Script supports patch/minor/major bumps and validates semantic versioning
- CI will now check that module versions are properly updated in PRs
---
 .github/scripts/version-bump.sh      | 248 +++++++++++++++++++++++++++
 .github/workflows/version-bump.yaml  | 106 ++++++++++++
 .github/workflows/version-check.yaml |  34 ++++
 CONTRIBUTING.md                      |  34 +++-
 4 files changed, 420 insertions(+), 2 deletions(-)
 create mode 100755 .github/scripts/version-bump.sh
 create mode 100644 .github/workflows/version-bump.yaml
 create mode 100644 .github/workflows/version-check.yaml

diff --git a/.github/scripts/version-bump.sh b/.github/scripts/version-bump.sh
new file mode 100755
index 0000000..7c07ed1
--- /dev/null
+++ b/.github/scripts/version-bump.sh
@@ -0,0 +1,248 @@
+#!/bin/bash
+
+# Version Bump Script
+# Extracts version bump logic from GitHub Actions workflow
+# Usage: ./version-bump.sh <bump_type> [base_ref]
+#   bump_type: patch, minor, or major
+#   base_ref: base reference for diff (default: origin/main)
+
+set -euo pipefail
+
+# Function to print usage
+usage() {
+    echo "Usage: $0 <bump_type> [base_ref]"
+    echo "  bump_type: patch, minor, or major"
+    echo "  base_ref: base reference for diff (default: origin/main)"
+    exit 1
+}
+
+# Function to validate version format
+validate_version() {
+    local version="$1"
+    if ! [[ "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+        echo "❌ Invalid version format: '$version'. Expected X.Y.Z format." >&2
+        return 1
+    fi
+    return 0
+}
+
+# Function to bump version
+bump_version() {
+    local current_version="$1"
+    local bump_type="$2"
+    
+    IFS='.' read -r major minor patch <<< "$current_version"
+    
+    # Validate that components are numeric
+    if ! [[ "$major" =~ ^[0-9]+$ ]] || ! [[ "$minor" =~ ^[0-9]+$ ]] || ! [[ "$patch" =~ ^[0-9]+$ ]]; then
+        echo "❌ Version components must be numeric: major='$major' minor='$minor' patch='$patch'" >&2
+        return 1
+    fi
+    
+    case "$bump_type" in
+        "patch")
+            echo "$major.$minor.$((patch + 1))"
+            ;;
+        "minor")
+            echo "$major.$((minor + 1)).0"
+            ;;
+        "major")
+            echo "$((major + 1)).0.0"
+            ;;
+        *)
+            echo "❌ Invalid bump type: '$bump_type'. Expected patch, minor, or major." >&2
+            return 1
+            ;;
+    esac
+}
+
+# Function to update README version
+update_readme_version() {
+    local readme_path="$1"
+    local namespace="$2"
+    local module_name="$3"
+    local new_version="$4"
+    
+    if [ ! -f "$readme_path" ]; then
+        return 1
+    fi
+    
+    # Check if README contains version references for this specific module
+    local module_source="registry.coder.com/${namespace}/${module_name}/coder"
+    if grep -q "source.*${module_source}" "$readme_path"; then
+        echo "Updating version references for $namespace/$module_name in $readme_path"
+        # Use awk to only update versions that follow the specific module source
+        awk -v module_source="$module_source" -v new_version="$new_version" '
+        /source.*=.*/ {
+          if ($0 ~ module_source) {
+            in_target_module = 1
+          } else {
+            in_target_module = 0
+          }
+        }
+        /version.*=.*"/ {
+          if (in_target_module) {
+            gsub(/version[[:space:]]*=[[:space:]]*"[^"]*"/, "version = \"" new_version "\"")
+            in_target_module = 0
+          }
+        }
+        { print }
+        ' "$readme_path" > "${readme_path}.tmp" && mv "${readme_path}.tmp" "$readme_path"
+        return 0
+    elif grep -q 'version\s*=\s*"' "$readme_path"; then
+        echo "⚠️  Found version references but no module source match for $namespace/$module_name"
+        return 1
+    fi
+    
+    return 1
+}
+
+# Main function
+main() {
+    # Parse arguments
+    if [ $# -lt 1 ] || [ $# -gt 2 ]; then
+        usage
+    fi
+    
+    local bump_type="$1"
+    local base_ref="${2:-origin/main}"
+    
+    # Validate bump type
+    case "$bump_type" in
+        "patch"|"minor"|"major")
+            ;;
+        *)
+            echo "❌ Invalid bump type: '$bump_type'. Expected patch, minor, or major." >&2
+            exit 1
+            ;;
+    esac
+    
+    echo "🔍 Detecting modified modules..."
+    
+    # Detect modified modules
+    local changed_files
+    changed_files=$(git diff --name-only "${base_ref}"...HEAD)
+    local modules
+    modules=$(echo "$changed_files" | grep -E '^registry/[^/]+/modules/[^/]+/' | cut -d'/' -f1-4 | sort -u)
+    
+    if [ -z "$modules" ]; then
+        echo "❌ No modules detected in changes"
+        exit 1
+    fi
+    
+    echo "Found modules:"
+    echo "$modules"
+    echo ""
+    
+    # Initialize tracking variables
+    local bumped_modules=""
+    local updated_readmes=""
+    local untagged_modules=""
+    local has_changes=false
+    
+    # Process each module
+    while IFS= read -r module_path; do
+        if [ -z "$module_path" ]; then continue; fi
+        
+        local namespace
+        namespace=$(echo "$module_path" | cut -d'/' -f2)
+        local module_name
+        module_name=$(echo "$module_path" | cut -d'/' -f4)
+        
+        echo "📦 Processing: $namespace/$module_name"
+        
+        # Find latest tag
+        local latest_tag
+        latest_tag=$(git tag -l "release/${namespace}/${module_name}/v*" | sort -V | tail -1)
+        local readme_path="$module_path/README.md"
+        local current_version
+        
+        if [ -z "$latest_tag" ]; then
+            # No tag found, check if README has version references
+            if [ -f "$readme_path" ] && grep -q 'version\s*=\s*"' "$readme_path"; then
+                # Extract version from README
+                local readme_version
+                readme_version=$(grep 'version\s*=\s*"' "$readme_path" | head -1 | sed 's/.*version\s*=\s*"\([^"]*\)".*/\1/')
+                echo "No git tag found, but README shows version: $readme_version"
+                
+                # Validate extracted version format
+                if ! validate_version "$readme_version"; then
+                    echo "Starting from v1.0.0 instead"
+                    current_version="1.0.0"
+                else
+                    current_version="$readme_version"
+                    untagged_modules="$untagged_modules\n- $namespace/$module_name (README: v$readme_version)"
+                fi
+            else
+                echo "No existing tags or version references found for $namespace/$module_name, starting from v1.0.0"
+                current_version="1.0.0"
+            fi
+        else
+            current_version=$(echo "$latest_tag" | sed 's/.*\/v//')
+            echo "Found git tag: $latest_tag (v$current_version)"
+        fi
+        
+        echo "Current version: $current_version"
+        
+        # Validate current version format
+        if ! validate_version "$current_version"; then
+            exit 1
+        fi
+        
+        # Calculate new version
+        local new_version
+        new_version=$(bump_version "$current_version" "$bump_type")
+        
+        echo "New version: $new_version"
+        
+        # Update README if applicable
+        if update_readme_version "$readme_path" "$namespace" "$module_name" "$new_version"; then
+            updated_readmes="$updated_readmes\n- $namespace/$module_name"
+            has_changes=true
+        fi
+        
+        bumped_modules="$bumped_modules\n- $namespace/$module_name: v$current_version → v$new_version"
+        echo ""
+        
+    done <<< "$modules"
+    
+    # Output results
+    echo "📋 Summary:"
+    echo "Bump Type: $bump_type"
+    echo ""
+    echo "Modules Updated:"
+    echo -e "$bumped_modules"
+    echo ""
+    
+    if [ -n "$updated_readmes" ]; then
+        echo "READMEs Updated:"
+        echo -e "$updated_readmes"
+        echo ""
+    fi
+    
+    if [ -n "$untagged_modules" ]; then
+        echo "⚠️  Modules Without Git Tags:"
+        echo -e "$untagged_modules"
+        echo "These modules were versioned based on README content. Consider creating proper release tags after merging."
+        echo ""
+    fi
+    
+    # Check for changes and provide guidance
+    if [ "$has_changes" = true ]; then
+        echo "✅ Version bump completed successfully!"
+        echo "📝 README files have been updated with new versions."
+        echo ""
+        echo "Next steps:"
+        echo "1. Review the changes: git diff"
+        echo "2. Commit the changes: git add . && git commit -m 'chore: bump module versions ($bump_type)'"
+        echo "3. Push the changes: git push"
+        exit 0
+    else
+        echo "ℹ️  No README files were updated (no version references found matching module sources)."
+        echo "Version calculations completed, but no files were modified."
+        exit 0
+    fi
+}
+
+# Run main function with all arguments
+main "$@"
\ No newline at end of file
diff --git a/.github/workflows/version-bump.yaml b/.github/workflows/version-bump.yaml
new file mode 100644
index 0000000..41a7cc0
--- /dev/null
+++ b/.github/workflows/version-bump.yaml
@@ -0,0 +1,106 @@
+name: Version Bump
+
+on:
+  pull_request:
+    types: [labeled]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  version-bump:
+    if: github.event.label.name == 'version:patch' || github.event.label.name == 'version:minor' || github.event.label.name == 'version:major'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Setup Git
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+      - name: Extract bump type from label
+        id: bump-type
+        run: |
+          case "${{ github.event.label.name }}" in
+            "version:patch")
+              echo "type=patch" >> $GITHUB_OUTPUT
+              ;;
+            "version:minor")
+              echo "type=minor" >> $GITHUB_OUTPUT
+              ;;
+            "version:major")
+              echo "type=major" >> $GITHUB_OUTPUT
+              ;;
+            *)
+              echo "Invalid version label: ${{ github.event.label.name }}"
+              exit 1
+              ;;
+          esac
+
+      - name: Run version bump script
+        id: version-bump
+        run: |
+          # Capture script output for later use in PR comment
+          output_file=$(mktemp)
+          if ./.github/scripts/version-bump.sh "${{ steps.bump-type.outputs.type }}" origin/main > "$output_file" 2>&1; then
+            echo "success=true" >> $GITHUB_OUTPUT
+            echo "Script completed successfully"
+          else
+            echo "success=false" >> $GITHUB_OUTPUT
+            echo "Script failed"
+            cat "$output_file"
+            exit 1
+          fi
+          
+          # Store output for PR comment
+          {
+            echo "output<<EOF"
+            cat "$output_file"
+            echo "EOF"
+          } >> $GITHUB_OUTPUT
+          
+          # Show output
+          cat "$output_file"
+
+      - name: Commit changes
+        if: steps.version-bump.outputs.success == 'true'
+        run: |
+          # Check if any README files were modified
+          if git diff --quiet 'registry/*/modules/*/README.md'; then
+            echo "No README changes to commit"
+          else
+            echo "Committing README changes..."
+            git diff --name-only 'registry/*/modules/*/README.md'
+            git add registry/*/modules/*/README.md
+            git commit -m "chore: bump module versions (${{ steps.bump-type.outputs.type }})"
+            git push
+          fi
+
+      - name: Comment on PR
+        if: steps.version-bump.outputs.success == 'true'
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const output = `${{ steps.version-bump.outputs.output }}`;
+            const bumpType = `${{ steps.bump-type.outputs.type }}`;
+            
+            let comment = `## 🚀 Version Bump Summary\n\n`;
+            comment += `**Bump Type:** \`${bumpType}\`\n\n`;
+            comment += `### Script Output:\n\`\`\`\n${output}\n\`\`\`\n\n`;
+            comment += `> Versions have been automatically updated using the version bump script.`;
+            
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: comment
+            });
\ No newline at end of file
diff --git a/.github/workflows/version-check.yaml b/.github/workflows/version-check.yaml
new file mode 100644
index 0000000..10eb31b
--- /dev/null
+++ b/.github/workflows/version-check.yaml
@@ -0,0 +1,34 @@
+name: Version Check
+
+on:
+  pull_request:
+    paths:
+      - 'registry/**/modules/**'
+
+jobs:
+  version-check:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Check if module versions need updating
+        run: |
+          echo "🔍 Checking if module versions need to be updated..."
+          
+          # Run the version bump script in dry-run mode to see what would change
+          if ./.github/scripts/version-bump.sh patch origin/main; then
+            echo "✅ Module versions are up to date or no modules were modified"
+          else
+            echo "❌ Module versions may need to be updated"
+            echo ""
+            echo "To update module versions, run one of:"
+            echo "  ./.github/scripts/version-bump.sh patch"
+            echo "  ./.github/scripts/version-bump.sh minor"
+            echo "  ./.github/scripts/version-bump.sh major"
+            echo ""
+            echo "Or add a version label to this PR: version:patch, version:minor, or version:major"
+            exit 1
+          fi
\ No newline at end of file
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index a0e8f63..8fc8778 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -258,13 +258,43 @@ All README files must follow these rules:
 
 ## Versioning Guidelines
 
-After your PR is merged, maintainers will handle the release. Understanding version numbers helps you describe the impact of your changes:
+When you modify a module, you need to update its version number in the README. Understanding version numbers helps you describe the impact of your changes:
 
 - **Patch** (1.2.3 → 1.2.4): Bug fixes
 - **Minor** (1.2.3 → 1.3.0): New features, adding inputs
 - **Major** (1.2.3 → 2.0.0): Breaking changes (removing inputs, changing types)
 
-**Important**: Always specify the version change in your PR (e.g., `v1.2.3 → v1.2.4`). This helps maintainers create the correct release tag.
+### Updating Module Versions
+
+Use the version bump script to automatically update module versions:
+
+```bash
+# For bug fixes
+./.github/scripts/version-bump.sh patch
+
+# For new features
+./.github/scripts/version-bump.sh minor
+
+# For breaking changes
+./.github/scripts/version-bump.sh major
+```
+
+The script will:
+1. Detect which modules you've modified
+2. Calculate the new version number
+3. Update all version references in the module's README
+4. Show you a summary of changes
+
+### Alternative: Use PR Labels
+
+You can also add a label to your PR instead of running the script manually:
+- `version:patch` - For bug fixes
+- `version:minor` - For new features  
+- `version:major` - For breaking changes
+
+The version bump will happen automatically when the label is added.
+
+**Important**: Always update module versions when making changes. The CI will check that versions are properly updated.
 
 ---
 

From b56adc5e51c91987e86959d497fb9d5b0771b7b1 Mon Sep 17 00:00:00 2001
From: "blink-so[bot]" <211532188+blink-so[bot]@users.noreply.github.com>
Date: Thu, 5 Jun 2025 17:11:42 +0000
Subject: [PATCH 02/10] fix: simplify version bump implementation to single
 script

- Modify version-bump.sh to support both update and check modes
- Add --check flag and 'check' command for validation without changes
- Combine version-check and version-bump workflows into single workflow
- Remove separate version-check.yaml workflow (was overcomplicated)
- Update CONTRIBUTING.md to document simplified approach
- Script now exits with proper codes: 0 for success, 1 for needs update
- Workflow runs check job on all PRs, bump job only on labels
- Much cleaner and simpler implementation as requested
---
 .github/scripts/version-bump.sh      | 129 +++++++++++++++++++--------
 .github/workflows/version-bump.yaml  |  39 ++++++--
 .github/workflows/version-check.yaml |  34 -------
 CONTRIBUTING.md                      |  12 ++-
 4 files changed, 132 insertions(+), 82 deletions(-)
 delete mode 100644 .github/workflows/version-check.yaml

diff --git a/.github/scripts/version-bump.sh b/.github/scripts/version-bump.sh
index 7c07ed1..2cec6d2 100755
--- a/.github/scripts/version-bump.sh
+++ b/.github/scripts/version-bump.sh
@@ -2,17 +2,24 @@
 
 # Version Bump Script
 # Extracts version bump logic from GitHub Actions workflow
-# Usage: ./version-bump.sh <bump_type> [base_ref]
-#   bump_type: patch, minor, or major
+# Usage: ./version-bump.sh <bump_type> [base_ref] [--check]
+#   bump_type: patch, minor, major, or check
 #   base_ref: base reference for diff (default: origin/main)
+#   --check: only check if versions need updating, don't modify files
 
 set -euo pipefail
 
 # Function to print usage
 usage() {
-    echo "Usage: $0 <bump_type> [base_ref]"
-    echo "  bump_type: patch, minor, or major"
+    echo "Usage: $0 <bump_type> [base_ref] [--check]"
+    echo "  bump_type: patch, minor, major, or check"
     echo "  base_ref: base reference for diff (default: origin/main)"
+    echo "  --check: only check if versions need updating, don't modify files"
+    echo ""
+    echo "Examples:"
+    echo "  $0 patch                    # Update versions with patch bump"
+    echo "  $0 check                    # Check if versions need updating"
+    echo "  $0 patch origin/main --check # Check what patch bump would do"
     exit 1
 }
 
@@ -62,6 +69,7 @@ update_readme_version() {
     local namespace="$2"
     local module_name="$3"
     local new_version="$4"
+    local check_mode="$5"
     
     if [ ! -f "$readme_path" ]; then
         return 1
@@ -70,24 +78,28 @@ update_readme_version() {
     # Check if README contains version references for this specific module
     local module_source="registry.coder.com/${namespace}/${module_name}/coder"
     if grep -q "source.*${module_source}" "$readme_path"; then
-        echo "Updating version references for $namespace/$module_name in $readme_path"
-        # Use awk to only update versions that follow the specific module source
-        awk -v module_source="$module_source" -v new_version="$new_version" '
-        /source.*=.*/ {
-          if ($0 ~ module_source) {
-            in_target_module = 1
-          } else {
-            in_target_module = 0
-          }
-        }
-        /version.*=.*"/ {
-          if (in_target_module) {
-            gsub(/version[[:space:]]*=[[:space:]]*"[^"]*"/, "version = \"" new_version "\"")
-            in_target_module = 0
-          }
-        }
-        { print }
-        ' "$readme_path" > "${readme_path}.tmp" && mv "${readme_path}.tmp" "$readme_path"
+        if [ "$check_mode" = "true" ]; then
+            echo "Would update version references for $namespace/$module_name in $readme_path"
+        else
+            echo "Updating version references for $namespace/$module_name in $readme_path"
+            # Use awk to only update versions that follow the specific module source
+            awk -v module_source="$module_source" -v new_version="$new_version" '
+            /source.*=.*/ {
+              if ($0 ~ module_source) {
+                in_target_module = 1
+              } else {
+                in_target_module = 0
+              }
+            }
+            /version.*=.*"/ {
+              if (in_target_module) {
+                gsub(/version[[:space:]]*=[[:space:]]*"[^"]*"/, "version = \"" new_version "\"")
+                in_target_module = 0
+              }
+            }
+            { print }
+            ' "$readme_path" > "${readme_path}.tmp" && mv "${readme_path}.tmp" "$readme_path"
+        fi
         return 0
     elif grep -q 'version\s*=\s*"' "$readme_path"; then
         echo "⚠️  Found version references but no module source match for $namespace/$module_name"
@@ -100,19 +112,40 @@ update_readme_version() {
 # Main function
 main() {
     # Parse arguments
-    if [ $# -lt 1 ] || [ $# -gt 2 ]; then
+    if [ $# -lt 1 ] || [ $# -gt 3 ]; then
         usage
     fi
     
     local bump_type="$1"
-    local base_ref="${2:-origin/main}"
+    local base_ref="origin/main"
+    local check_mode=false
+    
+    # Parse remaining arguments
+    shift
+    while [ $# -gt 0 ]; do
+        case "$1" in
+            --check)
+                check_mode=true
+                ;;
+            *)
+                base_ref="$1"
+                ;;
+        esac
+        shift
+    done
+    
+    # Handle "check" as bump type
+    if [ "$bump_type" = "check" ]; then
+        check_mode=true
+        bump_type="patch"  # Use patch as default for check mode
+    fi
     
     # Validate bump type
     case "$bump_type" in
         "patch"|"minor"|"major")
             ;;
         *)
-            echo "❌ Invalid bump type: '$bump_type'. Expected patch, minor, or major." >&2
+            echo "❌ Invalid bump type: '$bump_type'. Expected patch, minor, major, or check." >&2
             exit 1
             ;;
     esac
@@ -196,7 +229,7 @@ main() {
         echo "New version: $new_version"
         
         # Update README if applicable
-        if update_readme_version "$readme_path" "$namespace" "$module_name" "$new_version"; then
+        if update_readme_version "$readme_path" "$namespace" "$module_name" "$new_version" "$check_mode"; then
             updated_readmes="$updated_readmes\n- $namespace/$module_name"
             has_changes=true
         fi
@@ -228,19 +261,39 @@ main() {
     fi
     
     # Check for changes and provide guidance
-    if [ "$has_changes" = true ]; then
-        echo "✅ Version bump completed successfully!"
-        echo "📝 README files have been updated with new versions."
-        echo ""
-        echo "Next steps:"
-        echo "1. Review the changes: git diff"
-        echo "2. Commit the changes: git add . && git commit -m 'chore: bump module versions ($bump_type)'"
-        echo "3. Push the changes: git push"
-        exit 0
+    if [ "$check_mode" = "true" ]; then
+        if [ "$has_changes" = true ]; then
+            echo "❌ Module versions need to be updated!"
+            echo "📝 The following modules would have their README files updated:"
+            echo -e "$updated_readmes"
+            echo ""
+            echo "To fix this, run one of:"
+            echo "  ./.github/scripts/version-bump.sh patch"
+            echo "  ./.github/scripts/version-bump.sh minor"
+            echo "  ./.github/scripts/version-bump.sh major"
+            echo ""
+            echo "Or add a version label to your PR: version:patch, version:minor, or version:major"
+            exit 1
+        else
+            echo "✅ Module versions are up to date!"
+            echo "ℹ️  No version updates needed."
+            exit 0
+        fi
     else
-        echo "ℹ️  No README files were updated (no version references found matching module sources)."
-        echo "Version calculations completed, but no files were modified."
-        exit 0
+        if [ "$has_changes" = true ]; then
+            echo "✅ Version bump completed successfully!"
+            echo "📝 README files have been updated with new versions."
+            echo ""
+            echo "Next steps:"
+            echo "1. Review the changes: git diff"
+            echo "2. Commit the changes: git add . && git commit -m 'chore: bump module versions ($bump_type)'"
+            echo "3. Push the changes: git push"
+            exit 0
+        else
+            echo "ℹ️  No README files were updated (no version references found matching module sources)."
+            echo "Version calculations completed, but no files were modified."
+            exit 0
+        fi
     fi
 }
 
diff --git a/.github/workflows/version-bump.yaml b/.github/workflows/version-bump.yaml
index 41a7cc0..c180839 100644
--- a/.github/workflows/version-bump.yaml
+++ b/.github/workflows/version-bump.yaml
@@ -2,13 +2,35 @@ name: Version Bump
 
 on:
   pull_request:
-    types: [labeled]
+    types: [opened, synchronize, labeled]
+    paths:
+      - 'registry/**/modules/**'
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
 jobs:
+  version-check:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Check if version bump is needed
+        run: |
+          echo "🔍 Checking if module versions need to be updated..."
+          
+          # Run the script in check mode
+          if ./.github/scripts/version-bump.sh check origin/main; then
+            echo "✅ Module versions are up to date"
+          else
+            echo "❌ Module versions need to be updated"
+            exit 1
+          fi
+
   version-bump:
     if: github.event.label.name == 'version:patch' || github.event.label.name == 'version:minor' || github.event.label.name == 'version:major'
     runs-on: ubuntu-latest
@@ -49,7 +71,7 @@ jobs:
       - name: Run version bump script
         id: version-bump
         run: |
-          # Capture script output for later use in PR comment
+          # Run the script to update versions
           output_file=$(mktemp)
           if ./.github/scripts/version-bump.sh "${{ steps.bump-type.outputs.type }}" origin/main > "$output_file" 2>&1; then
             echo "success=true" >> $GITHUB_OUTPUT
@@ -71,16 +93,15 @@ jobs:
           # Show output
           cat "$output_file"
 
-      - name: Commit changes
+      - name: Check for changes and commit
         if: steps.version-bump.outputs.success == 'true'
         run: |
-          # Check if any README files were modified
-          if git diff --quiet 'registry/*/modules/*/README.md'; then
-            echo "No README changes to commit"
+          # Check if any files were modified
+          if git diff --quiet; then
+            echo "No changes to commit"
           else
-            echo "Committing README changes..."
-            git diff --name-only 'registry/*/modules/*/README.md'
-            git add registry/*/modules/*/README.md
+            echo "Committing version bump changes..."
+            git add .
             git commit -m "chore: bump module versions (${{ steps.bump-type.outputs.type }})"
             git push
           fi
diff --git a/.github/workflows/version-check.yaml b/.github/workflows/version-check.yaml
deleted file mode 100644
index 10eb31b..0000000
--- a/.github/workflows/version-check.yaml
+++ /dev/null
@@ -1,34 +0,0 @@
-name: Version Check
-
-on:
-  pull_request:
-    paths:
-      - 'registry/**/modules/**'
-
-jobs:
-  version-check:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Check if module versions need updating
-        run: |
-          echo "🔍 Checking if module versions need to be updated..."
-          
-          # Run the version bump script in dry-run mode to see what would change
-          if ./.github/scripts/version-bump.sh patch origin/main; then
-            echo "✅ Module versions are up to date or no modules were modified"
-          else
-            echo "❌ Module versions may need to be updated"
-            echo ""
-            echo "To update module versions, run one of:"
-            echo "  ./.github/scripts/version-bump.sh patch"
-            echo "  ./.github/scripts/version-bump.sh minor"
-            echo "  ./.github/scripts/version-bump.sh major"
-            echo ""
-            echo "Or add a version label to this PR: version:patch, version:minor, or version:major"
-            exit 1
-          fi
\ No newline at end of file
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 8fc8778..4068036 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -277,6 +277,9 @@ Use the version bump script to automatically update module versions:
 
 # For breaking changes
 ./.github/scripts/version-bump.sh major
+
+# To check if versions need updating (without making changes)
+./.github/scripts/version-bump.sh check
 ```
 
 The script will:
@@ -294,7 +297,14 @@ You can also add a label to your PR instead of running the script manually:
 
 The version bump will happen automatically when the label is added.
 
-**Important**: Always update module versions when making changes. The CI will check that versions are properly updated.
+### CI Validation
+
+The CI will automatically check that module versions are properly updated:
+- **Version Check**: Runs on all PRs that modify modules
+- **Fails if versions need updating** but haven't been bumped
+- **Passes if versions are up to date** or no modules were modified
+
+**Important**: Always update module versions when making changes. The CI will enforce this requirement.
 
 ---
 

From 6a1d6a5e6db7dcab7fee353133ac7220a76cce59 Mon Sep 17 00:00:00 2001
From: "blink-so[bot]" <211532188+blink-so[bot]@users.noreply.github.com>
Date: Thu, 5 Jun 2025 17:16:43 +0000
Subject: [PATCH 03/10] fix: simplify script to only support patch/minor/major,
 workflow checks diff

- Remove all check mode logic from version-bump.sh script
- Script now only supports patch, minor, major (as requested)
- Workflow runs script with patch and checks if diff exists
- If diff exists, CI fails and tells user to add version label
- Much simpler implementation: script updates, workflow checks diff
- Updated documentation to remove check mode references
- This is exactly what was requested: same script, check diff for validation
---
 .github/scripts/version-bump.sh     | 130 +++++++++-------------------
 .github/workflows/version-bump.yaml |  22 +++--
 CONTRIBUTING.md                     |   3 -
 3 files changed, 58 insertions(+), 97 deletions(-)

diff --git a/.github/scripts/version-bump.sh b/.github/scripts/version-bump.sh
index 2cec6d2..e3772f9 100755
--- a/.github/scripts/version-bump.sh
+++ b/.github/scripts/version-bump.sh
@@ -2,24 +2,22 @@
 
 # Version Bump Script
 # Extracts version bump logic from GitHub Actions workflow
-# Usage: ./version-bump.sh <bump_type> [base_ref] [--check]
-#   bump_type: patch, minor, major, or check
+# Usage: ./version-bump.sh <bump_type> [base_ref]
+#   bump_type: patch, minor, or major
 #   base_ref: base reference for diff (default: origin/main)
-#   --check: only check if versions need updating, don't modify files
 
 set -euo pipefail
 
 # Function to print usage
 usage() {
-    echo "Usage: $0 <bump_type> [base_ref] [--check]"
-    echo "  bump_type: patch, minor, major, or check"
+    echo "Usage: $0 <bump_type> [base_ref]"
+    echo "  bump_type: patch, minor, or major"
     echo "  base_ref: base reference for diff (default: origin/main)"
-    echo "  --check: only check if versions need updating, don't modify files"
     echo ""
     echo "Examples:"
     echo "  $0 patch                    # Update versions with patch bump"
-    echo "  $0 check                    # Check if versions need updating"
-    echo "  $0 patch origin/main --check # Check what patch bump would do"
+    echo "  $0 minor                    # Update versions with minor bump"
+    echo "  $0 major                    # Update versions with major bump"
     exit 1
 }
 
@@ -69,7 +67,6 @@ update_readme_version() {
     local namespace="$2"
     local module_name="$3"
     local new_version="$4"
-    local check_mode="$5"
     
     if [ ! -f "$readme_path" ]; then
         return 1
@@ -78,28 +75,24 @@ update_readme_version() {
     # Check if README contains version references for this specific module
     local module_source="registry.coder.com/${namespace}/${module_name}/coder"
     if grep -q "source.*${module_source}" "$readme_path"; then
-        if [ "$check_mode" = "true" ]; then
-            echo "Would update version references for $namespace/$module_name in $readme_path"
-        else
-            echo "Updating version references for $namespace/$module_name in $readme_path"
-            # Use awk to only update versions that follow the specific module source
-            awk -v module_source="$module_source" -v new_version="$new_version" '
-            /source.*=.*/ {
-              if ($0 ~ module_source) {
-                in_target_module = 1
-              } else {
-                in_target_module = 0
-              }
-            }
-            /version.*=.*"/ {
-              if (in_target_module) {
-                gsub(/version[[:space:]]*=[[:space:]]*"[^"]*"/, "version = \"" new_version "\"")
-                in_target_module = 0
-              }
-            }
-            { print }
-            ' "$readme_path" > "${readme_path}.tmp" && mv "${readme_path}.tmp" "$readme_path"
-        fi
+        echo "Updating version references for $namespace/$module_name in $readme_path"
+        # Use awk to only update versions that follow the specific module source
+        awk -v module_source="$module_source" -v new_version="$new_version" '
+        /source.*=.*/ {
+          if ($0 ~ module_source) {
+            in_target_module = 1
+          } else {
+            in_target_module = 0
+          }
+        }
+        /version.*=.*"/ {
+          if (in_target_module) {
+            gsub(/version[[:space:]]*=[[:space:]]*"[^"]*"/, "version = \"" new_version "\"")
+            in_target_module = 0
+          }
+        }
+        { print }
+        ' "$readme_path" > "${readme_path}.tmp" && mv "${readme_path}.tmp" "$readme_path"
         return 0
     elif grep -q 'version\s*=\s*"' "$readme_path"; then
         echo "⚠️  Found version references but no module source match for $namespace/$module_name"
@@ -112,40 +105,19 @@ update_readme_version() {
 # Main function
 main() {
     # Parse arguments
-    if [ $# -lt 1 ] || [ $# -gt 3 ]; then
+    if [ $# -lt 1 ] || [ $# -gt 2 ]; then
         usage
     fi
     
     local bump_type="$1"
-    local base_ref="origin/main"
-    local check_mode=false
-    
-    # Parse remaining arguments
-    shift
-    while [ $# -gt 0 ]; do
-        case "$1" in
-            --check)
-                check_mode=true
-                ;;
-            *)
-                base_ref="$1"
-                ;;
-        esac
-        shift
-    done
-    
-    # Handle "check" as bump type
-    if [ "$bump_type" = "check" ]; then
-        check_mode=true
-        bump_type="patch"  # Use patch as default for check mode
-    fi
+    local base_ref="${2:-origin/main}"
     
     # Validate bump type
     case "$bump_type" in
         "patch"|"minor"|"major")
             ;;
         *)
-            echo "❌ Invalid bump type: '$bump_type'. Expected patch, minor, major, or check." >&2
+            echo "❌ Invalid bump type: '$bump_type'. Expected patch, minor, or major." >&2
             exit 1
             ;;
     esac
@@ -229,7 +201,7 @@ main() {
         echo "New version: $new_version"
         
         # Update README if applicable
-        if update_readme_version "$readme_path" "$namespace" "$module_name" "$new_version" "$check_mode"; then
+        if update_readme_version "$readme_path" "$namespace" "$module_name" "$new_version"; then
             updated_readmes="$updated_readmes\n- $namespace/$module_name"
             has_changes=true
         fi
@@ -260,40 +232,20 @@ main() {
         echo ""
     fi
     
-    # Check for changes and provide guidance
-    if [ "$check_mode" = "true" ]; then
-        if [ "$has_changes" = true ]; then
-            echo "❌ Module versions need to be updated!"
-            echo "📝 The following modules would have their README files updated:"
-            echo -e "$updated_readmes"
-            echo ""
-            echo "To fix this, run one of:"
-            echo "  ./.github/scripts/version-bump.sh patch"
-            echo "  ./.github/scripts/version-bump.sh minor"
-            echo "  ./.github/scripts/version-bump.sh major"
-            echo ""
-            echo "Or add a version label to your PR: version:patch, version:minor, or version:major"
-            exit 1
-        else
-            echo "✅ Module versions are up to date!"
-            echo "ℹ️  No version updates needed."
-            exit 0
-        fi
+    # Provide guidance
+    if [ "$has_changes" = true ]; then
+        echo "✅ Version bump completed successfully!"
+        echo "📝 README files have been updated with new versions."
+        echo ""
+        echo "Next steps:"
+        echo "1. Review the changes: git diff"
+        echo "2. Commit the changes: git add . && git commit -m 'chore: bump module versions ($bump_type)'"
+        echo "3. Push the changes: git push"
+        exit 0
     else
-        if [ "$has_changes" = true ]; then
-            echo "✅ Version bump completed successfully!"
-            echo "📝 README files have been updated with new versions."
-            echo ""
-            echo "Next steps:"
-            echo "1. Review the changes: git diff"
-            echo "2. Commit the changes: git add . && git commit -m 'chore: bump module versions ($bump_type)'"
-            echo "3. Push the changes: git push"
-            exit 0
-        else
-            echo "ℹ️  No README files were updated (no version references found matching module sources)."
-            echo "Version calculations completed, but no files were modified."
-            exit 0
-        fi
+        echo "ℹ️  No README files were updated (no version references found matching module sources)."
+        echo "Version calculations completed, but no files were modified."
+        exit 0
     fi
 }
 
diff --git a/.github/workflows/version-bump.yaml b/.github/workflows/version-bump.yaml
index c180839..cc87a00 100644
--- a/.github/workflows/version-bump.yaml
+++ b/.github/workflows/version-bump.yaml
@@ -23,12 +23,24 @@ jobs:
         run: |
           echo "🔍 Checking if module versions need to be updated..."
           
-          # Run the script in check mode
-          if ./.github/scripts/version-bump.sh check origin/main; then
-            echo "✅ Module versions are up to date"
+          # Run the script with patch to see if it would make changes
+          if ./.github/scripts/version-bump.sh patch origin/main; then
+            # Check if the script made any changes
+            if git diff --quiet; then
+              echo "✅ Module versions are up to date"
+            else
+              echo "❌ Module versions need to be updated!"
+              echo "The script would make the following changes:"
+              git diff --name-only
+              echo ""
+              echo "To fix this, add a version label to your PR:"
+              echo "- version:patch (for bug fixes)"
+              echo "- version:minor (for new features)"
+              echo "- version:major (for breaking changes)"
+              exit 1
+            fi
           else
-            echo "❌ Module versions need to be updated"
-            exit 1
+            echo "ℹ️ No modules detected in changes"
           fi
 
   version-bump:
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 4068036..8b94b74 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -277,9 +277,6 @@ Use the version bump script to automatically update module versions:
 
 # For breaking changes
 ./.github/scripts/version-bump.sh major
-
-# To check if versions need updating (without making changes)
-./.github/scripts/version-bump.sh check
 ```
 
 The script will:

From 465d588604cf0a249df3632fc41425ee868aec51 Mon Sep 17 00:00:00 2001
From: "blink-so[bot]" <211532188+blink-so[bot]@users.noreply.github.com>
Date: Thu, 5 Jun 2025 17:28:16 +0000
Subject: [PATCH 04/10] fix: workflow only runs when version labels are applied

- Remove version-check job since it can't be required if it only runs on labels
- Workflow now only triggers on 'labeled' events with version:patch|minor|major
- This is the correct approach: workflow only runs when labels are applied
- No required checks since the workflow is optional/manual via labels
---
 .github/workflows/version-bump.yaml | 34 +----------------------------
 1 file changed, 1 insertion(+), 33 deletions(-)

diff --git a/.github/workflows/version-bump.yaml b/.github/workflows/version-bump.yaml
index cc87a00..46c39ff 100644
--- a/.github/workflows/version-bump.yaml
+++ b/.github/workflows/version-bump.yaml
@@ -2,7 +2,7 @@ name: Version Bump
 
 on:
   pull_request:
-    types: [opened, synchronize, labeled]
+    types: [labeled]
     paths:
       - 'registry/**/modules/**'
 
@@ -11,38 +11,6 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  version-check:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Check if version bump is needed
-        run: |
-          echo "🔍 Checking if module versions need to be updated..."
-          
-          # Run the script with patch to see if it would make changes
-          if ./.github/scripts/version-bump.sh patch origin/main; then
-            # Check if the script made any changes
-            if git diff --quiet; then
-              echo "✅ Module versions are up to date"
-            else
-              echo "❌ Module versions need to be updated!"
-              echo "The script would make the following changes:"
-              git diff --name-only
-              echo ""
-              echo "To fix this, add a version label to your PR:"
-              echo "- version:patch (for bug fixes)"
-              echo "- version:minor (for new features)"
-              echo "- version:major (for breaking changes)"
-              exit 1
-            fi
-          else
-            echo "ℹ️ No modules detected in changes"
-          fi
-
   version-bump:
     if: github.event.label.name == 'version:patch' || github.event.label.name == 'version:minor' || github.event.label.name == 'version:major'
     runs-on: ubuntu-latest

From 59617f8a84064995485e7921b1a84bd48a4bbdb2 Mon Sep 17 00:00:00 2001
From: DevelopmentCats <christofer@coder.com>
Date: Fri, 6 Jun 2025 01:45:56 +0000
Subject: [PATCH 05/10] docs: clarify version bump script usage in
 CONTRIBUTING.md

---
 CONTRIBUTING.md | 20 ++------------------
 1 file changed, 2 insertions(+), 18 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 8b94b74..c12878c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -266,7 +266,7 @@ When you modify a module, you need to update its version number in the README. U
 
 ### Updating Module Versions
 
-Use the version bump script to automatically update module versions:
+If your changes require a version bump, use the version bump script:
 
 ```bash
 # For bug fixes
@@ -285,23 +285,7 @@ The script will:
 3. Update all version references in the module's README
 4. Show you a summary of changes
 
-### Alternative: Use PR Labels
-
-You can also add a label to your PR instead of running the script manually:
-- `version:patch` - For bug fixes
-- `version:minor` - For new features  
-- `version:major` - For breaking changes
-
-The version bump will happen automatically when the label is added.
-
-### CI Validation
-
-The CI will automatically check that module versions are properly updated:
-- **Version Check**: Runs on all PRs that modify modules
-- **Fails if versions need updating** but haven't been bumped
-- **Passes if versions are up to date** or no modules were modified
-
-**Important**: Always update module versions when making changes. The CI will enforce this requirement.
+**Important**: Only run the version bump script if your changes require a new release. Documentation-only changes don't need version updates.
 
 ---
 

From 0eb33084551829606fabf20bcd86c6df25ac0b4f Mon Sep 17 00:00:00 2001
From: DevelopmentCats <christofer@coder.com>
Date: Fri, 6 Jun 2025 01:45:32 +0000
Subject: [PATCH 06/10] fix: update version bump workflow to improve version
 check and error handling

- Change permissions from 'write' to 'read' for contents
- Remove unnecessary Git setup steps
- Introduce a version check step to validate if module versions need updates
- Update PR comment to guide users on required actions when versions are not up to date
---
 .github/workflows/version-bump.yaml | 52 ++++++++++++++---------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/.github/workflows/version-bump.yaml b/.github/workflows/version-bump.yaml
index 46c39ff..2eb82cd 100644
--- a/.github/workflows/version-bump.yaml
+++ b/.github/workflows/version-bump.yaml
@@ -15,7 +15,7 @@ jobs:
     if: github.event.label.name == 'version:patch' || github.event.label.name == 'version:minor' || github.event.label.name == 'version:major'
     runs-on: ubuntu-latest
     permissions:
-      contents: write
+      contents: read
       pull-requests: write
     steps:
       - name: Checkout code
@@ -24,11 +24,6 @@ jobs:
           fetch-depth: 0
           token: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Setup Git
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-
       - name: Extract bump type from label
         id: bump-type
         run: |
@@ -48,16 +43,14 @@ jobs:
               ;;
           esac
 
-      - name: Run version bump script
-        id: version-bump
+      - name: Check version bump requirements
+        id: version-check
         run: |
-          # Run the script to update versions
+          # Run the script to check what versions should be
           output_file=$(mktemp)
           if ./.github/scripts/version-bump.sh "${{ steps.bump-type.outputs.type }}" origin/main > "$output_file" 2>&1; then
-            echo "success=true" >> $GITHUB_OUTPUT
             echo "Script completed successfully"
           else
-            echo "success=false" >> $GITHUB_OUTPUT
             echo "Script failed"
             cat "$output_file"
             exit 1
@@ -72,32 +65,39 @@ jobs:
           
           # Show output
           cat "$output_file"
-
-      - name: Check for changes and commit
-        if: steps.version-bump.outputs.success == 'true'
-        run: |
-          # Check if any files were modified
+          
+          # Check if any files would be modified by the script
           if git diff --quiet; then
-            echo "No changes to commit"
+            echo "versions_up_to_date=true" >> $GITHUB_OUTPUT
+            echo "✅ All module versions are already up to date"
           else
-            echo "Committing version bump changes..."
-            git add .
-            git commit -m "chore: bump module versions (${{ steps.bump-type.outputs.type }})"
-            git push
+            echo "versions_up_to_date=false" >> $GITHUB_OUTPUT
+            echo "❌ Module versions need to be updated"
+            echo "Files that would be changed:"
+            git diff --name-only
+            echo ""
+            echo "Diff preview:"
+            git diff
+            exit 1
           fi
 
-      - name: Comment on PR
-        if: steps.version-bump.outputs.success == 'true'
+      - name: Comment on PR - Failure
+        if: failure() && steps.version-check.outputs.versions_up_to_date == 'false'
         uses: actions/github-script@v7
         with:
           script: |
-            const output = `${{ steps.version-bump.outputs.output }}`;
+            const output = `${{ steps.version-check.outputs.output }}`;
             const bumpType = `${{ steps.bump-type.outputs.type }}`;
             
-            let comment = `## 🚀 Version Bump Summary\n\n`;
+            let comment = `## ❌ Version Bump Validation Failed\n\n`;
             comment += `**Bump Type:** \`${bumpType}\`\n\n`;
+            comment += `Module versions need to be updated but haven't been bumped yet.\n\n`;
+            comment += `**Required Actions:**\n`;
+            comment += `1. Run the version bump script locally: \`./.github/scripts/version-bump.sh ${bumpType}\`\n`;
+            comment += `2. Commit the changes: \`git add . && git commit -m "chore: bump module versions (${bumpType})"\`\n`;
+            comment += `3. Push the changes: \`git push\`\n\n`;
             comment += `### Script Output:\n\`\`\`\n${output}\n\`\`\`\n\n`;
-            comment += `> Versions have been automatically updated using the version bump script.`;
+            comment += `> Please update the module versions and push the changes to continue.`;
             
             github.rest.issues.createComment({
               issue_number: context.issue.number,

From 72f65e7f92fd94a54d3dd94b4a88b968ea941173 Mon Sep 17 00:00:00 2001
From: DevelopmentCats <christofer@coder.com>
Date: Fri, 6 Jun 2025 01:44:28 +0000
Subject: [PATCH 07/10] chore: streamline version bump script by removing
 unnecessary comments

---
 .github/scripts/version-bump.sh | 24 ------------------------
 1 file changed, 24 deletions(-)

diff --git a/.github/scripts/version-bump.sh b/.github/scripts/version-bump.sh
index e3772f9..d5ce407 100755
--- a/.github/scripts/version-bump.sh
+++ b/.github/scripts/version-bump.sh
@@ -1,14 +1,12 @@
 #!/bin/bash
 
 # Version Bump Script
-# Extracts version bump logic from GitHub Actions workflow
 # Usage: ./version-bump.sh <bump_type> [base_ref]
 #   bump_type: patch, minor, or major
 #   base_ref: base reference for diff (default: origin/main)
 
 set -euo pipefail
 
-# Function to print usage
 usage() {
     echo "Usage: $0 <bump_type> [base_ref]"
     echo "  bump_type: patch, minor, or major"
@@ -21,7 +19,6 @@ usage() {
     exit 1
 }
 
-# Function to validate version format
 validate_version() {
     local version="$1"
     if ! [[ "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
@@ -31,14 +28,12 @@ validate_version() {
     return 0
 }
 
-# Function to bump version
 bump_version() {
     local current_version="$1"
     local bump_type="$2"
     
     IFS='.' read -r major minor patch <<< "$current_version"
     
-    # Validate that components are numeric
     if ! [[ "$major" =~ ^[0-9]+$ ]] || ! [[ "$minor" =~ ^[0-9]+$ ]] || ! [[ "$patch" =~ ^[0-9]+$ ]]; then
         echo "❌ Version components must be numeric: major='$major' minor='$minor' patch='$patch'" >&2
         return 1
@@ -61,7 +56,6 @@ bump_version() {
     esac
 }
 
-# Function to update README version
 update_readme_version() {
     local readme_path="$1"
     local namespace="$2"
@@ -72,11 +66,9 @@ update_readme_version() {
         return 1
     fi
     
-    # Check if README contains version references for this specific module
     local module_source="registry.coder.com/${namespace}/${module_name}/coder"
     if grep -q "source.*${module_source}" "$readme_path"; then
         echo "Updating version references for $namespace/$module_name in $readme_path"
-        # Use awk to only update versions that follow the specific module source
         awk -v module_source="$module_source" -v new_version="$new_version" '
         /source.*=.*/ {
           if ($0 ~ module_source) {
@@ -102,9 +94,7 @@ update_readme_version() {
     return 1
 }
 
-# Main function
 main() {
-    # Parse arguments
     if [ $# -lt 1 ] || [ $# -gt 2 ]; then
         usage
     fi
@@ -112,7 +102,6 @@ main() {
     local bump_type="$1"
     local base_ref="${2:-origin/main}"
     
-    # Validate bump type
     case "$bump_type" in
         "patch"|"minor"|"major")
             ;;
@@ -124,7 +113,6 @@ main() {
     
     echo "🔍 Detecting modified modules..."
     
-    # Detect modified modules
     local changed_files
     changed_files=$(git diff --name-only "${base_ref}"...HEAD)
     local modules
@@ -139,13 +127,11 @@ main() {
     echo "$modules"
     echo ""
     
-    # Initialize tracking variables
     local bumped_modules=""
     local updated_readmes=""
     local untagged_modules=""
     local has_changes=false
     
-    # Process each module
     while IFS= read -r module_path; do
         if [ -z "$module_path" ]; then continue; fi
         
@@ -156,21 +142,17 @@ main() {
         
         echo "📦 Processing: $namespace/$module_name"
         
-        # Find latest tag
         local latest_tag
         latest_tag=$(git tag -l "release/${namespace}/${module_name}/v*" | sort -V | tail -1)
         local readme_path="$module_path/README.md"
         local current_version
         
         if [ -z "$latest_tag" ]; then
-            # No tag found, check if README has version references
             if [ -f "$readme_path" ] && grep -q 'version\s*=\s*"' "$readme_path"; then
-                # Extract version from README
                 local readme_version
                 readme_version=$(grep 'version\s*=\s*"' "$readme_path" | head -1 | sed 's/.*version\s*=\s*"\([^"]*\)".*/\1/')
                 echo "No git tag found, but README shows version: $readme_version"
                 
-                # Validate extracted version format
                 if ! validate_version "$readme_version"; then
                     echo "Starting from v1.0.0 instead"
                     current_version="1.0.0"
@@ -189,18 +171,15 @@ main() {
         
         echo "Current version: $current_version"
         
-        # Validate current version format
         if ! validate_version "$current_version"; then
             exit 1
         fi
         
-        # Calculate new version
         local new_version
         new_version=$(bump_version "$current_version" "$bump_type")
         
         echo "New version: $new_version"
         
-        # Update README if applicable
         if update_readme_version "$readme_path" "$namespace" "$module_name" "$new_version"; then
             updated_readmes="$updated_readmes\n- $namespace/$module_name"
             has_changes=true
@@ -211,7 +190,6 @@ main() {
         
     done <<< "$modules"
     
-    # Output results
     echo "📋 Summary:"
     echo "Bump Type: $bump_type"
     echo ""
@@ -232,7 +210,6 @@ main() {
         echo ""
     fi
     
-    # Provide guidance
     if [ "$has_changes" = true ]; then
         echo "✅ Version bump completed successfully!"
         echo "📝 README files have been updated with new versions."
@@ -249,5 +226,4 @@ main() {
     fi
 }
 
-# Run main function with all arguments
 main "$@"
\ No newline at end of file

From 93542324b0c03fa718e5c0a80dc653772c845120 Mon Sep 17 00:00:00 2001
From: DevelopmentCats <christofer@coder.com>
Date: Fri, 6 Jun 2025 01:56:46 +0000
Subject: [PATCH 08/10] docs: add missing newline in CONTRIBUTING.md for better
 readability

---
 CONTRIBUTING.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index c12878c..8d63b42 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -280,6 +280,7 @@ If your changes require a version bump, use the version bump script:
 ```
 
 The script will:
+
 1. Detect which modules you've modified
 2. Calculate the new version number
 3. Update all version references in the module's README

From ed1e1ae2df79ead367b98ff379609485b69f2ea2 Mon Sep 17 00:00:00 2001
From: DevelopmentCats <christofer@coder.com>
Date: Fri, 6 Jun 2025 01:59:42 +0000
Subject: [PATCH 09/10] chore: improve formatting and readability in version
 bump script

---
 .github/scripts/version-bump.sh | 368 ++++++++++++++++----------------
 1 file changed, 184 insertions(+), 184 deletions(-)

diff --git a/.github/scripts/version-bump.sh b/.github/scripts/version-bump.sh
index d5ce407..b074583 100755
--- a/.github/scripts/version-bump.sh
+++ b/.github/scripts/version-bump.sh
@@ -8,68 +8,68 @@
 set -euo pipefail
 
 usage() {
-    echo "Usage: $0 <bump_type> [base_ref]"
-    echo "  bump_type: patch, minor, or major"
-    echo "  base_ref: base reference for diff (default: origin/main)"
-    echo ""
-    echo "Examples:"
-    echo "  $0 patch                    # Update versions with patch bump"
-    echo "  $0 minor                    # Update versions with minor bump"
-    echo "  $0 major                    # Update versions with major bump"
-    exit 1
+  echo "Usage: $0 <bump_type> [base_ref]"
+  echo "  bump_type: patch, minor, or major"
+  echo "  base_ref: base reference for diff (default: origin/main)"
+  echo ""
+  echo "Examples:"
+  echo "  $0 patch                    # Update versions with patch bump"
+  echo "  $0 minor                    # Update versions with minor bump"
+  echo "  $0 major                    # Update versions with major bump"
+  exit 1
 }
 
 validate_version() {
-    local version="$1"
-    if ! [[ "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-        echo "❌ Invalid version format: '$version'. Expected X.Y.Z format." >&2
-        return 1
-    fi
-    return 0
+  local version="$1"
+  if ! [[ "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+    echo "❌ Invalid version format: '$version'. Expected X.Y.Z format." >&2
+    return 1
+  fi
+  return 0
 }
 
 bump_version() {
-    local current_version="$1"
-    local bump_type="$2"
-    
-    IFS='.' read -r major minor patch <<< "$current_version"
-    
-    if ! [[ "$major" =~ ^[0-9]+$ ]] || ! [[ "$minor" =~ ^[0-9]+$ ]] || ! [[ "$patch" =~ ^[0-9]+$ ]]; then
-        echo "❌ Version components must be numeric: major='$major' minor='$minor' patch='$patch'" >&2
-        return 1
-    fi
-    
-    case "$bump_type" in
-        "patch")
-            echo "$major.$minor.$((patch + 1))"
-            ;;
-        "minor")
-            echo "$major.$((minor + 1)).0"
-            ;;
-        "major")
-            echo "$((major + 1)).0.0"
-            ;;
-        *)
-            echo "❌ Invalid bump type: '$bump_type'. Expected patch, minor, or major." >&2
-            return 1
-            ;;
-    esac
+  local current_version="$1"
+  local bump_type="$2"
+
+  IFS='.' read -r major minor patch <<< "$current_version"
+
+  if ! [[ "$major" =~ ^[0-9]+$ ]] || ! [[ "$minor" =~ ^[0-9]+$ ]] || ! [[ "$patch" =~ ^[0-9]+$ ]]; then
+    echo "❌ Version components must be numeric: major='$major' minor='$minor' patch='$patch'" >&2
+    return 1
+  fi
+
+  case "$bump_type" in
+    "patch")
+      echo "$major.$minor.$((patch + 1))"
+      ;;
+    "minor")
+      echo "$major.$((minor + 1)).0"
+      ;;
+    "major")
+      echo "$((major + 1)).0.0"
+      ;;
+    *)
+      echo "❌ Invalid bump type: '$bump_type'. Expected patch, minor, or major." >&2
+      return 1
+      ;;
+  esac
 }
 
 update_readme_version() {
-    local readme_path="$1"
-    local namespace="$2"
-    local module_name="$3"
-    local new_version="$4"
-    
-    if [ ! -f "$readme_path" ]; then
-        return 1
-    fi
-    
-    local module_source="registry.coder.com/${namespace}/${module_name}/coder"
-    if grep -q "source.*${module_source}" "$readme_path"; then
-        echo "Updating version references for $namespace/$module_name in $readme_path"
-        awk -v module_source="$module_source" -v new_version="$new_version" '
+  local readme_path="$1"
+  local namespace="$2"
+  local module_name="$3"
+  local new_version="$4"
+
+  if [ ! -f "$readme_path" ]; then
+    return 1
+  fi
+
+  local module_source="registry.coder.com/${namespace}/${module_name}/coder"
+  if grep -q "source.*${module_source}" "$readme_path"; then
+    echo "Updating version references for $namespace/$module_name in $readme_path"
+    awk -v module_source="$module_source" -v new_version="$new_version" '
         /source.*=.*/ {
           if ($0 ~ module_source) {
             in_target_module = 1
@@ -85,145 +85,145 @@ update_readme_version() {
         }
         { print }
         ' "$readme_path" > "${readme_path}.tmp" && mv "${readme_path}.tmp" "$readme_path"
-        return 0
-    elif grep -q 'version\s*=\s*"' "$readme_path"; then
-        echo "⚠️  Found version references but no module source match for $namespace/$module_name"
-        return 1
-    fi
-    
+    return 0
+  elif grep -q 'version\s*=\s*"' "$readme_path"; then
+    echo "⚠️  Found version references but no module source match for $namespace/$module_name"
     return 1
+  fi
+
+  return 1
 }
 
 main() {
-    if [ $# -lt 1 ] || [ $# -gt 2 ]; then
-        usage
-    fi
-    
-    local bump_type="$1"
-    local base_ref="${2:-origin/main}"
-    
-    case "$bump_type" in
-        "patch"|"minor"|"major")
-            ;;
-        *)
-            echo "❌ Invalid bump type: '$bump_type'. Expected patch, minor, or major." >&2
-            exit 1
-            ;;
-    esac
-    
-    echo "🔍 Detecting modified modules..."
-    
-    local changed_files
-    changed_files=$(git diff --name-only "${base_ref}"...HEAD)
-    local modules
-    modules=$(echo "$changed_files" | grep -E '^registry/[^/]+/modules/[^/]+/' | cut -d'/' -f1-4 | sort -u)
-    
-    if [ -z "$modules" ]; then
-        echo "❌ No modules detected in changes"
-        exit 1
-    fi
-    
-    echo "Found modules:"
-    echo "$modules"
-    echo ""
-    
-    local bumped_modules=""
-    local updated_readmes=""
-    local untagged_modules=""
-    local has_changes=false
-    
-    while IFS= read -r module_path; do
-        if [ -z "$module_path" ]; then continue; fi
-        
-        local namespace
-        namespace=$(echo "$module_path" | cut -d'/' -f2)
-        local module_name
-        module_name=$(echo "$module_path" | cut -d'/' -f4)
-        
-        echo "📦 Processing: $namespace/$module_name"
-        
-        local latest_tag
-        latest_tag=$(git tag -l "release/${namespace}/${module_name}/v*" | sort -V | tail -1)
-        local readme_path="$module_path/README.md"
-        local current_version
-        
-        if [ -z "$latest_tag" ]; then
-            if [ -f "$readme_path" ] && grep -q 'version\s*=\s*"' "$readme_path"; then
-                local readme_version
-                readme_version=$(grep 'version\s*=\s*"' "$readme_path" | head -1 | sed 's/.*version\s*=\s*"\([^"]*\)".*/\1/')
-                echo "No git tag found, but README shows version: $readme_version"
-                
-                if ! validate_version "$readme_version"; then
-                    echo "Starting from v1.0.0 instead"
-                    current_version="1.0.0"
-                else
-                    current_version="$readme_version"
-                    untagged_modules="$untagged_modules\n- $namespace/$module_name (README: v$readme_version)"
-                fi
-            else
-                echo "No existing tags or version references found for $namespace/$module_name, starting from v1.0.0"
-                current_version="1.0.0"
-            fi
+  if [ $# -lt 1 ] || [ $# -gt 2 ]; then
+    usage
+  fi
+
+  local bump_type="$1"
+  local base_ref="${2:-origin/main}"
+
+  case "$bump_type" in
+    "patch" | "minor" | "major") ;;
+
+    *)
+      echo "❌ Invalid bump type: '$bump_type'. Expected patch, minor, or major." >&2
+      exit 1
+      ;;
+  esac
+
+  echo "🔍 Detecting modified modules..."
+
+  local changed_files
+  changed_files=$(git diff --name-only "${base_ref}"...HEAD)
+  local modules
+  modules=$(echo "$changed_files" | grep -E '^registry/[^/]+/modules/[^/]+/' | cut -d'/' -f1-4 | sort -u)
+
+  if [ -z "$modules" ]; then
+    echo "❌ No modules detected in changes"
+    exit 1
+  fi
+
+  echo "Found modules:"
+  echo "$modules"
+  echo ""
+
+  local bumped_modules=""
+  local updated_readmes=""
+  local untagged_modules=""
+  local has_changes=false
+
+  while IFS= read -r module_path; do
+    if [ -z "$module_path" ]; then continue; fi
+
+    local namespace
+    namespace=$(echo "$module_path" | cut -d'/' -f2)
+    local module_name
+    module_name=$(echo "$module_path" | cut -d'/' -f4)
+
+    echo "📦 Processing: $namespace/$module_name"
+
+    local latest_tag
+    latest_tag=$(git tag -l "release/${namespace}/${module_name}/v*" | sort -V | tail -1)
+    local readme_path="$module_path/README.md"
+    local current_version
+
+    if [ -z "$latest_tag" ]; then
+      if [ -f "$readme_path" ] && grep -q 'version\s*=\s*"' "$readme_path"; then
+        local readme_version
+        readme_version=$(grep 'version\s*=\s*"' "$readme_path" | head -1 | sed 's/.*version\s*=\s*"\([^"]*\)".*/\1/')
+        echo "No git tag found, but README shows version: $readme_version"
+
+        if ! validate_version "$readme_version"; then
+          echo "Starting from v1.0.0 instead"
+          current_version="1.0.0"
         else
-            current_version=$(echo "$latest_tag" | sed 's/.*\/v//')
-            echo "Found git tag: $latest_tag (v$current_version)"
+          current_version="$readme_version"
+          untagged_modules="$untagged_modules\n- $namespace/$module_name (README: v$readme_version)"
         fi
-        
-        echo "Current version: $current_version"
-        
-        if ! validate_version "$current_version"; then
-            exit 1
-        fi
-        
-        local new_version
-        new_version=$(bump_version "$current_version" "$bump_type")
-        
-        echo "New version: $new_version"
-        
-        if update_readme_version "$readme_path" "$namespace" "$module_name" "$new_version"; then
-            updated_readmes="$updated_readmes\n- $namespace/$module_name"
-            has_changes=true
-        fi
-        
-        bumped_modules="$bumped_modules\n- $namespace/$module_name: v$current_version → v$new_version"
-        echo ""
-        
-    done <<< "$modules"
-    
-    echo "📋 Summary:"
-    echo "Bump Type: $bump_type"
-    echo ""
-    echo "Modules Updated:"
-    echo -e "$bumped_modules"
-    echo ""
-    
-    if [ -n "$updated_readmes" ]; then
-        echo "READMEs Updated:"
-        echo -e "$updated_readmes"
-        echo ""
+      else
+        echo "No existing tags or version references found for $namespace/$module_name, starting from v1.0.0"
+        current_version="1.0.0"
+      fi
+    else
+      current_version=$(echo "$latest_tag" | sed 's/.*\/v//')
+      echo "Found git tag: $latest_tag (v$current_version)"
     fi
-    
-    if [ -n "$untagged_modules" ]; then
-        echo "⚠️  Modules Without Git Tags:"
-        echo -e "$untagged_modules"
-        echo "These modules were versioned based on README content. Consider creating proper release tags after merging."
-        echo ""
+
+    echo "Current version: $current_version"
+
+    if ! validate_version "$current_version"; then
+      exit 1
     fi
-    
-    if [ "$has_changes" = true ]; then
-        echo "✅ Version bump completed successfully!"
-        echo "📝 README files have been updated with new versions."
-        echo ""
-        echo "Next steps:"
-        echo "1. Review the changes: git diff"
-        echo "2. Commit the changes: git add . && git commit -m 'chore: bump module versions ($bump_type)'"
-        echo "3. Push the changes: git push"
-        exit 0
-    else
-        echo "ℹ️  No README files were updated (no version references found matching module sources)."
-        echo "Version calculations completed, but no files were modified."
-        exit 0
+
+    local new_version
+    new_version=$(bump_version "$current_version" "$bump_type")
+
+    echo "New version: $new_version"
+
+    if update_readme_version "$readme_path" "$namespace" "$module_name" "$new_version"; then
+      updated_readmes="$updated_readmes\n- $namespace/$module_name"
+      has_changes=true
     fi
+
+    bumped_modules="$bumped_modules\n- $namespace/$module_name: v$current_version → v$new_version"
+    echo ""
+
+  done <<< "$modules"
+
+  echo "📋 Summary:"
+  echo "Bump Type: $bump_type"
+  echo ""
+  echo "Modules Updated:"
+  echo -e "$bumped_modules"
+  echo ""
+
+  if [ -n "$updated_readmes" ]; then
+    echo "READMEs Updated:"
+    echo -e "$updated_readmes"
+    echo ""
+  fi
+
+  if [ -n "$untagged_modules" ]; then
+    echo "⚠️  Modules Without Git Tags:"
+    echo -e "$untagged_modules"
+    echo "These modules were versioned based on README content. Consider creating proper release tags after merging."
+    echo ""
+  fi
+
+  if [ "$has_changes" = true ]; then
+    echo "✅ Version bump completed successfully!"
+    echo "📝 README files have been updated with new versions."
+    echo ""
+    echo "Next steps:"
+    echo "1. Review the changes: git diff"
+    echo "2. Commit the changes: git add . && git commit -m 'chore: bump module versions ($bump_type)'"
+    echo "3. Push the changes: git push"
+    exit 0
+  else
+    echo "ℹ️  No README files were updated (no version references found matching module sources)."
+    echo "Version calculations completed, but no files were modified."
+    exit 0
+  fi
 }
 
-main "$@"
\ No newline at end of file
+main "$@"

From eaffb5e9378d41f7d2e2fa98b380f1ae7accfe53 Mon Sep 17 00:00:00 2001
From: DevelopmentCats <christofer@coder.com>
Date: Fri, 6 Jun 2025 02:00:09 +0000
Subject: [PATCH 10/10] chore: improve formatting

---
 .github/workflows/version-bump.yaml | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/version-bump.yaml b/.github/workflows/version-bump.yaml
index 2eb82cd..537830a 100644
--- a/.github/workflows/version-bump.yaml
+++ b/.github/workflows/version-bump.yaml
@@ -4,7 +4,7 @@ on:
   pull_request:
     types: [labeled]
     paths:
-      - 'registry/**/modules/**'
+      - "registry/**/modules/**"
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -55,17 +55,17 @@ jobs:
             cat "$output_file"
             exit 1
           fi
-          
+
           # Store output for PR comment
           {
             echo "output<<EOF"
             cat "$output_file"
             echo "EOF"
           } >> $GITHUB_OUTPUT
-          
+
           # Show output
           cat "$output_file"
-          
+
           # Check if any files would be modified by the script
           if git diff --quiet; then
             echo "versions_up_to_date=true" >> $GITHUB_OUTPUT
@@ -88,7 +88,7 @@ jobs:
           script: |
             const output = `${{ steps.version-check.outputs.output }}`;
             const bumpType = `${{ steps.bump-type.outputs.type }}`;
-            
+
             let comment = `## ❌ Version Bump Validation Failed\n\n`;
             comment += `**Bump Type:** \`${bumpType}\`\n\n`;
             comment += `Module versions need to be updated but haven't been bumped yet.\n\n`;
@@ -98,10 +98,10 @@ jobs:
             comment += `3. Push the changes: \`git push\`\n\n`;
             comment += `### Script Output:\n\`\`\`\n${output}\n\`\`\`\n\n`;
             comment += `> Please update the module versions and push the changes to continue.`;
-            
+
             github.rest.issues.createComment({
               issue_number: context.issue.number,
               owner: context.repo.owner,
               repo: context.repo.repo,
               body: comment
-            });
\ No newline at end of file
+            });