@sun-asterisk/impact-analyzer 1.0.0

package/modules/impact-analyzer.js

@@ -0,0 +1,124 @@
+/**
+ * Impact Analyzer Module
+ * Analyzes the impact of code changes across multiple dimensions
+ */
+
+import { MethodCallGraph } from './utils/method-call-graph.js';
+import { EndpointDetector } from './detectors/endpoint-detector.js';
+import { DatabaseDetector } from './detectors/database-detector.js';
+import path from 'path';
+
+export class ImpactAnalyzer {
+  constructor(config) {
+    this.config = config;
+    this.absoluteSourceDir = path.resolve(config.sourceDir);
+    this.methodCallGraph = null;
+  }
+
+  async initializeMethodCallGraph() {
+    this.methodCallGraph = new MethodCallGraph();
+    await this.methodCallGraph.initialize(
+      this.absoluteSourceDir,
+      this.config.excludePaths,
+      this.config.verbose
+    );
+
+    this.endpointDetector = new EndpointDetector(this.methodCallGraph, this.config);
+    this.databaseDetector = new DatabaseDetector(this.methodCallGraph, this.config);
+
+    const stats = this.methodCallGraph.getStats();
+    if (this.config.verbose) {
+      console.log(`\n📊 Call Graph Statistics:`);
+      console.log(`   Total methods: ${stats.totalMethods}`);
+      console.log(`   Total endpoints: ${stats.totalEndpoints}`);
+      console.log(`   Call relationships: ${stats.totalCallRelationships}\n`);
+    }
+  }
+
+  /**
+   * Perform comprehensive impact analysis
+   */
+  async analyzeImpact(changes) {
+    if (!this.methodCallGraph) {
+      await this.initializeMethodCallGraph();
+    }
+
+    const changedFilesWithAbsolutePaths = changes.changedFiles.map(file => ({
+      ...file,
+      absolutePath: path.join(path.dirname(this.absoluteSourceDir), file.path)
+    }));
+
+    const affectedEndpoints = await this.endpointDetector.detect(changedFilesWithAbsolutePaths);
+    const databaseImpact = await this.databaseDetector.detect(changedFilesWithAbsolutePaths);
+    const logicImpact = this.detectLogicImpact(changes.changedSymbols);
+
+    const impactScore = this.calculateImpactScore({
+      affectedEndpoints,
+      databaseImpact,
+      logicImpact,
+    });
+
+    return {
+      affectedEndpoints,
+      databaseImpact,
+      logicImpact,
+      impactScore,
+      severity: this.determineSeverity(impactScore),
+    };
+  }
+
+  detectLogicImpact(changedSymbols) {
+    const directCallers = new Set();
+    const indirectCallers = new Set();
+
+    for (const symbol of changedSymbols) {
+      const methodName = `${symbol.className || 'global'}.${symbol.name}`;
+      const callers = this.methodCallGraph.findAllCallers(methodName);
+      
+      callers.forEach(caller => {
+        directCallers.add(caller);
+        
+        const indirectCallersOfCaller = this.methodCallGraph.findAllCallers(caller);
+        indirectCallersOfCaller.forEach(ic => {
+          if (!callers.includes(ic)) {
+            indirectCallers.add(ic);
+          }
+        });
+      });
+    }
+
+    return {
+      directCallers: Array.from(directCallers),
+      indirectCallers: Array.from(indirectCallers),
+      riskLevel: this.calculateRiskLevel(directCallers.size, indirectCallers.size),
+    };
+  }
+
+  calculateRiskLevel(directCount, indirectCount) {
+    const total = directCount + indirectCount;
+    if (total > 10) return 'high';
+    if (total > 5) return 'medium';
+    return 'low';
+  }
+
+  calculateImpactScore(result) {
+    let score = 0;
+
+    score += (result.affectedEndpoints?.length || 0) * 10;
+    score += (result.databaseImpact?.length || 0) * 5;
+    score += (result.logicImpact?.directCallers.length || 0) * 3;
+    score += (result.logicImpact?.indirectCallers.length || 0) * 1;
+
+    if (result.logicImpact?.riskLevel === 'high') score *= 1.5;
+    if (result.databaseImpact?.some(d => d.hasMigration)) score += 20;
+
+    return Math.round(score);
+  }
+
+  determineSeverity(score) {
+    if (score > 100) return 'critical';
+    if (score > 50) return 'high';
+    if (score > 20) return 'medium';
+    return 'low';
+  }
+}

