myaidev-method 0.2.4 → 0.2.6

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

@@ -0,0 +1,512 @@
+# Create and deploy emergency hotfixes with fast-track procedures
+
+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 ""
+
+  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"
+
+  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"
+}
+
+# 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
+
+  # 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
+
+  echo "✅ Fast-track tests passed"
+}
+
+# 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 ""
+
+  # Require explicit approval
+  if [ -f ".hotfix-$incident_id.json" ]; then
+    severity=$(jq -r '.severity' ".hotfix-$incident_id.json")
+
+    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
+  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"
+}
+
+# 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"
+  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 "═══════════════════════════════════════"
+
+  # Deployment method selection
+  if [ -n "$COOLIFY_URL" ] && [ -n "$COOLIFY_PROD_APP_ID" ]; then
+    # Coolify method
+    echo "🚀 Deploying via Coolify..."
+
+    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$hotfix_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"
+
+  elif [ -n "$DOCKER_REGISTRY" ]; then
+    # Docker method
+    echo "🐳 Deploying via Docker..."
+
+    docker build -t "$DOCKER_REGISTRY/app:v$hotfix_version" .
+    docker push "$DOCKER_REGISTRY/app:v$hotfix_version"
+
+    ssh prod-server << EOF
+      docker pull $DOCKER_REGISTRY/app:v$hotfix_version
+      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$hotfix_version
+EOF
+
+    echo "✅ Deployed via Docker"
+  else
+    echo "❌ No deployment method configured"
+    exit 1
+  fi
+
+  # 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. 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
+
+  # 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"
+```
+
+## 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. Merge back
+merge_hotfix_back "$incident_id" "$hotfix_branch" "$hotfix_version"
+
+echo "✅ HOTFIX COMPLETE"
+echo "Incident ID: $incident_id"
+echo "Version: v$hotfix_version"
+```
+
+## 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
+```
+
+Execute emergency hotfix procedure with fast-track deployment and rollback safeguards.

package/src/templates/codex/commands/myai-git-pr.md

@@ -0,0 +1,196 @@
+# Create and manage GitHub Pull Requests with AI assistance
+
+You are a Git and GitHub workflow assistant specializing in creating professional pull requests.
+
+Task: $ARGUMENTS
+
+## Pull Request Workflow
+
+### 1. Analyze Current State
+```bash
+git status
+git branch
+git diff main...HEAD
+git log --oneline -10
+```
+
+### 2. Create Pull Request
+
+**Analyze Changes:**
+- Review all commits since branch diverged from main
+- Identify the core feature/fix being implemented
+- Note any breaking changes or migrations
+- Check for related issues or tickets
+
+**PR Title Format:**
+- Feature: `feat: Add user authentication with JWT`
+- Fix: `fix: Resolve memory leak in WebSocket connection`
+- Docs: `docs: Update API documentation for v2.0`
+- Refactor: `refactor: Optimize database query performance`
+- Chore: `chore: Update dependencies to latest versions`
+
+**PR Description Template:**
+```markdown
+## Summary
+[2-3 sentence overview of what this PR does]
+
+## Changes
+- **Feature/Component 1**: [What changed and why]
+- **Feature/Component 2**: [What changed and why]
+- **Tests**: [Testing added/updated]
+
+## Type of Change
+- [ ] Bug fix (non-breaking change fixing an issue)
+- [ ] New feature (non-breaking change adding functionality)
+- [ ] Breaking change (fix or feature causing existing functionality to break)
+- [ ] Documentation update
+
+## Testing
+- [ ] Unit tests pass locally
+- [ ] Integration tests pass locally
+- [ ] Manual testing completed
+- [ ] No console errors or warnings
+
+## Checklist
+- [ ] Code follows project style guidelines
+- [ ] Self-review completed
+- [ ] Comments added for complex logic
+- [ ] Documentation updated
+- [ ] No new warnings generated
+- [ ] Tests added/updated for changes
+- [ ] All tests passing
+
+## Related Issues
+Closes #[issue number]
+Fixes #[issue number]
+Relates to #[issue number]
+
+## Screenshots (if applicable)
+[Add screenshots or GIFs demonstrating the changes]
+
+## Deployment Notes
+[Any special deployment considerations]
+```
+
+### 3. Create PR Using GitHub CLI
+
+```bash
+# Ensure branch is pushed
+git push -u origin $(git branch --show-current)
+
+# Create PR with gh CLI
+gh pr create \
+  --title "Your PR Title" \
+  --body "$(cat <<'EOF'
+[Your PR description from template above]
+EOF
+)" \
+  --base main \
+  --head $(git branch --show-current)
+
+# Or with labels and reviewers
+gh pr create \
+  --title "Your PR Title" \
+  --body-file pr_description.md \
+  --label "enhancement" \
+  --reviewer @team-member \
+  --assignee @me
+```
+
+### 4. PR Review Checklist
+
+**Code Quality:**
+- [ ] No hardcoded credentials or secrets
+- [ ] Error handling implemented
+- [ ] Input validation in place
+- [ ] Logging appropriate and not excessive
+- [ ] No commented-out code blocks
+
+**Testing:**
+- [ ] Unit tests cover new code
+- [ ] Integration tests updated
+- [ ] Edge cases tested
+- [ ] Error scenarios tested
+
+**Documentation:**
+- [ ] README updated if needed
+- [ ] API docs updated
+- [ ] Code comments for complex logic
+- [ ] CHANGELOG updated
+
+**Security:**
+- [ ] No SQL injection vulnerabilities
+- [ ] XSS prevention in place
+- [ ] Authentication/authorization correct
+- [ ] Dependencies have no known vulnerabilities
+
+### 5. Managing PR
+
+```bash
+# Check PR status
+gh pr status
+
+# View PR details
+gh pr view [pr-number]
+
+# Add reviewers
+gh pr edit [pr-number] --add-reviewer username
+
+# Mark as ready for review
+gh pr ready [pr-number]
+
+# Merge PR (after approval)
+gh pr merge [pr-number] --squash --delete-branch
+
+# Or merge with merge commit
+gh pr merge [pr-number] --merge --delete-branch
+
+# Or rebase and merge
+gh pr merge [pr-number] --rebase --delete-branch
+```
+
+## Common PR Scenarios
+
+### Scenario 1: Feature PR
+```bash
+# From feature branch
+git checkout -b feature/user-profile
+# ... make changes ...
+git add .
+git commit -m "feat: Add user profile management"
+git push -u origin feature/user-profile
+gh pr create --title "feat: Add user profile management" --base main
+```
+
+### Scenario 2: Hotfix PR
+```bash
+git checkout -b hotfix/security-patch main
+# ... fix critical issue ...
+git commit -m "fix: Patch SQL injection vulnerability"
+git push -u origin hotfix/security-patch
+gh pr create --title "fix: Patch SQL injection vulnerability" --label "security,urgent" --base main
+```
+
+### Scenario 3: Update PR with Feedback
+```bash
+# Make requested changes
+git add .
+git commit -m "Address PR feedback: improve error handling"
+git push
+
+# Add comment to PR
+gh pr comment [pr-number] --body "Updated with requested changes"
+```
+
+## Best Practices
+
+1. **Keep PRs Small**: Aim for <400 lines of code changed
+2. **Single Purpose**: One feature/fix per PR
+3. **Clear Title**: Use conventional commit format
+4. **Detailed Description**: Explain what, why, and how
+5. **Self-Review First**: Review your own code before creating PR
+6. **Update Branch**: Keep feature branch up-to-date with main
+7. **Respond Quickly**: Address review comments promptly
+8. **Clean Commits**: Squash fixup commits before merge
+
+Execute the PR workflow based on the current repository state and task requirements.