climaybe 1.0.0

package/src/workflows/multi/root-to-stores.yml

@@ -0,0 +1,84 @@
+# climaybe — Root to Stores (Multi-store)
+# When direct commits (hotfixes) land on live-* branches,
+# syncs root JSON files back to stores/<alias>/ directory.
+# This prepares the data for backporting to main.
+
+name: Root to Stores
+
+on:
+  push:
+    branches:
+      - 'live-*'
+
+# Prevent concurrent runs per branch
+concurrency:
+  group: root-to-stores-${{ github.ref_name }}
+  cancel-in-progress: false
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Skip workflow commits
+        id: gate
+        run: |
+          COMMIT_MSG="${{ github.event.head_commit.message }}"
+          if echo "$COMMIT_MSG" | grep -qE "\[root-to-stores\]|\[stores-to-root\]|\[hotfix-backport\]|chore\(release\)"; then
+            echo "skip=true" >> $GITHUB_OUTPUT
+          else
+            echo "skip=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Extract store alias
+        if: steps.gate.outputs.skip != 'true'
+        id: alias
+        run: |
+          BRANCH="${{ github.ref_name }}"
+          ALIAS="${BRANCH#live-}"
+          echo "alias=$ALIAS" >> $GITHUB_OUTPUT
+
+      - name: Sync root to stores/<alias>/
+        if: steps.gate.outputs.skip != 'true'
+        run: |
+          ALIAS="${{ steps.alias.outputs.alias }}"
+          STORE_DIR="stores/${ALIAS}"
+
+          # Ensure store directory exists
+          mkdir -p "${STORE_DIR}/config" "${STORE_DIR}/templates" "${STORE_DIR}/sections"
+
+          # Sync directories: config, templates, sections
+          for DIR in config templates sections; do
+            if [ -d "$DIR" ]; then
+              find "$DIR" -name "*.json" | while read -r FILE; do
+                # Skip excluded files
+                if [ "$FILE" = "config/settings_schema.json" ]; then
+                  continue
+                fi
+
+                DEST="${STORE_DIR}/${FILE}"
+                mkdir -p "$(dirname "$DEST")"
+                cp "$FILE" "$DEST"
+                echo "  Synced: $FILE → $DEST"
+              done
+            fi
+          done
+
+      - name: Commit changes
+        if: steps.gate.outputs.skip != 'true'
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+          git add -A
+          if ! git diff --cached --quiet; then
+            git commit -m "chore: sync root to stores/${{ steps.alias.outputs.alias }}/ [root-to-stores]"
+            git push
+          else
+            echo "No changes to commit."
+          fi

package/src/workflows/multi/stores-to-root.yml

@@ -0,0 +1,89 @@
+# climaybe — Stores to Root (Multi-store)
+# When a push happens on staging-* branches (e.g., after main sync),
+# copies JSON files from stores/<alias>/ to the repo root.
+
+name: Stores to Root
+
+on:
+  push:
+    branches:
+      - 'staging-*'
+
+# Prevent concurrent runs per branch
+concurrency:
+  group: stores-to-root-${{ github.ref_name }}
+  cancel-in-progress: false
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Skip if this is a sync commit
+        id: gate
+        run: |
+          COMMIT_MSG="${{ github.event.head_commit.message }}"
+          if echo "$COMMIT_MSG" | grep -q "\[stores-to-root\]"; then
+            echo "skip=true" >> $GITHUB_OUTPUT
+          else
+            echo "skip=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Extract store alias from branch name
+        if: steps.gate.outputs.skip != 'true'
+        id: alias
+        run: |
+          BRANCH="${{ github.ref_name }}"
+          ALIAS="${BRANCH#staging-}"
+          echo "alias=$ALIAS" >> $GITHUB_OUTPUT
+          echo "Store alias: $ALIAS"
+
+      - name: Sync stores/<alias>/ to root
+        if: steps.gate.outputs.skip != 'true'
+        run: |
+          ALIAS="${{ steps.alias.outputs.alias }}"
+          STORE_DIR="stores/${ALIAS}"
+
+          if [ ! -d "$STORE_DIR" ]; then
+            echo "Store directory $STORE_DIR does not exist, skipping."
+            exit 0
+          fi
+
+          # Sync directories: config, templates, sections
+          for DIR in config templates sections; do
+            SRC="${STORE_DIR}/${DIR}"
+            if [ -d "$SRC" ]; then
+              # Copy JSON files only, preserving directory structure
+              find "$SRC" -name "*.json" | while read -r FILE; do
+                REL_PATH="${FILE#$STORE_DIR/}"
+
+                # Skip excluded files
+                if [ "$REL_PATH" = "config/settings_schema.json" ]; then
+                  continue
+                fi
+
+                mkdir -p "$(dirname "$REL_PATH")"
+                cp "$FILE" "$REL_PATH"
+                echo "  Copied: $REL_PATH"
+              done
+            fi
+          done
+
+      - name: Commit changes
+        if: steps.gate.outputs.skip != 'true'
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+          git add -A
+          if ! git diff --cached --quiet; then
+            git commit -m "chore: sync stores/${{ steps.alias.outputs.alias }}/ to root [stores-to-root]"
+            git push
+          else
+            echo "No changes to commit."
+          fi

