@sun-asterisk/sunlint 1.3.34 → 1.3.36

package/core/impact-integration.js

@@ -0,0 +1,551 @@
+/**
+ * Impact Integration for SunLint
+ * Wraps impact-analyzer module for seamless integration
+ * Following Rule C005: Single responsibility - handle impact analysis integration
+ */
+
+const path = require('path');
+const fs = require('fs');
+const chalk = require('chalk');
+const { execSync } = require('child_process');
+
+class ImpactIntegration {
+  constructor(options = {}) {
+    this.options = options;
+    this.impactModulePath = null;
+    this.ChangeDetector = null;
+    this.ImpactAnalyzer = null;
+    this.ReportGenerator = null;
+  }
+
+  /**
+   * Load impact analyzer module
+   * Note: impact-analyzer is ESM, so we use dynamic import
+   */
+  async loadImpactModule() {
+    if (this.ChangeDetector && this.ImpactAnalyzer) {
+      return;
+    }
+
+    // Priority 1: Try bundled version (engines/impact)
+    const bundledPath = path.join(__dirname, '..', 'engines', 'impact');
+    if (fs.existsSync(path.join(bundledPath, 'index.js'))) {
+      try {
+        this.impactModulePath = bundledPath;
+        await this.loadModules(bundledPath);
+        if (this.options.verbose) {
+          console.log(chalk.gray('📦 Loaded bundled impact-analyzer'));
+        }
+        return;
+      } catch (error) {
+        if (this.options.verbose) {
+          console.log(chalk.yellow(`⚠️ Failed to load bundled: ${error.message}`));
+        }
+      }
+    }
+
+    // Priority 2: Try local development path
+    const devPaths = [
+      path.join(__dirname, '..', '..', '..', '..', 'impact-analyzer'),
+      path.join(__dirname, '..', '..', '..', 'impact-analyzer'),
+    ];
+
+    for (const devPath of devPaths) {
+      if (fs.existsSync(path.join(devPath, 'index.js'))) {
+        try {
+          this.impactModulePath = devPath;
+          await this.loadModules(devPath);
+          if (this.options.verbose) {
+            console.log(chalk.gray(`📦 Loaded impact-analyzer from: ${devPath}`));
+          }
+          return;
+        } catch (error) {
+          if (this.options.verbose) {
+            console.log(chalk.yellow(`⚠️ Failed to load from ${devPath}: ${error.message}`));
+          }
+        }
+      }
+    }
+
+    throw new Error(
+      'Impact analyzer module not found. Ensure impact-analyzer exists in the monorepo.'
+    );
+  }
+
+  /**
+   * Load ESM modules using dynamic import
+   */
+  async loadModules(basePath) {
+    const changeDetectorPath = path.join(basePath, 'core', 'change-detector.js');
+    const impactAnalyzerPath = path.join(basePath, 'core', 'impact-analyzer.js');
+    const reportGeneratorPath = path.join(basePath, 'core', 'report-generator.js');
+
+    // Use dynamic import for ESM modules
+    const changeDetectorModule = await import(`file://${changeDetectorPath}`);
+    const impactAnalyzerModule = await import(`file://${impactAnalyzerPath}`);
+    const reportGeneratorModule = await import(`file://${reportGeneratorPath}`);
+
+    this.ChangeDetector = changeDetectorModule.ChangeDetector;
+    this.ImpactAnalyzer = impactAnalyzerModule.ImpactAnalyzer;
+    this.ReportGenerator = reportGeneratorModule.ReportGenerator;
+  }
+
+  /**
+   * Check if git repository
+   */
+  isGitRepo(projectPath) {
+    try {
+      execSync('git rev-parse --git-dir', {
+        cwd: projectPath,
+        stdio: 'pipe'
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check if git ref exists
+   */
+  refExists(ref, projectPath) {
+    try {
+      execSync(`git rev-parse ${ref}`, {
+        cwd: projectPath,
+        stdio: 'pipe'
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Build config object for impact analyzer
+   */
+  buildConfig(projectPath) {
+    return {
+      sourceDir: projectPath,
+      baseRef: this.options.impactBase || 'HEAD~1',
+      headRef: this.options.impactHead || '',  // Empty means current working directory
+      excludePaths: this.options.exclude 
+        ? this.options.exclude.split(',').map(p => p.trim())
+        : ['node_modules', 'dist', 'build', 'specs', 'coverage'],
+      maxDepth: this.options.impactMaxDepth || 3,
+      includeTests: this.options.impactIncludeTests || false,
+      verbose: this.options.verbose || false,
+    };
+  }
+
+  /**
+   * Run impact analysis on project
+   * @param {string} projectPath - Path to analyze
+   * @returns {Object} Impact analysis results
+   */
+  async analyze(projectPath) {
+    await this.loadImpactModule();
+
+    const absolutePath = path.resolve(projectPath);
+    const config = this.buildConfig(absolutePath);
+
+    // Validation
+    if (!fs.existsSync(absolutePath)) {
+      throw new Error(`Directory does not exist: ${absolutePath}`);
+    }
+
+    if (!this.isGitRepo(absolutePath)) {
+      throw new Error(`Not a git repository: ${absolutePath}`);
+    }
+
+    if (!this.refExists(config.baseRef, absolutePath)) {
+      throw new Error(`Git ref does not exist: ${config.baseRef}`);
+    }
+
+    if (config.headRef && !this.refExists(config.headRef, absolutePath)) {
+      throw new Error(`Head git ref does not exist: ${config.headRef}`);
+    }
+
+    // Ensure tsconfig.json exists (required by ts-morph)
+    await this.ensureTsConfig(absolutePath);
+
+    if (this.options.verbose) {
+      console.log(chalk.blue(`\n🔍 Impact Analysis Configuration`));
+      console.log(chalk.gray(`   Path: ${absolutePath}`));
+      console.log(chalk.gray(`   Base: ${config.baseRef}`));
+      console.log(chalk.gray(`   Head: ${config.headRef || 'working directory'}`));
+      console.log(chalk.gray(`   Max Depth: ${config.maxDepth}`));
+      console.log(chalk.gray(`   Include Tests: ${config.includeTests}`));
+    }
+
+    try {
+      // ============================================
+      // Step 1: Detect Changes
+      // ============================================
+      if (this.options.verbose) {
+        console.log(chalk.blue('\n📝 Step 1: Detecting changes...'));
+      }
+
+      const detector = new this.ChangeDetector(config);
+      const changedFiles = detector.detectChangedFiles();
+      
+      if (this.options.verbose) {
+        console.log(chalk.gray(`   ✓ Found ${changedFiles.length} changed files`));
+      }
+
+      const changedSymbols = detector.detectChangedSymbols(changedFiles);
+      
+      if (this.options.verbose) {
+        console.log(chalk.gray(`   ✓ Found ${changedSymbols.length} changed symbols`));
+      }
+
+      const changes = {
+        changedFiles,
+        changedSymbols,
+      };
+
+      // ============================================
+      // Step 2: Analyze Impact
+      // ============================================
+      if (this.options.verbose) {
+        console.log(chalk.blue('\n🔍 Step 2: Analyzing impact...'));
+      }
+
+      const analyzer = new this.ImpactAnalyzer(config);
+      
+      // Initialize method-level call graph for precise tracking
+      await analyzer.initializeMethodCallGraph();
+      
+      const impact = await analyzer.analyzeImpact(changes);
+      
+      if (this.options.verbose) {
+        console.log(chalk.gray(`   ✓ Impact score: ${impact.impactScore}`));
+        console.log(chalk.gray(`   ✓ Severity: ${impact.severity.toUpperCase()}`));
+      }
+
+      // ============================================
+      // Step 3: Build Result
+      // ============================================
+      const result = this.buildResult(changes, impact, config);
+
+      // Generate markdown report if requested
+      if (this.options.impactReport) {
+        const reporter = new this.ReportGenerator();
+        result.markdownReport = reporter.generateMarkdownReport(changes, impact);
+      }
+
+      return result;
+
+    } catch (error) {
+      // Re-throw with more context
+      throw new Error(`Impact analysis failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Ensure tsconfig.json exists (required by ts-morph)
+   */
+  async ensureTsConfig(projectPath) {
+    const tsconfigPath = path.join(projectPath, '..', 'tsconfig.json');
+    
+    if (fs.existsSync(tsconfigPath)) {
+      return; // Already exists
+    }
+
+    // Create minimal tsconfig.json for analysis
+    const minimalTsConfig = {
+      compilerOptions: {
+        target: "ES2020",
+        module: "commonjs",
+        lib: ["ES2020"],
+        moduleResolution: "node",
+        esModuleInterop: true,
+        skipLibCheck: true,
+        strict: false,
+        resolveJsonModule: true,
+        allowSyntheticDefaultImports: true,
+      },
+      include: ["**/*"],
+      exclude: ["node_modules", "dist", "build"]
+    };
+
+    if (this.options.verbose) {
+      console.log(chalk.gray(`   Creating minimal tsconfig.json at: ${tsconfigPath}`));
+    }
+
+    fs.writeFileSync(tsconfigPath, JSON.stringify(minimalTsConfig, null, 2));
+    
+    // Mark for cleanup
+    this.tempTsConfig = tsconfigPath;
+  }
+
+  /**
+   * Clean up temporary files
+   */
+  cleanup() {
+    if (this.tempTsConfig && fs.existsSync(this.tempTsConfig)) {
+      try {
+        fs.unlinkSync(this.tempTsConfig);
+        if (this.options.verbose) {
+          console.log(chalk.gray(`   Cleaned up temporary tsconfig.json`));
+        }
+      } catch (error) {
+        // Ignore cleanup errors
+      }
+    }
+  }
+
+  /**
+   * Build comprehensive result from impact analysis
+   */
+  buildResult(changes, impact, config) {
+    // Extract data from impact analysis
+    const { affectedEndpoints = [], databaseImpact = {}, logicImpact = {} } = impact;
+    
+    // Calculate category counts from file categorization
+    const fileCategories = this.categorizeFiles(changes.changedFiles);
+    
+    return {
+      summary: {
+        baseRef: config.baseRef,
+        headRef: config.headRef || 'working directory',
+        totalChanges: changes.changedFiles.length,
+        changedSymbols: changes.changedSymbols.length,
+        impactScore: impact.impactScore || 0,
+        severity: impact.severity || 'none',
+        categories: {
+          endpoints: affectedEndpoints.length,
+          database: databaseImpact.migrations?.length || 0,
+          logic: logicImpact.directCallers?.length || 0,
+          files: changes.changedFiles.length,
+        }
+      },
+      changes: {
+        changedFiles: changes.changedFiles,
+        changedSymbols: changes.changedSymbols,
+      },
+      impact: {
+        affectedEndpoints: affectedEndpoints.map(ep => ({
+          path: ep.path,
+          method: ep.method,
+          handler: ep.handler,
+          impactReason: ep.impactReason || 'Direct or indirect change',
+        })),
+        databaseImpact: {
+          migrations: databaseImpact.migrations || [],
+          schemaChanges: databaseImpact.schemaChanges || [],
+          riskLevel: databaseImpact.riskLevel || 'none',
+        },
+        logicImpact: {
+          directCallers: logicImpact.directCallers || [],
+          indirectCallers: logicImpact.indirectCallers || [],
+          riskLevel: logicImpact.riskLevel || 'none',
+        }
+      },
+      violations: this.generateViolationsFromImpact(impact),
+      fileCategories,
+    };
+  }
+
+  /**
+   * Categorize changed files for reporting
+   */
+  categorizeFiles(changedFiles) {
+    const categories = {
+      api: [],
+      database: [],
+      core: [],
+      ui: [],
+      tests: [],
+      config: [],
+      other: [],
+    };
+
+    const patterns = {
+      api: [/controller/i, /route/i, /endpoint/i, /api\//i, /handler/i],
+      database: [/repository/i, /model/i, /schema/i, /migration/i, /entity/i, /dao/i],
+      core: [/service/i, /usecase/i, /domain/i, /core\//i, /lib\//i],
+      ui: [/component/i, /view/i, /page/i, /screen/i, /widget/i, /\.tsx$/i, /\.vue$/i],
+      tests: [/test/i, /spec/i, /__tests__/i],
+      config: [/config/i, /\.json$/i, /\.ya?ml$/i, /\.env/i, /dockerfile/i],
+    };
+
+    for (const file of changedFiles) {
+      const filePath = file.path || file;
+      let categorized = false;
+
+      for (const [category, regexes] of Object.entries(patterns)) {
+        if (regexes.some(regex => regex.test(filePath))) {
+          categories[category].push(filePath);
+          categorized = true;
+          break;
+        }
+      }
+
+      if (!categorized) {
+        categories.other.push(filePath);
+      }
+    }
+
+    return categories;
+  }
+
+  /**
+   * Generate violations from impact analysis results
+   */
+  generateViolationsFromImpact(impact) {
+    const violations = [];
+
+    // Endpoint impact violations
+    if (impact.affectedEndpoints && impact.affectedEndpoints.length > 0) {
+      violations.push({
+        ruleId: 'IMPACT-ENDPOINTS',
+        severity: impact.affectedEndpoints.length > 5 ? 'error' : 'warning',
+        message: `${impact.affectedEndpoints.length} API endpoint(s) affected by changes`,
+        line: 1,
+        column: 1,
+        category: 'impact',
+        source: 'impact-analyzer',
+        details: {
+          endpoints: impact.affectedEndpoints.slice(0, 10).map(ep => 
+            `${ep.method || 'GET'} ${ep.path}`
+          ),
+          total: impact.affectedEndpoints.length,
+          recommendation: 'Review API contracts, update documentation, and verify backward compatibility',
+        },
+      });
+    }
+
+    // Database impact violations
+    if (impact.databaseImpact?.migrations?.length > 0 || 
+        impact.databaseImpact?.riskLevel !== 'none') {
+      violations.push({
+        ruleId: 'IMPACT-DATABASE',
+        severity: impact.databaseImpact.riskLevel === 'high' ? 'error' : 'warning',
+        message: `Database changes detected (${impact.databaseImpact.riskLevel} risk)`,
+        line: 1,
+        column: 1,
+        category: 'impact',
+        source: 'impact-analyzer',
+        details: {
+          migrations: impact.databaseImpact.migrations || [],
+          schemaChanges: impact.databaseImpact.schemaChanges || [],
+          riskLevel: impact.databaseImpact.riskLevel,
+          recommendation: 'Review migrations, ensure backward compatibility, and plan database rollback strategy',
+        },
+      });
+    }
+
+    // Logic impact violations
+    if (impact.logicImpact?.directCallers?.length > 5 ||
+        impact.logicImpact?.riskLevel === 'high') {
+      violations.push({
+        ruleId: 'IMPACT-LOGIC',
+        severity: impact.logicImpact.riskLevel === 'high' ? 'error' : 'warning',
+        message: `High logic impact: ${impact.logicImpact.directCallers?.length || 0} direct callers affected`,
+        line: 1,
+        column: 1,
+        category: 'impact',
+        source: 'impact-analyzer',
+        details: {
+          directCallers: impact.logicImpact.directCallers || [],
+          indirectCallers: impact.logicImpact.indirectCallers || [],
+          riskLevel: impact.logicImpact.riskLevel,
+          recommendation: 'Ensure comprehensive test coverage for affected code paths',
+        },
+      });
+    }
+
+    // High severity overall impact
+    if (impact.severity === 'critical' || impact.impactScore > 70) {
+      violations.push({
+        ruleId: 'IMPACT-CRITICAL',
+        severity: 'error',
+        message: `Critical impact detected (score: ${impact.impactScore}/100)`,
+        line: 1,
+        column: 1,
+        category: 'impact',
+        source: 'impact-analyzer',
+        details: {
+          impactScore: impact.impactScore,
+          severity: impact.severity,
+          recommendation: 'This change has wide-reaching impact. Consider phased rollout and comprehensive testing.',
+        },
+      });
+    }
+
+    return violations;
+  }
+
+  /**
+   * Generate markdown report (legacy - now handled by ReportGenerator)
+   */
+  generateMarkdownReport(result) {
+    const { summary } = result;
+    const severityEmoji = {
+      critical: '🔴',
+      high: '🟠',
+      medium: '🟡',
+      low: '🟢',
+      none: '⚪',
+    };
+
+    let md = `# Impact Analysis Report\n\n`;
+    md += `**Base Reference:** \`${summary.baseRef}\`\n`;
+    md += `**Generated:** ${new Date().toISOString()}\n\n`;
+
+    md += `## Summary\n\n`;
+    md += `| Metric | Value |\n`;
+    md += `|--------|-------|\n`;
+    md += `| Total Changes | ${summary.totalChanges} files |\n`;
+    md += `| Impact Score | ${summary.impactScore}/100 |\n`;
+    md += `| Severity | ${severityEmoji[summary.severity]} ${summary.severity.toUpperCase()} |\n\n`;
+
+    md += `## Changes by Category\n\n`;
+    md += `| Category | Files |\n`;
+    md += `|----------|-------|\n`;
+
+    for (const [category, count] of Object.entries(summary.categories)) {
+      if (count > 0) {
+        md += `| ${category.charAt(0).toUpperCase() + category.slice(1)} | ${count} |\n`;
+      }
+    }
+
+    md += `\n## Changed Files\n\n`;
+
+    for (const [category, files] of Object.entries(changes)) {
+      if (files.length > 0) {
+        md += `### ${category.charAt(0).toUpperCase() + category.slice(1)} (${files.length})\n\n`;
+        for (const file of files) {
+          md += `- \`${file}\`\n`;
+        }
+        md += `\n`;
+      }
+    }
+
+    md += `---\n`;
+    md += `*Generated by SunLint Impact Analyzer*\n`;
+
+    return md;
+  }
+
+  /**
+   * Save markdown report to file
+   */
+  async saveReport(markdownContent, outputPath) {
+    const resolvedPath = path.resolve(outputPath || 'impact-report.md');
+    fs.writeFileSync(resolvedPath, markdownContent, 'utf8');
+    return resolvedPath;
+  }
+
+  /**
+   * Save JSON report to file
+   */
+  async saveJsonReport(results, outputPath) {
+    const resolvedPath = path.resolve(outputPath);
+    const jsonContent = JSON.stringify(results, null, 2);
+    fs.writeFileSync(resolvedPath, jsonContent, 'utf8');
+    return resolvedPath;
+  }
+}
+
+module.exports = { ImpactIntegration };