myaidev-method 0.2.4 → 0.2.6

package/src/templates/gemini/commands/myai-git-release.toml

@@ -0,0 +1,802 @@
+prompt = """
+
+Task: Create release - {{args}}
+
+## Release Management Workflow
+
+### 1. Pre-Release Validation
+
+```bash
+echo \"🔍 Validating release prerequisites...\"
+
+# Ensure on correct branch
+current_branch=$(git branch --show-current)
+if [[ \"$current_branch\" != \"main\" && \"$current_branch\" != \"master\" ]]; then
+  echo \"⚠️  Not on main/master branch\"
+  read -p \"Continue from $current_branch? (yes/no): \" confirm
+  if [ \"$confirm\" != \"yes\" ]; then
+    exit 1
+  fi
+fi
+
+# Check for uncommitted changes
+if ! git diff-index --quiet HEAD --; then
+  echo \"❌ Uncommitted changes detected\"
+  git status
+  exit 1
+fi
+
+# Ensure branch is up to date
+git fetch origin
+if [ \"$(git rev-parse HEAD)\" != \"$(git rev-parse @{u})\" ]; then
+  echo \"❌ Branch not in sync with remote\"
+  echo \"Run: git pull origin $current_branch\"
+  exit 1
+fi
+
+# Check if tests pass
+echo \"🧪 Running tests before release...\"
+npm test || {
+  echo \"❌ Tests must pass before release\"
+  exit 1
+}
+
+echo \"✅ Pre-release validation passed\"
+```
+
+### 2. Determine Version Bump
+
+```bash
+determine_version_bump() {
+  echo \"📊 Analyzing commits for version bump...\"
+
+  # Get current version
+  if [ -f \"package.json\" ]; then
+    current_version=$(jq -r '.version' package.json)
+  elif [ -f \"version.txt\" ]; then
+    current_version=$(cat version.txt)
+  else
+    current_version=\"0.0.0\"
+  fi
+
+  echo \"Current version: $current_version\"
+
+  # Get latest tag
+  latest_tag=$(git describe --tags --abbrev=0 2>/dev/null || echo \"v0.0.0\")
+  echo \"Latest tag: $latest_tag\"
+
+  # Analyze commits since last tag
+  commits=$(git log $latest_tag..HEAD --oneline 2>/dev/null || git log --oneline)
+
+  # Determine bump type based on conventional commits
+  has_breaking=false
+  has_feature=false
+  has_fix=false
+
+  while IFS= read -r commit; do
+    commit_msg=$(echo \"$commit\" | cut -d' ' -f2-)
+
+    # Check for breaking changes
+    if echo \"$commit_msg\" | grep -qE \"^(BREAKING|breaking|BREAKING CHANGE|breaking change|!)\"; then
+      has_breaking=true
+    fi
+
+    # Check for features
+    if echo \"$commit_msg\" | grep -qE \"^(feat|feature|add|new):\"; then
+      has_feature=true
+    fi
+
+    # Check for fixes
+    if echo \"$commit_msg\" | grep -qE \"^(fix|bugfix|patch):\"; then
+      has_fix=true
+    fi
+  done <<< \"$commits\"
+
+  # Determine bump type
+  if [ \"$has_breaking\" = true ]; then
+    bump_type=\"major\"
+  elif [ \"$has_feature\" = true ]; then
+    bump_type=\"minor\"
+  elif [ \"$has_fix\" = true ]; then
+    bump_type=\"patch\"
+  else
+    bump_type=\"patch\"
+  fi
+
+  echo \"Recommended bump: $bump_type\"
+
+  # Calculate new version
+  IFS='.' read -r major minor patch <<< \"${current_version#v}\"
+
+  case $bump_type in
+    major)
+      major=$((major + 1))
+      minor=0
+      patch=0
+      ;;
+    minor)
+      minor=$((minor + 1))
+      patch=0
+      ;;
+    patch)
+      patch=$((patch + 1))
+      ;;
+  esac
+
+  new_version=\"$major.$minor.$patch\"
+  echo \"New version: $new_version\"
+
+  # Confirm version
+  read -p \"Accept version $new_version? (yes/no/custom): \" choice
+
+  case $choice in
+    yes)
+      echo \"$new_version\"
+      ;;
+    custom)
+      read -p \"Enter custom version: \" custom_version
+      echo \"$custom_version\"
+      ;;
+    *)
+      echo \"Release cancelled\"
+      exit 1
+      ;;
+  esac
+}
+
+# Get new version
+new_version=$(determine_version_bump)
+echo \"Releasing version: $new_version\"
+```
+
+### 3. Generate Changelog
+
+```bash
+generate_changelog() {
+  local version=$1
+  local previous_tag=$(git describe --tags --abbrev=0 2>/dev/null || echo \"\")
+
+  echo \"📝 Generating changelog for v$version...\"
+
+  # Create changelog file
+  changelog_file=\"CHANGELOG-v$version.md\"
+
+  cat > \"$changelog_file\" << EOF
+# Release v$version
+
+**Release Date:** $(date +%Y-%m-%d)
+
+## Changes
+
+EOF
+
+  # Get commits since last tag
+  if [ -n \"$previous_tag\" ]; then
+    commits=$(git log $previous_tag..HEAD --pretty=format:\"%s|%an|%h\" 2>/dev/null)
+  else
+    commits=$(git log --pretty=format:\"%s|%an|%h\")
+  fi
+
+  # Categorize commits
+  declare -A categories
+  categories=(
+    [\"💥 Breaking Changes\"]=\"\"
+    [\"✨ Features\"]=\"\"
+    [\"🐛 Bug Fixes\"]=\"\"
+    [\"📚 Documentation\"]=\"\"
+    [\"🔧 Maintenance\"]=\"\"
+    [\"⚡ Performance\"]=\"\"
+    [\"🎨 Style\"]=\"\"
+    [\"♻️  Refactor\"]=\"\"
+    [\"🧪 Tests\"]=\"\"
+    [\"Other\"]=\"\"
+  )
+
+  while IFS='|' read -r message author hash; do
+    # Categorize based on conventional commit format
+    case \"$message\" in
+      BREAKING*|breaking*|*!:*)
+        categories[\"💥 Breaking Changes\"]+=\"- $message ([$hash](commit/$hash)) - $author\\n\"
+        ;;
+      feat*|feature*|add*|new*)
+        categories[\"✨ Features\"]+=\"- $message ([$hash](commit/$hash)) - $author\\n\"
+        ;;
+      fix*|bugfix*|patch*)
+        categories[\"🐛 Bug Fixes\"]+=\"- $message ([$hash](commit/$hash)) - $author\\n\"
+        ;;
+      docs*|doc*)
+        categories[\"📚 Documentation\"]+=\"- $message ([$hash](commit/$hash)) - $author\\n\"
+        ;;
+      chore*|deps*|build*)
+        categories[\"🔧 Maintenance\"]+=\"- $message ([$hash](commit/$hash)) - $author\\n\"
+        ;;
+      perf*|performance*)
+        categories[\"⚡ Performance\"]+=\"- $message ([$hash](commit/$hash)) - $author\\n\"
+        ;;
+      style*|format*)
+        categories[\"🎨 Style\"]+=\"- $message ([$hash](commit/$hash)) - $author\\n\"
+        ;;
+      refactor*)
+        categories[\"♻️  Refactor\"]+=\"- $message ([$hash](commit/$hash)) - $author\\n\"
+        ;;
+      test*)
+        categories[\"🧪 Tests\"]+=\"- $message ([$hash](commit/$hash)) - $author\\n\"
+        ;;
+      *)
+        categories[\"Other\"]+=\"- $message ([$hash](commit/$hash)) - $author\\n\"
+        ;;
+    esac
+  done <<< \"$commits\"
+
+  # Write categories to changelog
+  for category in \"${!categories[@]}\"; do
+    if [ -n \"${categories[$category]}\" ]; then
+      echo -e \"\\n### $category\\n\" >> \"$changelog_file\"
+      echo -e \"${categories[$category]}\" >> \"$changelog_file\"
+    fi
+  done
+
+  # Add contributors
+  echo -e \"\\n## Contributors\\n\" >> \"$changelog_file\"
+  git log $previous_tag..HEAD --format='%aN' 2>/dev/null | sort -u | while read author; do
+    echo \"- $author\" >> \"$changelog_file\"
+  done
+
+  # Add statistics
+  echo -e \"\\n## Statistics\\n\" >> \"$changelog_file\"
+  commit_count=$(git rev-list $previous_tag..HEAD --count 2>/dev/null || git rev-list --count HEAD)
+  files_changed=$(git diff --stat $previous_tag..HEAD 2>/dev/null | tail -1 || echo \"N/A\")
+
+  echo \"- **Commits:** $commit_count\" >> \"$changelog_file\"
+  echo \"- **Files Changed:** $files_changed\" >> \"$changelog_file\"
+
+  echo \"✅ Changelog generated: $changelog_file\"
+  echo \"$changelog_file\"
+}
+
+# Generate changelog
+changelog_file=$(generate_changelog \"$new_version\")
+
+# Show changelog for review
+echo \"\"
+echo \"═══════════════════════════════════════\"
+cat \"$changelog_file\"
+echo \"═══════════════════════════════════════\"
+echo \"\"
+
+read -p \"Accept changelog? (yes/edit/cancel): \" changelog_choice
+
+case $changelog_choice in
+  edit)
+    ${EDITOR:-nano} \"$changelog_file\"
+    ;;
+  cancel)
+    echo \"Release cancelled\"
+    rm \"$changelog_file\"
+    exit 1
+    ;;
+esac
+```
+
+### 4. Update Version in Files
+
+```bash
+update_version_files() {
+  local version=$1
+
+  echo \"📝 Updating version in project files...\"
+
+  # Update package.json
+  if [ -f \"package.json\" ]; then
+    echo \"Updating package.json...\"
+    jq \".version = \\\"$version\\\"\" package.json > package.json.tmp
+    mv package.json.tmp package.json
+    echo \"✅ package.json updated\"
+  fi
+
+  # Update package-lock.json
+  if [ -f \"package-lock.json\" ]; then
+    echo \"Updating package-lock.json...\"
+    jq \".version = \\\"$version\\\"\" package-lock.json > package-lock.json.tmp
+    mv package-lock.json.tmp package-lock.json
+    echo \"✅ package-lock.json updated\"
+  fi
+
+  # Update version.txt if exists
+  if [ -f \"version.txt\" ]; then
+    echo \"$version\" > version.txt
+    echo \"✅ version.txt updated\"
+  fi
+
+  # Update Cargo.toml if Rust project
+  if [ -f \"Cargo.toml\" ]; then
+    sed -i \"s/^version = .*/version = \\\"$version\\\"/\" Cargo.toml
+    echo \"✅ Cargo.toml updated\"
+  fi
+
+  # Update pyproject.toml if Python project
+  if [ -f \"pyproject.toml\" ]; then
+    sed -i \"s/^version = .*/version = \\\"$version\\\"/\" pyproject.toml
+    echo \"✅ pyproject.toml updated\"
+  fi
+
+  # Update setup.py if Python project
+  if [ -f \"setup.py\" ]; then
+    sed -i \"s/version=['\\\"].*['\\\"]/version='$version'/\" setup.py
+    echo \"✅ setup.py updated\"
+  fi
+
+  # Stage all version changes
+  git add -A
+
+  echo \"✅ Version files updated\"
+}
+
+# Update version
+update_version_files \"$new_version\"
+```
+
+### 5. Commit and Tag Release
+
+```bash
+create_release_commit() {
+  local version=$1
+  local changelog_file=$2
+
+  echo \"🏷️  Creating release commit and tag...\"
+
+  # Create release commit
+  git commit -m \"chore(release): v$version
+
+$(cat $changelog_file)
+
+🤖 Generated with [Claude Code](https://claude.com/claude-code)
+
+Co-Authored-By: Claude <noreply@anthropic.com>\"
+
+  # Create annotated tag
+  git tag -a \"v$version\" -m \"Release v$version
+
+$(head -20 $changelog_file)
+
+Full changelog: See CHANGELOG.md\"
+
+  echo \"✅ Release commit and tag created\"
+}
+
+# Create commit and tag
+create_release_commit \"$new_version\" \"$changelog_file\"
+```
+
+### 6. Update CHANGELOG.md
+
+```bash
+update_main_changelog() {
+  local version=$1
+  local changelog_file=$2
+
+  echo \"📝 Updating CHANGELOG.md...\"
+
+  # Create CHANGELOG.md if it doesn't exist
+  if [ ! -f \"CHANGELOG.md\" ]; then
+    cat > CHANGELOG.md << EOF
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+EOF
+  fi
+
+  # Insert new version at the top (after header)
+  temp_file=$(mktemp)
+
+  # Read header
+  sed '/^## /q' CHANGELOG.md > \"$temp_file\"
+
+  # Add new version
+  echo \"\" >> \"$temp_file\"
+  cat \"$changelog_file\" >> \"$temp_file\"
+  echo \"\" >> \"$temp_file\"
+
+  # Add rest of changelog
+  sed -n '/^## /,$p' CHANGELOG.md >> \"$temp_file\"
+
+  # Replace old changelog
+  mv \"$temp_file\" CHANGELOG.md
+
+  # Stage changelog
+  git add CHANGELOG.md
+
+  # Amend the release commit to include updated CHANGELOG
+  git commit --amend --no-edit
+
+  # Update the tag
+  git tag -d \"v$version\"
+  git tag -a \"v$version\" -m \"Release v$version
+
+$(head -20 $changelog_file)
+
+Full changelog: See CHANGELOG.md\"
+
+  # Clean up temporary changelog
+  rm \"$changelog_file\"
+
+  echo \"✅ CHANGELOG.md updated\"
+}
+
+# Update main changelog
+update_main_changelog \"$new_version\" \"$changelog_file\"
+```
+
+### 7. Push Release
+
+```bash
+push_release() {
+  local version=$1
+
+  echo \"🚀 Pushing release to remote...\"
+
+  read -p \"Push release v$version to origin? (yes/no): \" push_confirm
+
+  if [ \"$push_confirm\" != \"yes\" ]; then
+    echo \"⚠️  Release created locally but not pushed\"
+    echo \"To push later: git push origin $current_branch && git push origin v$version\"
+    return
+  fi
+
+  # Push commit
+  git push origin \"$current_branch\" || {
+    echo \"❌ Failed to push commit\"
+    exit 1
+  }
+
+  # Push tag
+  git push origin \"v$version\" || {
+    echo \"❌ Failed to push tag\"
+    exit 1
+  }
+
+  echo \"✅ Release pushed to origin\"
+}
+
+# Push release
+push_release \"$new_version\"
+```
+
+### 8. Create GitHub Release
+
+```bash
+create_github_release() {
+  local version=$1
+
+  echo \"📦 Creating GitHub release...\"
+
+  # Check if gh CLI is installed
+  if ! command -v gh &> /dev/null; then
+    echo \"⚠️  GitHub CLI not installed. Install with: brew install gh\"
+    echo \"Manual release creation: https://github.com/$(git config remote.origin.url | sed 's/.*://;s/.git$//')/releases/new\"
+    return
+  fi
+
+  # Check if authenticated
+  if ! gh auth status &> /dev/null; then
+    echo \"🔐 Authenticating with GitHub...\"
+    gh auth login
+  fi
+
+  # Extract changelog content for this version
+  changelog_content=$(sed -n '/^# Release/,/^# Release/p' CHANGELOG.md | head -n -1)
+
+  # Create release
+  echo \"Creating GitHub release...\"
+
+  gh release create \"v$version\" \\
+    --title \"Release v$version\" \\
+    --notes \"$changelog_content\" \\
+    || {
+      echo \"❌ Failed to create GitHub release\"
+      exit 1
+    }
+
+  echo \"✅ GitHub release created\"
+  echo \"🌐 View at: https://github.com/$(git remote get-url origin | sed 's/.*://;s/.git$//')/releases/tag/v$version\"
+}
+
+# Create GitHub release if available
+create_github_release \"$new_version\"
+```
+
+### 9. Upload Release Assets
+
+```bash
+upload_release_assets() {
+  local version=$1
+
+  echo \"📎 Uploading release assets...\"
+
+  # Build release artifacts
+  if [ -f \"package.json\" ] && grep -q \"\\\"build\\\"\" package.json; then
+    echo \"Building release artifacts...\"
+    npm run build || echo \"⚠️  Build failed\"
+
+    # Create distribution archive
+    if [ -d \"dist\" ]; then
+      echo \"Creating distribution archive...\"
+      tar -czf \"dist-v$version.tar.gz\" dist/
+      asset_files+=(\"dist-v$version.tar.gz\")
+    fi
+  fi
+
+  # Upload checksums
+  if [ ${#asset_files[@]} -gt 0 ]; then
+    echo \"Generating checksums...\"
+    sha256sum \"${asset_files[@]}\" > \"checksums-v$version.txt\"
+    asset_files+=(\"checksums-v$version.txt\")
+  fi
+
+  # Upload to GitHub release
+  if command -v gh &> /dev/null; then
+    for asset in \"${asset_files[@]}\"; do
+      echo \"Uploading $asset...\"
+      gh release upload \"v$version\" \"$asset\" || echo \"⚠️  Failed to upload $asset\"
+    done
+
+    echo \"✅ Assets uploaded\"
+  else
+    echo \"⚠️  GitHub CLI not available, upload assets manually\"
+    echo \"Assets: ${asset_files[*]}\"
+  fi
+
+  # Clean up
+  rm -f \"${asset_files[@]}\"
+}
+
+# Upload assets
+declare -a asset_files=()
+upload_release_assets \"$new_version\"
+```
+
+### 10. Publish to NPM (Optional)
+
+```bash
+publish_to_npm() {
+  local version=$1
+
+  if [ ! -f \"package.json\" ]; then
+    return
+  fi
+
+  echo \"📦 NPM Publishing...\"
+
+  read -p \"Publish v$version to NPM? (yes/no): \" npm_confirm
+
+  if [ \"$npm_confirm\" != \"yes\" ]; then
+    echo \"⚠️  Skipping NPM publish\"
+    return
+  fi
+
+  # Check if logged in
+  if ! npm whoami &> /dev/null; then
+    echo \"🔐 Logging into NPM...\"
+    npm login
+  fi
+
+  # Run pre-publish checks
+  echo \"Running pre-publish checks...\"
+  npm run prepublishOnly || echo \"⚠️  Pre-publish hook failed\"
+
+  # Publish
+  echo \"Publishing to NPM...\"
+  npm publish --access public || {
+    echo \"❌ NPM publish failed\"
+    return 1
+  }
+
+  echo \"✅ Published to NPM\"
+  echo \"🌐 View at: https://www.npmjs.com/package/$(jq -r '.name' package.json)\"
+}
+
+# Publish to NPM
+publish_to_npm \"$new_version\"
+```
+
+### 11. Post-Release Actions
+
+```bash
+post_release_actions() {
+  local version=$1
+
+  echo \"🎉 Post-release actions...\"
+
+  # Trigger release deployment
+  if [ -f \".github/workflows/release.yml\" ]; then
+    echo \"📢 GitHub Actions will handle deployment\"
+  fi
+
+  # Create next development version
+  read -p \"Create next dev version? (yes/no): \" dev_version
+
+  if [ \"$dev_version\" == \"yes\" ]; then
+    IFS='.' read -r major minor patch <<< \"$version\"
+    next_patch=$((patch + 1))
+    dev_version=\"$major.$minor.$next_patch-dev\"
+
+    # Update version files
+    if [ -f \"package.json\" ]; then
+      jq \".version = \\\"$dev_version\\\"\" package.json > package.json.tmp
+      mv package.json.tmp package.json
+    fi
+
+    git add -A
+    git commit -m \"chore: bump to v$dev_version\"
+    git push origin \"$current_branch\"
+
+    echo \"✅ Development version set to v$dev_version\"
+  fi
+
+  # Notify team
+  send_release_notification \"$version\"
+
+  echo \"✅ Post-release actions complete\"
+}
+
+# Post-release actions
+post_release_actions \"$new_version\"
+```
+
+### 12. Release Notification
+
+```bash
+send_release_notification() {
+  local version=$1
+  local repo_url=$(git config remote.origin.url | sed 's/git@github.com:/https:\\/\\/github.com\\//' | sed 's/.git$//')
+  local release_url=\"$repo_url/releases/tag/v$version\"
+  local changelog=$(sed -n '/^# Release/,/^# Release/p' CHANGELOG.md | head -n -1)
+
+  # Slack notification
+  if [ -n \"$SLACK_WEBHOOK_URL\" ]; then
+    curl -X POST \"$SLACK_WEBHOOK_URL\" \\
+      -H 'Content-Type: application/json' \\
+      -d \"{
+        \\\"text\\\": \\\"🎉 New Release: v$version\\\",
+        \\\"blocks\\\": [
+          {
+            \\\"type\\\": \\\"header\\\",
+            \\\"text\\\": {
+              \\\"type\\\": \\\"plain_text\\\",
+              \\\"text\\\": \\\"🎉 New Release: v$version\\\"
+            }
+          },
+          {
+            \\\"type\\\": \\\"section\\\",
+            \\\"text\\\": {
+              \\\"type\\\": \\\"mrkdwn\\\",
+              \\\"text\\\": \\\"$changelog\\\"
+            }
+          },
+          {
+            \\\"type\\\": \\\"actions\\\",
+            \\\"elements\\\": [
+              {
+                \\\"type\\\": \\\"button\\\",
+                \\\"text\\\": {\\\"type\\\": \\\"plain_text\\\", \\\"text\\\": \\\"View Release\\\"},
+                \\\"url\\\": \\\"$release_url\\\"
+              }
+            ]
+          }
+        ]
+      }\"
+  fi
+
+  # Discord notification
+  if [ -n \"$DISCORD_WEBHOOK_URL\" ]; then
+    curl -X POST \"$DISCORD_WEBHOOK_URL\" \\
+      -H 'Content-Type: application/json' \\
+      -d \"{
+        \\\"content\\\": \\\"🎉 **New Release: v$version**\\\",
+        \\\"embeds\\\": [{
+          \\\"title\\\": \\\"Release v$version\\\",
+          \\\"url\\\": \\\"$release_url\\\",
+          \\\"description\\\": \\\"$(echo \"$changelog\" | head -500)\\\",
+          \\\"color\\\": 5763719,
+          \\\"timestamp\\\": \\\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\\\"
+        }]
+      }\"
+  fi
+
+  echo \"✅ Release notification sent\"
+}
+```
+
+## Complete Release Script
+
+```bash
+#!/bin/bash
+set -e
+
+echo \"🎉 Starting release process...\"
+
+# 1. Validate
+git diff-index --quiet HEAD -- || { echo \"❌ Uncommitted changes\"; exit 1; }
+npm test || { echo \"❌ Tests failed\"; exit 1; }
+
+# 2. Determine version
+new_version=$(determine_version_bump)
+
+# 3. Generate changelog
+changelog_file=$(generate_changelog \"$new_version\")
+
+# 4. Update files
+update_version_files \"$new_version\"
+
+# 5. Commit and tag
+create_release_commit \"$new_version\" \"$changelog_file\"
+update_main_changelog \"$new_version\" \"$changelog_file\"
+
+# 6. Push
+push_release \"$new_version\"
+
+# 7. Create GitHub release
+create_github_release \"$new_version\"
+
+# 8. Upload assets
+upload_release_assets \"$new_version\"
+
+# 9. Publish to NPM
+publish_to_npm \"$new_version\"
+
+# 10. Post-release
+post_release_actions \"$new_version\"
+
+echo \"✅ Release v$new_version complete!\"
+echo \"🌐 Release: https://github.com/$(git remote get-url origin | sed 's/.*://;s/.git$//')/releases/tag/v$new_version\"
+```
+
+## Quick Release Commands
+
+**Patch release (bug fixes):**
+```bash
+npm run release:patch
+# or
+/myai-git-release --patch
+```
+
+**Minor release (new features):**
+```bash
+npm run release:minor
+# or
+/myai-git-release --minor
+```
+
+**Major release (breaking changes):**
+```bash
+npm run release:major
+# or
+/myai-git-release --major
+```
+
+## Environment Configuration
+
+```bash
+# GitHub (for releases)
+GH_TOKEN=your_github_token
+
+# NPM (for publishing)
+NPM_TOKEN=your_npm_token
+
+# Notifications
+SLACK_WEBHOOK_URL=https://hooks.slack.com/services/YOUR/WEBHOOK
+DISCORD_WEBHOOK_URL=https://discord.com/api/webhooks/YOUR/WEBHOOK
+
+# Release settings
+AUTO_PUBLISH_NPM=false
+CREATE_DEV_VERSION=true
+UPLOAD_ASSETS=true
+```
+
+Execute the release workflow with semantic versioning and complete automation.
+
+"""