@sun-asterisk/sunlint 1.0.6 → 1.1.3

package/engines/eslint-engine.js

@@ -0,0 +1,601 @@
+/**
+ * ESLint Analysis Engine Plugin
+ * Following Rule C005: Single responsibility - ESLint integration
+ * Following Rule C014: Dependency injection - implements interface
+ * Following Rule C015: Use domain language - clear ESLint terms
+ */
+
+const AnalysisEngineInterface = require('../core/interfaces/analysis-engine.interface');
+const fs = require('fs');
+const path = require('path');
+
+class ESLintEngine extends AnalysisEngineInterface {
+  constructor() {
+    super('eslint', '8.x', ['typescript', 'javascript']);
+    
+    this.eslint = null;
+    this.configFiles = new Map();
+    this.ruleMapping = new Map();
+    
+    // Load rule mapping immediately (synchronous)
+    try {
+      this.loadRuleMappingSync();
+    } catch (error) {
+      console.error('🚨 Constructor failed to load mapping:', error.message);
+      this.createDefaultRuleMapping();
+    }
+  }
+
+  /**
+   * Load SunLint to ESLint rule mapping (synchronous)
+   */
+  loadRuleMappingSync() {
+    try {
+      const mappingPath = path.resolve(__dirname, '../config/eslint-rule-mapping.json');
+      
+      if (fs.existsSync(mappingPath)) {
+        const mappingData = JSON.parse(fs.readFileSync(mappingPath, 'utf8'));
+        const mapping = mappingData.mappings || mappingData;
+        
+        for (const [sunlintRule, eslintRules] of Object.entries(mapping)) {
+          this.ruleMapping.set(sunlintRule, eslintRules);
+        }
+      } else {
+        // Create default mapping for common rules
+        this.createDefaultRuleMapping();
+        console.warn('⚠️ Using default ESLint rule mapping');
+      }
+      
+    } catch (error) {
+      console.warn('⚠️ [ESLintEngine] Failed to load ESLint rule mapping:', error.message);
+      this.createDefaultRuleMapping();
+    }
+  }
+
+  /**
+   * Initialize ESLint engine with configuration
+   * Following Rule C006: Verb-noun naming
+   * @param {Object} config - Engine configuration
+   */
+  async initialize(config) {
+    try {
+      // Store verbosity setting for use in other methods
+      this.verbose = config?.verbose || false;
+      
+      // Dynamically import ESLint
+      const { ESLint } = await this.loadESLint();
+      
+      // Initialize ESLint with base configuration (v9+ compatible)
+      this.eslint = new ESLint({
+        overrideConfigFile: true, // Replaces useEslintrc: false
+        overrideConfig: this.createBaseConfig(),
+        fix: config?.fix || false,
+        cache: config?.cache || false,
+        cwd: process.cwd()
+      });
+
+      // Rule mapping already loaded in constructor
+      if (this.verbose) {
+        console.log(`🔧 [ESLintEngine] Initialize: Rule mapping size = ${this.ruleMapping.size}`);
+        console.log(`🔧 ESLint engine initialized`);
+      }
+      
+      this.initialized = true;
+      
+    } catch (error) {
+      console.error('Failed to initialize ESLint engine:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Load ESLint dynamically
+   * Following Rule C006: Verb-noun naming
+   * @returns {Promise<Object>} ESLint module
+   */
+  async loadESLint() {
+    try {
+      // Try to load ESLint from node_modules
+      return await import('eslint');
+    } catch (error) {
+      // Fallback to require for older versions
+      try {
+        return require('eslint');
+      } catch (requireError) {
+        throw new Error('ESLint not found. Please install ESLint: npm install eslint');
+      }
+    }
+  }
+
+  /**
+   * Create base ESLint configuration
+   * Following Rule C006: Verb-noun naming
+   * @returns {Object} ESLint configuration
+   */
+  createBaseConfig() {
+    // ESLint v9+ flat config format
+    return {
+      languageOptions: {
+        ecmaVersion: 'latest',
+        sourceType: 'module',
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true
+          }
+        },
+        globals: {
+          console: 'readonly',
+          process: 'readonly',
+          Buffer: 'readonly',
+          __dirname: 'readonly',
+          __filename: 'readonly',
+          module: 'readonly',
+          require: 'readonly',
+          exports: 'readonly',
+          global: 'readonly'
+        }
+      },
+      plugins: {},
+      rules: {}
+    };
+  }
+
+  /**
+   * Load SunLint to ESLint rule mapping
+   * Following Rule C006: Verb-noun naming
+   */
+  async loadRuleMapping() {
+    // Rule mapping already loaded in constructor - skip async load
+    console.log(`� [ESLintEngine] Skipping async loadRuleMapping, using constructor mapping (size: ${this.ruleMapping.size})`);
+    return;
+  }
+
+  /**
+   * Create default rule mapping
+   * Following Rule C006: Verb-noun naming
+   */
+  createDefaultRuleMapping() {
+    console.log(`🚨 [ESLintEngine] createDefaultRuleMapping() called - MAPPING WILL BE OVERWRITTEN!`);
+    
+    // Map common SunLint rules to ESLint equivalents
+    const defaultMappings = {
+      'C005': ['max-statements-per-line', 'complexity'],
+      'C006': ['func-names', 'func-name-matching'],
+      'C007': ['spaced-comment', 'no-inline-comments'],
+      'C014': ['no-new'],
+      'C019': ['no-console'],
+      'C031': ['no-implicit-coercion'],
+      'C033': ['prefer-const', 'no-var'],
+      'C037': ['consistent-return'],
+      'C040': ['no-duplicate-imports']
+    };
+
+    // CLEAR existing mapping first
+    console.log(`🚨 [ESLintEngine] Clearing existing ${this.ruleMapping.size} rules`);
+    this.ruleMapping.clear();
+
+    for (const [sunlintRule, eslintRules] of Object.entries(defaultMappings)) {
+      this.ruleMapping.set(sunlintRule, eslintRules);
+    }
+    
+    console.log(`🚨 [ESLintEngine] Set ${this.ruleMapping.size} default rules`);
+    console.warn('⚠️ Using default ESLint rule mapping');
+  }
+
+  /**
+   * Load React ESLint plugin
+   * Following Rule C006: Verb-noun naming
+   */
+  loadReactPlugin() {
+    try {
+      // Try current working directory first
+      return require(require.resolve('eslint-plugin-react', { paths: [process.cwd()] }));
+    } catch (error) {
+      try {
+        // Fallback to main package
+        return require('eslint-plugin-react');
+      } catch (fallbackError) {
+        console.warn('⚠️ React ESLint plugin not available:', error.message);
+        return null;
+      }
+    }
+  }
+
+  /**
+   * Load React Hooks ESLint plugin
+   * Following Rule C006: Verb-noun naming
+   */
+  loadReactHooksPlugin() {
+    try {
+      // Try current working directory first
+      return require(require.resolve('eslint-plugin-react-hooks', { paths: [process.cwd()] }));
+    } catch (error) {
+      try {
+        // Fallback to main package
+        return require('eslint-plugin-react-hooks');
+      } catch (fallbackError) {
+        console.warn('⚠️ React Hooks ESLint plugin not available:', error.message);
+        return null;
+      }
+    }
+  }
+
+  /**
+   * Load TypeScript parser
+   * Following Rule C006: Verb-noun naming
+   */
+  loadTypeScriptParser() {
+    try {
+      return require('@typescript-eslint/parser');
+    } catch (error) {
+      console.warn('⚠️ TypeScript parser not available:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Load TypeScript ESLint plugin
+   * Following Rule C006: Verb-noun naming
+   */
+  loadTypeScriptPlugin() {
+    try {
+      return require('@typescript-eslint/eslint-plugin');
+    } catch (error) {
+      console.warn('⚠️ TypeScript ESLint plugin not available:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Load custom ESLint plugin with SunLint rules
+   * Following Rule C006: Verb-noun naming
+   */
+  loadCustomPlugin() {
+    try {
+      const customRulesPath = path.resolve(__dirname, '../integrations/eslint/plugin/rules');
+      const plugin = {
+        rules: {}
+      };
+
+      // Load all custom rules dynamically
+      const ruleDirs = ['common', 'typescript', 'security'];
+      for (const dir of ruleDirs) {
+        const dirPath = path.join(customRulesPath, dir);
+        if (fs.existsSync(dirPath)) {
+          const ruleFiles = fs.readdirSync(dirPath).filter(file => file.endsWith('.js'));
+          for (const file of ruleFiles) {
+            const rulePath = path.join(dirPath, file);
+            try {
+              const rule = require(rulePath);
+              // Keep full filename as rule name for Security rules, remove prefix for others
+              const ruleName = dir === 'security' ? 
+                file.replace('.js', '') : 
+                file.replace('.js', '').replace(/^[ct]\d+-/, ''); // Remove prefix like c010-, t020-
+              plugin.rules[ruleName] = rule;
+            } catch (error) {
+              console.warn(`⚠️ Failed to load custom rule ${file}:`, error.message);
+            }
+          }
+        }
+      }
+
+      console.log(`✅ [ESLintEngine] Loaded ${Object.keys(plugin.rules).length} custom rules`);
+      return plugin;
+    } catch (error) {
+      console.warn('⚠️ Failed to load custom plugin:', error.message);
+      return { rules: {} };
+    }
+  }
+
+  /**
+   * Analyze files using ESLint
+   * Following Rule C006: Verb-noun naming
+   * @param {string[]} files - Files to analyze
+   * @param {Object[]} rules - Rules to apply
+   * @param {Object} options - Analysis options
+   * @returns {Promise<Object>} Analysis results
+   */
+  async analyze(files, rules, options) {
+    if (!this.initialized) {
+      throw new Error('ESLint engine not initialized');
+    }
+
+    const results = {
+      results: [],
+      filesAnalyzed: 0,
+      engine: 'eslint',
+      metadata: {
+        rulesAnalyzed: [],
+        eslintRulesUsed: []
+      }
+    };
+
+    try {
+      // Filter files for JS/TS only
+      const jstsFiles = files.filter(file => this.isJavaScriptTypeScriptFile(file));
+      
+      if (jstsFiles.length === 0) {
+        console.warn('⚠️ No JavaScript/TypeScript files found for ESLint analysis');
+        return results;
+      }
+
+      // Convert SunLint rules to ESLint rules
+      const eslintConfig = await this.createAnalysisConfig(rules);
+      
+      if (Object.keys(eslintConfig.rules).length === 0) {
+        console.warn('⚠️ No ESLint rules mapped from SunLint rules');
+        return results;
+      }
+
+      // Reconfigure ESLint with analysis-specific rules (v9+ compatible)
+      const { ESLint } = await this.loadESLint();
+      const eslintInstance = new ESLint({
+        overrideConfigFile: true,
+        overrideConfig: {
+          ...this.createBaseConfig(),
+          ...eslintConfig
+        },
+        cwd: process.cwd()
+      });
+
+      // Run ESLint analysis
+      const eslintResults = await eslintInstance.lintFiles(jstsFiles);
+      
+      // Convert ESLint results to SunLint format
+      results.results = this.convertESLintResults(eslintResults, rules);
+      results.filesAnalyzed = jstsFiles.length;
+      results.metadata.rulesAnalyzed = rules.map(r => r.id);
+      results.metadata.eslintRulesUsed = Object.keys(eslintConfig.rules);
+      
+    } catch (error) {
+      console.error('❌ ESLint analysis failed:', error.message);
+      throw error;
+    }
+
+    return results;
+  }
+
+  /**
+   * Check if file is JavaScript or TypeScript
+   * Following Rule C006: Verb-noun naming
+   * @param {string} filePath - File path to check
+   * @returns {boolean} True if JS/TS file
+   */
+  isJavaScriptTypeScriptFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs'].includes(ext);
+  }
+
+  /**
+   * Check if rules need React plugins
+   */
+  needsReactPlugins(rules) {
+    return rules.some(rule => {
+      const ruleId = typeof rule === 'string' ? rule : rule.id || rule.name;
+      return ruleId && ruleId.startsWith('R');
+    });
+  }
+
+  /**
+   * Check if rules need TypeScript plugins  
+   */
+  needsTypeScriptPlugins(rules) {
+    return rules.some(rule => {
+      const ruleId = typeof rule === 'string' ? rule : rule.id || rule.name;
+      return ruleId && ruleId.startsWith('T');
+    });
+  }
+
+  /**
+   * Build dynamic plugins based on rules being analyzed
+   * @param {Array} rules - Rules to analyze
+   * @returns {Object} Plugin configuration
+   */
+  buildPluginConfig(rules) {
+    const plugins = {
+      'custom': this.loadCustomPlugin()
+    };
+
+    // Only load TypeScript plugin if needed
+    if (this.needsTypeScriptPlugins(rules)) {
+      plugins['@typescript-eslint'] = this.loadTypeScriptPlugin();
+    }
+
+    // Only load React plugins if needed  
+    if (this.needsReactPlugins(rules)) {
+      plugins['react'] = this.loadReactPlugin();
+      plugins['react-hooks'] = this.loadReactHooksPlugin();
+    }
+
+    return plugins;
+  }
+
+  /**
+   * Create ESLint configuration for analysis
+   * Following Rule C006: Verb-noun naming
+   * @param {Object[]} rules - SunLint rules
+   * @returns {Promise<Object>} ESLint configuration
+   */
+  async createAnalysisConfig(rules) {
+    // ESLint v9+ flat config format
+    const config = {
+      files: ['**/*.js', '**/*.jsx', '**/*.ts', '**/*.tsx'], // Add file patterns
+      languageOptions: {
+        ecmaVersion: 'latest',
+        sourceType: 'module',
+        parser: this.loadTypeScriptParser(),
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true
+          }
+        },
+        globals: {
+          console: 'readonly',
+          process: 'readonly',
+          Buffer: 'readonly',
+          __dirname: 'readonly',
+          __filename: 'readonly',
+          module: 'readonly',
+          require: 'readonly',
+          exports: 'readonly',
+          global: 'readonly'
+        }
+      },
+      plugins: this.buildPluginConfig(rules),
+      settings: this.needsReactPlugins(rules) ? {
+        react: {
+          version: 'detect'
+        }
+      } : {},
+      rules: {}
+    };
+
+    // Map SunLint rules to ESLint rules
+    for (const rule of rules) {
+      const eslintRules = this.ruleMapping.get(rule.id);
+      
+      if (eslintRules && Array.isArray(eslintRules)) {
+        for (const eslintRule of eslintRules) {
+          // Set rule severity based on SunLint rule
+          const severity = this.mapSeverity(rule.severity || 'warning');
+          config.rules[eslintRule] = severity;
+        }
+      } else {
+        // Check if it's a custom rule (C010, etc.)
+        const customRuleName = `custom/${rule.id.toLowerCase()}`;
+        const ruleConfig = this.mapSeverity(rule.severity || 'warning');
+        
+        // Add rule configuration for specific rules
+        if (rule.id === 'C010') {
+          config.rules[customRuleName] = [ruleConfig, { maxDepth: 3 }];
+        } else {
+          config.rules[customRuleName] = ruleConfig;
+        }
+      }
+    }
+
+    return config;
+  }
+
+  /**
+   * Map SunLint severity to ESLint severity
+   * Following Rule C006: Verb-noun naming
+   * @param {string} sunlintSeverity - SunLint severity level
+   * @returns {number|string} ESLint severity
+   */
+  mapSeverity(sunlintSeverity) {
+    switch (sunlintSeverity.toLowerCase()) {
+      case 'error': return 'error';
+      case 'warning': return 'warn';
+      case 'info': return 'warn';
+      default: return 'warn';
+    }
+  }
+
+  /**
+   * Convert ESLint results to SunLint format
+   * Following Rule C006: Verb-noun naming
+   * @param {Object[]} eslintResults - ESLint results
+   * @param {Object[]} originalRules - Original SunLint rules
+   * @returns {Object[]} SunLint formatted results
+   */
+  convertESLintResults(eslintResults, originalRules) {
+    const sunlintResults = [];
+
+    for (const eslintResult of eslintResults) {
+      if (eslintResult.messages.length === 0) continue;
+
+      const fileResult = {
+        file: eslintResult.filePath,
+        violations: []
+      };
+
+      for (const message of eslintResult.messages) {
+        const violation = {
+          ruleId: this.mapESLintRuleToSunLint(message.ruleId, originalRules),
+          message: message.message,
+          severity: message.severity === 2 ? 'error' : 'warning',
+          line: message.line,
+          column: message.column,
+          endLine: message.endLine,
+          endColumn: message.endColumn,
+          engine: 'eslint',
+          eslintRule: message.ruleId,
+          fix: message.fix ? {
+            range: message.fix.range,
+            text: message.fix.text
+          } : null
+        };
+
+        fileResult.violations.push(violation);
+      }
+
+      if (fileResult.violations.length > 0) {
+        sunlintResults.push(fileResult);
+      }
+    }
+
+    return sunlintResults;
+  }
+
+  /**
+   * Map ESLint rule back to SunLint rule
+   * Following Rule C006: Verb-noun naming
+   * @param {string} eslintRuleId - ESLint rule ID
+   * @param {Object[]} originalRules - Original SunLint rules
+   * @returns {string} SunLint rule ID
+   */
+  mapESLintRuleToSunLint(eslintRuleId, originalRules) {
+    // Find which SunLint rule maps to this ESLint rule
+    for (const [sunlintRule, eslintRules] of this.ruleMapping.entries()) {
+      if (eslintRules.includes(eslintRuleId)) {
+        // Verify this rule was actually requested
+        const requestedRule = originalRules.find(r => r.id === sunlintRule);
+        if (requestedRule) {
+          return sunlintRule;
+        }
+      }
+    }
+
+    // Fallback to ESLint rule ID if no mapping found
+    return eslintRuleId;
+  }
+
+  /**
+   * Get supported rules
+   * Following Rule C006: Verb-noun naming
+   * @returns {string[]} Supported rule IDs
+   */
+  getSupportedRules() {
+    return Array.from(this.ruleMapping.keys());
+  }
+
+  /**
+   * Check if rule is supported
+   * Following Rule C006: Verb-noun naming
+   * @param {string} ruleId - Rule ID to check
+   * @returns {boolean} True if supported
+   */
+  isRuleSupported(ruleId) {
+    const supported = this.ruleMapping.has(ruleId);
+    if (this.verbose) {
+      console.log(`🔍 [ESLintEngine] isRuleSupported(${ruleId}): ${supported} (mapping size: ${this.ruleMapping.size})`);
+    }
+    return supported;
+  }
+
+  /**
+   * Cleanup ESLint engine resources
+   * Following Rule C006: Verb-noun naming
+   */
+  async cleanup() {
+    this.eslint = null;
+    this.configFiles.clear();
+    this.ruleMapping.clear();
+    
+    await super.cleanup();
+    console.log('🔧 ESLint engine cleanup completed');
+  }
+}
+
+module.exports = ESLintEngine;