@sun-asterisk/sunlint 1.2.2 → 1.3.0

package/engines/engine-factory.js

@@ -0,0 +1,275 @@
+/**
+ * Engine Factory
+ * Creates and manages engine instances with plugin support
+ * Following Rule C005: Single responsibility - Engine creation
+ */
+
+const PluginManager = require('../core/plugin-manager');
+const BaseEngine = require('./core/base-engine');
+
+// Engine imports
+const HeuristicEngine = require('../engines/heuristic-engine');
+const ESLintEngine = require('../engines/eslint-engine'); 
+const OpenAIEngine = require('../engines/openai-engine');
+
+class EngineFactory {
+  constructor() {
+    this.pluginManager = null;
+    this.engines = new Map();
+    this.verbose = false;
+  }
+
+  /**
+   * Initialize factory with plugin manager
+   * @param {Object} config - Configuration options
+   */
+  async initialize(config = {}) {
+    this.verbose = config.verbose || false;
+    
+    // Initialize plugin manager
+    this.pluginManager = new PluginManager();
+    await this.pluginManager.initialize(config);
+    
+    if (this.verbose) {
+      console.log('🏭 Engine Factory initialized');
+    }
+  }
+
+  /**
+   * Create an engine instance
+   * @param {string} engineType - Type of engine to create
+   * @param {Object} config - Engine configuration
+   * @returns {BaseEngine} Engine instance
+   */
+  async createEngine(engineType, config = {}) {
+    const engineConfig = {
+      ...config,
+      verbose: this.verbose,
+      pluginManager: this.pluginManager
+    };
+
+    let engine = null;
+
+    switch (engineType.toLowerCase()) {
+      case 'heuristic':
+        engine = new HeuristicEngine();
+        break;
+      case 'eslint':
+        engine = new ESLintEngine();
+        break;
+      case 'openai':
+        engine = new OpenAIEngine();
+        break;
+      default:
+        throw new Error(`Unknown engine type: ${engineType}`);
+    }
+
+    // Set plugin manager and initialize
+    if (engine instanceof BaseEngine) {
+      engine.setPluginManager(this.pluginManager);
+      await engine.initialize(engineConfig);
+    }
+
+    // Cache engine instance
+    this.engines.set(engineType, engine);
+
+    if (this.verbose) {
+      console.log(`🔧 Created ${engineType} engine with ${engine.ruleRegistry.size} rules`);
+    }
+
+    return engine;
+  }
+
+  /**
+   * Get an existing engine or create a new one
+   * @param {string} engineType - Type of engine
+   * @param {Object} config - Engine configuration
+   * @returns {BaseEngine} Engine instance
+   */
+  async getEngine(engineType, config = {}) {
+    if (this.engines.has(engineType)) {
+      return this.engines.get(engineType);
+    }
+
+    return await this.createEngine(engineType, config);
+  }
+
+  /**
+   * Get all available engines
+   * @returns {Map} Map of engine type to engine instance
+   */
+  getAllEngines() {
+    return this.engines;
+  }
+
+  /**
+   * Check if engine type is supported
+   * @param {string} engineType - Engine type to check
+   * @returns {boolean} True if supported
+   */
+  isEngineSupported(engineType) {
+    const supportedEngines = ['heuristic', 'eslint', 'openai'];
+    return supportedEngines.includes(engineType.toLowerCase());
+  }
+
+  /**
+   * Get engine metadata
+   * @param {string} engineType - Engine type
+   * @returns {Object|null} Engine metadata
+   */
+  getEngineMetadata(engineType) {
+    const engine = this.engines.get(engineType);
+    return engine ? engine.getMetadata() : null;
+  }
+
+  /**
+   * Reload custom rules in all engines
+   * @param {Object} config - Configuration options
+   */
+  async reloadCustomRules(config = {}) {
+    if (this.pluginManager) {
+      await this.pluginManager.reloadCustomRules(config);
+      
+      // Reinitialize all engines to pick up new rules
+      for (const [engineType, engine] of this.engines) {
+        if (engine instanceof BaseEngine) {
+          await engine.initialize({ ...config, verbose: this.verbose });
+        }
+      }
+
+      if (this.verbose) {
+        console.log('🔄 Reloaded custom rules in all engines');
+      }
+    }
+  }
+
+  /**
+   * Get compatible engines for a language
+   * @param {string} language - Programming language
+   * @returns {Array} Array of compatible engine types
+   */
+  getCompatibleEngines(language) {
+    const compatible = [];
+
+    for (const [engineType, engine] of this.engines) {
+      if (engine.supportedLanguages.includes(language.toLowerCase())) {
+        compatible.push(engineType);
+      }
+    }
+
+    return compatible;
+  }
+
+  /**
+   * Create multiple engines from configuration
+   * @param {Object} engineConfig - Engine configuration object
+   * @returns {Map} Map of created engines
+   */
+  async createEnginesFromConfig(engineConfig = {}) {
+    const engines = new Map();
+
+    for (const [engineType, config] of Object.entries(engineConfig)) {
+      if (this.isEngineSupported(engineType)) {
+        try {
+          const engine = await this.createEngine(engineType, config);
+          engines.set(engineType, engine);
+        } catch (error) {
+          if (this.verbose) {
+            console.warn(`⚠️ Failed to create ${engineType} engine: ${error.message}`);
+          }
+        }
+      }
+    }
+
+    return engines;
+  }
+
+  /**
+   * Analyze files using best engine for language
+   * @param {Array} files - Files to analyze
+   * @param {string} language - Programming language
+   * @param {Array} rules - Rules to apply
+   * @param {Object} options - Analysis options
+   * @returns {Array} Array of violations
+   */
+  async analyzeWithBestEngine(files, language, rules, options = {}) {
+    const compatibleEngines = this.getCompatibleEngines(language);
+    
+    if (compatibleEngines.length === 0) {
+      throw new Error(`No compatible engines found for language: ${language}`);
+    }
+
+    // Priority: heuristic > eslint > openai
+    const enginePriority = ['heuristic', 'eslint', 'openai'];
+    const bestEngine = enginePriority.find(type => compatibleEngines.includes(type));
+
+    if (!bestEngine) {
+      throw new Error(`No suitable engine found for language: ${language}`);
+    }
+
+    const engine = await this.getEngine(bestEngine, options);
+    return await engine.analyze(files, rules, { ...options, language });
+  }
+
+  /**
+   * Cleanup all engines and plugin manager
+   */
+  async cleanup() {
+    // Cleanup all engines
+    for (const [engineType, engine] of this.engines) {
+      try {
+        if (engine.cleanup) {
+          await engine.cleanup();
+        }
+      } catch (error) {
+        if (this.verbose) {
+          console.warn(`⚠️ Error cleaning up ${engineType} engine: ${error.message}`);
+        }
+      }
+    }
+
+    // Cleanup plugin manager
+    if (this.pluginManager) {
+      await this.pluginManager.cleanup();
+    }
+
+    this.engines.clear();
+    this.pluginManager = null;
+
+    if (this.verbose) {
+      console.log('🧹 Engine Factory cleanup completed');
+    }
+  }
+
+  /**
+   * Get factory statistics
+   * @returns {Object} Factory statistics
+   */
+  getStatistics() {
+    const stats = {
+      engineCount: this.engines.size,
+      engines: {},
+      totalRules: 0
+    };
+
+    for (const [engineType, engine] of this.engines) {
+      const metadata = engine.getMetadata ? engine.getMetadata() : {};
+      stats.engines[engineType] = {
+        ...metadata,
+        ruleCount: engine.ruleRegistry ? engine.ruleRegistry.size : 0
+      };
+      stats.totalRules += stats.engines[engineType].ruleCount;
+    }
+
+    if (this.pluginManager) {
+      stats.pluginManager = {
+        totalPlugins: this.pluginManager.getAllPlugins().size,
+        customRules: this.pluginManager.customRules.size
+      };
+    }
+
+    return stats;
+  }
+}
+
+module.exports = EngineFactory;

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;