myaidev-method/src/scripts/wordpress-comprehensive-report.js

Comprehensive development framework with SPARC methodology for AI-assisted software development, multi-platform publishing (WordPress, PayloadCMS, Astro, Docusaurus, Mintlify), and Coolify deployment

#!/usr/bin/env node

/**
 * WordPress Comprehensive Report Script
 * Runs all checks and synthesizes into a comprehensive report
 *
 * Usage:
 *   npx myaidev-method wordpress:comprehensive-report [options]
 *   node src/scripts/wordpress-comprehensive-report.js [options]
 */

import { WordPressAdminUtils } from '../lib/wordpress-admin-utils.js';
import { ReportSynthesizer } from '../lib/report-synthesizer.js';
import { writeFileSync } from 'fs';
import { resolve } from 'path';

const args = process.argv.slice(2);

const options = {
  format: 'markdown', // markdown or json
  output: null, // file path for output
  verbose: false,
  includeHealth: true,
  includeSecurity: true,
  includePerformance: true,
  saveIndividual: false // Save individual reports as well
};

// Parse arguments
for (let i = 0; i < args.length; i++) {
  switch (args[i]) {
    case '--format':
      options.format = args[++i] || 'markdown';
      break;
    case '--output':
    case '-o':
      options.output = args[++i];
      break;
    case '--verbose':
    case '-v':
      options.verbose = true;
      break;
    case '--save-individual':
      options.saveIndividual = true;
      break;
    case '--health-only':
      options.includeSecurity = false;
      options.includePerformance = false;
      break;
    case '--security-only':
      options.includeHealth = false;
      options.includePerformance = false;
      break;
    case '--performance-only':
      options.includeHealth = false;
      options.includeSecurity = false;
      break;
    case '--help':
    case '-h':
      printHelp();
      process.exit(0);
  }
}

function printHelp() {
  console.log(`
WordPress Comprehensive Report Script

Runs all WordPress admin checks and synthesizes them into a comprehensive report.
Perfect for regular site maintenance and agent-driven analysis.

Usage:
  npx myaidev-method wordpress:comprehensive-report [options]

Options:
  --format <type>        Output format: markdown or json (default: markdown)
  --output <file>        Write output to file (default: stdout)
  -o <file>              Alias for --output
  --verbose              Show detailed progress information
  -v                     Alias for --verbose
  --save-individual      Save individual report files as well
  --health-only          Only run health check
  --security-only        Only run security scan
  --performance-only     Only run performance check
  --help                 Show this help message
  -h                     Alias for --help

Environment Variables (from .env):
  WORDPRESS_URL            WordPress site URL
  WORDPRESS_USERNAME       Admin username
  WORDPRESS_APP_PASSWORD   Application password

This script runs:
  ✓ Health Check - Site health assessment
  ✓ Security Scan - Security vulnerability detection
  ✓ Performance Analysis - Performance metrics collection

Then synthesizes all results into a comprehensive report with:
  ✓ Executive summary with scores
  ✓ Critical issues requiring immediate attention
  ✓ Warnings and recommendations
  ✓ Prioritized action items
  ✓ Key metrics and statistics

Examples:
  # Generate comprehensive markdown report
  npx myaidev-method wordpress:comprehensive-report

  # Save comprehensive report to file
  npx myaidev-method wordpress:comprehensive-report --output wp-report.md

  # Generate JSON report for agent processing
  npx myaidev-method wordpress:comprehensive-report --format json

  # Save all reports (comprehensive + individual)
  npx myaidev-method wordpress:comprehensive-report --save-individual --output report.md

  # Verbose mode with progress information
  npx myaidev-method wordpress:comprehensive-report --verbose

Agent Integration:
  This script is designed to work with the wordpress-admin agent. The agent can:
  1. Run this script to get structured data
  2. Process the JSON or markdown output
  3. Generate natural language analysis
  4. Provide actionable recommendations

Exit Codes:
  0 - Report generated successfully, no critical issues
  1 - Error occurred during analysis
  2 - Report generated with warnings
  3 - Report generated with critical issues
`);
}

