myaidev-method 0.2.5 → 0.2.6

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

@@ -0,0 +1,953 @@
+prompt = """
+
+Task: Create and deploy hotfix - {{args}}
+
+## 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.
+
+"""