@sun-asterisk/sunlint 1.3.33 → 1.3.35

package/core/impact-integration.js

@@ -0,0 +1,433 @@
+/**
+ * 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.impactModule = null;
+  }
+
+  /**
+   * Load impact analyzer module
+   * Note: impact-analyzer is ESM, so we use dynamic import
+   */
+  async loadImpactModule() {
+    if (this.impactModule) {
+      return this.impactModule;
+    }
+
+    // Priority 1: Try bundled version (engines/impact)
+    const bundledPath = path.join(__dirname, '..', 'engines', 'impact');
+    if (fs.existsSync(path.join(bundledPath, 'index.js'))) {
+      try {
+        // For ESM modules, we need to use dynamic import
+        const modulePath = path.join(bundledPath, 'core', 'impact-analyzer.js');
+        if (fs.existsSync(modulePath)) {
+          this.impactModule = {
+            bundledPath,
+            type: 'bundled'
+          };
+          if (this.options.verbose) {
+            console.log(chalk.gray('📦 Found bundled impact-analyzer'));
+          }
+          return this.impactModule;
+        }
+      } 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'))) {
+        this.impactModule = {
+          bundledPath: devPath,
+          type: 'development'
+        };
+        if (this.options.verbose) {
+          console.log(chalk.gray(`📦 Found impact-analyzer at: ${devPath}`));
+        }
+        return this.impactModule;
+      }
+    }
+
+    throw new Error(
+      'Impact analyzer module not found. Run "npm run build" in sunlint directory.'
+    );
+  }
+
+  /**
+   * 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;
+    }
+  }
+
+  /**
+   * Get changed files from git
+   */
+  getChangedFiles(baseRef, projectPath) {
+    try {
+      const result = execSync(`git diff --name-only ${baseRef}`, {
+        cwd: projectPath,
+        encoding: 'utf-8'
+      });
+      return result.trim().split('\n').filter(Boolean);
+    } catch (error) {
+      throw new Error(`Failed to get changed files: ${error.message}`);
+    }
+  }
+
+  /**
+   * 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 baseRef = this.options.impactBase || 'HEAD~1';
+
+    // 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(baseRef, absolutePath)) {
+      throw new Error(`Git ref does not exist: ${baseRef}`);
+    }
+
+    if (this.options.verbose) {
+      console.log(chalk.blue(`\n🔍 Impact Analysis`));
+      console.log(chalk.gray(`   Path: ${absolutePath}`));
+      console.log(chalk.gray(`   Base: ${baseRef}`));
+    }
+
+    // Get changed files
+    const changedFiles = this.getChangedFiles(baseRef, absolutePath);
+
+    if (changedFiles.length === 0) {
+      return this.createEmptyResult(baseRef);
+    }
+
+    // Categorize changes
+    const categorizedChanges = this.categorizeChanges(changedFiles, absolutePath);
+
+    // Calculate impact score
+    const impactScore = this.calculateImpactScore(categorizedChanges);
+    const severity = this.getSeverity(impactScore);
+
+    // Build result
+    const result = {
+      summary: {
+        baseRef,
+        totalChanges: changedFiles.length,
+        impactScore,
+        severity,
+        categories: {
+          api: categorizedChanges.api.length,
+          database: categorizedChanges.database.length,
+          core: categorizedChanges.core.length,
+          ui: categorizedChanges.ui.length,
+          tests: categorizedChanges.tests.length,
+          config: categorizedChanges.config.length,
+          other: categorizedChanges.other.length,
+        }
+      },
+      changes: categorizedChanges,
+      changedFiles,
+      violations: this.generateViolations(categorizedChanges, impactScore),
+    };
+
+    // Generate markdown report if requested
+    if (this.options.impactReport) {
+      result.markdownReport = this.generateMarkdownReport(result);
+    }
+
+    return result;
+  }
+
+  /**
+   * Categorize changed files by type
+   */
+  categorizeChanges(files, basePath) {
+    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 files) {
+      let categorized = false;
+
+      for (const [category, regexes] of Object.entries(patterns)) {
+        if (regexes.some(regex => regex.test(file))) {
+          categories[category].push(file);
+          categorized = true;
+          break;
+        }
+      }
+
+      if (!categorized) {
+        categories.other.push(file);
+      }
+    }
+
+    return categories;
+  }
+
+  /**
+   * Calculate impact score based on changes
+   */
+  calculateImpactScore(categories) {
+    const weights = {
+      api: 30,
+      database: 35,
+      core: 25,
+      ui: 10,
+      tests: 5,
+      config: 15,
+      other: 5,
+    };
+
+    let score = 0;
+    let maxScore = 0;
+
+    for (const [category, files] of Object.entries(categories)) {
+      const weight = weights[category] || 5;
+      const fileCount = files.length;
+
+      // Diminishing returns for many files in same category
+      const categoryScore = Math.min(fileCount * weight, weight * 3);
+      score += categoryScore;
+      maxScore += weight * 3;
+    }
+
+    // Normalize to 0-100
+    return Math.min(Math.round((score / maxScore) * 100), 100);
+  }
+
+  /**
+   * Get severity based on impact score
+   */
+  getSeverity(score) {
+    if (score >= 70) return 'critical';
+    if (score >= 50) return 'high';
+    if (score >= 30) return 'medium';
+    return 'low';
+  }
+
+  /**
+   * Generate violations for SunLint format
+   */
+  generateViolations(categories, impactScore) {
+    const violations = [];
+
+    // Add violations for high-impact changes
+    if (categories.api.length > 0) {
+      violations.push({
+        ruleId: 'IMPACT-API',
+        severity: categories.api.length > 3 ? 'error' : 'warning',
+        message: `API changes detected: ${categories.api.length} file(s) modified`,
+        file: categories.api[0],
+        line: 1,
+        column: 1,
+        category: 'impact',
+        source: 'impact-analyzer',
+        details: {
+          files: categories.api,
+          recommendation: 'Review API contracts and update documentation',
+        },
+      });
+    }
+
+    if (categories.database.length > 0) {
+      violations.push({
+        ruleId: 'IMPACT-DATABASE',
+        severity: categories.database.length > 2 ? 'error' : 'warning',
+        message: `Database changes detected: ${categories.database.length} file(s) modified`,
+        file: categories.database[0],
+        line: 1,
+        column: 1,
+        category: 'impact',
+        source: 'impact-analyzer',
+        details: {
+          files: categories.database,
+          recommendation: 'Verify migrations and backup strategy',
+        },
+      });
+    }
+
+    if (categories.core.length > 5) {
+      violations.push({
+        ruleId: 'IMPACT-CORE',
+        severity: 'warning',
+        message: `Large core logic changes: ${categories.core.length} file(s) modified`,
+        file: categories.core[0],
+        line: 1,
+        column: 1,
+        category: 'impact',
+        source: 'impact-analyzer',
+        details: {
+          files: categories.core,
+          recommendation: 'Ensure adequate test coverage for core changes',
+        },
+      });
+    }
+
+    return violations;
+  }
+
+  /**
+   * Create empty result when no changes
+   */
+  createEmptyResult(baseRef) {
+    return {
+      summary: {
+        baseRef,
+        totalChanges: 0,
+        impactScore: 0,
+        severity: 'none',
+        categories: {
+          api: 0,
+          database: 0,
+          core: 0,
+          ui: 0,
+          tests: 0,
+          config: 0,
+          other: 0,
+        }
+      },
+      changes: {
+        api: [],
+        database: [],
+        core: [],
+        ui: [],
+        tests: [],
+        config: [],
+        other: [],
+      },
+      changedFiles: [],
+      violations: [],
+    };
+  }
+
+  /**
+   * Generate markdown report
+   */
+  generateMarkdownReport(result) {
+    const { summary, changes } = 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;
+  }
+}
+
+module.exports = { ImpactIntegration };