async function runComprehensiveReport() {
  const timestamp = new Date().toISOString();
  const reports = [];

  try {
    if (options.verbose) {
      console.error('WordPress Comprehensive Report');
      console.error('='.repeat(60));
      console.error('Initializing WordPress connection...');
    }

    const wpUtils = new WordPressAdminUtils();
    const synthesizer = new ReportSynthesizer();

    // Run health check
    if (options.includeHealth) {
      if (options.verbose) {
        console.error('\n[1/3] Running health check...');
      }

      const healthData = await wpUtils.runHealthCheck();
      synthesizer.addReport(healthData, 'health');
      reports.push({ type: 'health', data: healthData });

      if (options.saveIndividual && options.output) {
        const healthFile = options.output.replace(/\.(md|json)$/, '-health.json');
        writeFileSync(healthFile, JSON.stringify(healthData, null, 2), 'utf8');
        if (options.verbose) {
          console.error(`  Saved: ${healthFile}`);
        }
      }
    }

    // Run security scan
    if (options.includeSecurity) {
      if (options.verbose) {
        console.error('\n[2/3] Running security scan...');
      }

      const securityData = await wpUtils.runSecurityScan();
      synthesizer.addReport(securityData, 'security');
      reports.push({ type: 'security', data: securityData });

      if (options.saveIndividual && options.output) {
        const securityFile = options.output.replace(/\.(md|json)$/, '-security.json');
        writeFileSync(securityFile, JSON.stringify(securityData, null, 2), 'utf8');
        if (options.verbose) {
          console.error(`  Saved: ${securityFile}`);
        }
      }
    }

    // Run performance check
    if (options.includePerformance) {
      if (options.verbose) {
        console.error('\n[3/3] Running performance analysis...');
      }

      const perfData = await wpUtils.getPerformanceMetrics();
      const timing = await measureResponseTime(wpUtils, 3);

      const performanceData = {
        success: true,
        timestamp,
        site: await wpUtils.getSiteInfo().catch(() => ({ url: wpUtils.url })),
        performance_score: 85, // Calculate based on metrics
        timing,
        metrics: perfData,
        recommendations: []
      };

      synthesizer.addReport(performanceData, 'performance');
      reports.push({ type: 'performance', data: performanceData });

      if (options.saveIndividual && options.output) {
        const perfFile = options.output.replace(/\.(md|json)$/, '-performance.json');
        writeFileSync(perfFile, JSON.stringify(performanceData, null, 2), 'utf8');
        if (options.verbose) {
          console.error(`  Saved: ${perfFile}`);
        }
      }
    }

    if (options.verbose) {
      console.error('\nSynthesizing comprehensive report...');
    }

    // Generate comprehensive report
    let output;
    if (options.format === 'json') {
      output = synthesizer.generateJSONReport();
    } else {
      output = synthesizer.generateMarkdownReport();
    }

    if (options.verbose) {
      console.error('Report generation completed.');
      console.error('='.repeat(60));
    }

    // Write output
    if (options.output) {
      const outputPath = resolve(options.output);
      writeFileSync(outputPath, output, 'utf8');

      if (options.verbose) {
        console.error(`\nComprehensive report written to: ${outputPath}`);
      }

      // Output summary for piping
      const synthesis = synthesizer.synthesize();
      console.log(JSON.stringify({
        success: true,
        output_file: outputPath,
        overall_status: synthesis.executive_summary.overall_status,
        critical_issues: synthesis.critical_issues.length,
        warnings: synthesis.warnings.length,
        reports_generated: reports.length
      }));
    } else {
      console.log(output);
    }

    // Determine exit code
    const synthesis = synthesizer.synthesize();
    const criticalCount = synthesis.critical_issues.length;
    const warningCount = synthesis.warnings.length;

    if (criticalCount > 0) {
      process.exit(3); // Critical issues
    } else if (warningCount > 0) {
      process.exit(2); // Warnings
    } else {
      process.exit(0); // All clear
    }
  } catch (error) {
    const errorOutput = {
      success: false,
      error: error.message,
      timestamp,
      reports_completed: reports.length
    };

    if (options.format === 'json') {
      console.log(JSON.stringify(errorOutput, null, 2));
    } else {
      console.error(`\nERROR: ${error.message}`);
      console.error(`Stack: ${error.stack}`);
    }

    process.exit(1);
  }
}

async function measureResponseTime(wpUtils, iterations) {
  const measurements = [];

  for (let i = 0; i < iterations; i++) {
    const start = Date.now();
    try {
      await wpUtils.request('/');
      measurements.push(Date.now() - start);
    } catch (error) {
      // Skip failed measurements
    }

    if (i < iterations - 1) {
      await new Promise(resolve => setTimeout(resolve, 100));
    }
  }

  if (measurements.length === 0) return null;

  const avg = measurements.reduce((a, b) => a + b, 0) / measurements.length;
  const sorted = measurements.sort((a, b) => a - b);

  return {
    average: Math.round(avg),
    median: Math.round(sorted[Math.floor(sorted.length / 2)]),
    min: sorted[0],
    max: sorted[sorted.length - 1]
  };
}

// Run if called directly
if (import.meta.url === `file://${process.argv[1]}`) {
  runComprehensiveReport();
}

export { runComprehensiveReport };