package/src/workflows/shared/ai-changelog.yml

@@ -0,0 +1,108 @@
+# climaybe — AI Changelog Generator (Reusable Workflow)
+# Uses Google Gemini to classify commits and generate a changelog.
+
+name: AI Changelog
+
+on:
+  workflow_call:
+    inputs:
+      base_ref:
+        description: 'Base ref (tag or commit) to collect commits from'
+        required: true
+        type: string
+      head_ref:
+        description: 'Head ref to collect commits to (default: HEAD)'
+        required: false
+        type: string
+        default: 'HEAD'
+    outputs:
+      changelog:
+        description: 'Generated changelog in markdown format'
+        value: ${{ jobs.generate.outputs.changelog }}
+    secrets:
+      GEMINI_API_KEY:
+        required: true
+
+jobs:
+  generate:
+    runs-on: ubuntu-latest
+    outputs:
+      changelog: ${{ steps.ai.outputs.changelog }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Collect commits
+        id: commits
+        run: |
+          COMMITS=$(git log --pretty=format:"%h %s" ${{ inputs.base_ref }}..${{ inputs.head_ref }} 2>/dev/null || echo "")
+          if [ -z "$COMMITS" ]; then
+            echo "No commits found between ${{ inputs.base_ref }} and ${{ inputs.head_ref }}"
+            echo "commits=" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+          # Escape for JSON
+          COMMITS_ESCAPED=$(echo "$COMMITS" | jq -Rs .)
+          echo "commits=$COMMITS_ESCAPED" >> $GITHUB_OUTPUT
+
+      - name: Generate changelog with Gemini
+        id: ai
+        if: steps.commits.outputs.commits != ''
+        env:
+          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
+        run: |
+          COMMITS=${{ steps.commits.outputs.commits }}
+
+          PROMPT=$(cat <<'PROMPT_EOF'
+          You are a changelog generator for a Shopify theme repository.
+          Given the following git commits, classify each into one of these categories:
+          - **Features**: New functionality
+          - **Fixes**: Bug fixes
+          - **Improvements**: Enhancements to existing features
+          - **Chore**: Maintenance, refactoring, docs
+
+          Format the output as a markdown changelog. Group by category.
+          Omit empty categories. Write concise, merchant-friendly descriptions.
+          Do NOT include commit hashes in the output.
+
+          Commits:
+          PROMPT_EOF
+          )
+
+          PAYLOAD=$(jq -n \
+            --arg prompt "$PROMPT" \
+            --argjson commits "$COMMITS" \
+            '{
+              "contents": [{
+                "parts": [{"text": ($prompt + "\n" + $commits)}]
+              }],
+              "generationConfig": {
+                "temperature": 0.3,
+                "maxOutputTokens": 2048
+              }
+            }')
+
+          RESPONSE=$(curl -s -X POST \
+            "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=${GEMINI_API_KEY}" \
+            -H "Content-Type: application/json" \
+            -d "$PAYLOAD")
+
+          CHANGELOG=$(echo "$RESPONSE" | jq -r '.candidates[0].content.parts[0].text // "Changelog generation failed."')
+
+          # Write to output (multiline)
+          {
+            echo "changelog<<CHANGELOG_EOF"
+            echo "$CHANGELOG"
+            echo "CHANGELOG_EOF"
+          } >> $GITHUB_OUTPUT
+
+      - name: Fallback if no commits
+        if: steps.commits.outputs.commits == ''
+        run: |
+          {
+            echo "changelog<<CHANGELOG_EOF"
+            echo "No changes detected."
+            echo "CHANGELOG_EOF"
+          } >> $GITHUB_OUTPUT

package/src/workflows/shared/version-bump.yml

@@ -0,0 +1,122 @@
+# climaybe — Version Bump (Reusable Workflow)
+# Bumps version in settings_schema.json, creates a git tag, and pushes.
+
+name: Version Bump
+
+on:
+  workflow_call:
+    inputs:
+      bump_type:
+        description: 'Type of version bump: minor or patch'
+        required: true
+        type: string
+      version:
+        description: 'Explicit version to set (e.g., v3.2.0). If empty, auto-increments based on bump_type.'
+        required: false
+        type: string
+        default: ''
+      changelog:
+        description: 'Changelog text for the tag annotation'
+        required: false
+        type: string
+        default: ''
+    outputs:
+      new_version:
+        description: 'The new version tag that was created'
+        value: ${{ jobs.bump.outputs.new_version }}
+
+jobs:
+  bump:
+    runs-on: ubuntu-latest
+    outputs:
+      new_version: ${{ steps.bump.outputs.new_version }}
+
+    permissions:
+      contents: write
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Configure git
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+      - name: Determine new version
+        id: bump
+        run: |
+          BUMP_TYPE="${{ inputs.bump_type }}"
+          EXPLICIT_VERSION="${{ inputs.version }}"
+
+          if [ -n "$EXPLICIT_VERSION" ]; then
+            # Use explicit version, ensure it starts with v
+            NEW_VERSION="${EXPLICIT_VERSION#v}"
+            NEW_VERSION="v${NEW_VERSION}"
+          else
+            # Get latest tag
+            LATEST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "v0.0.0")
+            LATEST_TAG="${LATEST_TAG#v}"
+
+            IFS='.' read -r MAJOR MINOR PATCH <<< "$LATEST_TAG"
+            MAJOR=${MAJOR:-0}
+            MINOR=${MINOR:-0}
+            PATCH=${PATCH:-0}
+
+            if [ "$BUMP_TYPE" = "minor" ]; then
+              MINOR=$((MINOR + 1))
+              PATCH=0
+            elif [ "$BUMP_TYPE" = "patch" ]; then
+              PATCH=$((PATCH + 1))
+            fi
+
+            NEW_VERSION="v${MAJOR}.${MINOR}.${PATCH}"
+          fi
+
+          echo "new_version=$NEW_VERSION" >> $GITHUB_OUTPUT
+          echo "New version: $NEW_VERSION"
+
+      - name: Update settings_schema.json
+        run: |
+          NEW_VERSION="${{ steps.bump.outputs.new_version }}"
+          SCHEMA_FILE="config/settings_schema.json"
+
+          if [ -f "$SCHEMA_FILE" ]; then
+            # Update the theme_info version in settings_schema.json
+            node -e "
+              const fs = require('fs');
+              const schema = JSON.parse(fs.readFileSync('$SCHEMA_FILE', 'utf-8'));
+              const themeInfo = schema.find(s => s.name === 'theme_info');
+              if (themeInfo) {
+                themeInfo.theme_version = '${NEW_VERSION#v}';
+              }
+              fs.writeFileSync('$SCHEMA_FILE', JSON.stringify(schema, null, 2) + '\n');
+            "
+            echo "Updated $SCHEMA_FILE to ${NEW_VERSION}"
+          else
+            echo "No $SCHEMA_FILE found, skipping schema update."
+          fi
+
+      - name: Commit and tag
+        run: |
+          NEW_VERSION="${{ steps.bump.outputs.new_version }}"
+
+          # Stage changes
+          git add -A
+
+          # Only commit if there are changes
+          if ! git diff --cached --quiet; then
+            git commit -m "chore(release): bump version to ${NEW_VERSION}"
+          fi
+
+          # Create annotated tag
+          CHANGELOG="${{ inputs.changelog }}"
+          if [ -n "$CHANGELOG" ]; then
+            git tag -a "$NEW_VERSION" -m "$CHANGELOG"
+          else
+            git tag -a "$NEW_VERSION" -m "Release ${NEW_VERSION}"
+          fi
+
+          git push origin HEAD --follow-tags

