@sun-asterisk/sunlint 1.0.5

package/core/multi-rule-runner.js

@@ -0,0 +1,239 @@
+const path = require('path');
+const fs = require('fs');
+const glob = require('glob');
+const chalk = require('chalk');
+
+class MultiRuleRunner {
+  constructor(config, options) {
+    this.config = config;
+    this.options = options;
+    this.ruleCache = new Map();
+  }
+
+  async runRules(rules, inputPath, options) {
+    console.log(chalk.blue(`🔄 Analyzing ${rules.length} rules...`));
+    
+    // Get files to analyze
+    const files = await this.getFilesToAnalyze(inputPath, options);
+    
+    if (files.length === 0) {
+      console.log(chalk.yellow('⚠️  No files found to analyze'));
+      return [];
+    }
+
+    console.log(chalk.gray(`📁 Found ${files.length} files to analyze`));
+
+    // Group files by language
+    const filesByLanguage = this.groupFilesByLanguage(files);
+    
+    // Run rules in parallel (with concurrency limit)
+    const maxConcurrent = parseInt(options.maxConcurrent) || 5;
+    const timeout = parseInt(options.timeout) || 30000;
+    
+    const results = [];
+    
+    // Process rules in batches
+    for (let i = 0; i < rules.length; i += maxConcurrent) {
+      const batch = rules.slice(i, i + maxConcurrent);
+      
+      const batchPromises = batch.map(async (rule) => {
+        try {
+          return await this.runSingleRule(rule, filesByLanguage, options, timeout);
+        } catch (error) {
+          console.error(chalk.red(`❌ Rule ${rule.id} failed:`), error.message);
+          return {
+            ruleId: rule.id,
+            ruleName: rule.name,
+            violations: [],
+            error: error.message,
+            status: 'failed'
+          };
+        }
+      });
+
+      const batchResults = await Promise.all(batchPromises);
+      results.push(...batchResults);
+      
+      if (options.verbose) {
+        console.log(chalk.gray(`✅ Completed batch ${Math.floor(i/maxConcurrent) + 1}/${Math.ceil(rules.length/maxConcurrent)}`));
+      }
+    }
+
+    return this.consolidateResults(results, files.length);
+  }
+
+  async runSingleRule(rule, filesByLanguage, options, timeout) {
+    if (options.verbose) {
+      console.log(chalk.gray(`🔍 Running rule ${rule.id}: ${rule.name}`));
+    }
+
+    const startTime = Date.now();
+    
+    // Load rule analyzer
+    const analyzer = await this.loadRuleAnalyzer(rule);
+    
+    if (!analyzer) {
+      return {
+        ruleId: rule.id,
+        ruleName: rule.name,
+        violations: [],
+        error: 'Analyzer not found',
+        status: 'skipped'
+      };
+    }
+
+    const violations = [];
+
+    // Run analyzer for each supported language
+    for (const language of rule.languages) {
+      const languageFiles = filesByLanguage[language] || [];
+      
+      if (languageFiles.length === 0) {
+        continue;
+      }
+
+      try {
+        // Run with timeout
+        const languageViolations = await Promise.race([
+          analyzer.analyze(languageFiles, language, this.config),
+          new Promise((_, reject) => 
+            setTimeout(() => reject(new Error('Timeout')), timeout)
+          )
+        ]);
+
+        violations.push(...languageViolations);
+      } catch (error) {
+        console.error(chalk.yellow(`⚠️  Rule ${rule.id} failed for ${language}:`), error.message);
+      }
+    }
+
+    const duration = Date.now() - startTime;
+
+    return {
+      ruleId: rule.id,
+      ruleName: rule.name,
+      category: rule.category,
+      severity: rule.severity,
+      violations,
+      filesAnalyzed: Object.values(filesByLanguage).flat().length,
+      duration,
+      status: 'completed'
+    };
+  }
+
+  async loadRuleAnalyzer(rule) {
+    // Check cache first
+    if (this.ruleCache.has(rule.id)) {
+      return this.ruleCache.get(rule.id);
+    }
+
+    try {
+      const analyzerPath = path.resolve(__dirname, '..', rule.analyzer);
+      
+      if (!fs.existsSync(analyzerPath)) {
+        console.error(chalk.yellow(`⚠️  Analyzer not found for rule ${rule.id}: ${analyzerPath}`));
+        return null;
+      }
+
+      const analyzer = require(analyzerPath);
+      this.ruleCache.set(rule.id, analyzer);
+      return analyzer;
+    } catch (error) {
+      console.error(chalk.red(`❌ Failed to load analyzer for rule ${rule.id}:`), error.message);
+      return null;
+    }
+  }
+
+  async getFilesToAnalyze(inputPath, options) {
+    const isFile = fs.statSync(inputPath).isFile();
+    
+    if (isFile) {
+      return [path.resolve(inputPath)];
+    }
+
+    // Get include/exclude patterns
+    const includePatterns = this.config.include || ['**/*.ts', '**/*.tsx', '**/*.dart', '**/*.kt'];
+    const excludePatterns = this.config.exclude || ['**/node_modules/**', '**/build/**'];
+
+    // Find files using glob patterns
+    const files = [];
+    
+    for (const pattern of includePatterns) {
+      const fullPattern = path.join(inputPath, pattern);
+      const matchedFiles = glob.sync(fullPattern, {
+        ignore: excludePatterns.map(p => path.join(inputPath, p)),
+        absolute: true
+      });
+      files.push(...matchedFiles);
+    }
+
+    // Remove duplicates
+    return [...new Set(files)];
+  }
+
+  groupFilesByLanguage(files) {
+    const rulesRegistry = require('../config/rules-registry.json');
+    const languageConfig = rulesRegistry.languages;
+    
+    const filesByLanguage = {};
+
+    files.forEach(file => {
+      const ext = path.extname(file);
+      
+      for (const [language, config] of Object.entries(languageConfig)) {
+        if (config.extensions.includes(ext)) {
+          if (!filesByLanguage[language]) {
+            filesByLanguage[language] = [];
+          }
+          filesByLanguage[language].push(file);
+          break; // File belongs to first matching language
+        }
+      }
+    });
+
+    return filesByLanguage;
+  }
+
+  consolidateResults(results, totalFiles) {
+    const consolidatedResults = {
+      filesAnalyzed: totalFiles,
+      rulesRun: results.length,
+      totalViolations: 0,
+      violationsBySeverity: { error: 0, warning: 0, info: 0 },
+      violationsByRule: {},
+      violationsByFile: {},
+      results: []
+    };
+
+    results.forEach(result => {
+      consolidatedResults.results.push(result);
+      
+      if (result.violations) {
+        consolidatedResults.totalViolations += result.violations.length;
+        
+        // Count by severity
+        result.violations.forEach(violation => {
+          const severity = violation.severity || result.severity || 'warning';
+          consolidatedResults.violationsBySeverity[severity] = 
+            (consolidatedResults.violationsBySeverity[severity] || 0) + 1;
+        });
+
+        // Count by rule
+        consolidatedResults.violationsByRule[result.ruleId] = result.violations.length;
+
+        // Count by file
+        result.violations.forEach(violation => {
+          const file = violation.file || violation.filePath;
+          if (file) {
+            consolidatedResults.violationsByFile[file] = 
+              (consolidatedResults.violationsByFile[file] || 0) + 1;
+          }
+        });
+      }
+    });
+
+    return consolidatedResults;
+  }
+}
+
+module.exports = MultiRuleRunner;

