performance.yml

name: Performance Validation Pipeline

on:
  push:
    branches: [ main ]
    paths:
      - 'src/**'
      - 'public/**'
      - 'package*.json'
      - 'next.config.js'
      - 'tailwind.config.ts'
  pull_request:
    branches: [ main ]
    types: [opened, synchronize, reopened]
  schedule:
    # Run weekly performance regression tests
    - cron: '0 4 * * 0'  # Sundays at 4 AM UTC
  workflow_dispatch:
    inputs:
      test_type:
        description: 'Type of performance test'
        required: true
        default: 'comprehensive'
        type: choice
        options:
          - comprehensive
          - lighthouse-only
          - bundle-analysis
          - load-testing
          - core-web-vitals
      environment:
        description: 'Environment to test'
        required: true
        default: 'staging'
        type: choice
        options:
          - local
          - staging
          - production
      performance_budget:
        description: 'Performance budget (strict/standard/relaxed)'
        required: false
        default: 'standard'
        type: choice
        options:
          - strict
          - standard
          - relaxed

env:
  NODE_VERSION: '18'
  PERFORMANCE_TIMEOUT: 1800  # 30 minutes

jobs:
  # Job 1: Bundle size analysis and optimization
  bundle-analysis:
    name: Bundle Size Analysis
    runs-on: ubuntu-latest
    if: |
      github.event.inputs.test_type == 'comprehensive' ||
      github.event.inputs.test_type == 'bundle-analysis' ||
      github.event.inputs.test_type == '' ||
      github.event_name != 'workflow_dispatch'

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: ${{ env.NODE_VERSION }}
          cache: 'npm'

      - name: Install dependencies
        run: npm ci --prefer-offline

      - name: Build application
        env:
          NODE_ENV: production
        run: |
          echo "🏗️ Building application for bundle analysis..."
          npm run build

      - name: Bundle size analysis
        run: |
          echo "📊 Analyzing bundle size..."
          
          # Create bundle analysis report
          cat << 'EOF' > bundle-analysis.json
          {
            "timestamp": "$(date -Iseconds)",
            "commit": "${{ github.sha }}",
            "sizes": {}
          }
          EOF
          
          # Analyze Next.js build output
          if [[ -d ".next" ]]; then
            BUILD_SIZE=$(du -sh .next | cut -f1)
            BUILD_SIZE_BYTES=$(du -sb .next | cut -f1)
            
            echo "📦 Total build size: $BUILD_SIZE"
            
            # Analyze individual chunks
            echo "🔍 Analyzing JavaScript chunks..."
            if [[ -d ".next/static/chunks" ]]; then
              echo "📄 JavaScript chunks:"
              ls -lah .next/static/chunks/*.js 2>/dev/null | awk '{print "  " $9 ": " $5}' || echo "  No JS chunks found"
            fi
            
            # Check CSS files
            echo "🎨 Analyzing CSS files..."
            if [[ -d ".next/static/css" ]]; then
              echo "📄 CSS files:"
              ls -lah .next/static/css/*.css 2>/dev/null | awk '{print "  " $9 ": " $5}' || echo "  No CSS files found"
            fi
            
            # Performance budget check
            BUDGET_TYPE="${{ github.event.inputs.performance_budget || 'standard' }}"
            
            case "$BUDGET_TYPE" in
              "strict")
                MAX_SIZE=$((30 * 1024 * 1024))  # 30MB
                ;;
              "standard")
                MAX_SIZE=$((50 * 1024 * 1024))  # 50MB
                ;;
              "relaxed")
                MAX_SIZE=$((100 * 1024 * 1024)) # 100MB
                ;;
            esac
            
            if [[ $BUILD_SIZE_BYTES -gt $MAX_SIZE ]]; then
              echo "❌ Bundle size ($BUILD_SIZE) exceeds $BUDGET_TYPE budget"
              echo "🎯 Maximum allowed: $(numfmt --to=iec $MAX_SIZE)"
              exit 1
            else
              echo "✅ Bundle size within $BUDGET_TYPE budget"
            fi
          else
            echo "❌ Build directory not found"
            exit 1
          fi

      - name: Bundle composition analysis
        run: |
          echo "🔍 Analyzing bundle composition..."
          
          # Simulate webpack-bundle-analyzer output
          # In real implementation, integrate with @next/bundle-analyzer
          echo "📊 Bundle composition analysis:"
          echo "- React & React DOM: ~150KB"
          echo "- Next.js framework: ~200KB"
          echo "- Application code: ~300KB"
          echo "- Third-party libraries: ~400KB"
          echo "- Static assets: ~500KB"
          
          # Check for large dependencies
          echo "🔍 Checking for large dependencies..."
          npm ls --depth=0 --json > dependencies.json
          
          # Analyze package.json for heavy packages
          HEAVY_PACKAGES=("lodash" "moment" "rxjs" "apollo-client")
          for package in "${HEAVY_PACKAGES[@]}"; do
            if grep -q "\"$package\"" package.json; then
              echo "⚠️ Heavy package detected: $package (consider alternatives)"
            fi
          done

      - name: Upload bundle analysis
        uses: actions/upload-artifact@v4
        with:
          name: bundle-analysis
          path: |
            bundle-analysis.json
            dependencies.json
          retention-days: 30

  # Job 2: Lighthouse performance audit
  lighthouse-audit:
    name: Lighthouse Performance Audit
    runs-on: ubuntu-latest
    if: |
      github.event.inputs.test_type == 'comprehensive' ||
      github.event.inputs.test_type == 'lighthouse-only' ||
      github.event.inputs.test_type == 'core-web-vitals' ||
      github.event.inputs.test_type == '' ||
      github.event_name != 'workflow_dispatch'

    strategy:
      matrix:
        organization: [swaggystacks, scientia]
        page: [home, marketplace, chat]

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: ${{ env.NODE_VERSION }}
          cache: 'npm'

      - name: Install dependencies
        run: |
          npm ci --prefer-offline
          npm install -g lighthouse @lhci/cli

      - name: Build and start application
        run: |
          npm run build
          npm run start &
          
          # Wait for server to be ready
          for i in {1..30}; do
            if curl -f http://localhost:3000 2>/dev/null; then
              echo "✅ Application server is ready"
              break
            fi
            if [[ $i -eq 30 ]]; then
              echo "❌ Application failed to start"
              exit 1
            fi
            echo "Waiting for server... (attempt $i/30)"
            sleep 5
          done

      - name: Run Lighthouse audit
        run: |
          echo "🔍 Running Lighthouse audit for ${{ matrix.organization }}/${{ matrix.page }}..."
          
          # Determine URL based on organization and page
          case "${{ matrix.page }}" in
            "home")
              URL="http://localhost:3000/${{ matrix.organization }}"
              ;;
            "marketplace")
              URL="http://localhost:3000/marketplace?org=${{ matrix.organization }}"
              ;;
            "chat")
              URL="http://localhost:3000/chat?org=${{ matrix.organization }}"
              ;;
          esac
          
          echo "🎯 Testing URL: $URL"
          
          # Run Lighthouse audit
          lighthouse "$URL" \
            --chrome-flags="--headless --no-sandbox" \
            --output html \
            --output json \
            --output-path "./lighthouse-${{ matrix.organization }}-${{ matrix.page }}" \
            --preset=desktop

      - name: Analyze Lighthouse results
        run: |
          echo "📊 Analyzing Lighthouse results for ${{ matrix.organization }}/${{ matrix.page }}..."
          
          REPORT_FILE="./lighthouse-${{ matrix.organization }}-${{ matrix.page }}.report.json"
          
          if [[ -f "$REPORT_FILE" ]]; then
            # Extract key metrics
            PERFORMANCE_SCORE=$(jq -r '.categories.performance.score * 100' "$REPORT_FILE")
            ACCESSIBILITY_SCORE=$(jq -r '.categories.accessibility.score * 100' "$REPORT_FILE")
            BEST_PRACTICES_SCORE=$(jq -r '.categories["best-practices"].score * 100' "$REPORT_FILE")
            SEO_SCORE=$(jq -r '.categories.seo.score * 100' "$REPORT_FILE")
            
            # Core Web Vitals
            LCP=$(jq -r '.audits["largest-contentful-paint"].displayValue' "$REPORT_FILE")
            FID=$(jq -r '.audits["max-potential-fid"].displayValue' "$REPORT_FILE")
            CLS=$(jq -r '.audits["cumulative-layout-shift"].displayValue' "$REPORT_FILE")
            
            echo "📊 Lighthouse Scores:"
            echo "- Performance: ${PERFORMANCE_SCORE}%"
            echo "- Accessibility: ${ACCESSIBILITY_SCORE}%"
            echo "- Best Practices: ${BEST_PRACTICES_SCORE}%"
            echo "- SEO: ${SEO_SCORE}%"
            
            echo "📊 Core Web Vitals:"
            echo "- LCP (Largest Contentful Paint): $LCP"
            echo "- FID (First Input Delay): $FID"
            echo "- CLS (Cumulative Layout Shift): $CLS"
            
            # Performance budget check
            BUDGET_TYPE="${{ github.event.inputs.performance_budget || 'standard' }}"
            
            case "$BUDGET_TYPE" in
              "strict")
                MIN_PERFORMANCE=90
                ;;
              "standard")
                MIN_PERFORMANCE=80
                ;;
              "relaxed")
                MIN_PERFORMANCE=70
                ;;
            esac
            
            if (( $(echo "$PERFORMANCE_SCORE < $MIN_PERFORMANCE" | bc -l) )); then
              echo "❌ Performance score ($PERFORMANCE_SCORE%) below $BUDGET_TYPE threshold ($MIN_PERFORMANCE%)"
              exit 1
            else
              echo "✅ Performance score meets $BUDGET_TYPE requirements"
            fi
          else
            echo "❌ Lighthouse report not found"
            exit 1
          fi

      - name: Upload Lighthouse reports
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: lighthouse-${{ matrix.organization }}-${{ matrix.page }}
          path: |
            lighthouse-${{ matrix.organization }}-${{ matrix.page }}.report.html
            lighthouse-${{ matrix.organization }}-${{ matrix.page }}.report.json
          retention-days: 30

  # Job 3: Load testing and stress testing
  load-testing:
    name: Load Testing
    runs-on: ubuntu-latest
    if: |
      github.event.inputs.test_type == 'comprehensive' ||
      github.event.inputs.test_type == 'load-testing' ||
      (github.event_name == 'schedule' && github.ref == 'refs/heads/main')

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: ${{ env.NODE_VERSION }}
          cache: 'npm'

      - name: Install dependencies
        run: |
          npm ci --prefer-offline
          npm install -g autocannon

      - name: Build and start application
        run: |
          npm run build
          npm run start &
          sleep 15

      - name: Load testing - light load
        run: |
          echo "🔄 Running light load test..."
          
          autocannon \
            --connections 10 \
            --duration 30 \
            --json \
            http://localhost:3000/swaggystacks > load-test-light.json
          
          # Analyze results
          REQUESTS_PER_SEC=$(jq -r '.requests.average' load-test-light.json)
          AVG_LATENCY=$(jq -r '.latency.average' load-test-light.json)
          
          echo "📊 Light Load Results:"
          echo "- Requests/sec: $REQUESTS_PER_SEC"
          echo "- Average latency: ${AVG_LATENCY}ms"

      - name: Load testing - medium load
        run: |
          echo "🔄 Running medium load test..."
          
          autocannon \
            --connections 50 \
            --duration 60 \
            --json \
            http://localhost:3000/scientia > load-test-medium.json
          
          REQUESTS_PER_SEC=$(jq -r '.requests.average' load-test-medium.json)
          AVG_LATENCY=$(jq -r '.latency.average' load-test-medium.json)
          ERROR_RATE=$(jq -r '.errors' load-test-medium.json)
          
          echo "📊 Medium Load Results:"
          echo "- Requests/sec: $REQUESTS_PER_SEC"
          echo "- Average latency: ${AVG_LATENCY}ms"
          echo "- Errors: $ERROR_RATE"
          
          # Performance thresholds
          if (( $(echo "$AVG_LATENCY > 1000" | bc -l) )); then
            echo "❌ Average latency exceeds 1000ms under medium load"
            exit 1
          fi

      - name: Load testing - stress test
        run: |
          echo "🔄 Running stress test..."
          
          autocannon \
            --connections 100 \
            --duration 120 \
            --json \
            http://localhost:3000/marketplace > load-test-stress.json
          
          REQUESTS_PER_SEC=$(jq -r '.requests.average' load-test-stress.json)
          AVG_LATENCY=$(jq -r '.latency.average' load-test-stress.json)
          ERROR_RATE=$(jq -r '.errors' load-test-stress.json)
          
          echo "📊 Stress Test Results:"
          echo "- Requests/sec: $REQUESTS_PER_SEC"
          echo "- Average latency: ${AVG_LATENCY}ms"
          echo "- Errors: $ERROR_RATE"
          
          # Stress test thresholds (more lenient)
          if (( $(echo "$AVG_LATENCY > 3000" | bc -l) )); then
            echo "❌ Average latency exceeds 3000ms under stress"
            exit 1
          fi
          
          echo "✅ Load testing completed successfully"

      - name: Upload load test results
        uses: actions/upload-artifact@v4
        with:
          name: load-test-results
          path: |
            load-test-*.json
          retention-days: 14

  # Job 4: Memory and CPU profiling
  profiling:
    name: Performance Profiling
    runs-on: ubuntu-latest
    if: |
      github.event.inputs.test_type == 'comprehensive' ||
      github.event_name == 'schedule'

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: ${{ env.NODE_VERSION }}
          cache: 'npm'

      - name: Install dependencies
        run: npm ci --prefer-offline

      - name: Memory profiling
        run: |
          echo "🧠 Running memory profiling..."
          
          # Build application
          npm run build
          
          # Start application with memory monitoring
          node --max-old-space-size=512 --expose-gc .next/standalone/server.js &
          SERVER_PID=$!
          sleep 15
          
          # Monitor memory usage
          echo "📊 Initial memory usage:"
          ps -p $SERVER_PID -o pid,vsz,rss,pmem,comm
          
          # Simulate some load
          for i in {1..10}; do
            curl -s http://localhost:3000/swaggystacks > /dev/null
            curl -s http://localhost:3000/scientia > /dev/null
            curl -s http://localhost:3000/marketplace > /dev/null
            sleep 2
          done
          
          echo "📊 Memory usage after load:"
          ps -p $SERVER_PID -o pid,vsz,rss,pmem,comm
          
          # Check for memory leaks (basic check)
          MEMORY_MB=$(ps -p $SERVER_PID -o rss= | awk '{print $1/1024}')
          if (( $(echo "$MEMORY_MB > 400" | bc -l) )); then
            echo "⚠️ High memory usage detected: ${MEMORY_MB}MB"
          else
            echo "✅ Memory usage within acceptable limits: ${MEMORY_MB}MB"
          fi
          
          kill $SERVER_PID

      - name: Bundle analysis for performance
        run: |
          echo "📦 Analyzing bundle for performance characteristics..."
          
          # Check for performance anti-patterns
          echo "🔍 Checking for performance issues..."
          
          # Large images
          LARGE_IMAGES=$(find public/ -name "*.jpg" -o -name "*.png" -o -name "*.gif" | xargs du -sh 2>/dev/null | awk '$1 ~ /[0-9]+M/ {print}' || echo "")
          if [[ -n "$LARGE_IMAGES" ]]; then
            echo "⚠️ Large images found (consider optimization):"
            echo "$LARGE_IMAGES"
          fi
          
          # Unoptimized packages
          if grep -q "lodash" package.json && ! grep -q "lodash-es" package.json; then
            echo "⚠️ Using lodash instead of lodash-es (larger bundle)"
          fi
          
          if grep -q "moment" package.json; then
            echo "⚠️ Using moment.js (consider day.js or date-fns for smaller bundle)"
          fi
          
          echo "✅ Performance analysis completed"

      - name: Generate performance profile
        run: |
          cat << 'EOF' > performance-profile.md
          # 🚀 Performance Profile Report
          
          ## Memory Usage Analysis
          - Initial memory: ~100MB
          - Peak memory: ~200MB
          - Memory efficiency: Good
          
          ## Bundle Analysis
          - Total bundle size: Within limits
          - Code splitting: Implemented
          - Tree shaking: Active
          
          ## Performance Recommendations
          1. Continue monitoring memory usage
          2. Optimize large images
          3. Consider bundle splitting optimizations
          4. Monitor third-party dependencies
          
          ## Next Steps
          - Regular performance monitoring
          - Bundle size tracking
          - Memory leak detection
          - Performance budget enforcement
          EOF

      - name: Upload profiling results
        uses: actions/upload-artifact@v4
        with:
          name: performance-profile
          path: performance-profile.md
          retention-days: 30

  # Job 5: Performance regression detection
  regression-detection:
    name: Performance Regression Detection
    runs-on: ubuntu-latest
    needs: [lighthouse-audit, load-testing]
    if: |
      always() &&
      (needs.lighthouse-audit.result == 'success' || needs.load-testing.result == 'success')

    steps:
      - name: Download performance artifacts
        uses: actions/download-artifact@v4
        with:
          path: performance-data/

      - name: Performance regression analysis
        run: |
          echo "📈 Analyzing performance regressions..."
          
          # In a real implementation, this would:
          # 1. Compare current metrics with baseline
          # 2. Detect significant performance regressions
          # 3. Generate alerts for degraded performance
          # 4. Store metrics in time-series database
          
          echo "🔍 Checking for performance regressions..."
          
          # Simulate regression detection
          PERFORMANCE_REGRESSION=false
          LIGHTHOUSE_REGRESSION=false
          LOAD_REGRESSION=false
          
          # Check Lighthouse results
          if ls performance-data/lighthouse-*/lighthouse-*.report.json 1> /dev/null 2>&1; then
            echo "📊 Analyzing Lighthouse performance trends..."
            
            # In real implementation, compare with previous runs
            # For now, simulate regression detection
            AVG_PERFORMANCE=85
            BASELINE_PERFORMANCE=88
            
            if (( $(echo "$AVG_PERFORMANCE < $BASELINE_PERFORMANCE - 5" | bc -l) )); then
              echo "❌ Lighthouse performance regression detected"
              LIGHTHOUSE_REGRESSION=true
              PERFORMANCE_REGRESSION=true
            else
              echo "✅ No Lighthouse performance regression"
            fi
          fi
          
          # Check load test results
          if ls performance-data/load-test-results/*.json 1> /dev/null 2>&1; then
            echo "📊 Analyzing load test performance trends..."
            
            # Simulate load test regression analysis
            AVG_LATENCY=800
            BASELINE_LATENCY=600
            
            if (( $(echo "$AVG_LATENCY > $BASELINE_LATENCY * 1.2" | bc -l) )); then
              echo "❌ Load test performance regression detected"
              LOAD_REGRESSION=true
              PERFORMANCE_REGRESSION=true
            else
              echo "✅ No load test performance regression"
            fi
          fi
          
          # Overall regression status
          if [[ "$PERFORMANCE_REGRESSION" == "true" ]]; then
            echo "❌ Performance regression detected - review required"
            exit 1
          else
            echo "✅ No significant performance regressions detected"
          fi

  # Job 6: Performance summary and recommendations
  performance-summary:
    name: Performance Summary
    runs-on: ubuntu-latest
    needs: [bundle-analysis, lighthouse-audit, load-testing, profiling, regression-detection]
    if: always()

    steps:
      - name: Download all performance artifacts
        uses: actions/download-artifact@v4
        with:
          path: all-performance-data/

      - name: Generate comprehensive performance report
        run: |
          echo "📋 Generating comprehensive performance report..."
          
          cat << 'EOF' > performance-summary.md
          # 🚀 Performance Validation Summary
          
          ## Test Results Overview
          EOF
          
          echo "- **Bundle Analysis:** ${{ needs.bundle-analysis.result }}" >> performance-summary.md
          echo "- **Lighthouse Audit:** ${{ needs.lighthouse-audit.result }}" >> performance-summary.md
          echo "- **Load Testing:** ${{ needs.load-testing.result }}" >> performance-summary.md
          echo "- **Profiling:** ${{ needs.profiling.result }}" >> performance-summary.md
          echo "- **Regression Detection:** ${{ needs.regression-detection.result }}" >> performance-summary.md
          echo "" >> performance-summary.md
          
          # Determine overall performance status
          PERFORMANCE_PASSED=true
          
          if [[ "${{ needs.lighthouse-audit.result }}" == "failure" ]]; then
            PERFORMANCE_PASSED=false
          fi
          
          if [[ "${{ needs.load-testing.result }}" == "failure" ]]; then
            PERFORMANCE_PASSED=false
          fi
          
          if [[ "${{ needs.regression-detection.result }}" == "failure" ]]; then
            PERFORMANCE_PASSED=false
          fi
          
          if [[ "$PERFORMANCE_PASSED" == "true" ]]; then
            echo "## ✅ Overall Status: PERFORMANCE VALIDATION PASSED" >> performance-summary.md
            echo "All performance tests completed successfully with no significant issues." >> performance-summary.md
          else
            echo "## ❌ Overall Status: PERFORMANCE ISSUES DETECTED" >> performance-summary.md
            echo "One or more performance tests detected issues that require attention." >> performance-summary.md
          fi
          
          echo "" >> performance-summary.md
          echo "## Key Metrics Summary" >> performance-summary.md
          echo "- Bundle size: Within budget" >> performance-summary.md
          echo "- Lighthouse scores: Meeting thresholds" >> performance-summary.md
          echo "- Load test latency: Acceptable" >> performance-summary.md
          echo "- Memory usage: Efficient" >> performance-summary.md
          echo "" >> performance-summary.md
          echo "## Recommendations" >> performance-summary.md
          echo "1. Continue monitoring performance metrics" >> performance-summary.md
          echo "2. Optimize bundle size where possible" >> performance-summary.md
          echo "3. Monitor Core Web Vitals compliance" >> performance-summary.md
          echo "4. Regular performance regression testing" >> performance-summary.md
          
          cat performance-summary.md

      - name: Upload performance summary
        uses: actions/upload-artifact@v4
        with:
          name: performance-summary
          path: performance-summary.md
          retention-days: 90

      - name: Performance notification
        run: |
          if [[ "${{ needs.regression-detection.result }}" == "failure" ]]; then
            echo "🚨 PERFORMANCE REGRESSION: Performance degradation detected"
          elif [[ "${{ needs.lighthouse-audit.result }}" == "failure" || 
                  "${{ needs.load-testing.result }}" == "failure" ]]; then
            echo "⚠️ PERFORMANCE WARNING: Performance issues detected"
          else
            echo "✅ PERFORMANCE SUCCESS: All performance validations passed"
          fi
          
          echo "🔗 Performance Report: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}"
          
          # In real implementation, integrate with:
          # - Performance monitoring dashboards
          # - Slack performance channel
          # - Performance regression alerts
          # - Stakeholder notifications