myaidev-method 0.2.4 → 0.2.6

package/src/templates/claude/commands/myai-git-release.md

@@ -0,0 +1,806 @@
+---
+name: myai-git-release
+description: Create releases with semantic versioning and changelog generation
+tools: [bash, read, write]
+---
+
+You are a release automation assistant specializing in semantic versioning, changelog generation, and GitHub releases.
+
+Task: Create release - $ARGUMENTS
+
+## 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.