@sun-asterisk/sunlint 1.0.5

package/core/analysis-orchestrator.js

@@ -0,0 +1,705 @@
+/**
+ * Analysis Orchestrator
+ * Following Rule C005: Single responsibility - orchestrate analysis
+ * Following Rule C014: Dependency Injection - inject engines
+ */
+
+const chalk = require('chalk');
+const MultiRuleRunner = require('./multi-rule-runner');
+const TypeScriptEngine = require('./typescript-engine');
+const RuleMappingService = require('./rule-mapping-service');
+const ESLintIntegrationService = require('./eslint-integration-service');
+
+class AnalysisOrchestrator {
+  constructor() {
+    this.multiRuleRunner = null;
+    this.typeScriptEngine = null;
+    this.ruleMappingService = new RuleMappingService();
+    this.eslintIntegrationService = new ESLintIntegrationService();
+  }
+
+  async runAnalysis(rulesToRun, options, config = {}) {
+    try {
+      // Check for ESLint integration mode
+      if (this.shouldUseESLintIntegration(options, config)) {
+        return await this.runESLintIntegratedAnalysis(rulesToRun, options, config);
+      }
+
+      // Check AI configuration and provide feedback
+      if (options.ai === true) {
+        this.checkAIConfiguration(rulesToRun, config);
+      }
+
+      // Check if user explicitly requests TypeScript engine
+      if (options.typescript || options.typescriptEngine === 'eslint') {
+        // Force all rules through TypeScript engine when --typescript flag is used
+        return await this.runTypeScriptAnalysis(rulesToRun, options, config);
+      }
+
+      // Auto-detect based on rule analyzer
+      const eslintRules = rulesToRun.filter(rule => 
+        rule.analyzer === 'eslint' || 
+        rule.analyzer === 'typescript' // Legacy typescript analyzer routes to eslint
+      );
+      const customRules = rulesToRun.filter(rule => 
+        rule.analyzer && 
+        rule.analyzer !== 'eslint' && 
+        rule.analyzer !== 'typescript'
+      );
+      
+      // Debug logging for rule routing
+      if (!options.quiet && options.format !== 'json') {
+        console.log(chalk.cyan(`🔍 Rule routing: ${eslintRules.length} ESLint rules, ${customRules.length} custom rules`));
+        if (eslintRules.length > 0) {
+          console.log(chalk.cyan(`   ESLint rules: ${eslintRules.map(r => r.id).join(', ')}`));
+        }
+      }
+      
+      // If we have ESLint rules, run TypeScript analysis
+      if (eslintRules.length > 0) {
+        return await this.runTypeScriptAnalysis(eslintRules, options, config);
+      }
+
+      // For custom analyzer rules, use multi-rule runner
+      if (customRules.length > 0) {
+        // Initialize multi-rule runner if available
+        if (!this.multiRuleRunner) {
+          try {
+            this.multiRuleRunner = new MultiRuleRunner(config, options);
+          } catch (error) {
+            console.log(chalk.yellow('⚠️  Multi-rule runner not available, using basic analysis'));
+            return this.runBasicAnalysis(rulesToRun, options, config);
+          }
+        }
+
+        // Run analysis using existing multi-rule runner
+        return await this.multiRuleRunner.runRules(customRules, options.input, options);
+      }
+
+      // Fallback to basic analysis
+      return this.runBasicAnalysis(rulesToRun, options, config);
+      
+    } catch (error) {
+      console.log(chalk.yellow('⚠️  Falling back to basic analysis'));
+      return this.runBasicAnalysis(rulesToRun, options, config);
+    }
+  }
+
+  async runBasicAnalysis(rulesToRun, options, config = {}) {
+    console.log(chalk.blue(`🔄 Analyzing ${rulesToRun.length} rules...`));
+    
+    // Basic mock analysis for now
+    const results = {
+      results: [],
+      filesAnalyzed: 1,
+      engine: 'sunlint-basic'
+    };
+
+    // For demonstration, create some mock violations for C006
+    if (rulesToRun.some(rule => rule.id === 'C006')) {
+      results.results.push({
+        file: options.input,
+        violations: [
+          {
+            ruleId: 'C006',
+            severity: 'warning',
+            message: 'Function name should follow verb-noun pattern',
+            line: 1,
+            column: 1
+          }
+        ]
+      });
+    }
+
+    return results;
+  }
+
+  /**
+   * Run TypeScript analysis using ESLint
+   * Following Rule C005: Single responsibility
+   */
+  async runTypeScriptAnalysis(rulesToRun, options, config = {}) {
+    try {
+      // Initialize TypeScript engine
+      if (!this.typeScriptEngine) {
+        this.typeScriptEngine = new TypeScriptEngine();
+      }
+
+      // Check and install dependencies if needed
+      if (options.ensureDeps) {
+        await this.ensureTypeScriptDependencies();
+      }
+
+      // Configure rules dynamically (important for security rules)
+      const selectedRuleIds = rulesToRun.map(rule => rule.id);
+      await this.typeScriptEngine.configureRules(selectedRuleIds, options);
+
+      // Filter rules that can be handled by ESLint
+      const eslintSupportedRules = rulesToRun.filter(rule => 
+        this.ruleMappingService.isSunLintRuleSupportedByEslint(rule.id)
+      );
+
+      if (eslintSupportedRules.length === 0) {
+        if (!options.quiet && options.format !== 'json') {
+          console.log(chalk.yellow('⚠️  No ESLint-supported rules found, falling back to basic analysis'));
+        }
+        return this.runBasicAnalysis(rulesToRun, options, config);
+      }
+
+      if (!options.quiet && options.format !== 'json') {
+        console.log(chalk.blue(`🔄 Running TypeScript analysis with ${eslintSupportedRules.length} rules...`));
+      }
+
+      // Run ESLint analysis
+      const inputPaths = options.isFileList ? options.input : [options.input];
+      const eslintResults = await this.typeScriptEngine.runAnalysis(inputPaths, options);
+
+      // Convert results to SunLint format
+      const sunlintResults = this.typeScriptEngine.convertToSunLintFormat(
+        eslintResults,
+        this.ruleMappingService.eslintToSunlintMapping || {},
+        options
+      );
+
+      // Filter results to only include requested rules
+      const filteredResults = this.filterResultsByRules(sunlintResults, eslintSupportedRules);
+
+      return filteredResults;
+
+    } catch (error) {
+      // Following Rule C035: Log full error information
+      console.error(chalk.red('❌ TypeScript analysis failed:'), {
+        message: error.message,
+        rules: rulesToRun.map(r => r.id),
+        options,
+      });
+      
+      console.log(chalk.yellow('⚠️  Falling back to basic analysis'));
+      return this.runBasicAnalysis(rulesToRun, options, config);
+    }
+  }
+
+  /**
+   * Ensure TypeScript dependencies are installed
+   * Following Rule C006: Verb-noun naming
+   */
+  async ensureTypeScriptDependencies() {
+    const deps = await this.typeScriptEngine.checkDependencies();
+    
+    if (!deps.nodeModulesExists) {
+      console.log(chalk.blue('📦 Installing TypeScript dependencies...'));
+      await this.typeScriptEngine.installDependencies();
+    }
+  }
+
+  /**
+   * Filter results by requested rules
+   * Following Rule C012: Query - pure function
+   */
+  filterResultsByRules(results, requestedRules) {
+    const requestedRuleIds = new Set(requestedRules.map(r => r.id));
+    
+    const filteredResults = {
+      ...results,
+      results: results.results.map(fileResult => ({
+        ...fileResult,
+        violations: fileResult.violations.filter(violation => 
+          requestedRuleIds.has(violation.ruleId)
+        )
+      })).filter(fileResult => fileResult.violations.length > 0)
+    };
+
+    // Recalculate total violations
+    filteredResults.totalViolations = filteredResults.results.reduce(
+      (total, fileResult) => total + fileResult.violations.length,
+      0
+    );
+
+    return filteredResults;
+  }
+
+  /**
+   * Check AI configuration and provide user feedback
+   * Following Rule C006: Verb-noun naming - checkAIConfiguration
+   */
+  checkAIConfiguration(rulesToRun, config) {
+    const chalk = require('chalk');
+    const hasApiKey = process.env.OPENAI_API_KEY || (config.ai && config.ai.apiKey);
+    
+    // Check which rules support AI
+    const aiSupportedRules = ['C019', 'C029']; // Rules that have AI analyzer support
+    const aiCapableRules = rulesToRun.filter(rule => aiSupportedRules.includes(rule.id));
+    const nonAiRules = rulesToRun.filter(rule => !aiSupportedRules.includes(rule.id));
+    
+    if (nonAiRules.length > 0) {
+      console.log(chalk.yellow(`⚠️  AI analysis not supported for: ${nonAiRules.map(r => r.id).join(', ')}`));
+      console.log(chalk.gray(`   These rules will use pattern-based analysis`));
+    }
+    
+    if (aiCapableRules.length > 0) {
+      if (!hasApiKey) {
+        console.log(chalk.yellow(`⚠️  OPENAI_API_KEY not set for AI-capable rules: ${aiCapableRules.map(r => r.id).join(', ')}`));
+        console.log(chalk.gray(`   Falling back to pattern-based analysis`));
+        console.log(chalk.gray(`   To enable AI analysis: export OPENAI_API_KEY="your-api-key"`));
+      } else {
+        console.log(chalk.green(`🤖 AI analysis enabled for: ${aiCapableRules.map(r => r.id).join(', ')}`));
+      }
+    }
+  }
+
+  /**
+   * Check if ESLint integration should be used
+   */
+  shouldUseESLintIntegration(options, config) {
+    return (
+      options.eslintIntegration ||
+      config.eslintIntegration?.enabled ||
+      options.typescript  // Auto-enable for TypeScript analysis
+    );
+  }
+
+  /**
+   * Run analysis with ESLint integration (merged config)
+   */
+  async runESLintIntegratedAnalysis(rulesToRun, options, config) {
+    try {
+      if (!options.quiet) {
+        console.log(chalk.blue('🔗 Running integrated analysis (SunLint + ESLint)'));
+      }
+
+      // Determine file list
+      const filePaths = this.getFileList(options);
+
+      // First, run SunLint custom rules
+      const sunlintResults = await this.runStandardAnalysis(rulesToRun, options, config);
+
+      // Then, run integrated ESLint analysis
+      const eslintResults = await this.eslintIntegrationService.runIntegratedAnalysis(
+        filePaths, 
+        config, 
+        {
+          fix: options.fix,
+          quiet: true, // Suppress ESLint service logging
+          verbose: options.verbose
+        }
+      );
+
+      // Merge SunLint and ESLint results
+      if (!options.quiet) {
+        console.log('Debug: SunLint results structure:', JSON.stringify(sunlintResults, null, 2).substring(0, 300));
+        console.log('Debug: ESLint results structure:', JSON.stringify(eslintResults, null, 2).substring(0, 300));
+      }
+      const mergedResults = this.mergeAnalysisResults(sunlintResults, eslintResults, options);
+
+      // Log integration summary with merged results
+      if (!options.quiet) {
+        this.eslintIntegrationService.logIntegrationSummary(
+          eslintResults.categorized || { sunlint: [], user: [], combined: [] },
+          true,
+          mergedResults
+        );
+      }
+
+      // Add metadata
+      mergedResults.engine = 'sunlint-eslint-integrated';
+      mergedResults.integration = {
+        totalRules: eslintResults.totalRules,
+        sunlintRules: mergedResults.sources.sunlint,
+        userRules: mergedResults.sources.eslint,
+        categorized: eslintResults.categorized
+      };
+
+      // Convert merged results back to ESLint-compatible format for output
+      const finalResults = this.convertMergedResultsToESLintFormat(mergedResults);
+      
+      // Update metadata for proper display
+      finalResults.metadata = {
+        ...finalResults.metadata,
+        totalViolations: finalResults.violationCount,
+        totalFiles: finalResults.totalFiles
+      };
+
+      return finalResults;
+
+    } catch (error) {
+      if (!options.quiet) {
+        console.log(chalk.yellow(`⚠️  ESLint integration failed: ${error.message}`));
+        console.log(chalk.yellow('   Falling back to standard SunLint analysis'));
+      }
+      return this.runStandardAnalysis(rulesToRun, options, config);
+    }
+  }
+
+  /**
+   * Get file list based on options
+   */
+  getFileList(options) {
+    if (options.isFileList && Array.isArray(options.input)) {
+      return options.input;
+    } else if (typeof options.input === 'string') {
+      // Convert single path to array
+      return [options.input];
+    } else {
+      return ['src/**/*.{ts,tsx,js,jsx}'];
+    }
+  }
+
+  /**
+   * Convert ESLint results to SunLint format
+   */
+  convertESLintResultsToSunLintFormat(eslintResults, options) {
+    const results = {
+      results: [],
+      filesAnalyzed: eslintResults.results.length,
+      engine: 'eslint-integrated'
+    };
+
+    eslintResults.results.forEach(fileResult => {
+      if (fileResult.messages && fileResult.messages.length > 0) {
+        const violations = fileResult.messages.map(message => ({
+          ruleId: message.ruleId,
+          severity: this.mapESLintSeverityToSunLint(message.severity),
+          message: message.message,
+          line: message.line,
+          column: message.column,
+          source: this.eslintIntegrationService.isSunLintRule(message.ruleId) ? 'sunlint' : 'user-eslint'
+        }));
+
+        results.results.push({
+          filePath: fileResult.filePath,
+          violations: violations
+        });
+      }
+    });
+
+    return results;
+  }
+
+  /**
+   * Map ESLint severity to SunLint severity
+   */
+  mapESLintSeverityToSunLint(eslintSeverity) {
+    switch (eslintSeverity) {
+      case 1: return 'warning';
+      case 2: return 'error';
+      default: return 'info';
+    }
+  }
+
+  /**
+   * Merge SunLint custom rules results with ESLint results with conflict resolution
+   */
+  mergeAnalysisResults(sunlintResults, eslintResults, options) {
+    // Convert ESLint results to SunLint format
+    const eslintFormatted = this.convertESLintResultsToSunLintFormat(eslintResults, options);
+    
+    // Create violation maps for conflict detection
+    const sunlintViolations = new Map();
+    const eslintViolations = new Map();
+    const mergedViolations = [];
+    
+    // Extract SunLint violations from results format (ESLint-compatible)
+    const sunlintResults_violations = this.extractViolationsFromResults(sunlintResults);
+    
+    // Process SunLint violations first (higher priority)
+    if (sunlintResults_violations && sunlintResults_violations.length > 0) {
+      sunlintResults_violations.forEach(violation => {
+        const key = `${violation.file}:${violation.line}:${violation.column}`;
+        sunlintViolations.set(key, {
+          ...violation,
+          source: 'sunlint',
+          priority: 1
+        });
+        mergedViolations.push({
+          ...violation,
+          source: 'sunlint'
+        });
+      });
+    }
+    
+    // Extract ESLint violations
+    const eslintResults_violations = this.extractViolationsFromResults(eslintFormatted);
+    
+    // Process ESLint violations with conflict resolution
+    if (eslintResults_violations && eslintResults_violations.length > 0) {
+      eslintResults_violations.forEach(violation => {
+        const key = `${violation.file}:${violation.line}:${violation.column}`;
+        
+        // Check for conflicts
+        if (sunlintViolations.has(key)) {
+          const sunlintViolation = sunlintViolations.get(key);
+          
+          // Check if it's the same rule concept (e.g., both about console.log)
+          const isSameRule = this.isConflictingRule(sunlintViolation.ruleId, violation.ruleId);
+          
+          if (isSameRule) {
+            // SunLint takes priority, add ESLint as additional info
+            const mergedViolation = mergedViolations.find(v => 
+              v.file === violation.file && v.line === violation.line && v.column === violation.column
+            );
+            if (mergedViolation) {
+              mergedViolation.additionalInfo = {
+                eslintRule: violation.ruleId,
+                eslintMessage: violation.message
+              };
+            }
+          } else {
+            // Different rules on same line, keep both
+            mergedViolations.push({
+              ...violation,
+              source: 'eslint'
+            });
+          }
+        } else {
+          // No conflict, add ESLint violation
+          eslintViolations.set(key, violation);
+          mergedViolations.push({
+            ...violation,
+            source: 'eslint'
+          });
+        }
+      });
+    }
+    
+    // Create combined results in ESLint format
+    const mergedResults = {
+      ...eslintFormatted,
+      violations: mergedViolations,
+      violationCount: mergedViolations.length,
+      totalFiles: Math.max(sunlintResults.totalFiles || 0, eslintFormatted.totalFiles || 0),
+      analysisTime: (sunlintResults.analysisTime || 0) + (eslintFormatted.analysisTime || 0),
+      sources: {
+        sunlint: sunlintViolations.size,
+        eslint: eslintViolations.size,
+        conflicts: mergedViolations.filter(v => v.additionalInfo).length
+      }
+    };
+    
+    return mergedResults;
+  }
+
+  /**
+   * Extract violations from results in consistent format
+   */
+  extractViolationsFromResults(results) {
+    const violations = [];
+    
+    if (results && results.results) {
+      // Handle different result structures
+      results.results.forEach(result => {
+        // SunLint format: result.violations[]
+        if (result.violations && Array.isArray(result.violations)) {
+          result.violations.forEach(violation => {
+            violations.push({
+              file: violation.file,
+              line: violation.line,
+              column: violation.column || 1,
+              ruleId: violation.ruleId,
+              severity: violation.severity || 'warning',
+              message: violation.message
+            });
+          });
+        }
+        // ESLint format: result.messages[]
+        else if (result.messages && Array.isArray(result.messages)) {
+          result.messages.forEach(message => {
+            violations.push({
+              file: result.filePath,
+              line: message.line,
+              column: message.column,
+              ruleId: message.ruleId,
+              severity: this.mapESLintSeverityToString(message.severity),
+              message: message.message
+            });
+          });
+        }
+      });
+    } else if (Array.isArray(results)) {
+      // Direct array format
+      results.forEach(fileResult => {
+        if (fileResult.messages && fileResult.messages.length > 0) {
+          fileResult.messages.forEach(message => {
+            violations.push({
+              file: fileResult.filePath,
+              line: message.line,
+              column: message.column,
+              ruleId: message.ruleId,
+              severity: this.mapESLintSeverityToString(message.severity),
+              message: message.message
+            });
+          });
+        }
+      });
+    }
+    
+    return violations;
+  }
+
+  /**
+   * Map ESLint severity numbers to strings
+   */
+  mapESLintSeverityToString(severity) {
+    switch (severity) {
+      case 1: return 'warning';
+      case 2: return 'error';
+      default: return 'info';
+    }
+  }
+
+  /**
+   * Check if two rules are conflicting (same concept)
+   */
+  isConflictingRule(sunlintRule, eslintRule) {
+    const ruleMapping = {
+      'C019': ['no-console'],           // Console logging rules
+      'C045': ['no-console'],           // Console logging rules
+      'C006': [],                       // Function naming (SunLint specific)
+      'C032': []                        // Logging info (SunLint specific)
+    };
+    
+    return ruleMapping[sunlintRule] && ruleMapping[sunlintRule].includes(eslintRule);
+  }
+
+  /**
+   * Run standard SunLint analysis (fallback)
+   */
+  async runStandardAnalysis(rulesToRun, options, config) {
+    // Check AI configuration and provide feedback
+    if (options.ai === true) {
+      this.checkAIConfiguration(rulesToRun, config);
+    }
+
+    // Check if user explicitly requests TypeScript engine
+    if (options.typescript || options.typescriptEngine === 'eslint') {
+      // Force all rules through TypeScript engine when --typescript flag is used
+      return await this.runTypeScriptAnalysis(rulesToRun, options, config);
+    }
+
+    // Auto-detect based on rule analyzer
+    const eslintRules = rulesToRun.filter(rule => 
+      rule.analyzer === 'eslint' || 
+      rule.analyzer === 'typescript' // Legacy typescript analyzer routes to eslint
+    );
+    const customRules = rulesToRun.filter(rule => 
+      rule.analyzer && 
+      rule.analyzer !== 'eslint' && 
+      rule.analyzer !== 'typescript'
+    );
+    
+    // Debug logging for rule routing
+    if (!options.quiet && options.format !== 'json') {
+      console.log(chalk.cyan(`🔍 Rule routing: ${eslintRules.length} ESLint rules, ${customRules.length} custom rules`));
+      if (eslintRules.length > 0) {
+        console.log(chalk.cyan(`   ESLint rules: ${eslintRules.map(r => r.id).join(', ')}`));
+      }
+    }
+
+    // Run ESLint rules if any
+    let allResults = { results: [], filesAnalyzed: 0, engine: 'combined' };
+
+    if (eslintRules.length > 0) {
+      const eslintResults = await this.runTypeScriptAnalysis(eslintRules, options, config);
+      allResults.results.push(...eslintResults.results);
+      allResults.filesAnalyzed = Math.max(allResults.filesAnalyzed, eslintResults.filesAnalyzed);
+    }
+
+    // Run custom rules if any
+    if (customRules.length > 0) {
+      try {
+        if (!this.multiRuleRunner) {
+          const MultiRuleRunner = require('./multi-rule-runner');
+          if (MultiRuleRunner) {
+            this.multiRuleRunner = new MultiRuleRunner();
+          } else {
+            console.log(chalk.yellow('⚠️  Multi-rule runner not available, using basic analysis'));
+            return this.runBasicAnalysis(rulesToRun, options, config);
+          }
+        }
+
+        // Run analysis using existing multi-rule runner
+        const customResults = await this.multiRuleRunner.runRules(customRules, options.input, options);
+        allResults.results.push(...customResults.results);
+        allResults.filesAnalyzed = Math.max(allResults.filesAnalyzed, customResults.filesAnalyzed);
+      } catch (error) {
+        console.log(chalk.yellow('⚠️  Custom rule analysis failed, continuing with ESLint results only'));
+      }
+    }
+
+    return allResults.results.length > 0 ? allResults : this.runBasicAnalysis(rulesToRun, options, config);
+  }
+
+  /**
+   * Rule C006: Name method with verb-noun - createMockSummary
+   */
+  createMockSummary() {
+    return {
+      totalViolations: 1,
+      filesAnalyzed: 1,
+      rulesSummary: {
+        'C006': 1
+      }
+    };
+  }
+
+  /**
+   * Convert merged results back to ESLint-compatible format for output
+   */
+  convertMergedResultsToESLintFormat(mergedResults) {
+    const fileMap = new Map();
+    
+    // Group violations by file
+    if (mergedResults.violations) {
+      mergedResults.violations.forEach(violation => {
+        if (!fileMap.has(violation.file)) {
+          fileMap.set(violation.file, {
+            filePath: violation.file,
+            messages: [],
+            suppressedMessages: [],
+            errorCount: 0,
+            warningCount: 0,
+            fatalErrorCount: 0,
+            fixableErrorCount: 0,
+            fixableWarningCount: 0
+          });
+        }
+        
+        const fileResult = fileMap.get(violation.file);
+        const message = {
+          ruleId: violation.ruleId,
+          severity: violation.severity === 'error' ? 2 : 1,
+          message: violation.message,
+          line: violation.line || 1,
+          column: violation.column || 1,
+          nodeType: null,
+          messageId: null,
+          endLine: null,
+          endColumn: null,
+          source: violation.source || 'unknown'
+        };
+        
+        // Add additional info for conflicts
+        if (violation.additionalInfo) {
+          message.message += ` (ESLint: ${violation.additionalInfo.eslintRule})`;
+        }
+        
+        fileResult.messages.push(message);
+        
+        // Update counts
+        if (violation.severity === 'error') {
+          fileResult.errorCount++;
+        } else {
+          fileResult.warningCount++;
+        }
+      });
+    }
+    
+    return {
+      ...mergedResults,
+      results: Array.from(fileMap.values()),
+      violationCount: mergedResults.violations ? mergedResults.violations.length : 0,
+      totalFiles: fileMap.size
+    };
+  }
+}
+
+module.exports = AnalysisOrchestrator;