@sun-asterisk/sunlint 1.3.1 → 1.3.2

package/config/rules/rules-registry-generated.json

@@ -441,7 +441,7 @@
     },
     "C019": {
       "name": "Do not use `error` log level for non-critical issues",
-      "description": "Avoid noisy logs and false alarms; ensure meaningful log levels.",
+      "description": "Prevent noisy logs and false alarms; ensure consistent and meaningful log levels across the system.",
       "category": "Common",
       "severity": "major",
       "languages": [

package/core/enhanced-rules-registry.js

@@ -100,6 +100,7 @@ class EnhancedRulesRegistry {
       'C006': ['eslint', 'heuristic', 'openai'],
       'C007': ['eslint', 'heuristic', 'openai'],
       'C014': ['eslint', 'heuristic', 'openai'],
+      'C018': ['heuristic', 'eslint'],
       'C033': ['heuristic', 'eslint'],
       'C035': ['heuristic', 'eslint'],
       'C040': ['eslint', 'heuristic'],
@@ -328,4 +329,4 @@ class EnhancedRulesRegistry {
   }
 }
 
-module.exports = EnhancedRulesRegistry;
+module.exports = EnhancedRulesRegistry;

package/core/semantic-engine.js

@@ -82,9 +82,13 @@ class SemanticEngine {
         libFolderPath: undefined,           // Don't load TypeScript libs
       };
       
-      // Only use tsconfig when auto-discovering files (no targetFiles)
-      if (!targetFiles && tsConfigPath) {
-        projectOptions.tsConfigFilePath = tsConfigPath;
+      // NEVER use project tsconfig.json to avoid file resolution issues
+      // Instead, load files explicitly to ensure they can be found
+      if (this.options.verbose) {
+        console.log(`🔧 SemanticEngine: Skipping project tsconfig.json to avoid file resolution issues`);
+        if (tsConfigPath) {
+          console.log(`   📋 Found tsconfig: ${tsConfigPath} (ignored for better compatibility)`);
+        }
       }
       
       this.project = new Project(projectOptions);
@@ -653,6 +657,14 @@ class SemanticEngine {
   getParentContext(callExpr) { return null; }
   isKnownHook(functionName) { return false; }
   findSymbolUsages(sourceFile, namedImports) { return []; }
+
+  /**
+   * Check if symbol engine is ready for symbol-based analysis
+   * @returns {boolean} true if project is initialized and ready
+   */
+  isSymbolEngineReady() {
+    return this.initialized && this.project !== null;
+  }
 }
 
 module.exports = SemanticEngine;

package/core/semantic-rule-base.js

@@ -41,14 +41,16 @@ class SemanticRuleBase {
   /**
    * Initialize rule with SemanticEngine instance
    */
-  initialize(semanticEngine) {
+  initialize(semanticEngine, options = {}) {
     this.semanticEngine = semanticEngine;
     
     if (!this.semanticEngine || !this.semanticEngine.initialized) {
       throw new Error(`${this.ruleId}: SemanticEngine is required and must be initialized`);
     }
     
-    console.log(`🔧 Rule ${this.ruleId} initialized with semantic analysis`);
+    if (options?.verbose) {
+      console.log(`🔧 Rule ${this.ruleId} initialized with semantic analysis`);
+    }
   }
 
   /**

package/engines/heuristic-engine.js

@@ -56,8 +56,13 @@ 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) {
@@ -89,6 +94,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 +294,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 +497,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;
@@ -602,6 +646,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 +774,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 +849,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.2",
   "description": "☀️ SunLint - Multi-language static analysis tool for code quality and security | Sun* Engineering Standards",
   "main": "cli.js",
   "bin": {