@sun-asterisk/impact-analyzer 1.0.0

package/index.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+
+/**
+ * Impact Analyzer - Main Entry Point
+ * Orchestrates the entire impact analysis workflow
+ */
+
+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 fs from 'fs';
+import path from 'path';
+
+async function main() {
+  const cli = new CLI(process.argv);
+
+  // Load configuration
+  const config = loadConfig(cli);
+  const absoluteSourceDir = path.resolve(config.sourceDir);
+
+  console.log('🚀 Starting Impact Analysis...\n');
+  console.log('Configuration:');
+  console.log(`  Source Dir: ${config.sourceDir}`);
+  console.log(`  Absolute Path: ${absoluteSourceDir}`);
+  console.log(`  Base Ref: ${config.baseRef}`);
+  console.log(`  Head Ref: ${config.headRef}`);
+  console.log(`  Exclude: ${config.excludePaths.join(', ')}`);
+  console.log('');
+
+  try {
+    // ============================================
+    // Validation
+    // ============================================
+
+    // Check if source directory exists
+    if (! fs.existsSync(absoluteSourceDir)) {
+      throw new Error(`Source directory does not exist: ${absoluteSourceDir}`);
+    }
+
+    // Check if it's a git repository
+    if (!GitUtils.isGitRepo(absoluteSourceDir)) {
+      throw new Error(`Source directory is not a git repository: ${absoluteSourceDir}`);
+    }
+
+    // Check if refs exist
+    if (!GitUtils.refExists(config.baseRef, absoluteSourceDir)) {
+      throw new Error(`Base ref does not exist: ${config.baseRef}`);
+    }
+
+    console.log('✓ Validation passed\n');
+
+    // ============================================
+    // Step 1: Detect Changes
+    // ============================================
+    console.log('📝 Step 1: Detecting changes...');
+    const detector = new ChangeDetector(config);
+
+    const changedFiles = detector.detectChangedFiles();
+    console.log(`   ✓ Found ${changedFiles.length} changed files`);
+
+    const changedSymbols = detector.detectChangedSymbols(changedFiles);
+    console.log(`   ✓ Found ${changedSymbols.length} changed symbols\n`);
+
+    const changes = {
+      changedFiles,
+      changedSymbols,
+    };
+
+    // ============================================
+    // Step 2: Analyze Impact
+    // ============================================
+    console.log('🔍 Step 2: Analyzing impact...');
+    const analyzer = new ImpactAnalyzer(config);
+    
+    // Initialize method-level call graph for precise tracking
+    await analyzer.initializeMethodCallGraph();
+    
+    const impact = await analyzer.analyzeImpact(changes);
+    console.log(`   ✓ Impact score: ${impact.impactScore}`);
+    console.log(`   ✓ Severity: ${impact.severity.toUpperCase()}\n`);
+
+    // ============================================
+    // Step 3: Generate Reports
+    // ============================================
+    console.log('📄 Step 3: Generating reports...\n');
+    const reporter = new ReportGenerator();
+
+    // Console report
+    reporter.generateConsoleReport(changes, impact);
+
+    // Markdown report
+    const markdownReport = reporter.generateMarkdownReport(changes, impact);
+
+    // Save to file
+    const outputFile = cli.getArg('output', 'impact-report.md');
+    fs.writeFileSync(outputFile, markdownReport);
+    console.log(`✅ Report saved to: ${outputFile}\n`);
+
+    // JSON output (optional)
+    if (cli.hasArg('json')) {
+      const jsonOutput = cli.getArg('json');
+      fs.writeFileSync(jsonOutput, JSON.stringify({ changes, impact }, null, 2));
+      console.log(`✅ JSON report saved to: ${jsonOutput}\n`);
+    }
+
+    // Exit with code based on severity
+    if (impact.severity === 'critical' && ! cli.hasArg('no-fail')) {
+      console.log('⚠️  Critical impact detected - exiting with error code');
+      process.exit(1);
+    }
+
+    console.log('✨ Analysis completed successfully!\n');
+    process.exit(0);
+
+  } catch (error) {
+    console.error('❌ Error during analysis:', error.message);
+    if (cli.hasArg('verbose')) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+// Run if executed directly
+main();

package/modules/change-detector.js

@@ -0,0 +1,258 @@
+/**
+ * Change Detector Module
+ * Detects file and symbol changes between git refs
+ */
+
+import { GitUtils } from './utils/git-utils.js';
+import { FileUtils } from './utils/file-utils.js';
+import { ASTParser } from './utils/ast-parser.js';
+import path from 'path';
+import fs from 'fs';
+
+export class ChangeDetector {
+  constructor(config) {
+    this.config = config;
+    // Resolve absolute path for source directory
+    this.absoluteSourceDir = path.resolve(config.sourceDir);
+  }
+
+  /**
+   * Detect all changed files in PR/commit range
+   */
+  detectChangedFiles() {
+    // Get git changes from the source directory
+    const gitChanges = GitUtils.getChangedFiles(
+      this.config.baseRef,
+      this.config.headRef,
+      this.absoluteSourceDir
+    );
+
+    if (this.config.verbose) {
+      console.log(`\n📝 Detecting changed files...`);
+      console.log(`   Base: ${this.config.baseRef}`);
+      console.log(`   Head: ${this.config.headRef}`);
+      console.log(`   Git detected ${gitChanges.length} changed files`);
+    }
+
+    const changedFiles = [];
+
+    for (const change of gitChanges) {
+      const filePath = change.path;
+
+      // Filter based on configuration
+      if (!this.shouldAnalyzeFile(filePath)) {
+        if (this.config.verbose) {
+          console.log(`   ⊗ Skipped: ${filePath} (excluded or not source file)`);
+        }
+        continue;
+      }
+
+      // Get file diff to analyze actual changes
+      const diff = GitUtils.getFileDiff(
+        filePath,
+        this.config.baseRef,
+        this.config.headRef,
+        this.absoluteSourceDir
+      );
+
+      // Skip files with only whitespace/comment changes
+      if (!this.hasSignificantChanges(diff, filePath)) {
+        if (this.config.verbose) {
+          console.log(`   ⊗ Skipped: ${filePath} (only whitespace/comment changes)`);
+        }
+        continue;
+      }
+
+      // Get file contents from the source directory
+      const content = GitUtils.getFileContent(
+        filePath,
+        this.config.headRef,
+        this.absoluteSourceDir
+      );
+
+      const oldContent = change.status !== 'added'
+        ? GitUtils.getFileContent(
+            filePath,
+            this.config.baseRef,
+            this.absoluteSourceDir
+          )
+        : '';
+
+      // Calculate line changes
+      const changes = FileUtils.calculateLineChanges(oldContent, content);
+
+      const fileInfo = {
+        path: filePath,
+        absolutePath: path.join(this.absoluteSourceDir, filePath),
+        status: change.status,
+        type: FileUtils.categorizeFile(filePath),
+        changes,
+        content,
+        oldContent,
+        diff, // Store the diff for further analysis
+      };
+
+      if (this.config.verbose) {
+        console.log(`   ✓ ${change.status.toUpperCase()}: ${filePath} (+${changes.added} -${changes.deleted})`);
+      }
+
+      changedFiles.push(fileInfo);
+    }
+
+    if (this.config.verbose) {
+      console.log(`   Total files to analyze: ${changedFiles.length}\n`);
+    }
+
+    return changedFiles;
+  }
+
+  /**
+   * Check if diff contains significant code changes
+   * Ignore whitespace-only, comment-only, or formatting changes
+   */
+  hasSignificantChanges(diff, filePath) {
+    if (!diff || diff.trim().length === 0) {
+      // For new/deleted files, consider them significant
+      return true;
+    }
+
+    // Extract added/removed lines from diff
+    const lines = diff.split('\n');
+    const codeChanges = lines.filter(line => {
+      // Skip diff headers
+      if (line.startsWith('diff') || line.startsWith('index') || 
+          line.startsWith('+++') || line.startsWith('---') ||
+          line.startsWith('@@')) {
+        return false;
+      }
+
+      // Check for actual code changes (lines starting with + or -)
+      if (line.startsWith('+') || line.startsWith('-')) {
+        const content = line.substring(1).trim();
+        
+        // Ignore empty lines
+        if (content.length === 0) return false;
+        
+        // Ignore comment-only lines (be conservative - keep if unsure)
+        const isCommentOnly = content.startsWith('//') || 
+                              content.startsWith('/*') || 
+                              content.startsWith('*') ||
+                              content === '*/';
+        
+        if (isCommentOnly) return false;
+        
+        return true; // This is a significant change
+      }
+      
+      return false;
+    });
+
+    // If we found any code changes, or if the diff is non-empty, consider it significant
+    // Be conservative - if in doubt, include it
+    return codeChanges.length > 0 || lines.length > 10;
+  }
+
+  /**
+   * Detect changed symbols (functions, classes, methods)
+   */
+  detectChangedSymbols(changedFiles) {
+    const allChangedSymbols = [];
+
+    for (const file of changedFiles) {
+      // Only analyze source files
+      if (file.type !== 'source') continue;
+
+      // Extract symbols from current and old versions
+      const currentSymbols = ASTParser.extractSymbols(file.content, file.path);
+      const oldSymbols = file.oldContent
+        ? ASTParser.extractSymbols(file.oldContent, file.path)
+        : [];
+
+      // Compare and categorize changes
+      const changedSymbols = this.compareSymbols(currentSymbols, oldSymbols, file.path);
+      allChangedSymbols.push(...changedSymbols);
+    }
+
+    return allChangedSymbols;
+  }
+
+  /**
+   * Compare symbols to find added, modified, and deleted
+   */
+  compareSymbols(currentSymbols, oldSymbols, filePath) {
+    const changes = [];
+
+    // Create maps for easy lookup
+    const oldMap = new Map(oldSymbols.map(s => [s.name, s]));
+    const currentMap = new Map(currentSymbols.map(s => [s.name, s]));
+
+    // Find added and modified symbols
+    for (const symbol of currentSymbols) {
+      const oldSymbol = oldMap.get(symbol.name);
+
+      if (! oldSymbol) {
+        // New symbol
+        changes.push({
+          ...symbol,
+          changeType: 'added',
+          file: filePath,
+        });
+      } else if (this.hasSymbolChanged(symbol, oldSymbol)) {
+        // Modified symbol
+        changes.push({
+          ...symbol,
+          changeType: 'modified',
+          file: filePath,
+          oldSignature: oldSymbol.signature,
+        });
+      }
+    }
+
+    // Find deleted symbols
+    for (const symbol of oldSymbols) {
+      if (!currentMap.has(symbol.name)) {
+        changes.push({
+          ...symbol,
+          changeType: 'deleted',
+          file: filePath,
+        });
+      }
+    }
+
+    return changes;
+  }
+
+  /**
+   * Check if symbol has changed
+   */
+  hasSymbolChanged(newSymbol, oldSymbol) {
+    // Check signature change
+    if (newSymbol.signature !== oldSymbol.signature) return true;
+
+    // Check line number change (indicates body change)
+    if (newSymbol.startLine !== oldSymbol.startLine) return true;
+    if (newSymbol.endLine !== oldSymbol.endLine) return true;
+
+    return false;
+  }
+
+  /**
+   * Determine if file should be analyzed
+   */
+  shouldAnalyzeFile(filePath) {
+    // Must be a source file
+    if (!FileUtils.isSourceFile(filePath)) return false;
+
+    // Check exclude paths
+    if (this.config.excludePaths.some(exclude => filePath.includes(exclude))) {
+      return false;
+    }
+
+    // Optionally exclude test files
+    if (! this.config.includeTests && FileUtils.isTestFile(filePath)) {
+      return false;
+    }
+
+    return true;
+  }
+}

package/modules/detectors/database-detector.js

@@ -0,0 +1,182 @@
+/**
+ * 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;
+  }
+}

package/modules/detectors/endpoint-detector.js

@@ -0,0 +1,52 @@
+/**
+ * Endpoint Impact Detector
+ * Detects affected API endpoints using method-level call graph
+ */
+
+export class EndpointDetector {
+  constructor(methodCallGraph, config) {
+    this.methodCallGraph = methodCallGraph;
+    this.config = config;
+  }
+
+  /**
+   * Detect affected endpoints from changed files
+   */
+  async detect(changedFiles) {
+    const allChangedMethods = [];
+
+    for (const changedFile of changedFiles) {
+      const changedMethods = this.methodCallGraph.getChangedMethods(
+        changedFile.diff || '',
+        changedFile.absolutePath
+      );
+
+      allChangedMethods.push(...changedMethods);
+    }
+
+    if (allChangedMethods.length === 0) {
+      if (this.config.verbose) {
+        console.log('   ℹ️  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`);
+    }
+
+    const affectedEndpoints = this.methodCallGraph.findAffectedEndpoints(allChangedMethods);
+
+    if (this.config.verbose) {
+      for (const endpoint of affectedEndpoints) {
+        console.log(`\n   📍 Analyzing: ${endpoint.affectedBy}`);
+        console.log(`      ✓ Endpoint: ${endpoint.method} ${endpoint.path}`);
+        console.log(`      Chain: ${endpoint.callChain.join(' → ')}`);
+        console.log(`      Layers: ${endpoint.layers.join(' → ')}`);
+      }
+    }
+
+    return affectedEndpoints;
+  }
+}