@sun-asterisk/sunlint 1.2.2 → 1.3.0

package/engines/heuristic-engine.js

@@ -1,6 +1,6 @@
 /**
- * Heuristic Analysis Engine Plugin
- * Following Rule C005: Single responsibility - Pattern-based analysis with AST enhancement
+ * Heuristic Analysis Engine Plugin with ts-morph Core Integration
+ * Following Rule C005: Single responsibility - Pattern-based analysis with ts-morph core
  * Following Rule C014: Dependency injection - implements interface
  * Following Rule C015: Use domain language - clear heuristic analysis terms
  */
@@ -9,21 +9,32 @@ const AnalysisEngineInterface = require('../core/interfaces/analysis-engine.inte
 const ASTModuleRegistry = require('../core/ast-modules/index');
 const dependencyChecker = require('../core/dependency-checker');
 const SunlintRuleAdapter = require('../core/adapters/sunlint-rule-adapter');
+const SemanticEngine = require('../core/semantic-engine');
+const SemanticRuleBase = require('../core/semantic-rule-base');
+const { getInstance: getUnifiedRegistry } = require('../core/unified-rule-registry');
 const fs = require('fs');
 const path = require('path');
 
 class HeuristicEngine extends AnalysisEngineInterface {
   constructor() {
-    super('heuristic', '2.0', ['typescript', 'javascript', 'dart', 'swift', 'kotlin', 'java', 'python', 'go', 'rust', 'all']);
+    super('heuristic', '3.0', ['typescript', 'javascript', 'dart', 'swift', 'kotlin', 'java', 'python', 'go', 'rust', 'all']);
     
     this.ruleAnalyzers = new Map();
     this.supportedRulesList = [];
     this.ruleAdapter = SunlintRuleAdapter.getInstance();
     this.astRegistry = ASTModuleRegistry;
+    
+    // ts-morph as core technology for heuristic engine
+    this.semanticEngine = new SemanticEngine();
+    this.semanticRules = new Map();
+    this.symbolTableEnabled = false;
+    
+    // Unified rule registry
+    this.unifiedRegistry = getUnifiedRegistry();
   }
 
   /**
-   * Initialize Heuristic engine with configuration
+   * Initialize Heuristic engine with ts-morph core and configuration
    * Following Rule C006: Verb-noun naming
    * @param {Object} config - Engine configuration
    */
@@ -32,18 +43,27 @@ class HeuristicEngine extends AnalysisEngineInterface {
       // Store verbosity setting
       this.verbose = config?.verbose || false;
       
+      // Initialize unified rule registry
+      await this.unifiedRegistry.initialize({ verbose: this.verbose });
+      
       // Check for optional AST dependencies
       dependencyChecker.checkAndNotify('ast');
       
+      // Initialize ts-morph Symbol Table (core requirement)
+      await this.initializeSymbolTable(config);
+      
       // Initialize rule adapter
       await this.ruleAdapter.initialize();
       
-      // Scan for available rule analyzers
-      await this.scanRuleAnalyzers(config);
+      // Load available rules from unified registry
+      await this.loadRulesFromRegistry(config);
       
       this.initialized = true;
       if (this.verbose) {
-        console.log(`🔍 Heuristic engine v2.0 initialized with ${this.supportedRulesList.length} rules (AST-enhanced)`);
+        console.log(`🔍 Heuristic engine v3.0 initialized:`);
+        console.log(`   📊 Total rules: ${this.supportedRulesList.length}`);
+        console.log(`   🧠 Symbol Table: ${this.symbolTableInitialized ? 'enabled' : 'disabled'}`);
+        console.log(`   🔧 Semantic rules: ${this.semanticRules.size}`);
       }
       
     } catch (error) {
@@ -53,7 +73,171 @@ class HeuristicEngine extends AnalysisEngineInterface {
   }
 
   /**
-   * Scan for available rule analyzers
+   * Initialize ts-morph Symbol Table as core requirement
+   */
+  async initializeSymbolTable(config) {
+    const projectPath = config?.projectPath || process.cwd();
+    
+    try {
+      // ts-morph is now a core dependency
+      const success = await this.semanticEngine.initialize(projectPath);
+      
+      if (success) {
+        this.semanticEnabled = true;
+        this.symbolTableInitialized = true;
+        if (this.verbose) {
+          console.log(`🧠 Symbol Table initialized for: ${projectPath}`);
+        }
+      } else {
+        if (this.verbose) {
+          console.warn('⚠️  Symbol Table initialization failed, using fallback mode');
+        }
+      }
+      
+    } catch (error) {
+      if (this.verbose) {
+        console.warn('⚠️  ts-morph Symbol Table unavailable:', error.message);
+        console.warn('⚠️  Falling back to traditional AST/regex analysis only');
+      }
+    }
+  }
+
+  /**
+   * Load rules from unified registry instead of scanning directories
+   * Following Rule C006: Verb-noun naming
+   * @param {Object} config - Engine configuration
+   */
+  async loadRulesFromRegistry(config = {}) {
+    try {
+      // Get rules supported by heuristic engine from unified registry
+      const supportedRules = this.unifiedRegistry.getRulesForEngine('heuristic');
+      
+      if (this.verbose) {
+        console.log(`🔍 [HeuristicEngine] Found ${supportedRules.length} rules from unified registry`);
+      }
+      
+      // Load each rule
+      for (const ruleDefinition of supportedRules) {
+        await this.loadRuleFromDefinition(ruleDefinition);
+      }
+      
+      // Manually load C047 if needed (DEPRECATED - C047 now in enhanced registry)
+      // if (!this.semanticRules.has('C047') && !this.ruleAnalyzers.has('C047')) {
+      //   await this.manuallyLoadC047();
+      // }
+      
+      if (this.verbose) {
+        console.log(`✅ [HeuristicEngine] Loaded ${this.supportedRulesList.length} rules from unified registry`);
+      }
+      
+    } catch (error) {
+      console.error('Failed to load rules from registry:', error.message);
+      // Fallback to old scanning method
+      await this.scanRuleAnalyzers(config);
+    }
+  }
+
+  /**
+   * Load a single rule from its definition
+   * @param {Object} ruleDefinition - Rule definition from unified registry
+   */
+  async loadRuleFromDefinition(ruleDefinition) {
+    const ruleId = ruleDefinition.id;
+    
+    try {
+      // Resolve best analyzer path for this engine
+      const analyzerPath = this.unifiedRegistry.resolveAnalyzerPath(ruleId, 'heuristic');
+      
+      if (!analyzerPath) {
+        if (this.verbose) {
+          console.warn(`⚠️ [HeuristicEngine] No compatible analyzer found for ${ruleId}`);
+        }
+        return;
+      }
+      
+      // Determine analyzer type from path and strategy
+      const strategy = ruleDefinition.strategy.preferred;
+      const category = ruleDefinition.category;
+      
+      if (strategy === 'semantic' && this.symbolTableInitialized) {
+        // Load as semantic rule
+        await this.loadSemanticRule(ruleId, analyzerPath, { category });
+      } else {
+        // Load as traditional rule (ast/regex)
+        await this.loadTraditionalRule(ruleId, analyzerPath, { category, type: strategy });
+      }
+      
+    } catch (error) {
+      if (this.verbose) {
+        console.warn(`⚠️ [HeuristicEngine] Failed to load rule ${ruleId}:`, error.message);
+      }
+    }
+  }
+
+  /**
+   * Load semantic rule from analyzer path
+   * @param {string} ruleId - Rule ID
+   * @param {string} analyzerPath - Path to analyzer file
+   * @param {Object} metadata - Rule metadata
+   */
+  async loadSemanticRule(ruleId, analyzerPath, metadata) {
+    try {
+      const SemanticRuleClass = require(analyzerPath);
+      
+      // Verify it extends SemanticRuleBase
+      if (this.isSemanticRule(SemanticRuleClass)) {
+        await this.registerSemanticRule(ruleId, SemanticRuleClass, {
+          path: analyzerPath,
+          category: metadata.category
+        });
+        
+        if (this.verbose) {
+          console.log(`🧠 [HeuristicEngine] Loaded semantic rule: ${ruleId}`);
+        }
+      } else {
+        // Not a semantic rule, fallback to traditional
+        await this.loadTraditionalRule(ruleId, analyzerPath, metadata);
+      }
+      
+    } catch (error) {
+      if (this.verbose) {
+        console.warn(`⚠️ [HeuristicEngine] Failed to load semantic rule ${ruleId}:`, error.message);
+      }
+    }
+  }
+
+  /**
+   * Load traditional rule (ast/regex) from analyzer path
+   * @param {string} ruleId - Rule ID
+   * @param {string} analyzerPath - Path to analyzer file
+   * @param {Object} metadata - Rule metadata
+   */
+  async loadTraditionalRule(ruleId, analyzerPath, metadata) {
+    try {
+      const analyzerModule = require(analyzerPath);
+      const AnalyzerClass = analyzerModule.default || analyzerModule;
+      
+      this.registerTraditionalRule(ruleId, AnalyzerClass, {
+        path: analyzerPath,
+        category: metadata.category,
+        folder: ruleId, // Add folder name for config loading
+        type: metadata.type || 'regex'
+      });
+      
+      if (this.verbose) {
+        console.log(`🔧 [HeuristicEngine] Loaded ${metadata.type} rule: ${ruleId}`);
+      }
+      
+    } catch (error) {
+      if (this.verbose) {
+        console.warn(`⚠️ [HeuristicEngine] Failed to load traditional rule ${ruleId}:`, error.message);
+      }
+    }
+  }
+
+  /**
+   * Scan for available rule analyzers with semantic support
+   * Priority: semantic > ast > regex
    * Following Rule C006: Verb-noun naming
    */
   async scanRuleAnalyzers(config = {}) {
@@ -80,80 +264,195 @@ class HeuristicEngine extends AnalysisEngineInterface {
           .map(dirent => dirent.name);
 
         for (const ruleFolder of ruleFolders) {
-          const ruleId = this.extractRuleIdFromFolder(ruleFolder);
+          const ruleId = ruleFolder; // Use folder name directly as rule ID
+          const rulePath = path.join(categoryPath, ruleFolder);
           
-          // Priority 1: Check for AST analyzer (enhanced accuracy)
-          const astAnalyzerPath = path.join(categoryPath, ruleFolder, 'ast-analyzer.js');
-          const regexAnalyzerPath = path.join(categoryPath, ruleFolder, 'analyzer.js');
-          
-          let selectedAnalyzer = null;
-          let analyzerPath = null;
-          let analyzerType = 'regex';
-          
-          // Try AST analyzer first
-          if (fs.existsSync(astAnalyzerPath)) {
-            try {
-              const analyzerModule = require(astAnalyzerPath);
-              selectedAnalyzer = analyzerModule.default || analyzerModule;
-              analyzerPath = astAnalyzerPath;
-              analyzerType = 'ast';
-            } catch (error) {
-              console.debug(`AST analyzer for ${ruleId} failed to load, falling back to regex:`, error.message);
-            }
-          }
+          await this.loadRuleAnalyzer(ruleId, rulePath, categoryFolder);
+        }
+      }
+      
+    } catch (error) {
+      console.warn('⚠️ Error scanning rule analyzers:', error.message);
+    }
+  }
+
+  /**
+   * Manually load C047 semantic rule (special case)
+   */
+  async manuallyLoadC047() {
+    try {
+      if (this.verbose) {
+        console.log(`[DEBUG] 🔬 Manually loading C047 semantic rule...`);
+      }
+      
+      const c047Path = path.resolve(__dirname, '../rules/common/C047_no_duplicate_retry_logic/c047-semantic-rule.js');
+      
+      if (fs.existsSync(c047Path)) {
+        const C047SemanticRule = require(c047Path);
+        const instance = new C047SemanticRule();
+        
+        // Register as semantic rule
+        await this.registerSemanticRule('C047', C047SemanticRule, {
+          path: c047Path,
+          category: 'common',
+          type: 'semantic',
+          description: 'C047 - No Duplicate Retry Logic (Semantic Analysis)'
+        });
+        
+        if (this.verbose) {
+          console.log(`[DEBUG] ✅ C047 semantic rule loaded successfully`);
+        }
+      } else {
+        console.warn(`⚠️ C047 semantic rule not found at: ${c047Path}`);
+      }
+      
+    } catch (error) {
+      console.warn(`⚠️ Failed to manually load C047:`, error.message);
+    }
+  }
+
+  /**
+   * Load rule analyzer with semantic priority
+   */
+  async loadRuleAnalyzer(ruleId, rulePath, categoryFolder) {
+    // Analyzer priority: semantic > ast > regex
+    const analyzerCandidates = [
+      { path: path.join(rulePath, 'semantic-analyzer.js'), type: 'semantic' },
+      { path: path.join(rulePath, 'ast-analyzer.js'), type: 'ast' },
+      { path: path.join(rulePath, 'regex-analyzer.js'), type: 'regex' },
+      { path: path.join(rulePath, 'analyzer.js'), type: 'regex' } // legacy fallback
+    ];
+    
+    let selectedAnalyzer = null;
+    let analyzerPath = null;
+    let analyzerType = null;
+    
+    // Try semantic analyzer first if Symbol Table available
+    if (this.symbolTableInitialized) {
+      const semanticCandidate = analyzerCandidates[0];
+      if (fs.existsSync(semanticCandidate.path)) {
+        try {
+          const analyzerModule = require(semanticCandidate.path);
+          selectedAnalyzer = analyzerModule.default || analyzerModule;
+          analyzerPath = semanticCandidate.path;
+          analyzerType = 'semantic';
           
-          // Fallback to regex analyzer
-          if (!selectedAnalyzer && fs.existsSync(regexAnalyzerPath)) {
-            try {
-              const analyzerModule = require(regexAnalyzerPath);
-              selectedAnalyzer = analyzerModule.default || analyzerModule;
-              analyzerPath = regexAnalyzerPath;
-              analyzerType = 'regex';
-            } catch (error) {
-              console.warn(`⚠️ Failed to load analyzer for ${ruleId}:`, error.message);
-            }
+          // Verify it extends SemanticRuleBase
+          if (this.isSemanticRule(selectedAnalyzer)) {
+            await this.registerSemanticRule(ruleId, selectedAnalyzer, {
+              path: analyzerPath,
+              category: categoryFolder
+            });
+            return; // Successfully registered semantic rule
           }
-          
-          if (selectedAnalyzer) {
-            // Check if it's a class constructor, instance, or factory function
-            if (typeof selectedAnalyzer === 'function') {
-              // It's a class constructor
-              this.ruleAnalyzers.set(ruleId, {
-                path: analyzerPath,
-                class: selectedAnalyzer,
-                folder: ruleFolder,
-                category: categoryFolder,
-                type: 'class',
-                analyzerType: analyzerType // 'ast' or 'regex'
-              });
-              this.supportedRulesList.push(ruleId);
-            } else if (selectedAnalyzer && typeof selectedAnalyzer === 'object' && selectedAnalyzer.analyze) {
-              // It's an analyzer instance with analyze method
-              this.ruleAnalyzers.set(ruleId, {
-                path: analyzerPath,
-                instance: selectedAnalyzer,
-                folder: ruleFolder,
-                category: categoryFolder,
-                type: 'instance',
-                analyzerType: analyzerType // 'ast' or 'regex'
-              });
-              this.supportedRulesList.push(ruleId);
-            } else {
-              console.warn(`⚠️ Analyzer for ${ruleId} has unsupported format:`, typeof selectedAnalyzer);
-            }
+        } catch (error) {
+          console.debug(`Semantic analyzer for ${ruleId} failed to load:`, error.message);
+        }
+      }
+    }
+    
+    // Fall back to AST analyzer
+    const astCandidate = analyzerCandidates[1];
+    if (fs.existsSync(astCandidate.path)) {
+      try {
+        const analyzerModule = require(astCandidate.path);
+        selectedAnalyzer = analyzerModule.default || analyzerModule;
+        analyzerPath = astCandidate.path;
+        analyzerType = 'ast';
+      } catch (error) {
+        console.debug(`AST analyzer for ${ruleId} failed to load:`, error.message);
+      }
+    }
+    
+    // Fall back to regex analyzer
+    if (!selectedAnalyzer) {
+      for (const regexCandidate of analyzerCandidates.slice(2)) {
+        if (fs.existsSync(regexCandidate.path)) {
+          try {
+            const analyzerModule = require(regexCandidate.path);
+            selectedAnalyzer = analyzerModule.default || analyzerModule;
+            analyzerPath = regexCandidate.path;
+            analyzerType = 'regex';
+            break;
+          } catch (error) {
+            console.debug(`Regex analyzer for ${ruleId} failed to load:`, error.message);
           }
         }
       }
+    }
+    
+    // Register traditional (non-semantic) analyzer
+    if (selectedAnalyzer) {
+      this.registerTraditionalRule(ruleId, selectedAnalyzer, {
+        path: analyzerPath,
+        category: categoryFolder,
+        folder: fullRuleId, // Add folder name for config loading
+        type: analyzerType
+      });
+    }
+  }
 
-      if (config.verbose) {
+  /**
+   * Check if analyzer is a semantic rule
+   */
+  isSemanticRule(analyzerClass) {
+    if (typeof analyzerClass !== 'function') return false;
+    
+    try {
+      const instance = new analyzerClass(analyzerClass.name);
+      return instance instanceof SemanticRuleBase;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Register semantic rule
+   */
+  async registerSemanticRule(ruleId, analyzerClass, metadata) {
+    try {
+      const instance = new analyzerClass(ruleId);
+      instance.initialize(this.semanticEngine);
+      
+      this.semanticRules.set(ruleId, {
+        instance,
+        metadata,
+        type: 'semantic'
+      });
+      
+      this.supportedRulesList.push(ruleId);
+      
       if (this.verbose) {
-        console.log(`🔍 Found ${this.supportedRulesList.length} heuristic analyzers`);
-        console.log(`🔍 Supported rules: ${this.supportedRulesList.join(', ')}`);
-      }
+        console.log(`🧠 Registered semantic rule: ${ruleId}`);
       }
       
     } catch (error) {
-      console.error('Failed to scan rule analyzers:', error.message);
+      console.warn(`⚠️ Failed to register semantic rule ${ruleId}:`, error.message);
+    }
+  }
+
+  /**
+   * Register traditional (heuristic/AST/regex) rule
+   */
+  registerTraditionalRule(ruleId, analyzer, metadata) {
+    if (typeof analyzer === 'function') {
+      // Class constructor
+      this.ruleAnalyzers.set(ruleId, {
+        ...metadata,
+        class: analyzer,
+        type: 'class'
+      });
+      this.supportedRulesList.push(ruleId);
+    } else if (analyzer && typeof analyzer === 'object' && analyzer.analyze) {
+      // Instance with analyze method
+      this.ruleAnalyzers.set(ruleId, {
+        ...metadata,
+        instance: analyzer,
+        type: 'instance'
+      });
+      this.supportedRulesList.push(ruleId);
+    } else {
+      console.warn(`⚠️ Analyzer for ${ruleId} has unsupported format:`, typeof analyzer);
     }
   }
 
@@ -169,6 +468,60 @@ class HeuristicEngine extends AnalysisEngineInterface {
     return match ? match[1] : folderName;
   }
 
+  /**
+   * Get full rule ID from short rule ID (C029 -> C029_catch_block_logging)
+   * @param {string} ruleId - Short rule ID 
+   * @returns {string} Full rule ID or original if not found
+   */
+  getFullRuleId(ruleId) {
+    // Check exact match first
+    if (this.ruleAnalyzers.has(ruleId)) {
+      return ruleId;
+    }
+    
+    // Find full rule ID that starts with short rule ID
+    const shortRulePattern = new RegExp(`^${ruleId}_`);
+    const fullRuleId = Array.from(this.ruleAnalyzers.keys()).find(fullId => shortRulePattern.test(fullId));
+    
+    return fullRuleId || ruleId; // Return original if not found
+  }
+
+  /**
+   * Check if a rule is supported by this engine
+   * Following Rule C006: Verb-noun naming
+   * @param {string} ruleId - Rule ID to check
+   * @returns {boolean} True if rule is supported
+   */
+  isRuleSupported(ruleId) {
+    // Special case: C047 is always supported (loaded on-demand)
+    if (ruleId === 'C047') {
+      return true;
+    }
+    
+    // Use unified registry for primary lookup
+    if (this.unifiedRegistry && this.unifiedRegistry.initialized) {
+      return this.unifiedRegistry.isRuleSupported(ruleId, 'heuristic');
+    }
+    
+    // Fallback to original logic for backward compatibility
+    return this.supportedRulesList.includes(ruleId) || 
+           this.semanticRules.has(ruleId) ||
+           this.ruleAnalyzers.has(ruleId) ||
+           this.checkShortRuleIdMatch(ruleId);
+  }
+
+  /**
+   * Check short rule ID matches (backward compatibility)
+   * @param {string} ruleId - Short rule ID (e.g., C029)
+   * @returns {boolean} True if matches any full rule ID
+   */
+  checkShortRuleIdMatch(ruleId) {
+    const shortRulePattern = new RegExp(`^${ruleId}_`);
+    return this.supportedRulesList.some(fullRuleId => shortRulePattern.test(fullRuleId)) ||
+           Array.from(this.semanticRules.keys()).some(fullRuleId => shortRulePattern.test(fullRuleId)) ||
+           Array.from(this.ruleAnalyzers.keys()).some(fullRuleId => shortRulePattern.test(fullRuleId));
+  }
+
   /**
    * Analyze files using heuristic patterns
    * Following Rule C006: Verb-noun naming
@@ -202,6 +555,14 @@ class HeuristicEngine extends AnalysisEngineInterface {
     const filesByLanguage = this.groupFilesByLanguage(files);
 
     for (const rule of rules) {
+      // Special case: Load C047 semantic rule on-demand
+      if (rule.id === 'C047' && !this.semanticRules.has('C047')) {
+        if (options.verbose) {
+          console.log(`🔬 [HeuristicEngine] Loading C047 semantic rule on-demand...`);
+        }
+        await this.manuallyLoadC047();
+      }
+      
       if (!this.isRuleSupported(rule.id)) {
         if (options.verbose) {
           console.warn(`⚠️ Rule ${rule.id} not supported by Heuristic engine, skipping...`);
@@ -210,7 +571,21 @@ class HeuristicEngine extends AnalysisEngineInterface {
       }
 
       try {
-        const ruleViolations = await this.analyzeRule(rule, filesByLanguage, options);
+        let ruleViolations = [];
+        
+        // Check if this is a semantic rule first (higher priority)
+        if (this.semanticRules.has(rule.id)) {
+          if (options.verbose) {
+            console.log(`🧠 [HeuristicEngine] Running semantic analysis for rule ${rule.id}`);
+          }
+          ruleViolations = await this.analyzeSemanticRule(rule, files, options);
+        } else {
+          // Fallback to traditional analysis
+          if (options.verbose) {
+            console.log(`🔧 [HeuristicEngine] Running traditional analysis for rule ${rule.id}`);
+          }
+          ruleViolations = await this.analyzeRule(rule, filesByLanguage, options);
+        }
         
         if (ruleViolations.length > 0) {
           // Group violations by file
@@ -238,6 +613,59 @@ class HeuristicEngine extends AnalysisEngineInterface {
     return results;
   }
 
+  /**
+   * Analyze semantic rule across files
+   * Following Rule C006: Verb-noun naming
+   * @param {Object} rule - Rule to analyze
+   * @param {string[]} files - Files to analyze
+   * @param {Object} options - Analysis options
+   * @returns {Promise<Object[]>} Rule violations
+   */
+  async analyzeSemanticRule(rule, files, options) {
+    const semanticRuleInfo = this.semanticRules.get(rule.id);
+    if (!semanticRuleInfo) {
+      console.warn(`⚠️ Semantic rule ${rule.id} not found`);
+      return [];
+    }
+
+    try {
+      const ruleInstance = semanticRuleInfo.instance;
+      const allViolations = [];
+
+      // Run semantic analysis for each file
+      for (const filePath of files) {
+        try {
+          if (options.verbose) {
+            console.log(`🧠 [SemanticRule] Analyzing ${path.basename(filePath)} with ${rule.id}`);
+          }
+          
+          // Call semantic rule's analyzeFile method
+          await ruleInstance.analyzeFile(filePath, options);
+          
+          // Get violations from the rule instance
+          const fileViolations = ruleInstance.getViolations();
+          allViolations.push(...fileViolations);
+          
+          // Clear violations for next file
+          ruleInstance.clearViolations();
+          
+        } catch (fileError) {
+          console.warn(`⚠️ Semantic rule ${rule.id} failed for ${filePath}:`, fileError.message);
+        }
+      }
+
+      if (options.verbose && allViolations.length > 0) {
+        console.log(`🧠 [SemanticRule] Found ${allViolations.length} violations for ${rule.id}`);
+      }
+
+      return allViolations;
+      
+    } catch (error) {
+      console.error(`❌ Failed to run semantic rule ${rule.id}:`, error.message);
+      return [];
+    }
+  }
+
   /**
    * Analyze a specific rule across files
    * Following Rule C006: Verb-noun naming
@@ -247,21 +675,23 @@ class HeuristicEngine extends AnalysisEngineInterface {
    * @returns {Promise<Object[]>} Rule violations
    */
   async analyzeRule(rule, filesByLanguage, options) {
-    const analyzerInfo = this.ruleAnalyzers.get(rule.id);
+    // Get full rule ID (C029 -> C029_catch_block_logging)
+    const fullRuleId = this.getFullRuleId(rule.id);
+    const analyzerInfo = this.ruleAnalyzers.get(fullRuleId);
+    
     if (!analyzerInfo) {
       return [];
     }
 
     try {
       // Get analyzer - handle both class and instance types
-      const analyzerInfo = this.ruleAnalyzers.get(rule.id);
       let analyzer;
       
       if (analyzerInfo.type === 'class') {
         // Create analyzer instance from class
         const AnalyzerClass = analyzerInfo.class;
         try {
-          analyzer = new AnalyzerClass();
+          analyzer = new AnalyzerClass({ verbose: options.verbose });
         } catch (constructorError) {
           throw new Error(`Failed to instantiate analyzer class: ${constructorError.message}`);
         }
@@ -288,7 +718,7 @@ class HeuristicEngine extends AnalysisEngineInterface {
 
         try {
           // Load rule config
-          const ruleConfig = await this.loadRuleConfig(rule.id, analyzerInfo.folder, analyzerInfo.category);
+          const ruleConfig = await this.loadRuleConfig(rule.id, analyzerInfo.folder, analyzerInfo.category, options.verbose);
           
           // Run analysis with AST enhancement
           if (options.verbose) {
@@ -354,16 +784,19 @@ class HeuristicEngine extends AnalysisEngineInterface {
    * @param {string} ruleId - Rule ID
    * @param {string} ruleFolder - Rule folder name
    * @param {string} category - Rule category (common, security, etc)
+   * @param {boolean} verbose - Enable verbose logging
    * @returns {Promise<Object>} Rule configuration
    */
-  async loadRuleConfig(ruleId, ruleFolder, category = 'common') {
+  async loadRuleConfig(ruleId, ruleFolder, category = 'common', verbose = false) {
     try {
       const configPath = path.resolve(__dirname, '../rules', category, ruleFolder, 'config.json');
       if (fs.existsSync(configPath)) {
         return require(configPath);
       }
     } catch (error) {
-      console.warn(`⚠️ Failed to load config for ${ruleId}:`, error.message);
+      if (verbose) {
+        console.warn(`[DEBUG] ⚠️ Failed to load config for ${ruleId}:`, error.message);
+      }
     }
 
     // Return minimal config