@sun-asterisk/sunlint 1.2.2 → 1.3.1

package/engines/eslint-engine.js

@@ -9,6 +9,7 @@ const AnalysisEngineInterface = require('../core/interfaces/analysis-engine.inte
 const dependencyChecker = require('../core/dependency-checker');
 const fs = require('fs');
 const path = require('path');
+const { getInstance } = require('../core/unified-rule-registry');
 
 class ESLintEngine extends AnalysisEngineInterface {
   constructor() {
@@ -18,12 +19,16 @@ class ESLintEngine extends AnalysisEngineInterface {
     this.configFiles = new Map();
     this.ruleMapping = new Map();
     
+    // Unified rule registry
+    this.unifiedRegistry = getInstance();
+    
     // Load rule mapping immediately (synchronous)
     try {
       this.loadRuleMappingSync();
     } catch (error) {
       console.error('🚨 Constructor failed to load mapping:', error.message);
-      this.createDefaultRuleMapping();
+      // Defer async mapping loading to when needed
+      this.mappingLoaded = false;
     }
   }
 
@@ -41,15 +46,27 @@ class ESLintEngine extends AnalysisEngineInterface {
         for (const [sunlintRule, eslintRules] of Object.entries(mapping)) {
           this.ruleMapping.set(sunlintRule, eslintRules);
         }
+        this.mappingLoaded = true;
       } else {
-        // Create default mapping for common rules
-        this.createDefaultRuleMapping();
-        console.warn('⚠️ Using default ESLint rule mapping');
+        // Mark as not loaded, will load from registry later
+        this.mappingLoaded = false;
+        console.warn('⚠️ Legacy ESLint mapping file not found, will load from unified registry');
       }
       
     } catch (error) {
       console.warn('⚠️ [ESLintEngine] Failed to load ESLint rule mapping:', error.message);
-      this.createDefaultRuleMapping();
+      this.mappingLoaded = false;
+    }
+  }
+
+  /**
+   * Ensure rule mapping is loaded (async)
+   */
+  async ensureMappingLoaded() {
+    if (!this.mappingLoaded) {
+      console.log('📋 [ESLintEngine] Loading rule mapping from unified registry...');
+      await this.createDefaultRuleMapping();
+      this.mappingLoaded = true;
     }
   }
 
@@ -301,12 +318,14 @@ class ESLintEngine extends AnalysisEngineInterface {
       const rules = this.extractRulesFromConfig(eslintConfig);
       const needsReact = this.needsReactPlugins(rules);
       const needsTypeScript = this.needsTypeScriptPlugins(rules);
+      const needsImport = this.needsImportPlugin(rules);
       
       // Check plugin availability in target project
       const hasReact = needsReact && this.isReactPluginAvailable(projectPath);
       const hasReactHooks = needsReact && this.isReactHooksPluginAvailable(projectPath);
       const hasTypeScript = needsTypeScript && this.isTypeScriptPluginAvailable(projectPath);
       const hasTypeScriptParser = this.isTypeScriptParserAvailable(projectPath);
+      const hasImport = needsImport && this.isImportPluginAvailable(projectPath);
       
       let pluginImports = '';
       let pluginDefs = '{ "custom": customPlugin';
@@ -326,11 +345,16 @@ class ESLintEngine extends AnalysisEngineInterface {
         pluginDefs += ', "@typescript-eslint": typescriptPlugin';
       }
       
+      if (hasImport) {
+        pluginImports += `\nimport importPlugin from 'eslint-plugin-import';`;
+        pluginDefs += ', "import": importPlugin';
+      }
+      
       pluginDefs += ' }';
       
       // Filter rules to only include those for available plugins
       const filteredRules = {};
-      const skippedRules = { react: [], reactHooks: [], typescript: [] };
+      const skippedRules = { react: [], reactHooks: [], typescript: [], import: [] };
       
       for (const [ruleKey, ruleConfig] of Object.entries(eslintConfig.rules || {})) {
         if (ruleKey.startsWith('react/') && !hasReact) {
@@ -345,6 +369,10 @@ class ESLintEngine extends AnalysisEngineInterface {
           skippedRules.typescript.push(ruleKey);
           continue;
         }
+        if (ruleKey.startsWith('import/') && !hasImport) {
+          skippedRules.import.push(ruleKey);
+          continue;
+        }
         filteredRules[ruleKey] = ruleConfig;
       }
       
@@ -358,6 +386,9 @@ class ESLintEngine extends AnalysisEngineInterface {
       if (skippedRules.typescript.length > 0) {
         console.warn(`⚠️ [ESLintEngine] Skipped ${skippedRules.typescript.length} TypeScript ESLint rules - plugin not available`);
       }
+      if (skippedRules.import.length > 0) {
+        console.warn(`⚠️ [ESLintEngine] Skipped ${skippedRules.import.length} Import rules - plugin not available`);
+      }
       
       // Use only SunLint analysis config (filteredRules) - do not merge with project rules
       const mergedConfig = {
@@ -568,13 +599,18 @@ export default [
   }
 
   /**
-   * Create default rule mapping
+   * Create default rule mapping (DEPRECATED - use unified registry)
    * Following Rule C006: Verb-noun naming
    */
-  createDefaultRuleMapping() {
-    console.log(`🚨 [ESLintEngine] createDefaultRuleMapping() called - MAPPING WILL BE OVERWRITTEN!`);
+  async createDefaultRuleMapping() {
+    console.log(`⚠️ [ESLintEngine] createDefaultRuleMapping() is DEPRECATED - using unified registry instead`);
+    
+    // Use unified registry instead of hardcoded mappings
+    if (this.unifiedRegistry) {
+      return await this.loadMappingsFromRegistry();
+    }
     
-    // Map common SunLint rules to ESLint equivalents
+    // Legacy fallback mapping (will be removed)
     const defaultMappings = {
       'C005': ['max-statements-per-line', 'complexity'],
       'C006': ['func-names', 'func-name-matching'],
@@ -599,6 +635,32 @@ export default [
     console.warn('⚠️ Using default ESLint rule mapping');
   }
 
+  /**
+   * Load rule mappings from unified registry
+   */
+  async loadMappingsFromRegistry() {
+    if (!this.unifiedRegistry.initialized) {
+      await this.unifiedRegistry.initialize();
+    }
+    
+    const mappings = {};
+    for (const [ruleId, ruleDefinition] of this.unifiedRegistry.rules.entries()) {
+      if (ruleDefinition.engineMappings && ruleDefinition.engineMappings.eslint) {
+        mappings[ruleId] = ruleDefinition.engineMappings.eslint;
+      }
+    }
+    
+    console.log(`📋 [ESLintEngine] Loaded ${Object.keys(mappings).length} mappings from unified registry`);
+    
+    // Clear existing mapping and set new ones
+    this.ruleMapping.clear();
+    for (const [sunlintRule, eslintRules] of Object.entries(mappings)) {
+      this.ruleMapping.set(sunlintRule, eslintRules);
+    }
+    
+    return mappings;
+  }
+
   /**
    * Detect project type from package.json and file patterns
    * @param {string} projectPath - Project path
@@ -908,6 +970,20 @@ export default [
     }
   }
 
+  /**
+   * Check if Import plugin is available in project
+   * @param {string} projectPath - Project path to check
+   * @returns {boolean} True if Import plugin is available
+   */
+  isImportPluginAvailable(projectPath) {
+    try {
+      require.resolve('eslint-plugin-import', { paths: [projectPath] });
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
   /**
    * Load React ESLint plugin
    * Following Rule C006: Verb-noun naming
@@ -1026,6 +1102,9 @@ export default [
       throw new Error('ESLint engine not initialized');
     }
 
+    // Ensure rule mapping is loaded from unified registry
+    await this.ensureMappingLoaded();
+
     const results = {
       results: [],
       filesAnalyzed: 0,
@@ -1296,6 +1375,18 @@ export default [
     });
   }
 
+  /**
+   * Check if rules need Import plugin
+   */
+  needsImportPlugin(rules) {
+    // Check if any rules use import/ prefix or specific rules that need import plugin
+    return rules.some(ruleId => {
+      const id = typeof ruleId === 'string' ? ruleId : ruleId.id || ruleId.name;
+      return id && (id.includes('import/') || 
+                   ['C038', 'C040'].includes(id)); // Rules that map to import plugin
+    });
+  }
+
   /**
    * Build dynamic plugins based on rules being analyzed
    * @param {Array} rules - Rules to analyze
@@ -1370,8 +1461,41 @@ export default [
         continue;
       }
       
-      // For Common rules (C series), use rule ID directly in custom plugin
+      // For Common rules (C series), check mapping file first
       if (rule.id.startsWith('C')) {
+        const eslintRules = this.ruleMapping.get(rule.id);
+        
+        if (eslintRules && Array.isArray(eslintRules)) {
+          // Check if mapping contains custom rules
+          const customRules = eslintRules.filter(r => r.startsWith('custom/'));
+          const builtinRules = eslintRules.filter(r => !r.startsWith('custom/'));
+          
+          // If mapping has custom rules, use them
+          if (customRules.length > 0) {
+            for (const customRule of customRules) {
+              const ruleConfig = this.mapSeverity(rule.severity || 'warning');
+              
+              // Add rule configuration for specific rules
+              if (rule.id === 'C010') {
+                config.rules[customRule] = [ruleConfig, { maxDepth: 3 }];
+              } else {
+                config.rules[customRule] = ruleConfig;
+              }
+            }
+            continue;
+          }
+          
+          // If mapping has only builtin rules, use them
+          if (builtinRules.length > 0) {
+            for (const eslintRule of builtinRules) {
+              const severity = this.mapSeverity(rule.severity || 'warning');
+              config.rules[eslintRule] = severity;
+            }
+            continue;
+          }
+        }
+        
+        // If no mapping found, fallback to auto-generated custom rule name
         const customRuleName = `custom/${rule.id.toLowerCase()}`;
         const ruleConfig = this.mapSeverity(rule.severity || 'warning');
         
@@ -1384,29 +1508,57 @@ export default [
         continue;
       }
       
-      // For TypeScript rules (T series), use rule ID directly in custom plugin
+      // For TypeScript rules (T series), check mapping file first
       if (rule.id.startsWith('T')) {
+        const eslintRules = this.ruleMapping.get(rule.id);
+        
+        if (eslintRules && Array.isArray(eslintRules)) {
+          // Check if mapping contains custom rules
+          const customRules = eslintRules.filter(r => r.startsWith('custom/'));
+          const builtinRules = eslintRules.filter(r => !r.startsWith('custom/'));
+          
+          // If mapping has custom rules, use them
+          if (customRules.length > 0) {
+            for (const customRule of customRules) {
+              const ruleConfig = this.mapSeverity(rule.severity || 'warning');
+              config.rules[customRule] = ruleConfig;
+            }
+            continue;
+          }
+          
+          // If mapping has only builtin rules, use them
+          if (builtinRules.length > 0) {
+            for (const eslintRule of builtinRules) {
+              const severity = this.mapSeverity(rule.severity || 'warning');
+              config.rules[eslintRule] = severity;
+            }
+            continue;
+          }
+        }
+        
+        // If no mapping found, fallback to auto-generated custom rule name
         const customRuleName = `custom/${rule.id.toLowerCase()}`;
         const ruleConfig = this.mapSeverity(rule.severity || 'warning');
         config.rules[customRuleName] = ruleConfig;
         continue;
       }
       
-      // For other rules, check mapping file
+      // For other rules, check mapping file first
       const eslintRules = this.ruleMapping.get(rule.id);
       
       if (eslintRules && Array.isArray(eslintRules)) {
+        // Use mapping file (for builtin ESLint rules)
         for (const eslintRule of eslintRules) {
-          // Set rule severity based on SunLint rule
           const severity = this.mapSeverity(rule.severity || 'warning');
           config.rules[eslintRule] = severity;
         }
-      } else {
-        // Fallback - try as custom rule
-        const customRuleName = `custom/${rule.id.toLowerCase()}`;
-        const ruleConfig = this.mapSeverity(rule.severity || 'warning');
-        config.rules[customRuleName] = ruleConfig;
+        continue;
       }
+      
+      // Fallback - try as custom rule for any remaining rules
+      const customRuleName = `custom/${rule.id.toLowerCase()}`;
+      const ruleConfig = this.mapSeverity(rule.severity || 'warning');
+      config.rules[customRuleName] = ruleConfig;
     }
 
     return config;