@sun-asterisk/sunlint 1.2.2 → 1.3.1

package/engines/core/base-engine.js

@@ -0,0 +1,249 @@
+/**
+ * Base Engine Abstract Class
+ * Following Rule C005: Single responsibility - Base engine functionality
+ * Following Rule C014: Dependency injection - Plugin architecture
+ */
+
+const EventEmitter = require('events');
+
+class BaseEngine extends EventEmitter {
+  constructor(name, version, supportedLanguages = []) {
+    super();
+    this.name = name;
+    this.version = version;
+    this.supportedLanguages = supportedLanguages;
+    this.initialized = false;
+    this.verbose = false;
+    this.ruleRegistry = new Map();
+    this.pluginManager = null;
+  }
+
+  /**
+   * Set plugin manager for this engine
+   * @param {PluginManager} pluginManager - Plugin manager instance
+   */
+  setPluginManager(pluginManager) {
+    this.pluginManager = pluginManager;
+  }
+
+  /**
+   * Abstract method - must be implemented by subclasses
+   */
+  async initialize(config) {
+    this.verbose = config.verbose || false;
+    
+    // Load rules from plugin manager if available
+    if (this.pluginManager) {
+      const engineRules = await this.pluginManager.loadRulesForEngine(this.name, config);
+      this.ruleRegistry = engineRules;
+      
+      if (this.verbose) {
+        console.log(`🔧 [${this.name}] Loaded ${engineRules.size} rules from Plugin Manager`);
+      }
+    }
+    
+    this.initialized = true;
+  }
+
+  /**
+   * Abstract method - must be implemented by subclasses
+   */
+  async analyze(files, rules, options) {
+    throw new Error('analyze() must be implemented by subclass');
+  }
+
+  /**
+   * Analyze files with a specific rule plugin
+   * @param {string} ruleId - Rule identifier
+   * @param {Array} files - Files to analyze
+   * @param {string} language - Programming language
+   * @param {Object} options - Analysis options
+   * @returns {Array} Array of violations
+   */
+  async analyzeWithRule(ruleId, files, language, options = {}) {
+    const ruleInfo = this.ruleRegistry.get(ruleId);
+    
+    if (!ruleInfo) {
+      if (this.verbose) {
+        console.warn(`⚠️ [${this.name}] Rule ${ruleId} not found`);
+      }
+      return [];
+    }
+
+    try {
+      const violations = await ruleInfo.plugin.analyze(files, language, {
+        ...options,
+        engine: this.name,
+        metadata: ruleInfo.metadata
+      });
+
+      // Ensure violations have correct rule ID
+      return violations.map(violation => ({
+        ...violation,
+        ruleId: ruleId,
+        engine: this.name,
+        pluginType: ruleInfo.type
+      }));
+
+    } catch (error) {
+      if (this.verbose) {
+        console.error(`❌ [${this.name}] Error analyzing with rule ${ruleId}: ${error.message}`);
+      }
+      return [];
+    }
+  }
+
+  /**
+   * Check if a rule is supported by this engine
+   * @param {string} ruleId - Rule ID to check
+   * @returns {boolean} True if rule is supported
+   */
+  isRuleSupported(ruleId) {
+    return this.ruleRegistry.has(ruleId);
+  }
+
+  /**
+   * Get engine information
+   * @returns {Object} Engine metadata
+   */
+  getEngineInfo() {
+    return {
+      name: this.name,
+      version: this.version,
+      supportedLanguages: this.supportedLanguages,
+      initialized: this.initialized,
+      rulesLoaded: this.ruleRegistry.size
+    };
+  }
+
+  /**
+   * Register a rule with the engine
+   * @param {string} ruleId - Rule identifier
+   * @param {Object} ruleInfo - Rule information and analyzer
+   */
+  registerRule(ruleId, ruleInfo) {
+    this.ruleRegistry.set(ruleId, ruleInfo);
+    this.emit('ruleRegistered', { ruleId, engine: this.name });
+  }
+
+  /**
+   * Unregister a rule from the engine
+   * @param {string} ruleId - Rule identifier
+   */
+  unregisterRule(ruleId) {
+    const removed = this.ruleRegistry.delete(ruleId);
+    if (removed) {
+      this.emit('ruleUnregistered', { ruleId, engine: this.name });
+    }
+    return removed;
+  }
+
+  /**
+   * Get all registered rules
+   * @returns {string[]} Array of rule IDs
+   */
+  getRegisteredRules() {
+    return Array.from(this.ruleRegistry.keys());
+  }
+
+  /**
+   * Set plugin manager
+   * @param {Object} pluginManager - Plugin manager instance
+   */
+  setPluginManager(pluginManager) {
+    this.pluginManager = pluginManager;
+  }
+
+  /**
+   * Load rules using plugin manager
+   * @param {Object} config - Configuration options
+   */
+  async loadRules(config = {}) {
+    if (!this.pluginManager) {
+      throw new Error('Plugin manager not set');
+    }
+    
+    const rules = await this.pluginManager.loadRulesForEngine(this.name, config);
+    
+    for (const [ruleId, ruleInfo] of rules) {
+      this.registerRule(ruleId, ruleInfo);
+    }
+    
+    if (this.verbose) {
+      console.log(`📚 [${this.name}] Loaded ${rules.size} rules`);
+    }
+  }
+
+  /**
+   * Cleanup engine resources
+   */
+  async cleanup() {
+    this.ruleRegistry.clear();
+    this.initialized = false;
+    this.emit('cleanup', { engine: this.name });
+    
+    if (this.verbose) {
+      console.log(`🔧 [${this.name}] Engine cleanup completed`);
+    }
+  }
+
+  /**
+   * Group files by programming language
+   * @param {string[]} files - Files to group
+   * @returns {Object} Files grouped by language
+   */
+  groupFilesByLanguage(files) {
+    const groups = {};
+
+    for (const file of files) {
+      const language = this.detectLanguage(file);
+      if (!groups[language]) {
+        groups[language] = [];
+      }
+      groups[language].push(file);
+    }
+
+    return groups;
+  }
+
+  /**
+   * Detect programming language from file extension
+   * @param {string} filePath - File path
+   * @returns {string} Detected language
+   */
+  detectLanguage(filePath) {
+    const path = require('path');
+    const ext = path.extname(filePath).toLowerCase();
+    
+    const languageMap = {
+      '.ts': 'typescript',
+      '.tsx': 'typescript',
+      '.js': 'javascript', 
+      '.jsx': 'javascript',
+      '.dart': 'dart',
+      '.swift': 'swift',
+      '.kt': 'kotlin',
+      '.kts': 'kotlin',
+      '.java': 'java',
+      '.py': 'python',
+      '.go': 'go',
+      '.rs': 'rust',
+      '.php': 'php',
+      '.rb': 'ruby'
+    };
+
+    return languageMap[ext] || 'unknown';
+  }
+
+  /**
+   * Check if language is supported
+   * @param {string} language - Language to check
+   * @returns {boolean} True if supported
+   */
+  isLanguageSupported(language) {
+    return this.supportedLanguages.includes(language) || 
+           this.supportedLanguages.includes('all');
+  }
+}
+
+module.exports = BaseEngine;

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;