package/src/workflows/single/nightly-hotfix.yml

@@ -0,0 +1,73 @@
+# climaybe — Nightly Hotfix Tagger (Single-store)
+# Runs at 02:00 US Eastern (07:00 UTC) every night.
+# If there are untagged commits on main (not from staging merges),
+# generates a changelog and creates a patch version tag.
+
+name: Nightly Hotfix Tag
+
+on:
+  schedule:
+    # 02:00 US Eastern = 07:00 UTC
+    - cron: '0 7 * * *'
+  # Allow manual trigger for testing
+  workflow_dispatch:
+
+# Prevent concurrent runs
+concurrency:
+  group: nightly-hotfix
+  cancel-in-progress: false
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    outputs:
+      has_changes: ${{ steps.check.outputs.has_changes }}
+      last_tag: ${{ steps.check.outputs.last_tag }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Check for untagged commits
+        id: check
+        run: |
+          LATEST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "")
+
+          if [ -z "$LATEST_TAG" ]; then
+            echo "No tags found, skipping."
+            echo "has_changes=false" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+
+          echo "last_tag=$LATEST_TAG" >> $GITHUB_OUTPUT
+
+          # Count commits since last tag, excluding version bump commits
+          COMMITS=$(git log ${LATEST_TAG}..HEAD --pretty=format:"%s" | grep -v "chore(release): bump version" | grep -v "\[hotfix-backport\]" || true)
+
+          if [ -n "$COMMITS" ]; then
+            COMMIT_COUNT=$(echo "$COMMITS" | wc -l | tr -d ' ')
+            echo "Found $COMMIT_COUNT untagged commit(s) since $LATEST_TAG"
+            echo "has_changes=true" >> $GITHUB_OUTPUT
+          else
+            echo "No untagged hotfix commits since $LATEST_TAG"
+            echo "has_changes=false" >> $GITHUB_OUTPUT
+          fi
+
+  changelog:
+    needs: check
+    if: needs.check.outputs.has_changes == 'true'
+    uses: ./.github/workflows/ai-changelog.yml
+    with:
+      base_ref: ${{ needs.check.outputs.last_tag }}
+      head_ref: HEAD
+    secrets:
+      GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
+
+  bump:
+    needs: [check, changelog]
+    if: needs.check.outputs.has_changes == 'true'
+    uses: ./.github/workflows/version-bump.yml
+    with:
+      bump_type: patch
+      changelog: ${{ needs.changelog.outputs.changelog }}
+    secrets: inherit

