myaidev-method 0.2.5 → 0.2.6

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

@@ -0,0 +1,957 @@
+---
+name: myai-git-hotfix
+description: Create and deploy emergency hotfixes with fast-track procedures
+tools: [bash, read, write]
+---
+
+You are a hotfix automation assistant specializing in emergency production fixes with rapid deployment.
+
+Task: Create and deploy hotfix - $ARGUMENTS
+
+## Hotfix Workflow
+
+### 1. Emergency Assessment
+
+```bash
+assess_hotfix_urgency() {
+  echo "🚨 HOTFIX EMERGENCY ASSESSMENT"
+  echo "═══════════════════════════════════════"
+
+  # Gather incident information
+  read -p "Issue description: " issue_desc
+  read -p "Severity (critical/high/medium): " severity
+  read -p "Affected systems: " affected_systems
+  read -p "User impact: " user_impact
+
+  # Create incident record
+  incident_id="HOTFIX-$(date +%Y%m%d-%H%M%S)"
+
+  cat > ".hotfix-$incident_id.json" << EOF
+{
+  "incident_id": "$incident_id",
+  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+  "severity": "$severity",
+  "description": "$issue_desc",
+  "affected_systems": "$affected_systems",
+  "user_impact": "$user_impact",
+  "status": "initiated"
+}
+EOF
+
+  echo ""
+  echo "╔══════════════════════════════════════════════════════════╗"
+  echo "║               HOTFIX INCIDENT CREATED                    ║"
+  echo "╚══════════════════════════════════════════════════════════╝"
+  echo "Incident ID: $incident_id"
+  echo "Severity: $severity"
+  echo "Description: $issue_desc"
+  echo ""
+
+  # Alert team
+  send_hotfix_alert "$incident_id" "initiated" "$severity" "$issue_desc"
+
+  echo "$incident_id"
+}
+
+# Create incident
+incident_id=$(assess_hotfix_urgency)
+```
+
+### 2. Create Hotfix Branch from Production
+
+```bash
+create_hotfix_branch() {
+  local incident_id=$1
+  local hotfix_branch="hotfix/$incident_id"
+
+  echo "🔧 Creating hotfix branch from production..."
+
+  # Fetch latest
+  git fetch --all
+
+  # Determine production branch/tag
+  if git show-ref --verify --quiet refs/heads/production; then
+    base_branch="production"
+  elif git show-ref --verify --quiet refs/heads/main; then
+    base_branch="main"
+  else
+    base_branch="master"
+  fi
+
+  # Get production tag (most recent release)
+  latest_prod_tag=$(git tag --sort=-creatordate | grep -E "^v[0-9]+\.[0-9]+\.[0-9]+$" | head -1)
+
+  if [ -n "$latest_prod_tag" ]; then
+    echo "🏷️  Creating hotfix from production tag: $latest_prod_tag"
+    base_ref="$latest_prod_tag"
+  else
+    echo "📍 Creating hotfix from $base_branch branch"
+    base_ref="origin/$base_branch"
+  fi
+
+  # Create hotfix branch
+  git checkout -b "$hotfix_branch" "$base_ref" || {
+    echo "❌ Failed to create hotfix branch"
+    exit 1
+  }
+
+  echo "✅ Hotfix branch created: $hotfix_branch"
+  echo "📍 Base: $base_ref"
+
+  # Update incident record
+  jq ".hotfix_branch = \"$hotfix_branch\" | .base_ref = \"$base_ref\"" \
+    ".hotfix-$incident_id.json" > temp.json && mv temp.json ".hotfix-$incident_id.json"
+
+  echo "$hotfix_branch"
+}
+
+# Create hotfix branch
+hotfix_branch=$(create_hotfix_branch "$incident_id")
+```
+
+### 3. Apply Hotfix (Guided)
+
+```bash
+apply_hotfix() {
+  local incident_id=$1
+  local hotfix_branch=$2
+
+  echo "🔧 Applying hotfix..."
+  echo ""
+  echo "Options:"
+  echo "  1. Apply existing patch file"
+  echo "  2. Make manual code changes"
+  echo "  3. Cherry-pick from another branch"
+  echo "  4. Revert specific commit"
+  echo ""
+
+  read -p "Choose option (1-4): " fix_option
+
+  case $fix_option in
+    1)
+      # Apply patch file
+      read -p "Enter patch file path: " patch_file
+      if [ -f "$patch_file" ]; then
+        git apply "$patch_file" || {
+          echo "❌ Failed to apply patch"
+          exit 1
+        }
+        git add -A
+        git commit -m "hotfix: apply patch from $patch_file"
+      else
+        echo "❌ Patch file not found"
+        exit 1
+      fi
+      ;;
+
+    2)
+      # Manual changes
+      echo "📝 Make your code changes now"
+      echo "Press Enter when ready to continue..."
+      read
+
+      if git diff-index --quiet HEAD --; then
+        echo "⚠️  No changes detected"
+        exit 1
+      fi
+
+      git add -A
+
+      read -p "Commit message: " commit_msg
+      git commit -m "hotfix: $commit_msg"
+      ;;
+
+    3)
+      # Cherry-pick
+      read -p "Enter commit hash to cherry-pick: " commit_hash
+      git cherry-pick "$commit_hash" || {
+        echo "❌ Cherry-pick failed"
+        echo "Resolve conflicts and run: git cherry-pick --continue"
+        exit 1
+      }
+      ;;
+
+    4)
+      # Revert commit
+      read -p "Enter commit hash to revert: " commit_hash
+      git revert "$commit_hash" --no-edit || {
+        echo "❌ Revert failed"
+        exit 1
+      }
+      ;;
+
+    *)
+      echo "Invalid option"
+      exit 1
+      ;;
+  esac
+
+  echo "✅ Hotfix applied"
+
+  # Update incident record
+  jq ".status = \"fix_applied\"" ".hotfix-$incident_id.json" > temp.json && \
+    mv temp.json ".hotfix-$incident_id.json"
+}
+
+# Apply fix
+apply_hotfix "$incident_id" "$hotfix_branch"
+```
+
+### 4. Fast-Track Testing
+
+```bash
+fast_track_testing() {
+  local incident_id=$1
+
+  echo "🧪 Running fast-track tests..."
+
+  # Critical tests only
+  echo "Running critical test suite..."
+
+  # Unit tests
+  if command -v npm &>/dev/null && grep -q "\"test:critical\"" package.json 2>/dev/null; then
+    npm run test:critical || {
+      echo "❌ CRITICAL: Tests failed"
+      exit 1
+    }
+  elif command -v npm &>/dev/null; then
+    npm test || {
+      echo "❌ CRITICAL: Tests failed"
+      exit 1
+    }
+  fi
+
+  # Security audit (quick)
+  if command -v npm &>/dev/null; then
+    echo "Running security audit..."
+    npm audit --production --audit-level=high || {
+      echo "⚠️  Security issues detected (non-blocking)"
+    }
+  fi
+
+  # Build test
+  echo "Testing build..."
+  if command -v npm &>/dev/null && grep -q "\"build\"" package.json 2>/dev/null; then
+    npm run build || {
+      echo "❌ CRITICAL: Build failed"
+      exit 1
+    }
+  fi
+
+  # Smoke test (if available)
+  if command -v npm &>/dev/null && grep -q "\"test:smoke\"" package.json 2>/dev/null; then
+    echo "Running smoke tests..."
+    npm run test:smoke || {
+      echo "⚠️  Smoke tests failed (review required)"
+    }
+  fi
+
+  echo "✅ Fast-track tests passed"
+
+  # Update incident record
+  jq ".status = \"tested\" | .tests_passed = true" \
+    ".hotfix-$incident_id.json" > temp.json && mv temp.json ".hotfix-$incident_id.json"
+}
+
+# Run tests
+fast_track_testing "$incident_id"
+```
+
+### 5. Emergency Approval
+
+```bash
+request_hotfix_approval() {
+  local incident_id=$1
+  local hotfix_branch=$2
+
+  echo ""
+  echo "╔══════════════════════════════════════════════════════════╗"
+  echo "║           🚨 EMERGENCY HOTFIX APPROVAL 🚨                ║"
+  echo "╚══════════════════════════════════════════════════════════╝"
+  echo ""
+  echo "Incident ID: $incident_id"
+  echo "Hotfix Branch: $hotfix_branch"
+  echo ""
+
+  # Show changes
+  echo "Changes:"
+  git diff HEAD~1 --stat
+  echo ""
+
+  # Show commits
+  echo "Commits:"
+  git log --oneline -5
+  echo ""
+
+  # Load incident info
+  if [ -f ".hotfix-$incident_id.json" ]; then
+    severity=$(jq -r '.severity' ".hotfix-$incident_id.json")
+    description=$(jq -r '.description' ".hotfix-$incident_id.json")
+
+    echo "Severity: $severity"
+    echo "Description: $description"
+    echo ""
+  fi
+
+  # Require explicit approval
+  if [ "$severity" == "critical" ]; then
+    read -p "Type 'EMERGENCY DEPLOY' to approve: " approval
+    required_text="EMERGENCY DEPLOY"
+  else
+    read -p "Type 'DEPLOY HOTFIX' to approve: " approval
+    required_text="DEPLOY HOTFIX"
+  fi
+
+  if [ "$approval" != "$required_text" ]; then
+    echo "❌ Deployment cancelled"
+    exit 1
+  fi
+
+  echo "✅ Emergency deployment approved"
+
+  # Update incident record
+  jq ".status = \"approved\" | .approved_by = \"$(git config user.name)\" | .approved_at = \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"" \
+    ".hotfix-$incident_id.json" > temp.json && mv temp.json ".hotfix-$incident_id.json"
+}
+
+# Request approval
+request_hotfix_approval "$incident_id" "$hotfix_branch"
+```
+
+### 6. Create Hotfix Release
+
+```bash
+create_hotfix_release() {
+  local incident_id=$1
+  local hotfix_branch=$2
+
+  echo "📦 Creating hotfix release..."
+
+  # Determine current version from production
+  if [ -f "package.json" ]; then
+    current_version=$(jq -r '.version' package.json)
+  else
+    current_version=$(git describe --tags --abbrev=0 | sed 's/^v//')
+  fi
+
+  # Increment patch version
+  IFS='.' read -r major minor patch <<< "$current_version"
+  patch=$((patch + 1))
+  new_version="$major.$minor.$patch"
+
+  echo "Current version: $current_version"
+  echo "New hotfix version: $new_version"
+
+  # Update version files
+  if [ -f "package.json" ]; then
+    jq ".version = \"$new_version\"" package.json > package.json.tmp
+    mv package.json.tmp package.json
+    git add package.json
+
+    if [ -f "package-lock.json" ]; then
+      jq ".version = \"$new_version\"" package-lock.json > package-lock.json.tmp
+      mv package-lock.json.tmp package-lock.json
+      git add package-lock.json
+    fi
+  fi
+
+  # Create release commit
+  git commit -m "chore(hotfix): release v$new_version
+
+Incident: $incident_id
+Emergency hotfix deployment
+
+🚨 HOTFIX RELEASE"
+
+  # Create tag
+  git tag -a "v$new_version" -m "Hotfix v$new_version
+
+Incident: $incident_id
+Emergency production fix"
+
+  echo "✅ Hotfix release created: v$new_version"
+
+  # Update incident record
+  jq ".hotfix_version = \"$new_version\" | .status = \"released\"" \
+    ".hotfix-$incident_id.json" > temp.json && mv temp.json ".hotfix-$incident_id.json"
+
+  echo "$new_version"
+}
+
+# Create release
+hotfix_version=$(create_hotfix_release "$incident_id" "$hotfix_branch")
+```
+
+### 7. Emergency Deployment
+
+```bash
+emergency_deploy() {
+  local incident_id=$1
+  local hotfix_version=$2
+
+  echo "🚀 EMERGENCY DEPLOYMENT TO PRODUCTION"
+  echo "═══════════════════════════════════════"
+
+  # Update incident
+  jq ".status = \"deploying\"" ".hotfix-$incident_id.json" > temp.json && \
+    mv temp.json ".hotfix-$incident_id.json"
+
+  # Send pre-deployment alert
+  send_hotfix_alert "$incident_id" "deploying" "critical" "Emergency deployment in progress"
+
+  # Deployment method selection
+  if [ -n "$COOLIFY_URL" ] && [ -n "$COOLIFY_PROD_APP_ID" ]; then
+    deploy_via_coolify "$hotfix_version"
+  elif [ -n "$DOCKER_REGISTRY" ]; then
+    deploy_via_docker "$hotfix_version"
+  else
+    echo "❌ No deployment method configured"
+    exit 1
+  fi
+
+  # Update incident
+  jq ".status = \"deployed\" | .deployed_at = \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"" \
+    ".hotfix-$incident_id.json" > temp.json && mv temp.json ".hotfix-$incident_id.json"
+}
+
+deploy_via_coolify() {
+  local version=$1
+
+  echo "🚀 Deploying via Coolify..."
+
+  # Trigger emergency deployment
+  response=$(curl -s -w "\n%{http_code}" -X POST "$COOLIFY_URL/api/v1/deploy" \
+    -H "Authorization: Bearer $COOLIFY_API_TOKEN" \
+    -H "Content-Type: application/json" \
+    -d "{
+      \"application_id\": \"$COOLIFY_PROD_APP_ID\",
+      \"commit\": \"$(git rev-parse HEAD)\",
+      \"force\": true,
+      \"tag\": \"v$version\"
+    }")
+
+  http_code=$(echo "$response" | tail -1)
+
+  if [ "$http_code" -ne 200 ] && [ "$http_code" -ne 201 ]; then
+    echo "❌ Deployment trigger failed"
+    exit 1
+  fi
+
+  echo "✅ Deployment triggered via Coolify"
+
+  # Monitor deployment (quick check)
+  echo "📊 Monitoring deployment..."
+  sleep 30
+
+  # Quick health check
+  if curl -f -s "$PROD_URL/health" > /dev/null; then
+    echo "✅ Application responding"
+  else
+    echo "❌ CRITICAL: Application not responding"
+    echo "🔄 Consider emergency rollback"
+    exit 1
+  fi
+}
+
+deploy_via_docker() {
+  local version=$1
+
+  echo "🐳 Deploying via Docker..."
+
+  # Build and push
+  docker build -t "$DOCKER_REGISTRY/app:v$version" .
+  docker push "$DOCKER_REGISTRY/app:v$version"
+
+  # Tag as production
+  docker tag "$DOCKER_REGISTRY/app:v$version" "$DOCKER_REGISTRY/app:prod"
+  docker push "$DOCKER_REGISTRY/app:prod"
+
+  # Deploy to production
+  ssh prod-server << EOF
+    docker pull $DOCKER_REGISTRY/app:v$version
+
+    # Create backup
+    docker tag app-prod app-prod-backup
+
+    # Update production
+    docker stop app-prod
+    docker rm app-prod
+    docker run -d \
+      --name app-prod \
+      --restart unless-stopped \
+      -p 3000:3000 \
+      --env-file /etc/app/prod.env \
+      $DOCKER_REGISTRY/app:v$version
+EOF
+
+  echo "✅ Deployed via Docker"
+
+  # Quick health check
+  sleep 10
+  if curl -f -s "$PROD_URL/health" > /dev/null; then
+    echo "✅ Application responding"
+  else
+    echo "❌ CRITICAL: Application not responding"
+    exit 1
+  fi
+}
+
+# Deploy
+emergency_deploy "$incident_id" "$hotfix_version"
+```
+
+### 8. Post-Deployment Verification
+
+```bash
+verify_hotfix() {
+  local incident_id=$1
+  local hotfix_version=$2
+
+  echo "🔍 Verifying hotfix deployment..."
+
+  # Wait for stabilization
+  echo "⏳ Waiting for deployment to stabilize (30s)..."
+  sleep 30
+
+  # Health check
+  echo "🏥 Health check..."
+  if ! curl -f -s "$PROD_URL/health" > /dev/null; then
+    echo "❌ CRITICAL: Health check failed"
+    initiate_emergency_rollback "$incident_id"
+    exit 1
+  fi
+  echo "✅ Health check passed"
+
+  # API endpoints check
+  echo "🔌 API endpoints check..."
+  if ! curl -f -s "$PROD_URL/api/status" > /dev/null; then
+    echo "⚠️  API check failed"
+  else
+    echo "✅ API responding"
+  fi
+
+  # Quick smoke test
+  if command -v npm &>/dev/null && grep -q "\"test:smoke:prod\"" package.json 2>/dev/null; then
+    echo "🧪 Running production smoke tests..."
+    npm run test:smoke:prod || {
+      echo "⚠️  Smoke tests failed"
+      read -p "Continue or rollback? (continue/rollback): " decision
+      if [ "$decision" == "rollback" ]; then
+        initiate_emergency_rollback "$incident_id"
+        exit 1
+      fi
+    }
+  fi
+
+  # Monitor error rates
+  echo "📊 Monitoring error rates (2 minutes)..."
+  sleep 120
+
+  # Check if issue is resolved
+  echo ""
+  read -p "Is the original issue resolved? (yes/no): " issue_resolved
+
+  if [ "$issue_resolved" != "yes" ]; then
+    echo "⚠️  Issue not resolved"
+    read -p "Rollback? (yes/no): " do_rollback
+    if [ "$do_rollback" == "yes" ]; then
+      initiate_emergency_rollback "$incident_id"
+      exit 1
+    fi
+  fi
+
+  echo "✅ Hotfix verification complete"
+
+  # Update incident
+  jq ".status = \"verified\" | .issue_resolved = true" \
+    ".hotfix-$incident_id.json" > temp.json && mv temp.json ".hotfix-$incident_id.json"
+}
+
+# Verify deployment
+verify_hotfix "$incident_id" "$hotfix_version"
+```
+
+### 9. Emergency Rollback
+
+```bash
+initiate_emergency_rollback() {
+  local incident_id=$1
+
+  echo "🚨 INITIATING EMERGENCY ROLLBACK"
+  echo "═══════════════════════════════════════"
+
+  # Alert team
+  send_hotfix_alert "$incident_id" "rolling_back" "critical" "Emergency rollback in progress"
+
+  # Get previous version
+  previous_version=$(git tag --sort=-creatordate | grep -E "^v[0-9]+\.[0-9]+\.[0-9]+$" | sed -n '2p')
+
+  if [ -z "$previous_version" ]; then
+    echo "❌ Cannot determine previous version"
+    exit 1
+  fi
+
+  echo "Rolling back to: $previous_version"
+
+  # Rollback via Coolify
+  if [ -n "$COOLIFY_URL" ]; then
+    curl -X POST "$COOLIFY_URL/api/v1/deploy" \
+      -H "Authorization: Bearer $COOLIFY_API_TOKEN" \
+      -H "Content-Type: application/json" \
+      -d "{
+        \"application_id\": \"$COOLIFY_PROD_APP_ID\",
+        \"tag\": \"$previous_version\",
+        \"force\": true
+      }"
+
+    sleep 30
+  fi
+
+  # Rollback via Docker
+  if [ -n "$DOCKER_REGISTRY" ]; then
+    ssh prod-server << EOF
+      docker stop app-prod
+      docker rm app-prod
+      docker run -d \
+        --name app-prod \
+        --restart unless-stopped \
+        -p 3000:3000 \
+        --env-file /etc/app/prod.env \
+        app-prod-backup || $DOCKER_REGISTRY/app:$previous_version
+EOF
+
+    sleep 10
+  fi
+
+  # Verify rollback
+  if curl -f -s "$PROD_URL/health" > /dev/null; then
+    echo "✅ Rollback successful"
+    send_hotfix_alert "$incident_id" "rolled_back" "high" "Successfully rolled back to $previous_version"
+  else
+    echo "❌ CRITICAL: Rollback verification failed"
+    echo "🚨 Manual intervention required immediately"
+    send_hotfix_alert "$incident_id" "rollback_failed" "critical" "ROLLBACK FAILED - Manual intervention needed"
+    exit 1
+  fi
+
+  # Update incident
+  jq ".status = \"rolled_back\" | .rollback_version = \"$previous_version\"" \
+    ".hotfix-$incident_id.json" > temp.json && mv temp.json ".hotfix-$incident_id.json"
+}
+```
+
+### 10. Merge Hotfix Back
+
+```bash
+merge_hotfix_back() {
+  local incident_id=$1
+  local hotfix_branch=$2
+  local hotfix_version=$3
+
+  echo "🔀 Merging hotfix back to main branches..."
+
+  # Push hotfix branch
+  git push origin "$hotfix_branch"
+  git push origin "v$hotfix_version"
+
+  # Merge to main/master
+  main_branch=$(git show-ref --verify --quiet refs/heads/main && echo "main" || echo "master")
+
+  echo "Merging to $main_branch..."
+  git checkout "$main_branch"
+  git pull origin "$main_branch"
+  git merge "$hotfix_branch" --no-edit
+
+  # Push main
+  git push origin "$main_branch"
+
+  # Merge to develop if exists
+  if git show-ref --verify --quiet refs/heads/develop; then
+    echo "Merging to develop..."
+    git checkout develop
+    git pull origin develop
+    git merge "$hotfix_branch" --no-edit
+    git push origin develop
+  fi
+
+  # Merge to dev if exists
+  if git show-ref --verify --quiet refs/heads/dev; then
+    echo "Merging to dev..."
+    git checkout dev
+    git pull origin dev
+    git merge "$hotfix_branch" --no-edit
+    git push origin dev
+  fi
+
+  # Delete hotfix branch
+  read -p "Delete hotfix branch? (yes/no): " delete_branch
+  if [ "$delete_branch" == "yes" ]; then
+    git branch -d "$hotfix_branch"
+    git push origin --delete "$hotfix_branch"
+    echo "✅ Hotfix branch deleted"
+  fi
+
+  echo "✅ Hotfix merged back to main branches"
+}
+
+# Merge back
+merge_hotfix_back "$incident_id" "$hotfix_branch" "$hotfix_version"
+```
+
+### 11. Post-Mortem Report
+
+```bash
+generate_post_mortem() {
+  local incident_id=$1
+
+  echo "📝 Generating post-mortem report..."
+
+  # Load incident data
+  if [ ! -f ".hotfix-$incident_id.json" ]; then
+    echo "❌ Incident record not found"
+    return
+  fi
+
+  incident_data=$(cat ".hotfix-$incident_id.json")
+
+  # Create post-mortem
+  cat > "post-mortem-$incident_id.md" << EOF
+# Post-Mortem: $incident_id
+
+**Date:** $(date +%Y-%m-%d)
+**Severity:** $(echo "$incident_data" | jq -r '.severity')
+**Status:** $(echo "$incident_data" | jq -r '.status')
+
+## Incident Summary
+
+$(echo "$incident_data" | jq -r '.description')
+
+## Timeline
+
+- **Initiated:** $(echo "$incident_data" | jq -r '.timestamp')
+- **Fix Applied:** $(echo "$incident_data" | jq -r '.status')
+- **Deployed:** $(echo "$incident_data" | jq -r '.deployed_at // "N/A"')
+- **Verified:** $(echo "$incident_data" | jq -r '.verified_at // "N/A"')
+
+## Technical Details
+
+- **Hotfix Version:** $(echo "$incident_data" | jq -r '.hotfix_version')
+- **Base Version:** $(echo "$incident_data" | jq -r '.base_ref')
+- **Hotfix Branch:** $(echo "$incident_data" | jq -r '.hotfix_branch')
+
+## Impact
+
+- **Affected Systems:** $(echo "$incident_data" | jq -r '.affected_systems')
+- **User Impact:** $(echo "$incident_data" | jq -r '.user_impact')
+
+## Resolution
+
+$(echo "$incident_data" | jq -r '.issue_resolved // false' | \
+  sed 's/true/Issue successfully resolved/;s/false/Issue partially resolved/')
+
+## Changes Made
+
+\`\`\`
+$(git diff "v$(echo "$incident_data" | jq -r '.hotfix_version')^..v$(echo "$incident_data" | jq -r '.hotfix_version')" --stat)
+\`\`\`
+
+## Lessons Learned
+
+[To be filled by team]
+
+## Action Items
+
+- [ ] Root cause analysis
+- [ ] Update monitoring/alerts
+- [ ] Add preventive measures
+- [ ] Update documentation
+- [ ] Team debrief
+
+## Approval
+
+- **Approved By:** $(echo "$incident_data" | jq -r '.approved_by // "N/A"')
+- **Approved At:** $(echo "$incident_data" | jq -r '.approved_at // "N/A"')
+
+EOF
+
+  echo "✅ Post-mortem created: post-mortem-$incident_id.md"
+
+  # Clean up incident record
+  mv ".hotfix-$incident_id.json" "incident-$incident_id.json"
+}
+
+# Generate post-mortem
+generate_post_mortem "$incident_id"
+```
+
+### 12. Hotfix Notification
+
+```bash
+send_hotfix_alert() {
+  local incident_id=$1
+  local status=$2
+  local severity=$3
+  local message=$4
+
+  # Determine color based on severity
+  case $severity in
+    critical) color="16711680" ;; # Red
+    high) color="16744192" ;; # Orange
+    medium) color="16776960" ;; # Yellow
+    *) color="8421504" ;; # Gray
+  esac
+
+  # Slack notification
+  if [ -n "$SLACK_WEBHOOK_URL" ]; then
+    curl -X POST "$SLACK_WEBHOOK_URL" \
+      -H 'Content-Type: application/json' \
+      -d "{
+        \"text\": \"🚨 HOTFIX ALERT\",
+        \"blocks\": [
+          {
+            \"type\": \"header\",
+            \"text\": {
+              \"type\": \"plain_text\",
+              \"text\": \"🚨 HOTFIX: $incident_id\"
+            }
+          },
+          {
+            \"type\": \"section\",
+            \"fields\": [
+              {\"type\": \"mrkdwn\", \"text\": \"*Status:*\n$status\"},
+              {\"type\": \"mrkdwn\", \"text\": \"*Severity:*\n$severity\"},
+              {\"type\": \"mrkdwn\", \"text\": \"*Message:*\n$message\"}
+            ]
+          }
+        ]
+      }"
+  fi
+
+  # Discord notification (with @everyone for critical)
+  if [ -n "$DISCORD_WEBHOOK_URL" ]; then
+    mention=""
+    if [ "$severity" == "critical" ]; then
+      mention="@everyone "
+    fi
+
+    curl -X POST "$DISCORD_WEBHOOK_URL" \
+      -H 'Content-Type: application/json' \
+      -d "{
+        \"content\": \"${mention}🚨 **HOTFIX ALERT**\",
+        \"embeds\": [{
+          \"title\": \"Incident: $incident_id\",
+          \"fields\": [
+            {\"name\": \"Status\", \"value\": \"$status\", \"inline\": true},
+            {\"name\": \"Severity\", \"value\": \"$severity\", \"inline\": true},
+            {\"name\": \"Message\", \"value\": \"$message\"}
+          ],
+          \"color\": $color,
+          \"timestamp\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"
+        }]
+      }"
+  fi
+
+  # PagerDuty integration (for critical)
+  if [ "$severity" == "critical" ] && [ -n "$PAGERDUTY_API_KEY" ]; then
+    curl -X POST "https://api.pagerduty.com/incidents" \
+      -H "Authorization: Token token=$PAGERDUTY_API_KEY" \
+      -H "Content-Type: application/json" \
+      -d "{
+        \"incident\": {
+          \"type\": \"incident\",
+          \"title\": \"HOTFIX: $incident_id\",
+          \"service\": {\"id\": \"$PAGERDUTY_SERVICE_ID\", \"type\": \"service_reference\"},
+          \"urgency\": \"high\",
+          \"body\": {\"type\": \"incident_body\", \"details\": \"$message\"}
+        }
+      }"
+  fi
+}
+```
+
+## Complete Hotfix Script
+
+```bash
+#!/bin/bash
+set -e
+
+echo "🚨 EMERGENCY HOTFIX PROCEDURE"
+echo "═══════════════════════════════════════"
+
+# 1. Assess emergency
+incident_id=$(assess_hotfix_urgency)
+
+# 2. Create hotfix branch from production
+hotfix_branch=$(create_hotfix_branch "$incident_id")
+
+# 3. Apply fix
+apply_hotfix "$incident_id" "$hotfix_branch"
+
+# 4. Fast-track testing
+fast_track_testing "$incident_id"
+
+# 5. Request approval
+request_hotfix_approval "$incident_id" "$hotfix_branch"
+
+# 6. Create release
+hotfix_version=$(create_hotfix_release "$incident_id" "$hotfix_branch")
+
+# 7. Emergency deploy
+emergency_deploy "$incident_id" "$hotfix_version"
+
+# 8. Verify deployment
+verify_hotfix "$incident_id" "$hotfix_version"
+
+# 9. Merge back
+merge_hotfix_back "$incident_id" "$hotfix_branch" "$hotfix_version"
+
+# 10. Generate post-mortem
+generate_post_mortem "$incident_id"
+
+# 11. Final notification
+send_hotfix_alert "$incident_id" "completed" "high" "Hotfix v$hotfix_version deployed and verified"
+
+echo "✅ HOTFIX COMPLETE"
+echo "Incident ID: $incident_id"
+echo "Version: v$hotfix_version"
+```
+
+## Quick Hotfix Commands
+
+```bash
+# Start hotfix procedure
+/myai-git-hotfix
+
+# Emergency rollback
+/myai-git-hotfix --rollback
+
+# Generate post-mortem only
+/myai-git-hotfix --post-mortem <incident-id>
+```
+
+## Environment Configuration
+
+```bash
+# Production
+PROD_URL=https://your-app.com
+
+# Coolify
+COOLIFY_URL=https://coolify.your-server.com
+COOLIFY_API_TOKEN=your_token
+COOLIFY_PROD_APP_ID=your_app_id
+
+# Docker
+DOCKER_REGISTRY=registry.your-domain.com
+
+# Notifications (CRITICAL)
+SLACK_WEBHOOK_URL=https://hooks.slack.com/services/YOUR/WEBHOOK
+DISCORD_WEBHOOK_URL=https://discord.com/api/webhooks/YOUR/WEBHOOK
+PAGERDUTY_API_KEY=your_pagerduty_key
+PAGERDUTY_SERVICE_ID=your_service_id
+
+# Team
+ONCALL_EMAIL=oncall@yourcompany.com
+TEAM_CHANNEL=#incidents
+```
+
+Execute emergency hotfix procedure with fast-track deployment and rollback safeguards.