myaidev-method 0.0.8 → 0.1.0

package/src/scripts/wordpress-performance-check.js

@@ -0,0 +1,461 @@
+#!/usr/bin/env node
+
+/**
+ * WordPress Performance Analysis Script
+ * Scriptable performance check with JSON output for agent processing
+ *
+ * Usage:
+ *   npx myaidev-method wordpress:performance-check [options]
+ *   node src/scripts/wordpress-performance-check.js [options]
+ */
+
+import { WordPressAdminUtils } from '../lib/wordpress-admin-utils.js';
+import { writeFileSync } from 'fs';
+import { resolve } from 'path';
+
+const args = process.argv.slice(2);
+
+const options = {
+  format: 'json', // json or text
+  output: null, // file path for output
+  verbose: false,
+  iterations: 3 // Number of iterations for timing measurements
+};
+
+// Parse arguments
+for (let i = 0; i < args.length; i++) {
+  switch (args[i]) {
+    case '--format':
+      options.format = args[++i] || 'json';
+      break;
+    case '--output':
+    case '-o':
+      options.output = args[++i];
+      break;
+    case '--verbose':
+    case '-v':
+      options.verbose = true;
+      break;
+    case '--iterations':
+    case '-i':
+      options.iterations = parseInt(args[++i]) || 3;
+      break;
+    case '--help':
+    case '-h':
+      printHelp();
+      process.exit(0);
+  }
+}
+
+function printHelp() {
+  console.log(`
+WordPress Performance Analysis Script
+
+Usage:
+  npx myaidev-method wordpress:performance-check [options]
+
+Options:
+  --format <type>     Output format: json or text (default: json)
+  --output <file>     Write output to file
+  -o <file>           Alias for --output
+  --verbose           Show detailed progress information
+  -v                  Alias for --verbose
+  --iterations <n>    Number of timing test iterations (default: 3)
+  -i <n>              Alias for --iterations
+  --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
+
+Performance Checks:
+  ✓ API response time measurement
+  ✓ Database content analysis
+  ✓ Media file optimization opportunities
+  ✓ Plugin performance impact
+  ✓ Resource usage patterns
+
+Examples:
+  # Run performance check with JSON output
+  npx myaidev-method wordpress:performance-check
+
+  # Save performance report to file
+  npx myaidev-method wordpress:performance-check --output perf-report.json
+
+  # Display human-readable text report
+  npx myaidev-method wordpress:performance-check --format text
+
+  # Run 5 timing iterations for more accurate measurements
+  npx myaidev-method wordpress:performance-check --iterations 5 --verbose
+
+Output Structure (JSON):
+  {
+    "success": true,
+    "timestamp": "2025-10-01T12:00:00.000Z",
+    "site": { "name": "...", "url": "..." },
+    "performance_score": 85,
+    "metrics": {
+      "api_response_time_ms": 250,
+      "post_count": 150,
+      "media_count": 400,
+      "plugin_count": 15,
+      "active_plugins": 12
+    },
+    "analysis": {...},
+    "recommendations": [...]
+  }
+
+Exit Codes:
+  0 - No performance issues
+  1 - Check error occurred
+  2 - Performance warnings
+`);
+}
+
+async function measureResponseTime(wpUtils, iterations) {
+  const measurements = [];
+
+  for (let i = 0; i < iterations; i++) {
+    const start = Date.now();
+    try {
+      await wpUtils.request('/');
+      const duration = Date.now() - start;
+      measurements.push(duration);
+    } catch (error) {
+      // Skip failed measurements
+    }
+
+    // Small delay between iterations
+    if (i < iterations - 1) {
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+  }
+
+  if (measurements.length === 0) {
+    return null;
+  }
+
+  // Calculate statistics
+  const avg = measurements.reduce((a, b) => a + b, 0) / measurements.length;
+  const sorted = measurements.sort((a, b) => a - b);
+  const median = sorted[Math.floor(sorted.length / 2)];
+  const min = sorted[0];
+  const max = sorted[sorted.length - 1];
+
+  return {
+    average: Math.round(avg),
+    median: Math.round(median),
+    min,
+    max,
+    measurements
+  };
+}
+
+function analyzePerformance(metrics, timing) {
+  const analysis = {
+    api_performance: { status: 'good', message: '' },
+    content_volume: { status: 'good', message: '' },
+    media_optimization: { status: 'good', message: '' },
+    plugin_impact: { status: 'good', message: '' }
+  };
+
+  // API performance
+  if (timing && timing.average > 1000) {
+    analysis.api_performance = {
+      status: 'critical',
+      message: `Slow API response time: ${timing.average}ms (target: <500ms)`
+    };
+  } else if (timing && timing.average > 500) {
+    analysis.api_performance = {
+      status: 'warning',
+      message: `Moderate API response time: ${timing.average}ms (target: <500ms)`
+    };
+  } else if (timing) {
+    analysis.api_performance = {
+      status: 'good',
+      message: `Good API response time: ${timing.average}ms`
+    };
+  }
+
+  // Content volume
+  const totalContent = metrics.post_count + metrics.media_count;
+  if (totalContent > 10000) {
+    analysis.content_volume = {
+      status: 'warning',
+      message: `High content volume: ${totalContent} items (consider archiving strategy)`
+    };
+  } else {
+    analysis.content_volume = {
+      status: 'good',
+      message: `Content volume: ${totalContent} items`
+    };
+  }
+
+  // Media optimization
+  if (metrics.media_count > 1000) {
+    analysis.media_optimization = {
+      status: 'warning',
+      message: `Large media library: ${metrics.media_count} files (consider CDN and optimization)`
+    };
+  }
+
+  // Plugin impact
+  if (metrics.active_plugins > 20) {
+    analysis.plugin_impact = {
+      status: 'warning',
+      message: `Many active plugins: ${metrics.active_plugins} (each adds overhead)`
+    };
+  } else if (metrics.active_plugins > 30) {
+    analysis.plugin_impact = {
+      status: 'critical',
+      message: `Excessive active plugins: ${metrics.active_plugins} (significant performance impact)`
+    };
+  }
+
+  return analysis;
+}
+
+function generateRecommendations(analysis, metrics) {
+  const recommendations = [];
+
+  if (analysis.api_performance.status !== 'good') {
+    recommendations.push({
+      priority: 'high',
+      area: 'API Performance',
+      action: 'Implement page caching and object caching',
+      impact: 'Reduce API response time by 50-80%'
+    });
+  }
+
+  if (analysis.plugin_impact.status !== 'good') {
+    recommendations.push({
+      priority: 'medium',
+      area: 'Plugin Optimization',
+      action: 'Audit and deactivate unused plugins',
+      impact: 'Reduce overhead and improve load times'
+    });
+  }
+
+  if (analysis.media_optimization.status !== 'good') {
+    recommendations.push({
+      priority: 'medium',
+      area: 'Media Optimization',
+      action: 'Implement image optimization and lazy loading',
+      impact: 'Reduce bandwidth usage and improve page speed'
+    });
+  }
+
+  if (metrics.post_count > 1000) {
+    recommendations.push({
+      priority: 'low',
+      area: 'Database Optimization',
+      action: 'Schedule regular database cleanup and optimization',
+      impact: 'Maintain query performance over time'
+    });
+  }
+
+  return recommendations;
+}
+
+function calculatePerformanceScore(analysis, timing) {
+  let score = 100;
+
+  // API performance impact (0-30 points)
+  if (timing) {
+    if (timing.average > 1000) {
+      score -= 30;
+    } else if (timing.average > 500) {
+      score -= 15;
+    } else if (timing.average > 300) {
+      score -= 5;
+    }
+  }
+
+  // Plugin impact (0-20 points)
+  if (analysis.plugin_impact.status === 'critical') {
+    score -= 20;
+  } else if (analysis.plugin_impact.status === 'warning') {
+    score -= 10;
+  }
+
+  // Media optimization (0-15 points)
+  if (analysis.media_optimization.status === 'warning') {
+    score -= 10;
+  }
+
+  // Content volume (0-10 points)
+  if (analysis.content_volume.status === 'warning') {
+    score -= 10;
+  }
+
+  return Math.max(0, score);
+}
+
+function formatPerformanceReport(perfData) {
+  if (!perfData.success) {
+    return `ERROR: ${perfData.error}`;
+  }
+
+  const lines = [];
+  lines.push('='.repeat(60));
+  lines.push('WordPress Performance Analysis Report');
+  lines.push('='.repeat(60));
+  lines.push(`Site: ${perfData.site.name || perfData.site.url}`);
+  lines.push(`Timestamp: ${perfData.timestamp}`);
+  lines.push('');
+  lines.push(`Performance Score: ${perfData.performance_score}/100`);
+  lines.push('');
+
+  if (perfData.timing) {
+    lines.push('API Response Time:');
+    lines.push(`  Average: ${perfData.timing.average}ms`);
+    lines.push(`  Median:  ${perfData.timing.median}ms`);
+    lines.push(`  Range:   ${perfData.timing.min}ms - ${perfData.timing.max}ms`);
+    lines.push('');
+  }
+
+  lines.push('Performance Metrics:');
+  lines.push('-'.repeat(60));
+  lines.push(`Posts:          ${perfData.metrics.post_count}`);
+  lines.push(`Media Files:    ${perfData.metrics.media_count}`);
+  lines.push(`Plugins:        ${perfData.metrics.plugin_count} (${perfData.metrics.active_plugins} active)`);
+  lines.push('');
+
+  lines.push('Performance Analysis:');
+  lines.push('-'.repeat(60));
+  Object.entries(perfData.analysis).forEach(([key, value]) => {
+    const statusIcon = {
+      good: '✓',
+      warning: '⚠',
+      critical: '✗'
+    }[value.status] || '?';
+
+    lines.push(`${statusIcon} ${key}: ${value.message}`);
+  });
+
+  if (perfData.recommendations.length > 0) {
+    lines.push('');
+    lines.push('Recommendations:');
+    lines.push('-'.repeat(60));
+    perfData.recommendations.forEach((rec, i) => {
+      lines.push(`${i + 1}. [${rec.priority.toUpperCase()}] ${rec.area}`);
+      lines.push(`   Action: ${rec.action}`);
+      lines.push(`   Impact: ${rec.impact}`);
+    });
+  }
+
+  lines.push('');
+  lines.push('='.repeat(60));
+
+  return lines.join('\n');
+}
+
+async function runPerformanceCheck() {
+  try {
+    if (options.verbose) {
+      console.error('Initializing WordPress connection...');
+    }
+
+    const wpUtils = new WordPressAdminUtils();
+
+    if (options.verbose) {
+      console.error(`Running performance tests (${options.iterations} iterations)...`);
+    }
+
+    // Measure response time
+    const timing = await measureResponseTime(wpUtils, options.iterations);
+
+    if (options.verbose) {
+      console.error('Collecting performance metrics...');
+    }
+
+    // Get performance metrics
+    const metrics = await wpUtils.getPerformanceMetrics();
+
+    if (options.verbose) {
+      console.error('Analyzing performance data...');
+    }
+
+    // Analyze results
+    const analysis = analyzePerformance(metrics, timing);
+    const recommendations = generateRecommendations(analysis, metrics);
+    const performanceScore = calculatePerformanceScore(analysis, timing);
+
+    const siteInfo = await wpUtils.getSiteInfo().catch(() => ({ url: wpUtils.url }));
+
+    const perfData = {
+      success: true,
+      timestamp: new Date().toISOString(),
+      site: siteInfo,
+      performance_score: performanceScore,
+      timing,
+      metrics,
+      analysis,
+      recommendations
+    };
+
+    if (options.verbose) {
+      console.error('Performance analysis completed.');
+    }
+
+    // Format output
+    let output;
+    if (options.format === 'text') {
+      output = formatPerformanceReport(perfData);
+    } else {
+      output = JSON.stringify(perfData, null, 2);
+    }
+
+    // Write to file or stdout
+    if (options.output) {
+      const outputPath = resolve(options.output);
+      writeFileSync(outputPath, output, 'utf8');
+
+      if (options.verbose) {
+        console.error(`Report written to: ${outputPath}`);
+      }
+
+      // Also output summary to stdout for piping
+      console.log(JSON.stringify({
+        success: true,
+        output_file: outputPath,
+        performance_score: perfData.performance_score,
+        avg_response_time: timing?.average
+      }));
+    } else {
+      console.log(output);
+    }
+
+    // Exit with appropriate code
+    const hasWarnings = Object.values(analysis).some(a => a.status === 'warning' || a.status === 'critical');
+
+    if (hasWarnings) {
+      process.exit(2); // Performance warnings
+    }
+
+    process.exit(0);
+  } catch (error) {
+    const errorOutput = {
+      success: false,
+      error: error.message,
+      timestamp: new Date().toISOString()
+    };
+
+    if (options.format === 'json') {
+      console.log(JSON.stringify(errorOutput, null, 2));
+    } else {
+      console.error(`ERROR: ${error.message}`);
+    }
+
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runPerformanceCheck();
+}
+
+export { runPerformanceCheck };

package/src/scripts/wordpress-security-scan.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+
+/**
+ * WordPress Security Scan Script
+ * Scriptable security scan with JSON output for agent processing
+ *
+ * Usage:
+ *   npx myaidev-method wordpress:security-scan [options]
+ *   node src/scripts/wordpress-security-scan.js [options]
+ */
+
+import { WordPressAdminUtils } from '../lib/wordpress-admin-utils.js';
+import { writeFileSync } from 'fs';
+import { resolve } from 'path';
+
+const args = process.argv.slice(2);
+
+const options = {
+  format: 'json', // json or text
+  output: null, // file path for output
+  verbose: false,
+  detailed: false
+};
+
+// Parse arguments
+for (let i = 0; i < args.length; i++) {
+  switch (args[i]) {
+    case '--format':
+      options.format = args[++i] || 'json';
+      break;
+    case '--output':
+    case '-o':
+      options.output = args[++i];
+      break;
+    case '--verbose':
+    case '-v':
+      options.verbose = true;
+      break;
+    case '--detailed':
+    case '-d':
+      options.detailed = true;
+      break;
+    case '--help':
+    case '-h':
+      printHelp();
+      process.exit(0);
+  }
+}
+
+function printHelp() {
+  console.log(`
+WordPress Security Scan Script
+
+Usage:
+  npx myaidev-method wordpress:security-scan [options]
+
+Options:
+  --format <type>     Output format: json or text (default: json)
+  --output <file>     Write output to file
+  -o <file>           Alias for --output
+  --verbose           Show detailed progress information
+  -v                  Alias for --verbose
+  --detailed          Include detailed vulnerability information
+  -d                  Alias for --detailed
+  --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
+
+Security Checks:
+  ✓ User account security audit
+  ✓ Plugin vulnerability detection
+  ✓ Outdated software detection
+  ✓ Common security misconfigurations
+  ✓ Weak password patterns
+
+Examples:
+  # Run security scan with JSON output
+  npx myaidev-method wordpress:security-scan
+
+  # Save detailed scan to file
+  npx myaidev-method wordpress:security-scan --detailed --output security-report.json
+
+  # Display human-readable text report
+  npx myaidev-method wordpress:security-scan --format text
+
+  # Verbose mode with progress information
+  npx myaidev-method wordpress:security-scan --verbose
+
+Output Structure (JSON):
+  {
+    "success": true,
+    "timestamp": "2025-10-01T12:00:00.000Z",
+    "site": { "name": "...", "url": "..." },
+    "security_score": 85,
+    "vulnerabilities": [],
+    "warnings": [...],
+    "summary": {
+      "critical_issues": 0,
+      "warnings": 2,
+      "status": "warning"
+    },
+    "recommendations": [...]
+  }
+
+Exit Codes:
+  0 - No security issues found
+  1 - Scan error occurred
+  2 - Security warnings found
+  3 - Critical vulnerabilities found
+`);
+}
+
+async function runSecurityScan() {
+  try {
+    if (options.verbose) {
+      console.error('Initializing WordPress connection...');
+    }
+
+    const wpUtils = new WordPressAdminUtils();
+
+    if (options.verbose) {
+      console.error('Running security scan...');
+      console.error('  - Auditing user accounts...');
+    }
+
+    const securityData = await wpUtils.runSecurityScan();
+
+    if (options.verbose) {
+      console.error('  - Checking plugin vulnerabilities...');
+      console.error('  - Analyzing security configuration...');
+      console.error('Security scan completed.');
+    }
+
+    // Remove detailed info if not requested
+    if (!options.detailed && securityData.success) {
+      // Truncate detailed information for cleaner output
+      if (securityData.warnings) {
+        securityData.warnings.forEach(warning => {
+          if (warning.details && warning.details.length > 5) {
+            warning.details = [
+              ...warning.details.slice(0, 5),
+              `... and ${warning.details.length - 5} more`
+            ];
+          }
+        });
+      }
+    }
+
+    // Format output
+    let output;
+    if (options.format === 'text') {
+      output = wpUtils.formatSecurityReport(securityData);
+    } else {
+      output = JSON.stringify(securityData, null, 2);
+    }
+
+    // Write to file or stdout
+    if (options.output) {
+      const outputPath = resolve(options.output);
+      writeFileSync(outputPath, output, 'utf8');
+
+      if (options.verbose) {
+        console.error(`Report written to: ${outputPath}`);
+      }
+
+      // Also output summary to stdout for piping
+      console.log(JSON.stringify({
+        success: true,
+        output_file: outputPath,
+        security_score: securityData.security_score,
+        critical_issues: securityData.summary?.critical_issues || 0,
+        warnings: securityData.summary?.warnings || 0
+      }));
+    } else {
+      console.log(output);
+    }
+
+    // Exit with appropriate code
+    if (!securityData.success) {
+      process.exit(1);
+    }
+
+    const criticalIssues = securityData.vulnerabilities?.length || 0;
+    const warnings = securityData.warnings?.length || 0;
+
+    if (criticalIssues > 0) {
+      process.exit(3); // Critical vulnerabilities found
+    }
+
+    if (warnings > 0) {
+      process.exit(2); // Warnings found
+    }
+
+    process.exit(0); // All clear
+  } catch (error) {
+    const errorOutput = {
+      success: false,
+      error: error.message,
+      timestamp: new Date().toISOString()
+    };
+
+    if (options.format === 'json') {
+      console.log(JSON.stringify(errorOutput, null, 2));
+    } else {
+      console.error(`ERROR: ${error.message}`);
+    }
+
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runSecurityScan();
+}
+
+export { runSecurityScan };