myaidev-method 0.2.5 → 0.2.7

package/src/templates/claude/commands/myai-deploy-dev.md

@@ -0,0 +1,500 @@
+---
+name: myai-deploy-dev
+description: Deploy to development environment via Coolify or Docker
+tools: [bash, read, write]
+---
+
+You are a deployment automation assistant specializing in development environment deployments.
+
+Task: Deploy to development environment - $ARGUMENTS
+
+## Development Deployment Workflow
+
+### 1. Pre-Deployment Checks
+
+```bash
+# Check current branch and status
+git branch --show-current
+git status
+
+# Ensure on dev branch
+if [ "$(git branch --show-current)" != "dev" ] && [ "$(git branch --show-current)" != "develop" ]; then
+  echo "⚠️  Not on dev/develop branch. Switch first."
+  git checkout dev || git checkout develop
+fi
+
+# Pull latest changes
+git pull origin $(git branch --show-current)
+
+# Check for uncommitted changes (warning only, not blocking)
+if ! git diff-index --quiet HEAD --; then
+  echo "⚠️  Uncommitted changes detected (non-blocking for dev)"
+  git status
+fi
+```
+
+### 2. Environment Validation
+
+**Check Required Environment Variables:**
+```bash
+# For Coolify
+required_vars=("COOLIFY_URL" "COOLIFY_API_TOKEN" "COOLIFY_DEV_APP_ID")
+
+# For Docker
+docker_vars=("DOCKER_REGISTRY" "DEV_IMAGE_TAG")
+
+# Check Coolify vars
+missing_vars=()
+for var in "${required_vars[@]}"; do
+  if [ -z "${!var}" ]; then
+    missing_vars+=("$var")
+  fi
+done
+
+# If Coolify vars missing, check Docker vars
+if [ ${#missing_vars[@]} -gt 0 ]; then
+  echo "⚠️  Coolify variables not set, checking Docker..."
+  for var in "${docker_vars[@]}"; do
+    if [ -z "${!var}" ]; then
+      echo "❌ Missing required variable: $var"
+      exit 1
+    fi
+  done
+fi
+```
+
+### 3. Quick Build and Test
+
+```bash
+# Run minimal tests for faster deployment
+echo "🧪 Running quick test suite..."
+npm run test:unit || echo "⚠️  Unit tests failed (non-blocking for dev)"
+
+# Build application
+echo "🏗️  Building application..."
+npm run build || { echo "❌ Build failed"; exit 1; }
+
+# Skip linter for dev (optional)
+# npm run lint || echo "⚠️  Linting issues detected"
+```
+
+### 4. Deployment Options
+
+#### Option A: Deploy with Coolify
+
+```bash
+# Using Coolify API
+echo "🚀 Deploying to Coolify dev environment..."
+
+# Trigger 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_DEV_APP_ID\",
+    \"force\": true,
+    \"commit\": \"$(git rev-parse HEAD)\"
+  }")
+
+http_code=$(echo "$response" | tail -1)
+body=$(echo "$response" | head -n -1)
+
+if [ "$http_code" -ne 200 ] && [ "$http_code" -ne 201 ]; then
+  echo "❌ Deployment trigger failed with status $http_code"
+  echo "$body"
+  exit 1
+fi
+
+echo "✅ Deployment triggered successfully!"
+
+# Quick status check (don't wait for completion)
+echo "📊 Deployment initiated. Check Coolify dashboard for progress."
+echo "🌐 Dashboard: $COOLIFY_URL/applications/$COOLIFY_DEV_APP_ID"
+```
+
+#### Option B: Deploy with Docker
+
+```bash
+echo "🐳 Deploying with Docker..."
+
+# Build Docker image with dev tag
+docker build -t $DOCKER_REGISTRY/app:dev -f Dockerfile.dev .
+
+# Push to registry
+docker push $DOCKER_REGISTRY/app:dev
+
+# Deploy to dev server via SSH
+ssh dev-server << 'EOF'
+  # Pull latest image
+  docker pull $DOCKER_REGISTRY/app:dev
+
+  # Stop and remove old container
+  docker stop app-dev 2>/dev/null || true
+  docker rm app-dev 2>/dev/null || true
+
+  # Run new container
+  docker run -d \
+    --name app-dev \
+    --restart unless-stopped \
+    -p 3000:3000 \
+    --env-file /etc/app/dev.env \
+    -e NODE_ENV=development \
+    $DOCKER_REGISTRY/app:dev
+
+  # Show container status
+  docker ps | grep app-dev
+EOF
+
+echo "✅ Docker deployment complete!"
+```
+
+#### Option C: Deploy with Docker Compose
+
+```bash
+echo "🐳 Deploying with Docker Compose..."
+
+# Deploy to dev server
+ssh dev-server << 'EOF'
+  cd /opt/app
+  git pull origin dev
+  docker-compose -f docker-compose.dev.yml pull
+  docker-compose -f docker-compose.dev.yml up -d --remove-orphans --force-recreate
+  docker-compose -f docker-compose.dev.yml ps
+EOF
+
+echo "✅ Docker Compose deployment complete!"
+```
+
+#### Option D: Hot Reload Development (Watch Mode)
+
+```bash
+echo "🔥 Setting up hot-reload development deployment..."
+
+# Sync code to dev server with watch
+rsync -avz --delete \
+  --exclude 'node_modules' \
+  --exclude '.git' \
+  --exclude 'dist' \
+  ./ dev-server:/opt/app/
+
+# Start development server with hot reload
+ssh dev-server << 'EOF'
+  cd /opt/app
+  npm install
+  pm2 restart app-dev || pm2 start npm --name app-dev -- run dev
+  pm2 logs app-dev --lines 20
+EOF
+
+echo "✅ Hot-reload deployment active!"
+echo "💡 Changes will auto-reload on the dev server"
+```
+
+### 5. Post-Deployment Verification
+
+```bash
+echo "🔍 Verifying deployment..."
+
+# Quick health check (shorter timeout for dev)
+max_retries=10
+retry_count=0
+
+while [ $retry_count -lt $max_retries ]; do
+  if curl -f -s "$DEV_URL/health" > /dev/null 2>&1; then
+    echo "✅ Health check passed!"
+    break
+  else
+    echo "⏳ Waiting for application... ($retry_count/$max_retries)"
+    sleep 3
+    ((retry_count++))
+  fi
+done
+
+if [ $retry_count -eq $max_retries ]; then
+  echo "⚠️  Health check timeout (non-critical for dev)"
+  echo "Check logs: $COOLIFY_URL/applications/$COOLIFY_DEV_APP_ID/logs"
+fi
+
+# Quick smoke test
+echo "🧪 Running quick smoke test..."
+response=$(curl -s -o /dev/null -w "%{http_code}" "$DEV_URL/")
+if [ "$response" -eq 200 ]; then
+  echo "✅ Application responding correctly"
+else
+  echo "⚠️  Application returned status: $response"
+fi
+
+# Show recent logs
+echo "📋 Recent logs:"
+if [ -n "$COOLIFY_URL" ]; then
+  curl -s "$COOLIFY_URL/api/v1/applications/$COOLIFY_DEV_APP_ID/logs" \
+    -H "Authorization: Bearer $COOLIFY_API_TOKEN" | tail -20
+else
+  ssh dev-server "docker logs --tail 20 app-dev" || \
+  ssh dev-server "pm2 logs app-dev --lines 20 --nostream"
+fi
+```
+
+### 6. Rollback Procedure
+
+```bash
+rollback_dev() {
+  echo "🔄 Rolling back dev deployment..."
+
+  # Get previous commit
+  previous_commit=$(git log --oneline -2 | tail -1 | cut -d' ' -f1)
+  echo "Rolling back to: $previous_commit"
+
+  # 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_DEV_APP_ID\",
+        \"commit\": \"$previous_commit\",
+        \"force\": true
+      }"
+  fi
+
+  # Or rollback via Docker
+  if [ -n "$DOCKER_REGISTRY" ]; then
+    ssh dev-server << EOF
+      docker pull $DOCKER_REGISTRY/app:dev-previous
+      docker stop app-dev
+      docker rm app-dev
+      docker run -d \
+        --name app-dev \
+        --restart unless-stopped \
+        -p 3000:3000 \
+        $DOCKER_REGISTRY/app:dev-previous
+EOF
+  fi
+
+  # Or rollback via git
+  if [ -n "$DEV_SERVER_PATH" ]; then
+    ssh dev-server << EOF
+      cd /opt/app
+      git checkout $previous_commit
+      npm install
+      npm run build
+      pm2 restart app-dev
+EOF
+  fi
+
+  echo "✅ Rollback complete!"
+}
+
+# Call rollback if needed
+# rollback_dev
+```
+
+### 7. Auto-Deploy on Push (CI/CD Setup)
+
+```bash
+setup_auto_deploy() {
+  echo "⚙️  Setting up auto-deploy for dev branch..."
+
+  # Create GitHub Actions workflow
+  cat > .github/workflows/deploy-dev.yml << 'EOF'
+name: Deploy to Dev
+
+on:
+  push:
+    branches: [dev, develop]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: '18'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build
+        run: npm run build
+
+      - name: Deploy to Coolify
+        env:
+          COOLIFY_URL: ${{ secrets.COOLIFY_URL }}
+          COOLIFY_API_TOKEN: ${{ secrets.COOLIFY_API_TOKEN }}
+          COOLIFY_DEV_APP_ID: ${{ secrets.COOLIFY_DEV_APP_ID }}
+        run: |
+          curl -X POST "$COOLIFY_URL/api/v1/deploy" \
+            -H "Authorization: Bearer $COOLIFY_API_TOKEN" \
+            -H "Content-Type: application/json" \
+            -d "{\"application_id\":\"$COOLIFY_DEV_APP_ID\",\"commit\":\"$GITHUB_SHA\"}"
+
+      - name: Notify
+        if: always()
+        env:
+          SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK_URL }}
+        run: |
+          curl -X POST "$SLACK_WEBHOOK" \
+            -H 'Content-Type: application/json' \
+            -d '{"text":"🚀 Dev deployment completed"}'
+EOF
+
+  echo "✅ Auto-deploy workflow created!"
+  echo "💡 Configure secrets in GitHub repository settings"
+}
+
+# Call setup if needed
+# setup_auto_deploy
+```
+
+### 8. Deployment Notification
+
+```bash
+send_deployment_notification() {
+  local status=$1
+  local commit_sha=$(git rev-parse HEAD)
+  local commit_msg=$(git log -1 --pretty=%B)
+  local deployed_by=$(git config user.name)
+  local branch=$(git branch --show-current)
+
+  # Slack notification (if webhook configured)
+  if [ -n "$SLACK_WEBHOOK_URL" ]; then
+    curl -X POST "$SLACK_WEBHOOK_URL" \
+      -H 'Content-Type: application/json' \
+      -d "{
+        \"text\": \"🔧 Dev Deployment $status\",
+        \"blocks\": [
+          {
+            \"type\": \"section\",
+            \"text\": {
+              \"type\": \"mrkdwn\",
+              \"text\": \"*Dev Deployment $status*\n*Branch:* $branch\n*Commit:* \`$commit_sha\`\n*Message:* $commit_msg\n*Deployed by:* $deployed_by\n*Environment:* Development\"
+            }
+          }
+        ]
+      }"
+  fi
+
+  # Discord notification (if webhook configured)
+  if [ -n "$DISCORD_WEBHOOK_URL" ]; then
+    curl -X POST "$DISCORD_WEBHOOK_URL" \
+      -H 'Content-Type: application/json' \
+      -d "{
+        \"content\": \"🔧 **Dev Deployment $status**\",
+        \"embeds\": [{
+          \"title\": \"Development Deployment\",
+          \"color\": 3447003,
+          \"fields\": [
+            {\"name\": \"Branch\", \"value\": \"$branch\", \"inline\": true},
+            {\"name\": \"Commit\", \"value\": \"$commit_sha\", \"inline\": true},
+            {\"name\": \"Message\", \"value\": \"$commit_msg\"},
+            {\"name\": \"Deployed by\", \"value\": \"$deployed_by\", \"inline\": true}
+          ],
+          \"timestamp\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"
+        }]
+      }"
+  fi
+}
+
+# Send notification
+send_deployment_notification "Success"
+```
+
+## Complete Deployment Script
+
+```bash
+#!/bin/bash
+set -e
+
+echo "🚀 Starting dev deployment..."
+
+# 1. Quick pre-flight checks
+current_branch=$(git branch --show-current)
+if [[ "$current_branch" != "dev" && "$current_branch" != "develop" ]]; then
+  echo "⚠️  Not on dev branch, switching..."
+  git checkout dev || git checkout develop
+fi
+
+git pull origin $(git branch --show-current)
+
+# 2. Build (tests optional for dev)
+echo "🏗️  Building..."
+npm run build || { echo "❌ Build failed"; exit 1; }
+
+# 3. Deploy (choose method)
+if [ -n "$COOLIFY_DEV_APP_ID" ]; then
+  # Coolify method
+  echo "🚀 Deploying via Coolify..."
+  curl -X POST "$COOLIFY_URL/api/v1/deploy" \
+    -H "Authorization: Bearer $COOLIFY_API_TOKEN" \
+    -H "Content-Type: application/json" \
+    -d "{\"application_id\":\"$COOLIFY_DEV_APP_ID\",\"commit\":\"$(git rev-parse HEAD)\",\"force\":true}"
+elif [ -n "$DOCKER_REGISTRY" ]; then
+  # Docker method
+  echo "🐳 Deploying via Docker..."
+  docker build -t $DOCKER_REGISTRY/app:dev .
+  docker push $DOCKER_REGISTRY/app:dev
+  ssh dev-server "docker pull $DOCKER_REGISTRY/app:dev && docker stop app-dev; docker rm app-dev; docker run -d --name app-dev -p 3000:3000 $DOCKER_REGISTRY/app:dev"
+else
+  echo "❌ No deployment method configured"
+  exit 1
+fi
+
+# 4. Quick verify
+sleep 5
+curl -f "$DEV_URL/health" || echo "⚠️  Health check failed (non-critical)"
+
+# 5. Notify
+send_deployment_notification "Success"
+
+echo "✅ Dev deployment complete!"
+echo "🌐 Application: $DEV_URL"
+```
+
+## Environment Configuration
+
+**Required .env variables:**
+```bash
+# Coolify
+COOLIFY_URL=https://coolify.your-server.com
+COOLIFY_API_TOKEN=your_api_token
+COOLIFY_DEV_APP_ID=your_dev_app_id
+
+# Docker (alternative)
+DOCKER_REGISTRY=registry.your-domain.com
+DEV_IMAGE_TAG=dev
+
+# Application
+DEV_URL=https://dev.your-app.com
+
+# Server (optional for direct deployment)
+DEV_SERVER=dev-server.your-domain.com
+DEV_SERVER_PATH=/opt/app
+
+# Notifications (optional)
+SLACK_WEBHOOK_URL=https://hooks.slack.com/services/YOUR/WEBHOOK/URL
+DISCORD_WEBHOOK_URL=https://discord.com/api/webhooks/YOUR/WEBHOOK
+```
+
+## Development Tips
+
+**Fast iteration workflow:**
+```bash
+# Watch mode with auto-deploy
+npm run dev -- --watch
+
+# Or use rsync for live sync
+while inotifywait -r -e modify,create,delete src/; do
+  rsync -avz src/ dev-server:/opt/app/src/
+done
+```
+
+**Skip tests for rapid deployment:**
+```bash
+export SKIP_TESTS=true
+/myai-deploy-dev --quick
+```
+
+Execute the dev deployment workflow with minimal checks for fast iteration.