package/src/workflows/single/post-merge-tag.yml

@@ -0,0 +1,96 @@
+# climaybe — Post-Merge Tag (Single-store)
+# After a staging → main PR is merged, detects the target version from the PR title
+# and bumps the minor version accordingly.
+# PR title convention: "Release v3.2" or "Release v3.2.0"
+
+name: Post-Merge Tag
+
+on:
+  push:
+    branches: [main]
+
+# Prevent concurrent version bumps
+concurrency:
+  group: post-merge-tag
+  cancel-in-progress: false
+
+jobs:
+  detect:
+    runs-on: ubuntu-latest
+    outputs:
+      is_release: ${{ steps.check.outputs.is_release }}
+      version: ${{ steps.check.outputs.version }}
+    steps:
+      - name: Check if this push is from a merged staging PR
+        id: check
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          # Check the commit message for merge indicator
+          COMMIT_MSG=$(echo "${{ github.event.head_commit.message }}" | head -1)
+
+          # Skip hotfix backports
+          if echo "$COMMIT_MSG" | grep -q "\[hotfix-backport\]"; then
+            echo "is_release=false" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+
+          # Skip version bump commits from this workflow
+          if echo "$COMMIT_MSG" | grep -q "chore(release): bump version"; then
+            echo "is_release=false" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+
+          # Look for merged PR that targeted main from staging
+          PR_NUMBER=$(echo "$COMMIT_MSG" | grep -oP '#\K\d+' | head -1 || true)
+
+          if [ -n "$PR_NUMBER" ]; then
+            PR_DATA=$(gh api repos/${{ github.repository }}/pulls/$PR_NUMBER 2>/dev/null || echo "")
+
+            if [ -n "$PR_DATA" ]; then
+              HEAD_REF=$(echo "$PR_DATA" | jq -r '.head.ref')
+              TITLE=$(echo "$PR_DATA" | jq -r '.title')
+
+              if [ "$HEAD_REF" = "staging" ]; then
+                # Extract version from PR title: "Release v3.2" or "Release v3.2.0"
+                VERSION=$(echo "$TITLE" | grep -oP 'v\d+\.\d+(\.\d+)?' || true)
+
+                if [ -n "$VERSION" ]; then
+                  # Ensure it has 3 parts
+                  PARTS=$(echo "$VERSION" | tr '.' '\n' | wc -l)
+                  if [ "$PARTS" -eq "2" ]; then
+                    VERSION="${VERSION}.0"
+                  fi
+
+                  echo "is_release=true" >> $GITHUB_OUTPUT
+                  echo "version=$VERSION" >> $GITHUB_OUTPUT
+                  echo "Detected release version: $VERSION"
+                  exit 0
+                fi
+              fi
+            fi
+          fi
+
+          echo "is_release=false" >> $GITHUB_OUTPUT
+
+  # Generate changelog for the release
+  changelog:
+    needs: detect
+    if: needs.detect.outputs.is_release == 'true'
+    uses: ./.github/workflows/ai-changelog.yml
+    with:
+      base_ref: ${{ needs.detect.outputs.version }}
+      head_ref: HEAD
+    secrets:
+      GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
+
+  # Apply version bump
+  bump:
+    needs: [detect, changelog]
+    if: needs.detect.outputs.is_release == 'true'
+    uses: ./.github/workflows/version-bump.yml
+    with:
+      bump_type: minor
+      version: ${{ needs.detect.outputs.version }}
+      changelog: ${{ needs.changelog.outputs.changelog }}
+    secrets: inherit