@sun-asterisk/impact-analyzer 1.0.4 → 1.0.6

package/{modules → core}/detectors/endpoint-detector.js

@@ -1,18 +1,22 @@
 /**
  * Endpoint Impact Detector
- * Detects affected API endpoints using method-level call graph
+ * Detects affected API endpoints using method-level call graph with performance optimization
  */
 
+import { createLogger } from '../utils/logger.js';
+
 export class EndpointDetector {
   constructor(methodCallGraph, config) {
     this.methodCallGraph = methodCallGraph;
     this.config = config;
+    this.logger = createLogger(config.verbose);
   }
 
   /**
    * Detect affected endpoints from changed files
    */
   async detect(changedFiles) {
+    const startTime = Date.now();
     const allChangedMethods = [];
 
     for (const changedFile of changedFiles) {
@@ -25,19 +29,18 @@ export class EndpointDetector {
     }
 
     if (allChangedMethods.length === 0) {
-      if (this.config.verbose) {
-        console.log('   ℹ️  No method-level changes detected');
-      }
+      this.logger.info('   ℹ️  No method-level changes detected');
       return [];
     }
 
-    if (this.config.verbose) {
-      console.log(`\n   🔍 Finding affected endpoints for ${allChangedMethods.length} changed methods...`);
-      console.log(`   Call graph size: ${this.methodCallGraph.methodCallMap.size} entries`);
-    }
+    this.logger.info(`\n   🔍 Finding affected endpoints for ${allChangedMethods.length} changed methods...`);
+    this.logger.verbose('EndpointDetector', `Call graph size: ${this.methodCallGraph.methodCallMap.size} entries`);
 
     const affectedEndpoints = this.methodCallGraph.findAffectedEndpoints(allChangedMethods);
 
+    const duration = Date.now() - startTime;
+    this.logger.verbose('EndpointDetector', `Completed in ${duration}ms`);
+
     if (this.config.verbose) {
       for (const endpoint of affectedEndpoints) {
         console.log(`\n   📍 Analyzing: ${endpoint.affectedBy}`);

package/{modules → core}/report-generator.js

@@ -61,9 +61,10 @@ export class ReportGenerator {
     if (impact.databaseImpact.length > 0) {
       console.log('💾 DATABASE IMPACT:');
       impact.databaseImpact.forEach(d => {
-        console.log(`   • ${d.table} (${d.operations.join(', ')})`);
+        console.log(`   • ${d.tableName} (${d.impactType}, ${d.severity})`);
+        console.log(`     Operations: ${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(`     Fields: ${d.fields.slice(0, 5).join(', ')}${d.fields.length > 5 ? '...' : ''}`);
         }
       });
       console.log('');
@@ -162,31 +163,32 @@ export class ReportGenerator {
 
     lines.push(`**Total Tables Affected:** ${dbImpacts.length}\n`);
 
-    // Simple table summary
-    lines.push('| Table | Operations | Fields |');
-    lines.push('|-------|------------|--------|');
+    // Summary table with new fields
+    lines.push('| Table | Model | Impact Type | Severity | Operations |');
+    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} |`);
+      const opsDisplay = db.operations.join(', ');
+      lines.push(`| \`${db.tableName}\` | ${db.modelName} | ${db.impactType} | ${db.severity} | ${opsDisplay} |`);
     });
 
     lines.push('');
 
-    // Detailed breakdown only if fields exist
-    const tablesWithFields = dbImpacts.filter(db => db.fields && db.fields.length > 0);
+    // Detailed breakdown
+    lines.push('### Details\n');
 
-    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`);
-      });
-    }
+    dbImpacts.forEach(db => {
+      lines.push(`#### \`${db.tableName}\` (${db.modelName})\n`);
+      lines.push(`- **Impact Type:** ${db.impactType}`);
+      lines.push(`- **Severity:** ${db.severity}`);
+      lines.push(`- **Operations:** ${db.operations.join(', ')}`);
+      lines.push(`- **Entity File:** ${db.modelPath}`);
+      
+      if (db.fields && db.fields.length > 0) {
+        lines.push(`- **Affected Fields:** ${db.fields.map(f => `\`${f}\``).join(', ')}`);
+      }
+      lines.push('');
+    });
 
     return lines.join('\n');
   }
@@ -377,4 +379,84 @@ export class ReportGenerator {
   capitalizeFirst(str) {
     return str.charAt(0).toUpperCase() + str.slice(1);
   }
+
+  /**
+   * Generate clean JSON report suitable for CI/CD
+   * Excludes source code, diffs, and internal data structures
+   */
+  generateJSONReport(changes, impact) {
+    return {
+      metadata: {
+        timestamp: new Date().toISOString(),
+        filesChanged: changes.changedFiles.length,
+        symbolsChanged: changes.changedSymbols?.length || 0,
+      },
+      summary: {
+        impactScore: impact.impactScore,
+        severity: impact.severity,
+        affectedEndpoints: impact.affectedEndpoints?.length || 0,
+        affectedTables: impact.databaseImpact?.length || 0,
+        affectedComponents: this.countComponents(changes.changedFiles),
+      },
+      endpoints: this.formatEndpointsForJSON(impact.affectedEndpoints),
+      database: this.formatDatabaseForJSON(impact.databaseImpact),
+      components: this.formatComponentsForJSON(changes.changedFiles),
+      logic: {
+        riskLevel: impact.logicImpact?.riskLevel || 'low',
+        directCallers: impact.logicImpact?.directCallers?.length || 0,
+        indirectCallers: impact.logicImpact?.indirectCallers?.length || 0,
+      }
+    };
+  }
+
+  formatEndpointsForJSON(endpoints) {
+    if (!endpoints || endpoints.length === 0) return [];
+    
+    return endpoints.map(e => ({
+      method: e.method,
+      path: e.path,
+      controller: e.controller,
+      impactLevel: e.impactLevel,
+      layers: e.layers,
+    }));
+  }
+
+  formatDatabaseForJSON(dbImpacts) {
+    if (!dbImpacts || dbImpacts.length === 0) return [];
+    
+    return dbImpacts.map(db => ({
+      tableName: db.tableName,
+      modelName: db.modelName,
+      modelPath: db.modelPath,
+      impactType: db.impactType,
+      severity: db.severity,
+      operations: db.operations,
+      fields: db.fields || [],
+    }));
+  }
+
+  formatComponentsForJSON(changedFiles) {
+    const components = changedFiles.filter(f => this.isComponentFile(f));
+    
+    return components.map(c => ({
+      path: c.path,
+      type: this.detectPageType(c.path),
+      status: c.status,
+      linesAdded: c.changes?.added || 0,
+      linesDeleted: c.changes?.deleted || 0,
+    }));
+  }
+
+  isComponentFile(file) {
+    const path = file.path.toLowerCase();
+    return (
+      path.includes('/page') || path.includes('/component') ||
+      path.includes('/view') || path.includes('/screen') ||
+      path.includes('.page.') || path.includes('.component.')
+    );
+  }
+
+  countComponents(changedFiles) {
+    return changedFiles.filter(f => this.isComponentFile(f)).length;
+  }
 }

package/core/utils/logger.js

@@ -0,0 +1,12 @@
+/**
+ * Logger Utility
+ * Provides structured logging with verbose mode support
+ */
+
+export function createLogger(verbose = false) {
+  return {
+    info: (msg) => console.log(msg),
+    debug: (msg) => verbose && console.log(`[DEBUG] ${msg}`),
+    verbose: (component, msg) => verbose && console.log(`[${component}] ${msg}`)
+  };
+}

package/index.js

@@ -7,10 +7,10 @@
 
 import { CLI } from './cli.js';
 import { loadConfig } from './config/default-config.js';
-import { ChangeDetector } from './modules/change-detector.js';
-import { ImpactAnalyzer } from './modules/impact-analyzer.js';
-import { ReportGenerator } from './modules/report-generator.js';
-import { GitUtils } from './modules/utils/git-utils.js';
+import { ChangeDetector } from './core/change-detector.js';
+import { ImpactAnalyzer } from './core/impact-analyzer.js';
+import { ReportGenerator } from './core/report-generator.js';
+import { GitUtils } from './core/utils/git-utils.js';
 import fs from 'fs';
 import path from 'path';
 
@@ -102,7 +102,8 @@ async function main() {
     // JSON output (optional)
     if (cli.hasArg('json')) {
       const jsonOutput = cli.getArg('json');
-      fs.writeFileSync(jsonOutput, JSON.stringify({ changes, impact }, null, 2));
+      const jsonReport = reporter.generateJSONReport(changes, impact);
+      fs.writeFileSync(jsonOutput, JSON.stringify(jsonReport, null, 2));
       console.log(`✅ JSON report saved to: ${jsonOutput}\n`);
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sun-asterisk/impact-analyzer",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Automated impact analysis for TypeScript/JavaScript projects",
   "main": "index.js",
   "type": "module",

package/modules/detectors/database-detector.js

@@ -1,182 +0,0 @@
-/**
- * Database Impact Detector
- * Detects database changes using layer-aware method tracking
- */
-
-import path from 'path';
-
-export class DatabaseDetector {
-  constructor(methodCallGraph, config) {
-    this.methodCallGraph = methodCallGraph;
-    this.config = config;
-  }
-
-  /**
-   * Detect database impact from changed files using layer-aware tracking
-   */
-  async detect(changedFiles) {
-    const databaseChanges = {
-      tables: new Set(),
-      fields: new Map(), // table -> Set of fields
-      operations: new Map(), // table -> Set of operations
-    };
-
-    // Extract changed methods
-    const allChangedMethods = [];
-    for (const changedFile of changedFiles) {
-      const changedMethods = this.methodCallGraph.getChangedMethods(
-        changedFile.diff || '',
-        changedFile.absolutePath
-      );
-      allChangedMethods.push(...changedMethods);
-    }
-
-    if (this.config.verbose) {
-      console.log(`\n   🔍 Analyzing database impact for ${allChangedMethods.length} changed methods`);
-    }
-
-    // Find affected repository methods through call graph
-    const affectedRepoMethods = this.findAffectedRepositoryMethods(allChangedMethods);
-
-    if (this.config.verbose) {
-      console.log(`\n   📊 Found ${affectedRepoMethods.length} affected repository methods`);
-    }
-
-    // Analyze repository methods for database operations
-    for (const repoMethod of affectedRepoMethods) {
-      const dbOps = this.extractDatabaseOperationsFromCallGraph(repoMethod);
-
-
-      
-      for (const op of dbOps) {
-        databaseChanges.tables.add(op.table);
-        
-        if (!databaseChanges.operations.has(op.table)) {
-          databaseChanges.operations.set(op.table, new Set());
-        }
-        databaseChanges.operations.get(op.table).add(op.operation);
-
-        if (op.fields && op.fields.length > 0) {
-          if (!databaseChanges.fields.has(op.table)) {
-            databaseChanges.fields.set(op.table, new Set());
-          }
-          op.fields.forEach(field => databaseChanges.fields.get(op.table).add(field));
-        }
-      }
-    }
-
-    return this.formatDatabaseImpact(databaseChanges);
-  }
-
-  findAffectedRepositoryMethods(changedMethods) {
-    const visited = new Set();
-    const repoMethods = [];
-    const queue = [...changedMethods];
-
-    while (queue.length > 0) {
-      const method = queue.shift();
-      
-      if (!method || !method.file) continue;
-      
-      const key = `${method.file}:${method.className}.${method.methodName}`;
-      if (visited.has(key)) continue;
-      visited.add(key);
-
-      const isRepository = method.file.includes('repository') || 
-                          (method.className && method.className.toLowerCase().includes('repository'));
-      
-      if (isRepository) {
-        repoMethods.push(method);
-      }
-
-      const callers = this.methodCallGraph.getCallers(method);
-      queue.push(...callers);
-    }
-
-    return repoMethods;
-  }
-
-  extractDatabaseOperationsFromCallGraph(repoMethod) {
-    const operations = [];
-    
-    const methodKey = `${repoMethod.className}.${repoMethod.methodName}`;
-    const methodCalls = this.methodCallGraph.methodCallsMap?.get(methodKey) || [];
-    
-    if (this.config.verbose) {
-      console.log(`   📞 Analyzing ${methodCalls.length} calls in ${repoMethod.className}.${repoMethod.methodName}`);
-    }
-    
-    for (const call of methodCalls) {
-      const dbOp = this.detectDatabaseOperationFromCall(call);
-
-      if (dbOp) {
-        operations.push({
-          ...dbOp,
-          method: `${repoMethod.className}.${repoMethod.methodName}`,
-          file: repoMethod.file,
-        });
-      }
-    }
-
-    return operations;
-  }
-   
-  detectDatabaseOperationFromCall(call) {
-    const typeOrmOps = {
-      'insert': 'INSERT',
-      'save': 'INSERT/UPDATE',
-      'create': 'INSERT',
-      'update': 'UPDATE',
-      'merge': 'UPDATE',
-      'delete': 'DELETE',
-      'remove': 'DELETE',
-      'softDelete': 'SOFT_DELETE',
-      'find': 'SELECT',
-      'findOne': 'SELECT',
-      'findAndCount': 'SELECT',
-      'findBy': 'SELECT',
-      'findOneBy': 'SELECT',
-    };
-
-    const methodName = call.method;
-    if (!typeOrmOps[methodName]) return null;
-
-    const target = call.target;
-    const entityMatch = target?.match(/(\w+Repository)/);
-    
-    if (!entityMatch) return null;
-
-    const entityName = entityMatch[1].replace(/Repository$/, '') + 'Entity';
-    
-    return {
-      table: this.entityToTableName(entityName),
-      operation: typeOrmOps[methodName],
-      fields: [],
-    };
-  }
-
-  entityToTableName(entityName) {
-    return entityName
-      .replace(/Entity$/, '')
-      .replace(/([A-Z])/g, '_$1')
-      .toLowerCase()
-      .replace(/^_/, '');
-  }
-
-  formatDatabaseImpact(databaseChanges) {
-    const tables = [];
-
-    for (const tableName of databaseChanges.tables) {
-      const operations = Array.from(databaseChanges.operations.get(tableName) || []);
-      const fields = Array.from(databaseChanges.fields.get(tableName) || []);
-
-      tables.push({
-        name: tableName,
-        operations,
-        fields: fields.length > 0 ? fields : undefined,
-      });
-    }
-
-    return tables;
-  }
-}