myaidev-method 0.0.8 → 0.1.0

package/src/lib/report-synthesizer.js

@@ -0,0 +1,504 @@
+/**
+ * Report Synthesizer Utilities
+ * Tools for combining script outputs into comprehensive reports for agent processing
+ */
+
+import { readFileSync } from 'fs';
+
+export class ReportSynthesizer {
+  constructor() {
+    this.reports = [];
+  }
+
+  /**
+   * Add a report from JSON string or object
+   */
+  addReport(report, type = 'generic') {
+    const reportData = typeof report === 'string' ? JSON.parse(report) : report;
+
+    this.reports.push({
+      type,
+      timestamp: reportData.timestamp || new Date().toISOString(),
+      data: reportData
+    });
+  }
+
+  /**
+   * Add report from file
+   */
+  addReportFromFile(filePath, type = 'generic') {
+    const content = readFileSync(filePath, 'utf8');
+    this.addReport(content, type);
+  }
+
+  /**
+   * Synthesize all reports into comprehensive analysis
+   */
+  synthesize() {
+    const synthesis = {
+      timestamp: new Date().toISOString(),
+      reports_analyzed: this.reports.length,
+      site_info: this.extractSiteInfo(),
+      executive_summary: this.generateExecutiveSummary(),
+      critical_issues: this.extractCriticalIssues(),
+      warnings: this.extractWarnings(),
+      metrics: this.aggregateMetrics(),
+      recommendations: this.prioritizeRecommendations(),
+      action_items: this.generateActionItems()
+    };
+
+    return synthesis;
+  }
+
+  /**
+   * Extract common site information from reports
+   */
+  extractSiteInfo() {
+    const siteReport = this.reports.find(r => r.data.site);
+    if (!siteReport) return null;
+
+    return {
+      name: siteReport.data.site.name,
+      url: siteReport.data.site.url,
+      wordpress_version: siteReport.data.site.wordpress_version,
+      analysis_date: siteReport.timestamp
+    };
+  }
+
+  /**
+   * Generate executive summary
+   */
+  generateExecutiveSummary() {
+    const summary = {
+      overall_status: 'unknown',
+      health_score: null,
+      security_score: null,
+      performance_score: null,
+      key_findings: []
+    };
+
+    this.reports.forEach(report => {
+      // Extract scores
+      if (report.data.overall_health?.score) {
+        summary.health_score = report.data.overall_health.score;
+      }
+
+      if (report.data.security_score !== undefined) {
+        summary.security_score = report.data.security_score;
+      }
+
+      if (report.data.performance_score !== undefined) {
+        summary.performance_score = report.data.performance_score;
+      }
+
+      // Extract key findings
+      if (report.data.overall_health?.status) {
+        summary.key_findings.push({
+          type: 'health',
+          status: report.data.overall_health.status,
+          score: report.data.overall_health.score
+        });
+      }
+
+      if (report.data.summary?.status) {
+        summary.key_findings.push({
+          type: report.type,
+          status: report.data.summary.status,
+          critical: report.data.summary.critical_issues || 0,
+          warnings: report.data.summary.warnings || 0
+        });
+      }
+    });
+
+    // Determine overall status
+    const hasHealthIssues = summary.health_score && summary.health_score < 70;
+    const hasSecurityIssues = summary.security_score && summary.security_score < 70;
+    const hasPerformanceIssues = summary.performance_score && summary.performance_score < 70;
+
+    if (hasSecurityIssues) {
+      summary.overall_status = 'critical';
+    } else if (hasHealthIssues || hasPerformanceIssues) {
+      summary.overall_status = 'warning';
+    } else {
+      summary.overall_status = 'healthy';
+    }
+
+    return summary;
+  }
+
+  /**
+   * Extract all critical issues
+   */
+  extractCriticalIssues() {
+    const criticalIssues = [];
+
+    this.reports.forEach(report => {
+      // From health checks
+      if (report.data.checks) {
+        const critical = report.data.checks.filter(c => c.status === 'critical');
+        critical.forEach(issue => {
+          criticalIssues.push({
+            source: report.type,
+            check: issue.check,
+            message: issue.message,
+            severity: 'critical'
+          });
+        });
+      }
+
+      // From security scans
+      if (report.data.vulnerabilities) {
+        report.data.vulnerabilities.forEach(vuln => {
+          criticalIssues.push({
+            source: 'security',
+            type: vuln.type,
+            severity: vuln.severity,
+            details: vuln.details
+          });
+        });
+      }
+    });
+
+    return criticalIssues;
+  }
+
+  /**
+   * Extract all warnings
+   */
+  extractWarnings() {
+    const warnings = [];
+
+    this.reports.forEach(report => {
+      // From health checks
+      if (report.data.checks) {
+        const warningChecks = report.data.checks.filter(c => c.status === 'warning');
+        warningChecks.forEach(warning => {
+          warnings.push({
+            source: report.type,
+            check: warning.check,
+            message: warning.message
+          });
+        });
+      }
+
+      // From security scans
+      if (report.data.warnings) {
+        report.data.warnings.forEach(warning => {
+          warnings.push({
+            source: 'security',
+            type: warning.type,
+            severity: warning.severity,
+            count: warning.count,
+            summary: warning.details?.[0] || 'See details'
+          });
+        });
+      }
+
+      // From performance analysis
+      if (report.data.analysis) {
+        Object.entries(report.data.analysis).forEach(([key, value]) => {
+          if (value.status === 'warning' || value.status === 'critical') {
+            warnings.push({
+              source: 'performance',
+              check: key,
+              status: value.status,
+              message: value.message
+            });
+          }
+        });
+      }
+    });
+
+    return warnings;
+  }
+
+  /**
+   * Aggregate metrics from all reports
+   */
+  aggregateMetrics() {
+    const metrics = {};
+
+    this.reports.forEach(report => {
+      if (report.data.metrics) {
+        Object.assign(metrics, report.data.metrics);
+      }
+
+      if (report.data.timing) {
+        metrics.api_response_time = report.data.timing.average;
+      }
+
+      if (report.data.post_stats) {
+        metrics.posts = report.data.post_stats;
+      }
+
+      if (report.data.media_stats) {
+        metrics.media = report.data.media_stats;
+      }
+    });
+
+    return metrics;
+  }
+
+  /**
+   * Prioritize and deduplicate recommendations
+   */
+  prioritizeRecommendations() {
+    const allRecommendations = [];
+
+    this.reports.forEach(report => {
+      if (Array.isArray(report.data.recommendations)) {
+        // Simple string recommendations
+        report.data.recommendations.forEach(rec => {
+          if (typeof rec === 'string') {
+            allRecommendations.push({
+              priority: 'medium',
+              source: report.type,
+              recommendation: rec
+            });
+          } else {
+            // Structured recommendations
+            allRecommendations.push({
+              priority: rec.priority || 'medium',
+              source: report.type,
+              area: rec.area,
+              action: rec.action || rec.recommendation,
+              impact: rec.impact
+            });
+          }
+        });
+      }
+    });
+
+    // Deduplicate by action/recommendation text
+    const unique = new Map();
+    allRecommendations.forEach(rec => {
+      const key = rec.action || rec.recommendation;
+      if (!unique.has(key)) {
+        unique.set(key, rec);
+      }
+    });
+
+    // Sort by priority
+    const priorityOrder = { high: 0, medium: 1, low: 2 };
+    return Array.from(unique.values()).sort((a, b) => {
+      return (priorityOrder[a.priority] || 1) - (priorityOrder[b.priority] || 1);
+    });
+  }
+
+  /**
+   * Generate prioritized action items
+   */
+  generateActionItems() {
+    const actionItems = [];
+
+    // Critical issues become immediate actions
+    const critical = this.extractCriticalIssues();
+    critical.forEach((issue, index) => {
+      actionItems.push({
+        priority: 1,
+        category: 'critical',
+        action: `Address critical issue: ${issue.message || issue.type}`,
+        source: issue.source
+      });
+    });
+
+    // High-priority recommendations
+    const recommendations = this.prioritizeRecommendations();
+    recommendations
+      .filter(rec => rec.priority === 'high')
+      .forEach(rec => {
+        actionItems.push({
+          priority: 2,
+          category: 'high-priority',
+          action: rec.action || rec.recommendation,
+          area: rec.area,
+          impact: rec.impact
+        });
+      });
+
+    // Medium-priority warnings
+    const warnings = this.extractWarnings();
+    const uniqueWarnings = new Map();
+    warnings.forEach(warning => {
+      const key = warning.check || warning.type;
+      if (!uniqueWarnings.has(key)) {
+        uniqueWarnings.set(key, warning);
+      }
+    });
+
+    Array.from(uniqueWarnings.values())
+      .slice(0, 5) // Top 5 warnings
+      .forEach(warning => {
+        actionItems.push({
+          priority: 3,
+          category: 'warning',
+          action: `Review warning: ${warning.message || warning.type}`,
+          source: warning.source
+        });
+      });
+
+    return actionItems.slice(0, 10); // Top 10 action items
+  }
+
+  /**
+   * Generate comprehensive markdown report
+   */
+  generateMarkdownReport() {
+    const synthesis = this.synthesize();
+    const lines = [];
+
+    lines.push('# WordPress Comprehensive Analysis Report');
+    lines.push('');
+
+    if (synthesis.site_info) {
+      lines.push('## Site Information');
+      lines.push(`- **Name**: ${synthesis.site_info.name}`);
+      lines.push(`- **URL**: ${synthesis.site_info.url}`);
+      lines.push(`- **WordPress Version**: ${synthesis.site_info.wordpress_version}`);
+      lines.push(`- **Analysis Date**: ${synthesis.site_info.analysis_date}`);
+      lines.push('');
+    }
+
+    lines.push('## Executive Summary');
+    lines.push('');
+    lines.push(`**Overall Status**: ${synthesis.executive_summary.overall_status.toUpperCase()}`);
+    lines.push('');
+    lines.push('### Scores');
+    if (synthesis.executive_summary.health_score) {
+      lines.push(`- Health: ${synthesis.executive_summary.health_score}/100`);
+    }
+    if (synthesis.executive_summary.security_score !== null) {
+      lines.push(`- Security: ${synthesis.executive_summary.security_score}/100`);
+    }
+    if (synthesis.executive_summary.performance_score !== null) {
+      lines.push(`- Performance: ${synthesis.executive_summary.performance_score}/100`);
+    }
+    lines.push('');
+
+    if (synthesis.critical_issues.length > 0) {
+      lines.push('## 🚨 Critical Issues');
+      lines.push('');
+      synthesis.critical_issues.forEach((issue, i) => {
+        lines.push(`${i + 1}. **${issue.check || issue.type}** (${issue.source})`);
+        lines.push(`   - ${issue.message || issue.details?.[0] || 'See details'}`);
+        lines.push('');
+      });
+    }
+
+    if (synthesis.warnings.length > 0) {
+      lines.push('## ⚠️ Warnings');
+      lines.push('');
+      synthesis.warnings.slice(0, 10).forEach((warning, i) => {
+        lines.push(`${i + 1}. **${warning.check || warning.type}** (${warning.source})`);
+        lines.push(`   - ${warning.message || warning.summary}`);
+        lines.push('');
+      });
+
+      if (synthesis.warnings.length > 10) {
+        lines.push(`_... and ${synthesis.warnings.length - 10} more warnings_`);
+        lines.push('');
+      }
+    }
+
+    lines.push('## 📊 Key Metrics');
+    lines.push('');
+    if (synthesis.metrics.post_count !== undefined) {
+      lines.push(`- **Posts**: ${synthesis.metrics.post_count}`);
+    }
+    if (synthesis.metrics.media_count !== undefined) {
+      lines.push(`- **Media Files**: ${synthesis.metrics.media_count}`);
+    }
+    if (synthesis.metrics.plugin_count !== undefined) {
+      lines.push(`- **Plugins**: ${synthesis.metrics.plugin_count} (${synthesis.metrics.active_plugins} active)`);
+    }
+    if (synthesis.metrics.api_response_time) {
+      lines.push(`- **API Response Time**: ${synthesis.metrics.api_response_time}ms`);
+    }
+    lines.push('');
+
+    if (synthesis.recommendations.length > 0) {
+      lines.push('## 💡 Recommendations');
+      lines.push('');
+      synthesis.recommendations.forEach((rec, i) => {
+        const priorityIcon = {
+          high: '🔴',
+          medium: '🟡',
+          low: '🟢'
+        }[rec.priority] || '⚪';
+
+        lines.push(`${i + 1}. ${priorityIcon} **${rec.area || rec.source}**`);
+        lines.push(`   - ${rec.action || rec.recommendation}`);
+        if (rec.impact) {
+          lines.push(`   - _Impact_: ${rec.impact}`);
+        }
+        lines.push('');
+      });
+    }
+
+    if (synthesis.action_items.length > 0) {
+      lines.push('## ✅ Action Items');
+      lines.push('');
+      lines.push('Priority-ordered tasks:');
+      lines.push('');
+      synthesis.action_items.forEach((item, i) => {
+        lines.push(`${i + 1}. [${item.category.toUpperCase()}] ${item.action}`);
+        if (item.impact) {
+          lines.push(`   - ${item.impact}`);
+        }
+      });
+      lines.push('');
+    }
+
+    lines.push('---');
+    lines.push(`_Report generated: ${synthesis.timestamp}_`);
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Generate JSON report for agent consumption
+   */
+  generateJSONReport() {
+    return JSON.stringify(this.synthesize(), null, 2);
+  }
+
+  /**
+   * Reset synthesizer state
+   */
+  reset() {
+    this.reports = [];
+  }
+}
+
+/**
+ * Convenience function to synthesize multiple report files
+ */
+export async function synthesizeReports(reportFiles, options = {}) {
+  const synthesizer = new ReportSynthesizer();
+
+  reportFiles.forEach(file => {
+    const type = file.type || inferReportType(file.path);
+    synthesizer.addReportFromFile(file.path, type);
+  });
+
+  if (options.format === 'markdown') {
+    return synthesizer.generateMarkdownReport();
+  }
+
+  return synthesizer.generateJSONReport();
+}
+
+/**
+ * Infer report type from filename
+ */
+function inferReportType(filePath) {
+  const fileName = filePath.toLowerCase();
+
+  if (fileName.includes('health')) return 'health';
+  if (fileName.includes('security')) return 'security';
+  if (fileName.includes('performance') || fileName.includes('perf')) return 'performance';
+
+  return 'generic';
+}
+
+export default ReportSynthesizer;