@sun-asterisk/sunlint 1.3.1 → 1.3.3

package/engines/heuristic-engine.js

@@ -12,12 +12,13 @@ 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 AutoPerformanceManager = require('../core/auto-performance-manager');
 const fs = require('fs');
 const path = require('path');
 
 class HeuristicEngine extends AnalysisEngineInterface {
   constructor() {
-    super('heuristic', '3.0', ['typescript', 'javascript', 'dart', 'swift', 'kotlin', 'java', 'python', 'go', 'rust', 'all']);
+    super('heuristic', '4.0', ['typescript', 'javascript', 'dart', 'swift', 'kotlin', 'java', 'python', 'go', 'rust', 'all']);
     
     this.ruleAnalyzers = new Map();
     this.supportedRulesList = [];
@@ -32,18 +33,38 @@ class HeuristicEngine extends AnalysisEngineInterface {
     
     // Unified rule registry
     this.unifiedRegistry = getUnifiedRegistry();
+    
+    // ✅ PERFORMANCE OPTIMIZATIONS (Integrated)
+    this.performanceManager = new AutoPerformanceManager();
+    this.performanceConfig = null;
+    this.metrics = {
+      startTime: null,
+      filesProcessed: 0,
+      rulesProcessed: 0,
+      violationsFound: 0,
+      memoryUsage: 0
+    };
   }
 
   /**
    * Initialize Heuristic engine with ts-morph core and configuration
+   * ✅ ENHANCED: Now includes performance optimization
    * Following Rule C006: Verb-noun naming
    * @param {Object} config - Engine configuration
    */
   async initialize(config) {
     try {
+      // ✅ PERFORMANCE: Get optimal settings based on project
+      this.performanceConfig = this.performanceManager.getOptimalSettings(config, config?.targetFiles || []);
+      
       // Store verbosity setting
       this.verbose = config?.verbose || false;
       
+      if (this.verbose && this.performanceConfig.autoDetected) {
+        console.log(`🤖 [HeuristicEngine] Auto-detected performance profile: ${this.performanceConfig.name}`);
+        console.log(`   ⚡ Settings: ${this.performanceConfig.timeout/1000}s timeout, ${this.performanceConfig.batchSize || 'auto'} batch size`);
+      }
+      
       // Initialize unified rule registry
       await this.unifiedRegistry.initialize({ verbose: this.verbose });
       
@@ -56,15 +77,21 @@ class HeuristicEngine extends AnalysisEngineInterface {
       // Initialize rule adapter
       await this.ruleAdapter.initialize();
       
-      // Load available rules from unified registry
-      await this.loadRulesFromRegistry(config);
+      // Load available rules from unified registry (OPTIMIZED: skip for performance)
+      // Rules will be loaded on-demand in analyze() method 
+      if (config.loadAllRules) {
+        await this.loadRulesFromRegistry(config);
+      } else if (this.verbose) {
+        console.log(`⚡ [HeuristicEngine] Skipping bulk rule loading for performance - will load on-demand`);
+      }
       
       this.initialized = true;
       if (this.verbose) {
-        console.log(`🔍 Heuristic engine v3.0 initialized:`);
+        console.log(`🔍 Heuristic engine v4.0 initialized:`);
         console.log(`   📊 Total rules: ${this.supportedRulesList.length}`);
         console.log(`   🧠 Symbol Table: ${this.symbolTableInitialized ? 'enabled' : 'disabled'}`);
         console.log(`   🔧 Semantic rules: ${this.semanticRules.size}`);
+        console.log(`   ⚡ Performance: ${this.performanceConfig.name || 'standard'}`);
       }
       
     } catch (error) {
@@ -89,6 +116,8 @@ class HeuristicEngine extends AnalysisEngineInterface {
       };
       
       this.semanticEngine = new SemanticEngine(semanticOptions);
+      // Pass verbose option to semantic engine
+      this.semanticEngine.verbose = this.verbose;
       
       // ts-morph is now a core dependency - but optimized for targeted files
       const success = await this.semanticEngine.initialize(projectPath, config?.targetFiles);
@@ -287,6 +316,43 @@ class HeuristicEngine extends AnalysisEngineInterface {
     }
   }
 
+  /**
+   * Lazy load a single rule on-demand
+   * @param {string} ruleId - Rule ID to load
+   * @param {Object} options - Loading options
+   */
+  async lazyLoadRule(ruleId, options = {}) {
+    try {
+      const ruleDefinition = this.unifiedRegistry.getRuleDefinition(ruleId);
+      
+      if (!ruleDefinition) {
+        if (options.verbose) {
+          console.warn(`⚠️ [HeuristicEngine] Rule definition not found for ${ruleId}`);
+        }
+        return;
+      }
+
+      // Check if rule supports heuristic engine
+      if (!this.unifiedRegistry.isRuleSupported(ruleId, 'heuristic')) {
+        if (options.verbose) {
+          console.warn(`⚠️ [HeuristicEngine] Rule ${ruleId} not supported by heuristic engine`);
+        }
+        return;
+      }
+
+      if (options.verbose) {
+        console.log(`🔄 [HeuristicEngine] Lazy loading rule ${ruleId}...`);
+      }
+
+      await this.loadRuleFromDefinition(ruleDefinition);
+      
+    } catch (error) {
+      if (options.verbose) {
+        console.warn(`⚠️ [HeuristicEngine] Failed to lazy load rule ${ruleId}:`, error.message);
+      }
+    }
+  }
+
   /**
    * Manually load C047 semantic rule (special case)
    */
@@ -453,7 +519,7 @@ class HeuristicEngine extends AnalysisEngineInterface {
 
     try {
       const instance = new ruleEntry.analyzerClass(ruleId);
-      instance.initialize(this.semanticEngine);
+      instance.initialize(this.semanticEngine, { verbose: this.verbose });
       
       // Update entry with initialized instance
       ruleEntry.instance = instance;
@@ -563,6 +629,7 @@ class HeuristicEngine extends AnalysisEngineInterface {
 
   /**
    * Analyze files using heuristic patterns
+   * ✅ ENHANCED: Now includes performance optimizations and batch processing
    * Following Rule C006: Verb-noun naming
    * @param {string[]} files - Files to analyze
    * @param {Object[]} rules - Rules to apply
@@ -574,12 +641,166 @@ class HeuristicEngine extends AnalysisEngineInterface {
       throw new Error('Heuristic engine not initialized');
     }
 
+    // ✅ PERFORMANCE: Apply file limits and timeout protection
+    const startTime = Date.now();
+    this.metrics.startTime = startTime;
+    
+    // Apply analysis file limits (different from semantic file limits)
+    const maxFiles = this.getAnalysisFileLimit(options);
+    const limitedFiles = files.slice(0, maxFiles);
+    
+    if (files.length > maxFiles && this.verbose) {
+      console.warn(`⚠️  [HeuristicEngine] Analysis file limit: ${limitedFiles.length}/${files.length} files`);
+      console.log(`   💡 Note: Symbol table uses separate limit (--max-semantic-files)`);
+    }
+
+    // Set up timeout if configured
+    const timeout = this.performanceConfig?.timeout || parseInt(options.timeout) || 0;
+    let timeoutId = null;
+    
+    if (timeout > 0) {
+      timeoutId = setTimeout(() => {
+        throw new Error(`Analysis timeout after ${timeout}ms`);
+      }, timeout);
+    }
+
     if (options.verbose) {
-      console.log(`🔍 [HeuristicEngine] Analyzing ${files.length} files with ${rules.length} rules`);
-      console.log(`🔍 [HeuristicEngine] Files: ${files.map(f => path.basename(f)).join(', ')}`);
-      console.log(`🔍 [HeuristicEngine] Rules: ${rules.map(r => r.id).join(', ')}`);
+      console.log(`🔍 [HeuristicEngine] Analyzing ${limitedFiles.length} files with ${rules.length} rules`);
+      if (this.performanceConfig?.name) {
+        console.log(`⚡ [Performance] Using ${this.performanceConfig.name} profile`);
+      }
+      if (timeout > 0) {
+        console.log(`⏰ [Timeout] Analysis will timeout after ${timeout/1000}s`);
+      }
+    }
+
+    try {
+      // Check if we should use batch processing
+      if (this.shouldUseBatchProcessing(limitedFiles, rules)) {
+        return await this.analyzeBatched(limitedFiles, rules, options);
+      } else {
+        return await this.analyzeStandard(limitedFiles, rules, options);
+      }
+    } finally {
+      // Clear timeout
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      
+      // Log performance metrics
+      const duration = Date.now() - startTime;
+      this.metrics.filesProcessed = limitedFiles.length;
+      this.metrics.rulesProcessed = rules.length;
+      
+      if (options.verbose) {
+        console.log(`✅ [HeuristicEngine] Analysis completed in ${duration}ms`);
+      }
+    }
+  }
+
+  /**
+   * ✅ NEW: Get analysis file limit (separate from semantic file limit)
+   */
+  getAnalysisFileLimit(options) {
+    // User-specified limit
+    if (options.maxFiles && parseInt(options.maxFiles) > 0) {
+      return parseInt(options.maxFiles);
+    }
+    
+    // Performance config limit
+    if (this.performanceConfig?.maxFiles) {
+      return this.performanceConfig.maxFiles;
+    }
+    
+    // Default based on performance mode
+    const mode = options.performance || 'auto';
+    const defaults = {
+      fast: 500,
+      auto: 1000,
+      careful: 1500
+    };
+    
+    return defaults[mode] || 1000;
+  }
+
+  /**
+   * ✅ NEW: Determine if batch processing should be used
+   */
+  shouldUseBatchProcessing(files, rules) {
+    const batchThreshold = this.performanceConfig?.batchThreshold || 100;
+    const totalWorkload = files.length * rules.length;
+    
+    return totalWorkload > batchThreshold || 
+           files.length > 200 || 
+           rules.length > 30;
+  }
+
+  /**
+   * ✅ NEW: Batch processing for large workloads
+   */
+  async analyzeBatched(files, rules, options) {
+    if (options.verbose) {
+      console.log(`� [HeuristicEngine] Using batch processing for large workload`);
     }
 
+    const results = {
+      results: [],
+      filesAnalyzed: files.length,
+      engine: 'heuristic',
+      metadata: {
+        rulesAnalyzed: rules.map(r => r.id),
+        analyzersUsed: [],
+        batchProcessing: true
+      }
+    };
+
+    // Create rule batches
+    const batchSize = this.performanceConfig?.batchSize || 10;
+    const ruleBatches = [];
+    
+    for (let i = 0; i < rules.length; i += batchSize) {
+      ruleBatches.push(rules.slice(i, i + batchSize));
+    }
+
+    if (options.verbose) {
+      console.log(`📦 [Batch] Processing ${ruleBatches.length} rule batches (${batchSize} rules each)`);
+    }
+
+    // Process each batch
+    for (let batchIndex = 0; batchIndex < ruleBatches.length; batchIndex++) {
+      const ruleBatch = ruleBatches[batchIndex];
+      
+      if (options.verbose) {
+        console.log(`⚡ [Batch ${batchIndex + 1}/${ruleBatches.length}] Processing ${ruleBatch.length} rules...`);
+      }
+
+      const batchResults = await this.analyzeStandard(files, ruleBatch, options);
+      
+      // Merge batch results
+      for (const fileResult of batchResults.results) {
+        let existingFile = results.results.find(r => r.file === fileResult.file);
+        if (!existingFile) {
+          existingFile = { file: fileResult.file, violations: [] };
+          results.results.push(existingFile);
+        }
+        existingFile.violations.push(...fileResult.violations);
+      }
+      
+      results.metadata.analyzersUsed.push(...batchResults.metadata.analyzersUsed);
+      
+      // Memory management
+      if (batchIndex % 3 === 0 && global.gc) {
+        global.gc(); // Trigger garbage collection every 3 batches
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * ✅ REFACTORED: Standard analysis method (extracted from original analyze)
+   */
+  async analyzeStandard(files, rules, options) {
     const results = {
       results: [],
       filesAnalyzed: files.length,
@@ -602,6 +823,14 @@ class HeuristicEngine extends AnalysisEngineInterface {
         await this.manuallyLoadC047();
       }
       
+      // Lazy load rule if not already loaded
+      if (!this.isRuleSupported(rule.id)) {
+        if (options.verbose) {
+          console.log(`🔄 [HeuristicEngine] Lazy loading rule ${rule.id}...`);
+        }
+        await this.lazyLoadRule(rule.id, options);
+      }
+      
       if (!this.isRuleSupported(rule.id)) {
         if (options.verbose) {
           console.warn(`⚠️ Rule ${rule.id} not supported by Heuristic engine, skipping...`);
@@ -722,6 +951,15 @@ class HeuristicEngine extends AnalysisEngineInterface {
   async analyzeRule(rule, filesByLanguage, options) {
     // Get full rule ID (C029 -> C029_catch_block_logging)
     const fullRuleId = this.getFullRuleId(rule.id);
+    
+    // Lazy load rule if not already loaded
+    if (!this.ruleAnalyzers.has(fullRuleId)) {
+      if (options.verbose) {
+        console.log(`🔄 [HeuristicEngine] Lazy loading rule ${rule.id} for analysis...`);
+      }
+      await this.lazyLoadRule(rule.id, options);
+    }
+    
     const analyzerInfo = this.ruleAnalyzers.get(fullRuleId);
     
     if (!analyzerInfo) {
@@ -788,7 +1026,7 @@ class HeuristicEngine extends AnalysisEngineInterface {
             rule.id,
             languageFiles, 
             language, 
-            { ...ruleConfig, ...options }
+            { ...ruleConfig, ...options, semanticEngine: this.semanticEngine }
           );
 
           allViolations.push(...languageViolations);

package/integrations/eslint/plugin/rules/common/c003-no-vague-abbreviations.js

@@ -92,6 +92,59 @@ const c003Rule = {
       return false;
     }
 
+    function isMathContext(node, name) {
+      // Check for math variable patterns
+      const mathPatterns = [
+        // Coordinate pairs: x1, y1, x2, y2
+        /^[xyz][12]$/i,
+        // Delta notation: dx, dy, dt, dr
+        /^d[xyztr]$/i,
+        // Math constants: a, b, c in equations
+        /^[abc]$/i,
+        // Vector components: vx, vy, vz
+        /^v[xyz]$/i,
+        // Position/point notation: p1, p2
+        /^p\d+$/i
+      ];
+      
+      if (mathPatterns.some(pattern => pattern.test(name))) {
+        return true;
+      }
+      
+      // Check if we're in a math function context
+      let parent = node.parent;
+      while (parent) {
+        if (parent.type === 'FunctionDeclaration' || parent.type === 'FunctionExpression' || parent.type === 'ArrowFunctionExpression') {
+          const functionName = parent.id && parent.id.name;
+          if (functionName && /^(distance|calculate|compute|solve|formula|algorithm|equation|math)/i.test(functionName)) {
+            return true;
+          }
+          break; // Don't check beyond the immediate function
+        }
+        parent = parent.parent;
+      }
+      
+      // Check if we're in a context with Math operations
+      let currentNode = node.parent;
+      while (currentNode) {
+        if (currentNode.type === 'CallExpression') {
+          const callee = currentNode.callee;
+          if (callee && callee.object && callee.object.name === 'Math') {
+            return true;
+          }
+          if (callee && callee.name && /^(sqrt|pow|abs|sin|cos|tan|distance|calculate)$/i.test(callee.name)) {
+            return true;
+          }
+        }
+        if (currentNode.type === 'BinaryExpression' && ['+', '-', '*', '/'].includes(currentNode.operator)) {
+          return true;
+        }
+        currentNode = currentNode.parent;
+      }
+      
+      return false;
+    }
+
     function checkVariableName(node, name) {
       // Safety checks
       if (!node || !name || typeof name !== 'string') {
@@ -112,7 +165,7 @@ const c003Rule = {
 
       // Single character check
       if (name.length === 1) {
-        if (!allowedSingleChar.has(name.toLowerCase()) && !isCounterContext(node)) {
+        if (!allowedSingleChar.has(name.toLowerCase()) && !isCounterContext(node) && !isMathContext(node, name)) {
           context.report({
             node,
             messageId: "singleChar",
@@ -137,6 +190,11 @@ const c003Rule = {
         return;
       }
 
+      // Check for math context before flagging as unclear
+      if (isMathContext(node, name)) {
+        return;
+      }
+
       // Check for unclear/generic names
       if (unclearNames.has(name.toLowerCase())) {
         context.report({

package/integrations/eslint/plugin/rules/common/c006-function-name-verb-noun.js

@@ -79,6 +79,22 @@ const c006Rule = {
       ...commonVerbPrefixes,
       ...(options.allowedVerbs || [])
     ]);
+    
+    // Generic/vague verbs that should be flagged even if they are technically verbs
+    const genericVerbs = new Set([
+      'do', 'handle', 'process', 'manage', 'execute', 'work', 'stuff', 'thing', 'data'
+    ]);
+    
+    function isGenericVerbUsage(name) {
+      // Check if the function name is exactly a generic verb or starts with generic verb + something generic
+      const genericPatterns = [
+        /^(do|handle|process|manage|execute)(Something|Stuff|Data|Info|Work|Thing|Items|Objects?)$/i,
+        /^(do|handle|process|manage|execute)$/i,
+        /^(do|handle|process|manage|execute)[A-Z].*$/i // Any pattern starting with generic verb + capital letter
+      ];
+      
+      return genericPatterns.some(pattern => pattern.test(name));
+    }
 
     const allowConstructors = options.allowConstructors !== false;
 
@@ -142,7 +158,16 @@ const c006Rule = {
 
       // Check if it follows verb-noun pattern
       if (isVerbNounPattern(name)) {
-        return; // Good! Follows the pattern
+        // But still check if it's using generic verbs that should be flagged
+        if (isGenericVerbUsage(name)) {
+          context.report({
+            node,
+            messageId: "notVerbNoun",
+            data: { name }
+          });
+          return;
+        }
+        return; // Good! Follows the pattern and not generic
       }
 
       // Check if it's likely a noun-only name

package/integrations/eslint/plugin/rules/common/c030-use-custom-error-classes.js

@@ -52,6 +52,10 @@ const c030Rule = {
     messages: {
       useCustomError: "Use custom error class instead of generic 'Error'. Consider using specific error types like ValidationError, NotFoundError, BusinessRuleError, etc. Vietnamese: 'Dùng custom error class thay vì Error generic'",
       useSpecificBuiltin: "Consider using a more specific built-in error type like TypeError, RangeError, or a custom error class. Vietnamese: 'Cân nhắc dùng built-in error cụ thể hơn hoặc custom error class'",
+      throwStringLiteral: "Use custom error classes instead of throwing string literals",
+      throwTemplateLiteral: "Use custom error classes instead of throwing template literals", 
+      throwNumber: "Use custom error classes instead of throwing numbers",
+      throwVariable: "Use custom error classes instead of throwing variables",
       missingErrorCode: "Custom error class should include an error code property. Vietnamese: 'Custom error class nên có thuộc tính error code'",
       missingStatusCode: "HTTP-related error class should include a status code property. Vietnamese: 'Error class liên quan HTTP nên có thuộc tính status code'",
       preferCustomError: "Prefer custom error classes for better error categorization and handling. Vietnamese: 'Ưu tiên custom error classes để phân loại và xử lý lỗi tốt hơn'"
@@ -223,35 +227,66 @@ const c030Rule = {
         // Skip rethrow statements if allowed
         if (isRethrowStatement(node)) return;
 
-        const errorClassName = getErrorClassName(node);
+        // Handle different throw argument types
+        if (node.argument) {
+          // Check for new Error(...) constructors
+          if (node.argument.type === 'NewExpression' && 
+              node.argument.callee && 
+              node.argument.callee.name === 'Error') {
+            context.report({
+              node: node.argument,
+              messageId: "useCustomError"
+            });
+            return;
+          }
 
-        // Check for generic Error usage
-        if (errorClassName === 'Error') {
-          context.report({
-            node: node.argument,
-            messageId: "useCustomError"
-          });
-          return;
-        }
+          // Check for other built-in error constructors
+          if (node.argument.type === 'NewExpression' && 
+              node.argument.callee && 
+              allowedBuiltinErrors.has(node.argument.callee.name)) {
+            if (['TypeError', 'RangeError'].includes(node.argument.callee.name)) {
+              context.report({
+                node: node.argument,
+                messageId: "useSpecificBuiltin"
+              });
+            }
+            return;
+          }
 
-        // In strict mode, only custom errors are allowed
-        if (strictMode && errorClassName) {
-          if (!isCustomErrorClass(errorClassName) && !allowedBuiltinErrors.has(errorClassName)) {
+          // Check for throwing string literals
+          if (node.argument.type === 'Literal' && typeof node.argument.value === 'string') {
             context.report({
               node: node.argument,
-              messageId: "preferCustomError"
+              messageId: "throwStringLiteral"
             });
+            return;
+          }
+
+          // Check for throwing template literals
+          if (node.argument.type === 'TemplateLiteral') {
+            context.report({
+              node: node.argument,
+              messageId: "throwTemplateLiteral"
+            });
+            return;
+          }
+
+          // Check for throwing numbers
+          if (node.argument.type === 'Literal' && typeof node.argument.value === 'number') {
+            context.report({
+              node: node.argument,
+              messageId: "throwNumber"
+            });
+            return;
           }
-        }
 
-        // Check for other built-in errors that could be more specific
-        if (allowedBuiltinErrors.has(errorClassName) && !strictMode) {
-          // Only suggest if it's a generic built-in error
-          if (['TypeError', 'RangeError'].includes(errorClassName)) {
+          // Check for throwing variables (identifiers)
+          if (node.argument.type === 'Identifier') {
             context.report({
               node: node.argument,
-              messageId: "useSpecificBuiltin"
+              messageId: "throwVariable"
             });
+            return;
           }
         }
       },

package/origin-rules/common-en.md

@@ -269,13 +269,17 @@
 
 ### 📘 Rule C019 – Do not use `error` log level for non-critical issues
 
-- **Objective**: Avoid noisy logs and false alarms; ensure meaningful log levels.
-- **Details**:
-  - Use `info` or `warn` for recoverable or normal issues
-  - Reserve `error` for critical failures that require immediate attention
-  - Use `warn` for potential issues that don't crash the system
-  - Use `info` for normal business flow events
-  - Use `debug` for detailed information when troubleshooting
+- **Objective**: Prevent noisy logs and false alarms; ensure consistent and meaningful log levels across the system.
+- **Details**:
+  - Reserve `error` for critical failures that require immediate attention or system intervention.
+  - Use `warn` for potential issues that may affect functionality but don’t crash the system (e.g., retryable errors).
+  - Use `info` for normal business events (e.g., login, order success, expected validation failures).
+  - Use `debug` for detailed troubleshooting information; avoid excessive debug logs in production.
+  - Avoid using `error` for:
+    - Expected business cases (e.g., wrong password, expired card).
+    - Normal validation failures.
+    - Temporary, recoverable conditions (e.g., network retry).
+  - Additional goal: Ensure **logs exist at the right places with the right severity level**, avoiding both over-logging and missing critical logs.
 - **Applies to**: All languages
 - **Tools**: Log linter / Custom rule
 - **Principles**: CODE_QUALITY

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sun-asterisk/sunlint",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "description": "☀️ SunLint - Multi-language static analysis tool for code quality and security | Sun* Engineering Standards",
   "main": "cli.js",
   "bin": {
@@ -22,6 +22,7 @@
     "test:integration": "echo 'Temporarily disabled - config extension issue'",
     "test:realworld": "node examples/integration-tests/realworld-integration-test.js",
     "test:cli": "node examples/integration-tests/direct-cli-test.js",
+    "test:performance": "node test/performance-test.js",
     "test:c019": "node cli.js --rule=C019 --input=examples/test-fixtures --format=eslint",
     "test:c006": "node cli.js --rule=C006 --input=examples/test-fixtures --format=eslint",
     "test:c029": "node cli.js --rule=C029 --input=examples/test-fixtures --format=eslint",