@sun-asterisk/sunlint 1.3.35 → 1.3.36

package/core/cli-action-handler.js

@@ -591,7 +591,9 @@ class CliActionHandler {
       const integration = new ImpactIntegration({
         ...this.options,
         impactBase: this.options.impactBase || 'HEAD~1',
+        impactHead: this.options.impactHead,
         impactReport: this.options.impactReport,
+        impactMaxDepth: this.options.impactMaxDepth ? parseInt(this.options.impactMaxDepth, 10) : 3,
       });
 
       const projectPath = this.getProjectPath();
@@ -635,6 +637,14 @@ class CliActionHandler {
         }
       }
 
+      // Save JSON report if requested
+      if (this.options.impactJson) {
+        const jsonPath = await integration.saveJsonReport(results, this.options.impactJson);
+        if (!this.options.quiet) {
+          console.log(chalk.green(`📊 Impact JSON saved: ${jsonPath}`));
+        }
+      }
+
       return results;
     } catch (error) {
       console.error(chalk.yellow(`⚠️ Impact analysis failed: ${error.message}`));

package/core/cli-program.js

@@ -71,7 +71,10 @@ function createCliProgram() {
     .option('--arch-report', 'Generate architecture markdown report')
     .option('--impact', 'Enable impact analysis (analyze code changes)')
     .option('--impact-base <ref>', 'Base git ref for impact analysis (default: HEAD~1)')
+    .option('--impact-head <ref>', 'Head git ref for impact analysis (default: working directory)')
     .option('--impact-report <file>', 'Output impact report file (default: impact-report.md)')
+    .option('--impact-json <file>', 'Output impact analysis as JSON file')
+    .option('--impact-max-depth <n>', 'Maximum call graph depth for impact analysis (default: 3)')
     .option('--engine <engine>', 'Analysis engine: auto, eslint, heuristic', 'auto')
     .option('--eslint-integration', 'Merge with existing ESLint config')
     .option('--no-eslint-integration', 'Disable ESLint integration');
@@ -123,9 +126,12 @@ Architecture:
   sunlint --architecture --arch-report         # Generate MD report
 
 Impact Analysis:
-  sunlint --impact --input=src                 # Analyze code changes
-  sunlint --impact --impact-base=origin/main   # Compare with main
-  sunlint --impact --impact-report=report.md   # Custom output file
+  sunlint --impact --input=src                       # Analyze code changes
+  sunlint --impact --impact-base=origin/main         # Compare with main
+  sunlint --impact --impact-head=HEAD                # Specify head ref
+  sunlint --impact --impact-report=report.md         # Markdown report
+  sunlint --impact --impact-json=report.json         # JSON report
+  sunlint --impact --impact-max-depth=5              # Call graph depth
 
 Performance:
   sunlint --all --performance=fast --input=.   # Quick scan

package/core/impact-integration.js

@@ -12,7 +12,10 @@ const { execSync } = require('child_process');
 class ImpactIntegration {
   constructor(options = {}) {
     this.options = options;
-    this.impactModule = null;
+    this.impactModulePath = null;
+    this.ChangeDetector = null;
+    this.ImpactAnalyzer = null;
+    this.ReportGenerator = null;
   }
 
   /**
@@ -20,26 +23,20 @@ class ImpactIntegration {
    * Note: impact-analyzer is ESM, so we use dynamic import
    */
   async loadImpactModule() {
-    if (this.impactModule) {
-      return this.impactModule;
+    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 {
-        // 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;
+        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}`));
@@ -55,22 +52,44 @@ class ImpactIntegration {
 
     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}`));
+        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}`));
+          }
         }
-        return this.impactModule;
       }
     }
 
     throw new Error(
-      'Impact analyzer module not found. Run "npm run build" in sunlint directory.'
+      '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
    */
@@ -102,18 +121,20 @@ class ImpactIntegration {
   }
 
   /**
-   * Get changed files from git
+   * Build config object for impact analyzer
    */
-  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}`);
-    }
+  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,
+    };
   }
 
   /**
@@ -125,7 +146,7 @@ class ImpactIntegration {
     await this.loadImpactModule();
 
     const absolutePath = path.resolve(projectPath);
-    const baseRef = this.options.impactBase || 'HEAD~1';
+    const config = this.buildConfig(absolutePath);
 
     // Validation
     if (!fs.existsSync(absolutePath)) {
@@ -136,64 +157,199 @@ class ImpactIntegration {
       throw new Error(`Not a git repository: ${absolutePath}`);
     }
 
-    if (!this.refExists(baseRef, absolutePath)) {
-      throw new Error(`Git ref does not exist: ${baseRef}`);
+    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`));
+      console.log(chalk.blue(`\n🔍 Impact Analysis Configuration`));
       console.log(chalk.gray(`   Path: ${absolutePath}`));
-      console.log(chalk.gray(`   Base: ${baseRef}`));
+      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}`));
     }
 
-    // Get changed files
-    const changedFiles = this.getChangedFiles(baseRef, absolutePath);
+    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;
 
-    if (changedFiles.length === 0) {
-      return this.createEmptyResult(baseRef);
+    } 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
     }
 
-    // Categorize changes
-    const categorizedChanges = this.categorizeChanges(changedFiles, absolutePath);
+    // 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"]
+    };
 
-    // Calculate impact score
-    const impactScore = this.calculateImpactScore(categorizedChanges);
-    const severity = this.getSeverity(impactScore);
+    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;
+  }
 
-    // Build result
-    const result = {
+  /**
+   * 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,
-        totalChanges: changedFiles.length,
-        impactScore,
-        severity,
+        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: {
-          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,
+          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',
         }
       },
-      changes: categorizedChanges,
-      changedFiles,
-      violations: this.generateViolations(categorizedChanges, impactScore),
+      violations: this.generateViolationsFromImpact(impact),
+      fileCategories,
     };
-
-    // Generate markdown report if requested
-    if (this.options.impactReport) {
-      result.markdownReport = this.generateMarkdownReport(result);
-    }
-
-    return result;
   }
 
   /**
-   * Categorize changed files by type
+   * Categorize changed files for reporting
    */