package/modules/report-generator.js

@@ -0,0 +1,373 @@
+/**
+ * Report Generator Module
+ * Generates formatted reports in various formats
+ */
+
+export class ReportGenerator {
+  /**
+   * Generate Markdown report
+   */
+  generateMarkdownReport(changes, impact) {
+    const sections = [];
+
+    // Header
+    sections.push('# 🔍 Impact Analysis Report\n');
+    sections.push(this.generateSummarySection(changes, impact));
+    sections.push(this.generateEndpointsSection(impact.affectedEndpoints));
+    sections.push(this.generateDatabaseSection(impact.databaseImpact));
+    sections.push(this.generatePagesSection(changes.changedFiles));
+    sections.push(this.generateLogicSection(impact.logicImpact));
+    sections.push(this.generateChangedFilesSection(changes.changedFiles));
+
+    return sections.filter(s => s).join('\n');
+  }
+
+  /**
+   * Generate console report
+   */
+  generateConsoleReport(changes, impact) {
+    const width = 70;
+
+    console.log('\n' + '='.repeat(width));
+    console.log(this.centerText('IMPACT ANALYSIS REPORT', width));
+    console.log('='.repeat(width) + '\n');
+
+    // Summary
+    console.log('📊 SUMMARY:');
+    console.log(`   Files Changed: ${changes.changedFiles.length}`);
+    console.log(`   Symbols Modified: ${changes.changedSymbols.length}`);
+    console.log(`   Impact Score: ${impact.impactScore}`);
+    console.log(`   Severity: ${this.getSeverityEmoji(impact.severity)} ${impact.severity.toUpperCase()}`);
+    console.log('');
+
+    // Endpoints
+    if (impact.affectedEndpoints.length > 0) {
+      console.log('📡 AFFECTED API ENDPOINTS:');
+      impact.affectedEndpoints.slice(0, 10).forEach(e => {
+        console.log(`   ${this.getImpactEmoji(e.impactLevel)} ${e.method.padEnd(7)} ${e.path}`);
+      });
+      if (impact.affectedEndpoints.length > 10) {
+        console.log(`   ...and ${impact.affectedEndpoints.length - 10} more`);
+      }
+      console.log('');
+    }
+
+    // Database
+    if (impact.databaseImpact.length > 0) {
+      console.log('💾 DATABASE IMPACT:');
+      impact.databaseImpact.forEach(d => {
+        console.log(`   • ${d.table} (${d.operations.join(', ')})`);
+        if (d.fields && d.fields.length > 0) {
+          console.log(`     Fields: ${d.fields.slice(0, 10).join(', ')}${d.fields.length > 10 ? '...' : ''}`);
+        }
+      });
+      console.log('');
+    }
+
+    // Pages/Components
+    const pageFiles = changes.changedFiles.filter(f => {
+      const path = f.path.toLowerCase();
+      return (
+        path.includes('/page') || path.includes('/component') ||
+        path.includes('/view') || path.includes('/screen') ||
+        path.includes('.page.') || path.includes('.component.') ||
+        path.includes('.view.') || path.includes('.screen.')
+      );
+    });
+
+    if (pageFiles.length > 0) {
+      console.log('📄 AFFECTED PAGES/COMPONENTS:');
+      pageFiles.slice(0, 10).forEach(f => {
+        const type = this.detectPageType(f.path);
+        const statusEmoji = this.getStatusEmoji(f.status);
+        console.log(`   ${statusEmoji} ${type} ${f.path}`);
+      });
+      if (pageFiles.length > 10) {
+        console.log(`   ...and ${pageFiles.length - 10} more`);
+      }
+      console.log('');
+    }
+
+    // Logic Impact
+    console.log('🔄 LOGIC IMPACT:');
+    console.log(`   Risk Level: ${this.getRiskEmoji(impact.logicImpact.riskLevel)} ${impact.logicImpact.riskLevel.toUpperCase()}`);
+    console.log(`   Direct Callers: ${impact.logicImpact.directCallers.length}`);
+    console.log(`   Indirect Callers: ${impact.logicImpact.indirectCallers.length}`);
+    console.log('');
+
+    console.log('='.repeat(width) + '\n');
+  }
+
+  /**
+   * Generate JSON report
+   */
+  generateJSONReport(changes, impact) {
+    return JSON.stringify({
+      timestamp: new Date().toISOString(),
+      summary: {
+        filesChanged: changes.changedFiles.length,
+        symbolsModified: changes.changedSymbols.length,
+        impactScore: impact.impactScore,
+        severity: impact.severity,
+      },
+      changes,
+      impact,
+    }, null, 2);
+  }
+
+  /**
+   * Section Generators
+   */
+  generateSummarySection(changes, impact) {
+    return `## 📊 Summary
+
+| Metric | Value |
+|--------|-------|
+| Files Changed | ${changes.changedFiles.length} |
+| Symbols Modified | ${changes.changedSymbols.length} |
+| Impact Score | **${impact.impactScore}** |
+| Severity | ${this.getSeverityEmoji(impact.severity)} **${impact.severity.toUpperCase()}** |
+
+`;
+  }
+
+  generateEndpointsSection(endpoints) {
+    if (! endpoints || endpoints.length === 0) return '';
+
+    const lines = ['## 📡 Affected API Endpoints\n'];
+
+    lines.push('| Method | Path | Controller | Impact |');
+    lines.push('|--------|------|------------|--------|');
+
+    endpoints.forEach(e => {
+      const emoji = this.getImpactEmoji(e.impactLevel);
+      lines.push(`| **${e.method}** | \`${e.path}\` | ${e.controller} | ${emoji} ${e.impactLevel} |`);
+    });
+
+    lines.push('');
+    return lines.join('\n');
+  }
+
+  generateDatabaseSection(dbImpacts) {
+    if (!dbImpacts || dbImpacts.length === 0) return '';
+
+    const lines = ['## 💾 Database Impact\n'];
+
+    lines.push(`**Total Tables Affected:** ${dbImpacts.length}\n`);
+
+    // Simple table summary
+    lines.push('| Table | Operations | Fields |');
+    lines.push('|-------|------------|--------|');
+
+    dbImpacts.forEach(db => {
+      const fieldsDisplay = db.fields && db.fields.length > 0
+        ? db.fields.slice(0, 3).join(', ') + (db.fields.length > 3 ? '...' : '')
+        : '-';
+      lines.push(`| \`${db.table}\` | ${db.operations.join(', ')} | ${fieldsDisplay} |`);
+    });
+
+    lines.push('');
+
+    // Detailed breakdown only if fields exist
+    const tablesWithFields = dbImpacts.filter(db => db.fields && db.fields.length > 0);
+
+    if (tablesWithFields.length > 0) {
+      lines.push('### Field Details\n');
+
+      tablesWithFields.forEach(db => {
+        lines.push(`#### \`${db.table}\`\n`);
+        lines.push(`**Operations:** ${db.operations.join(', ')}\n`);
+        lines.push(`**Fields (${db.fields.length}):** ${db.fields.map(f => `\`${f}\``).join(', ')}\n`);
+      });
+    }
+
+    return lines.join('\n');
+  }
+
+  generatePagesSection(changedFiles) {
+    if (!changedFiles || changedFiles.length === 0) return '';
+
+    // Detect page files (components, pages, views, screens)
+    const pageFiles = changedFiles.filter(f => {
+      const path = f.path.toLowerCase();
+      return (
+        path.includes('/page') ||
+        path.includes('/component') ||
+        path.includes('/view') ||
+        path.includes('/screen') ||
+        path.includes('.page.') ||
+        path.includes('.component.') ||
+        path.includes('.view.') ||
+        path.includes('.screen.')
+      );
+    });
+
+    if (pageFiles.length === 0) return '';
+
+    const lines = ['## 📄 Affected Pages/Components\n'];
+
+    lines.push(`**Total Pages/Components Affected:** ${pageFiles.length}\n`);
+
+    // Group by type
+    const byType = {
+      page: [],
+      component: [],
+      view: [],
+      screen: [],
+      other: []
+    };
+
+    pageFiles.forEach(f => {
+      const path = f.path.toLowerCase();
+      if (path.includes('/page') || path.includes('.page.')) {
+        byType.page.push(f);
+      } else if (path.includes('/component') || path.includes('.component.')) {
+        byType.component.push(f);
+      } else if (path.includes('/view') || path.includes('.view.')) {
+        byType.view.push(f);
+      } else if (path.includes('/screen') || path.includes('.screen.')) {
+        byType.screen.push(f);
+      } else {
+        byType.other.push(f);
+      }
+    });
+
+    // List all pages
+    lines.push('### Pages/Components List\n');
+    lines.push('| Type | File | Status | Changes |');
+    lines.push('|------|------|--------|---------|');
+
+    pageFiles.forEach(f => {
+      const statusEmoji = this.getStatusEmoji(f.status);
+      const changes = `+${f.changes.added} -${f.changes.deleted}`;
+      const type = this.detectPageType(f.path);
+      lines.push(`| ${type} | \`${f.path}\` | ${statusEmoji} ${f.status} | ${changes} |`);
+    });
+
+    lines.push('');
+
+    // Group by type for easier review
+    Object.entries(byType).forEach(([type, files]) => {
+      if (files.length > 0) {
+        lines.push(`### ${this.capitalizeFirst(type)}s (${files.length})\n`);
+        files.forEach(f => {
+          const statusEmoji = this.getStatusEmoji(f.status);
+          const changes = `+${f.changes.added} -${f.changes.deleted}`;
+          lines.push(`- ${statusEmoji} \`${f.path}\` (${changes})`);
+        });
+        lines.push('');
+      }
+    });
+
+    return lines.join('\n');
+  }
+
+  generateLogicSection(logicImpact) {
+    const lines = ['## 🔄 Logic Impact\n'];
+
+    lines.push(`**Risk Level:** ${this.getRiskEmoji(logicImpact.riskLevel)} ${logicImpact.riskLevel.toUpperCase()}\n`);
+
+    if (logicImpact.directCallers.length > 0) {
+      lines.push('### Direct Callers\n');
+      logicImpact.directCallers.slice(0, 15).forEach(c => {
+        lines.push(`- \`${c}\``);
+      });
+      if (logicImpact.directCallers.length > 15) {
+        lines.push(`- ...and ${logicImpact.directCallers.length - 15} more`);
+      }
+      lines.push('');
+    }
+
+    if (logicImpact.indirectCallers.length > 0) {
+      lines.push('### Indirect Callers\n');
+      logicImpact.indirectCallers.slice(0, 10).forEach(c => {
+        lines.push(`- \`${c}\``);
+      });
+      if (logicImpact.indirectCallers.length > 10) {
+        lines.push(`- ...and ${logicImpact.indirectCallers.length - 10} more`);
+      }
+      lines.push('');
+    }
+
+    return lines.join('\n');
+  }
+
+
+
+  generateChangedFilesSection(changedFiles) {
+    if (!changedFiles || changedFiles.length === 0) return '';
+
+    const lines = ['## 📝 Changed Files\n'];
+
+    lines.push('| File | Status | Type | Lines Changed |');
+    lines.push('|------|--------|------|---------------|');
+
+    changedFiles.forEach(f => {
+      const statusEmoji = this.getStatusEmoji(f.status);
+      const changes = `+${f.changes.added} -${f.changes.deleted}`;
+      lines.push(`| \`${f.path}\` | ${statusEmoji} ${f.status} | ${f.type} | ${changes} |`);
+    });
+
+    lines.push('');
+    return lines.join('\n');
+  }
+
+  /**
+   * Helper methods
+   */
+  getSeverityEmoji(severity) {
+    const map = {
+      low: '🟢',
+      medium: '🟡',
+      high: '🟠',
+      critical: '🔴',
+    };
+    return map[severity] || '⚪';
+  }
+
+  getImpactEmoji(impact) {
+    const map = {
+      low: '🟢',
+      medium: '🟡',
+      high: '🔴',
+    };
+    return map[impact] || '⚪';
+  }
+
+  getRiskEmoji(risk) {
+    const map = {
+      low: '✅',
+      medium: '⚠️',
+      high: '🚨',
+    };
+    return map[risk] || '⚪';
+  }
+
+  getStatusEmoji(status) {
+    const map = {
+      added: '✨',
+      modified: '📝',
+      deleted: '🗑️',
+      renamed: '📋',
+    };
+    return map[status] || '📄';
+  }
+
+  centerText(text, width) {
+    const padding = Math.floor((width - text.length) / 2);
+    return ' '.repeat(padding) + text;
+  }
+
+  detectPageType(path) {
+    const lower = path.toLowerCase();
+    if (lower.includes('/page') || lower.includes('.page.')) return '📄 Page';
+    if (lower.includes('/component') || lower.includes('.component.')) return '🧩 Component';
+    if (lower.includes('/view') || lower.includes('.view.')) return '👁️ View';
+    if (lower.includes('/screen') || lower.includes('.screen.')) return '📱 Screen';
+    return '📄 UI';
+  }
+
+  capitalizeFirst(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+}