package/core/output-service.js

@@ -0,0 +1,250 @@
+/**
+ * Output Service
+ * Following Rule C005: Single responsibility - handle output operations
+ */
+
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+class OutputService {
+  constructor() {}
+
+  async outputResults(results, options, metadata = {}) {
+    // Generate report based on format
+    const report = this.generateReport(results, metadata, options);
+
+    // Console output
+    if (!options.quiet) {
+      console.log(report.formatted);
+    }
+
+    // File output
+    if (options.output) {
+      const outputData = options.format === 'json' ? report.raw : report.formatted;
+      const content = typeof outputData === 'string' ? outputData : JSON.stringify(outputData, null, 2);
+      fs.writeFileSync(options.output, content);
+      console.log(chalk.green(`📄 Report saved to: ${options.output}`));
+    }
+
+    // Summary (skip for JSON format)
+    if (!options.quiet && options.format !== 'json') {
+      console.log(report.summary);
+    }
+  }
+
+  generateReport(results, metadata, options = {}) {
+    const allViolations = [];
+    let totalFiles = results.filesAnalyzed || results.totalFiles || results.fileCount || 0;
+
+    // Collect all violations - handle both file-based and rule-based results
+    if (results.results) {
+      results.results.forEach(result => {
+        if (result.violations) {
+          // Handle rule-based format (MultiRuleRunner)
+          if (result.ruleId) {
+            result.violations.forEach(violation => {
+              allViolations.push(violation); // violation already has file path
+            });
+          } 
+          // Handle file-based format (legacy)
+          else {
+            result.violations.forEach(violation => {
+              allViolations.push({
+                ...violation,
+                file: result.filePath || result.file // Use filePath first, then file
+              });
+            });
+          }
+        }
+        
+        // Handle ESLint format (messages array)
+        if (result.messages) {
+          result.messages.forEach(message => {
+            allViolations.push({
+              file: result.filePath || message.file,
+              ruleId: message.ruleId,
+              severity: message.severity === 2 ? 'error' : 'warning',
+              message: message.message,
+              line: message.line,
+              column: message.column,
+              source: message.source || 'eslint'
+            });
+          });
+        }
+      });
+    }
+
+    // Generate output based on format
+    let formatted;
+    let raw;
+
+    if (options.format === 'json') {
+      // ESLint-compatible JSON format
+      raw = this.generateJsonFormat(results, allViolations, options);
+      formatted = JSON.stringify(raw, null, 2);
+    } else {
+      // Default text format
+      formatted = this.formatViolations(allViolations);
+      raw = {
+        violations: allViolations,
+        filesAnalyzed: totalFiles,
+        metadata
+      };
+    }
+
+    const summary = this.generateSummary(allViolations, totalFiles, metadata);
+
+    return {
+      formatted,
+      summary,
+      raw
+    };
+  }
+
+  formatViolations(violations) {
+    if (violations.length === 0) {
+      return chalk.green('✅ No violations found!');
+    }
+
+    let output = '';
+    const fileGroups = {};
+
+    // Group violations by file
+    violations.forEach(violation => {
+      let file = violation.file || violation.filePath || 'unknown';
+      
+      // Convert absolute path to relative path for better display
+      if (file !== 'unknown' && path.isAbsolute(file)) {
+        const cwd = process.cwd();
+        if (file.startsWith(cwd)) {
+          file = path.relative(cwd, file);
+        }
+      }
+      
+      if (!fileGroups[file]) {
+        fileGroups[file] = [];
+      }
+      fileGroups[file].push(violation);
+    });
+
+    // Format each file's violations (ESLint-compatible format)
+    Object.keys(fileGroups).forEach(file => {
+      output += `\n${file}\n`;
+      fileGroups[file].forEach(violation => {
+        const line = (violation.line || 1).toString().padStart(3);
+        const column = (violation.column || 1).toString().padStart(2);
+        const severityText = violation.severity === 'error' ? 'error' : 'warning';
+        const severityColor = violation.severity === 'error' ? chalk.red : chalk.yellow;
+        
+        // ESLint-style formatting: "  line:col  severity  message  ruleId"
+        output += `  ${line}:${column}  ${severityColor(severityText)}  ${violation.message}  ${chalk.gray(violation.ruleId)}\n`;
+      });
+    });
+
+    // Add violation count (ESLint-compatible)
+    const errorCount = violations.filter(v => v.severity === 'error').length;
+    const warningCount = violations.filter(v => v.severity === 'warning').length;
+
+    output += `\n${chalk.red('✖')} ${violations.length} problems `;
+    output += `(${errorCount} errors, ${warningCount} warnings)\n`;
+
+    return output;
+  }
+
+  generateSummary(violations, filesAnalyzed, metadata) {
+    const duration = metadata.duration || 0;
+    const errorCount = violations.filter(v => v.severity === 'error').length;
+    const warningCount = violations.filter(v => v.severity === 'warning').length;
+
+    let summary = chalk.blue('\n📊 Sun Lint Summary:\n');
+    summary += `Analysis completed in ${duration}ms\n`;
+    summary += `Files: ${filesAnalyzed} | Total: ${violations.length}\n`;
+    
+    if (errorCount > 0) {
+      summary += chalk.red(`Errors: ${errorCount} `);
+    }
+    if (warningCount > 0) {
+      summary += chalk.yellow(`Warnings: ${warningCount} `);
+    }
+    if (violations.length === 0) {
+      summary += chalk.green('All checks passed! ✅');
+    }
+
+    return summary;
+  }
+
+  generateJsonFormat(results, allViolations, options = {}) {
+    // ESLint-compatible JSON format
+    const jsonResults = [];
+    const fileGroups = {};
+
+    // Group violations by file
+    allViolations.forEach(violation => {
+      let file = violation.file || violation.filePath || 'unknown';
+      
+      // Convert absolute path to relative path for better display
+      if (file !== 'unknown' && path.isAbsolute(file)) {
+        const cwd = process.cwd();
+        if (file.startsWith(cwd)) {
+          file = path.relative(cwd, file);
+        }
+      }
+      
+      if (!fileGroups[file]) {
+        fileGroups[file] = [];
+      }
+      fileGroups[file].push(violation);
+    });
+
+    // Add files with violations
+    Object.keys(fileGroups).forEach(filePath => {
+      const messages = fileGroups[filePath].map(violation => ({
+        ruleId: violation.ruleId,
+        severity: violation.severity === 'error' ? 2 : 1, // ESLint: 1=warning, 2=error
+        message: violation.message,
+        line: violation.line || 1,
+        column: violation.column || 1,
+        nodeType: violation.nodeType || null,
+        messageId: violation.messageId || null,
+        endLine: violation.endLine || null,
+        endColumn: violation.endColumn || null
+      }));
+
+      jsonResults.push({
+        filePath: filePath,
+        messages: messages,
+        suppressedMessages: [],
+        errorCount: messages.filter(m => m.severity === 2).length,
+        warningCount: messages.filter(m => m.severity === 1).length,
+        fatalErrorCount: 0,
+        fixableErrorCount: 0,
+        fixableWarningCount: 0,
+        source: null
+      });
+    });
+
+    // Add files without violations (if any were analyzed)
+    if (results.results) {
+      results.results.forEach(fileResult => {
+        if (!fileGroups[fileResult.file] && fileResult.violations.length === 0) {
+          jsonResults.push({
+            filePath: fileResult.file,
+            messages: [],
+            suppressedMessages: [],
+            errorCount: 0,
+            warningCount: 0,
+            fatalErrorCount: 0,
+            fixableErrorCount: 0,
+            fixableWarningCount: 0,
+            source: null
+          });
+        }
+      });
+    }
+
+    return jsonResults;
+  }
+}
+
+module.exports = OutputService;