-  categorizeChanges(files, basePath) {
+  categorizeFiles(changedFiles) {
     const categories = {
       api: [],
       database: [],
@@ -213,19 +369,20 @@ class ImpactIntegration {
       config: [/config/i, /\.json$/i, /\.ya?ml$/i, /\.env/i, /dockerfile/i],
     };
 
-    for (const file of files) {
+    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(file))) {
-          categories[category].push(file);
+        if (regexes.some(regex => regex.test(filePath))) {
+          categories[category].push(filePath);
           categorized = true;
           break;
         }
       }
 
       if (!categorized) {
-        categories.other.push(file);
+        categories.other.push(filePath);
       }
     }
 
@@ -233,146 +390,97 @@ class ImpactIntegration {
   }
 
   /**
-   * 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
+   * Generate violations from impact analysis results
    */
-  generateViolations(categories, impactScore) {
+  generateViolationsFromImpact(impact) {
     const violations = [];
 
-    // Add violations for high-impact changes
-    if (categories.api.length > 0) {
+    // Endpoint impact violations
+    if (impact.affectedEndpoints && impact.affectedEndpoints.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],
+        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: {
-          files: categories.api,
-          recommendation: 'Review API contracts and update documentation',
+          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',
         },
       });
     }
 
-    if (categories.database.length > 0) {
+    // Database impact violations
+    if (impact.databaseImpact?.migrations?.length > 0 || 
+        impact.databaseImpact?.riskLevel !== 'none') {
       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],
+        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: {
-          files: categories.database,
-          recommendation: 'Verify migrations and backup strategy',
+          migrations: impact.databaseImpact.migrations || [],
+          schemaChanges: impact.databaseImpact.schemaChanges || [],
+          riskLevel: impact.databaseImpact.riskLevel,
+          recommendation: 'Review migrations, ensure backward compatibility, and plan database rollback strategy',
         },
       });
     }
 
-    if (categories.core.length > 5) {
+    // Logic impact violations
+    if (impact.logicImpact?.directCallers?.length > 5 ||
+        impact.logicImpact?.riskLevel === 'high') {
       violations.push({
-        ruleId: 'IMPACT-CORE',
-        severity: 'warning',
-        message: `Large core logic changes: ${categories.core.length} file(s) modified`,
-        file: categories.core[0],
+        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: {
-          files: categories.core,
-          recommendation: 'Ensure adequate test coverage for core changes',
+          directCallers: impact.logicImpact.directCallers || [],
+          indirectCallers: impact.logicImpact.indirectCallers || [],
+          riskLevel: impact.logicImpact.riskLevel,
+          recommendation: 'Ensure comprehensive test coverage for affected code paths',
         },
       });
     }
 
-    return violations;
-  }
+    // 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.',
+        },
+      });
+    }
 
-  /**
-   * 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: [],
-    };
+    return violations;
   }
 
   /**
-   * Generate markdown report
+   * Generate markdown report (legacy - now handled by ReportGenerator)
    */
   generateMarkdownReport(result) {
-    const { summary, changes } = result;
+    const { summary } = result;
     const severityEmoji = {
       critical: '🔴',
       high: '🟠',
@@ -428,6 +536,16 @@ class ImpactIntegration {
     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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sun-asterisk/sunlint",
-  "version": "1.3.35",
+  "version": "1.3.36",
   "description": "☀️ SunLint - Multi-language static analysis tool for code quality and security | Sun* Engineering Standards",
   "main": "cli.js",
   "bin": {