@sun-asterisk/sunlint 1.2.2 → 1.3.0

package/integrations/eslint/plugin/index.js

@@ -85,33 +85,33 @@ const s058 = require("./rules/security/s058-no-ssrf.js");
 
 module.exports = {
   rules: {
-    "c002": c002,
-    "c003": c003,
-    "c006": c006,
-    "c010": c010,
-    "c013": c013,
-    "c014": c014,
-    "c017": c017,
-    "c018": c018,
-    "c030": c030,
-    "c035": c035,
-    "c023": c023,
-    "c029": c029,
-    "c041": c041,
-    "c042": c042,
-    "c043": c043,
-    "c047": c047,
-    "c072": c072,
-    "c075": c075,
-    "c076": c076,
-    "t002": t002,
-    "t003": t003,
-    "t004": t004,
-    "t007": t007,
-    "t010": t010,
-    "t019": t019,
-    "t020": t020,
-    "t021": t021,
+    "c002-no-duplicate-code": c002,
+    "c003-no-vague-abbreviations": c003,
+    "c006-function-name-verb-noun": c006,
+    "c010-limit-block-nesting": c010,
+    "c013-no-dead-code": c013,
+    "c014-abstract-dependency-preferred": c014,
+    "c017-limit-constructor-logic": c017,
+    "c018-no-generic-throw": c018,
+    "c030-use-custom-error-classes": c030,
+    "c035-no-empty-catch": c035,
+    "c023-no-duplicate-variable-name-in-scope": c023,
+    "c029-catch-block-logging": c029,
+    "c041-no-config-inline": c041,
+    "c042-boolean-name-prefix": c042,
+    "c043-no-console-or-print": c043,
+    "c047-no-duplicate-retry-logic": c047,
+    "c072-one-assert-per-test": c072,
+    "c075-explicit-function-return-types": c075,
+    "c076-single-behavior-per-test": c076,
+    "t002-interface-prefix-i": t002,
+    "t003-ts-ignore-reason": t003,
+    "t004-no-empty-type": t004,
+    "t007-no-fn-in-constructor": t007,
+    "t010-no-nested-union-tuple": t010,
+    "t019-no-this-assign": t019,
+    "t020-no-default-multi-export": t020,
+    "t021-limit-nested-generics": t021,
     // Security rules
     "typescript_s001": s001,
     "typescript_s002": s002,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sun-asterisk/sunlint",
-  "version": "1.2.2",
+  "version": "1.3.0",
   "description": "☀️ SunLint - Multi-language static analysis tool for code quality and security | Sun* Engineering Standards",
   "main": "cli.js",
   "bin": {
@@ -40,17 +40,18 @@
     "demo:file-targeting": "./demo-file-targeting.sh",
     "lint": "node cli.js --config=.sunlint.json --input=.",
     "lint:eslint-integration": "node cli.js --all --eslint-integration --input=.",
-    "build": "npm run copy-rules && echo 'Build completed with rules copy'",
+    "build": "npm run copy-rules && npm run generate-registry && echo 'Build completed with rules copy and registry generation'",
     "copy-rules": "node scripts/copy-rules.js",
+    "generate-registry": "node scripts/generate-rules-registry.js",
     "clean": "rm -rf coverage/ *.log reports/ *.tgz",
     "postpack": "echo '📦 Package created successfully! Size: ' && ls -lh *.tgz | awk '{print $5}'",
     "start": "node cli.js --help",
     "version": "node cli.js --version",
-    "pack": "npm run copy-rules && npm pack",
+    "pack": "npm run copy-rules && npm run generate-registry && npm pack",
     "publish:github": "npm publish --registry=https://npm.pkg.github.com",
     "publish:npmjs": "npm publish --registry=https://registry.npmjs.org",
     "publish:test": "npm publish --dry-run --registry=https://registry.npmjs.org",
-    "prepublishOnly": "npm run clean && npm run copy-rules"
+    "prepublishOnly": "npm run clean && npm run copy-rules && npm run generate-registry"
   },
   "keywords": [
     "linting",
@@ -99,7 +100,8 @@
     "espree": "^10.3.0",
     "minimatch": "^10.0.3",
     "node-fetch": "^3.3.2",
-    "table": "^6.8.2"
+    "table": "^6.8.2",
+    "ts-morph": "^26.0.0"
   },
   "peerDependencies": {
     "typescript": ">=4.0.0"
@@ -126,8 +128,10 @@
   },
   "devDependencies": {
     "@types/node": "^22.10.1",
+    "eslint-plugin-import": "^2.32.0",
     "glob": "^11.0.3",
-    "jest": "^29.7.0"
+    "jest": "^29.7.0",
+    "typescript": "^5.8.3"
   },
   "bugs": {
     "url": "https://github.com/sun-asterisk/engineer-excellence/issues"

package/rules/common/C003_no_vague_abbreviations/analyzer.js

@@ -295,7 +295,7 @@ class C003NoVagueAbbreviations {
             const violation = this.checkVariableName(variableName, content, lineNumber, match.index);
             if (violation) {
               violations.push({
-                rule: 'C003',
+                ruleId: 'C003',
                 severity: 'warning',
                 message: violation.message,
                 line: lineNumber,

package/rules/common/C029_catch_block_logging/analyzer.js

@@ -8,30 +8,42 @@ const fs = require('fs');
 const path = require('path');
 
 class C029Analyzer {
-  constructor() {
+  constructor(options = {}) {
     this.ruleId = 'C029';
     this.ruleName = 'Enhanced Catch Block Error Logging';
     this.description = 'Mọi catch block phải log nguyên nhân lỗi đầy đủ và bảo toàn context (Smart Pipeline 3-stage analysis)';
+    this.verbose = options.verbose || false;
     
     // Load Smart Pipeline as primary analyzer
     this.smartPipeline = null;
     
     try {
       this.smartPipeline = require('./analyzer-smart-pipeline.js');
-      console.log('🎯 C029: Smart Pipeline loaded (3-stage: Regex → AST → Data Flow)');
+      if (this.verbose) {
+        console.log('[DEBUG] 🎯 C029: Smart Pipeline loaded (3-stage: Regex → AST → Data Flow)');
+      }
     } catch (error) {
-      console.warn('⚠️ C029: Smart Pipeline failed, using fallback:', error.message);
+      if (this.verbose) {
+        console.warn('[DEBUG] ⚠️ C029: Smart Pipeline failed, using fallback:', error.message);
+      }
       this.smartPipeline = null;
     }
   }
 
   async analyze(files, language, options = {}) {
+    // Store verbose option for this analysis
+    this.verbose = options.verbose || this.verbose || false;
+    
     // Use Smart Pipeline as primary choice
     if (this.smartPipeline) {
-      console.log('🎯 C029: Using Smart Pipeline (3-stage analysis)...');
+      if (this.verbose) {
+        console.log('[DEBUG] 🎯 C029: Using Smart Pipeline (3-stage analysis)...');
+      }
       return await this.smartPipeline.analyze(files, language, options);
     } else {
-      console.log('🔍 C029: Using fallback regex analysis...');
+      if (this.verbose) {
+        console.log('[DEBUG] 🔍 C029: Using fallback regex analysis...');
+      }
       return await this.analyzeWithRegex(files, language, options);
     }
   }

package/rules/common/C047_no_duplicate_retry_logic/c047-semantic-rule.js

@@ -0,0 +1,278 @@
+/**
+ * C047 Semantic Rule - Adapted for Shared Symbol Table
+ */
+
+const C047SymbolAnalyzerEnhanced = require('./symbol-analyzer-enhanced');
+
+class C047SemanticRule extends C047SymbolAnalyzerEnhanced {
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    this.verbose = options.verbose || false; // Store verbose setting
+    this.currentViolations = []; // Store violations for heuristic engine compatibility
+  }
+
+  /**
+   * Initialize the semantic rule (required by heuristic engine)
+   */
+  async initialize(semanticEngine = null) {
+    if (this.verbose) {
+      console.log(`[DEBUG] 🔧 Initializing C047 semantic rule...`);
+    }
+    // Store semantic engine reference if provided
+    if (semanticEngine) {
+      this.semanticEngine = semanticEngine;
+    }
+    // Load configuration from parent class
+    await this.loadConfiguration();
+    if (this.verbose) {
+      console.log(`[DEBUG] ✅ C047 semantic rule initialized`);
+    }
+  }
+
+  /**
+   * Analyze single file (required by heuristic engine)
+   */
+  async analyzeFile(filePath, options = {}) {
+    if (this.verbose) {
+      console.log(`[DEBUG] 🔍 C047: Analyzing file ${filePath}`);
+    }
+    try {
+      // Use parent analyze method for single file
+      const violations = await this.analyze([filePath], 'typescript', options);
+      this.currentViolations = violations || [];
+      if (this.verbose || options.verbose) {
+        console.log(`✅ C047: Found ${this.currentViolations.length} violations in ${filePath}`);
+      }
+    } catch (error) {
+      if (this.verbose || options.verbose) {
+        console.error(`❌ C047 analysis failed for ${filePath}:`, error.message);
+      }
+      this.currentViolations = [];
+    }
+  }
+
+  /**
+   * Get violations (required by heuristic engine)
+   */
+  getViolations() {
+    return this.currentViolations;
+  }
+
+  /**
+   * Clear violations (required by heuristic engine)
+   */
+  clearViolations() {
+    this.currentViolations = [];
+  }
+
+  /**
+   * New method: Analyze using shared Symbol Table
+   * This is more efficient than creating separate ts-morph projects
+   */
+  async analyzeWithSymbolTable(symbolTable, options = {}) {
+    if (this.verbose) {
+      console.log(`[DEBUG] 🔍 C047 Semantic Rule: Using shared Symbol Table...`);
+    }
+    const startTime = Date.now();
+    
+    try {
+      // Skip the project initialization since we use shared Symbol Table
+      if (this.verbose) {
+        console.log(`[DEBUG] 📋 Step 1: Using shared configuration...`);
+      }
+      await this.loadConfiguration();
+      
+      // Use shared Symbol Table instead of creating new project
+      if (this.verbose) {
+        console.log(`[DEBUG] 🏗️ Step 2: Using shared Symbol Table...`);
+      }
+      this.project = symbolTable.project;
+      
+      // Detect retry patterns using cached symbols
+      if (this.verbose) {
+        console.log(`[DEBUG] 🔍 Step 3: Detecting retry patterns with Symbol Table...`);
+      }
+      const allRetryPatterns = await this.detectRetryPatternsWithSymbolTable(symbolTable, options);
+      if (this.verbose) {
+        console.log(`[DEBUG] ✅ Pattern detection complete: ${allRetryPatterns.length} patterns`);
+      }
+      
+      // Group by layers and flows
+      if (this.verbose) {
+        console.log(`[DEBUG] 📊 Step 4: Grouping patterns...`);
+      }
+      const layeredPatterns = this.groupByLayersAndFlows(allRetryPatterns);
+      if (this.verbose) {
+        console.log(`[DEBUG] ✅ Grouping complete`);
+      }
+      
+      // Apply violation detection logic
+      if (this.verbose) {
+        console.log(`[DEBUG] ⚠️ Step 5: Detecting violations...`);
+      }
+      const violations = this.detectViolations(layeredPatterns);
+      if (this.verbose) {
+        console.log(`[DEBUG] ✅ Violation detection complete: ${violations.length} violations`);
+      }
+      
+      const duration = Date.now() - startTime;
+      if (this.verbose) {
+        console.log(`[DEBUG] 🎯 C047 Semantic analysis complete in ${duration}ms!`);
+      }
+      
+      if (options.verbose) {
+        this.printAnalysisStats(allRetryPatterns, layeredPatterns, violations);
+      }
+      
+      return violations;
+      
+    } catch (error) {
+      console.error('❌ C047 Semantic rule failed:', error.message);
+      return [];
+    }
+  }
+
+  /**
+   * Detect retry patterns using cached Symbol Table
+   */
+  async detectRetryPatternsWithSymbolTable(symbolTable, options) {
+    if (this.verbose) {
+      console.log(`[DEBUG] 🔍 Detecting retry patterns with Symbol Table...`);
+    }
+    const allPatterns = [];
+    
+    // Use cached source files from Symbol Table
+    const sourceFiles = symbolTable.sourceFiles;
+    if (this.verbose) {
+      console.log(`[DEBUG] 📄 Found ${sourceFiles.length} source files in Symbol Table`);
+    }
+    
+    for (let i = 0; i < sourceFiles.length; i++) {
+      const sourceFile = sourceFiles[i];
+      const fileName = sourceFile.getBaseName();
+      
+      if (this.verbose || options.verbose) {
+        console.log(`[DEBUG]     🔍 Analyzing ${i + 1}/${sourceFiles.length}: ${fileName}`);
+      }
+      
+      try {
+        // Check if symbols are already cached
+        const cachedSymbols = symbolTable.getSymbols(sourceFile.getFilePath());
+        let filePatterns;
+        
+        if (cachedSymbols && this.options.useSymbolCache) {
+          // Use cached symbols for faster analysis
+          filePatterns = await this.analyzeWithCachedSymbols(sourceFile, cachedSymbols);
+        } else {
+          // Fallback to direct AST analysis
+          filePatterns = await this.analyzeSourceFile(sourceFile);
+        }
+        
+        allPatterns.push(...filePatterns);
+        
+        if (this.verbose || options.verbose) {
+          console.log(`[DEBUG]     ✅ Found ${filePatterns.length} patterns in ${fileName}`);
+        }
+      } catch (error) {
+        if (this.verbose) {
+          console.warn(`[DEBUG]     ⚠️ Error analyzing ${fileName}: ${error.message}`);
+        }
+      }
+    }
+    
+    if (this.verbose) {
+      console.log(`[DEBUG] 🎯 Total patterns detected: ${allPatterns.length}`);
+    }
+    return allPatterns;
+  }
+
+  /**
+   * Analyze using pre-cached symbols (faster)
+   */
+  async analyzeWithCachedSymbols(sourceFile, cachedSymbols) {
+    const patterns = [];
+    const filePath = sourceFile.getFilePath() || sourceFile.getBaseName();
+    
+    if (this.verbose) {
+      console.log(`[DEBUG]   📁 Analyzing ${require('path').basename(filePath)} with cached symbols`);
+    }
+    
+    // Process cached classes
+    for (const classSymbol of cachedSymbols.classes) {
+      if (this.verbose) {
+        console.log(`[DEBUG]       📦 Cached class: ${classSymbol.name}`);
+      }
+      
+      for (const methodName of classSymbol.methods) {
+        const fullFunctionName = `${classSymbol.name}.${methodName}`;
+        if (this.verbose) {
+          console.log(`[DEBUG]           🎯 Cached method: ${fullFunctionName}`);
+        }
+        
+        // Get the actual AST node for detailed analysis
+        const classNode = sourceFile.getClasses().find(c => c.getName() === classSymbol.name);
+        if (classNode) {
+          const methodNode = classNode.getMethods().find(m => m.getName() === methodName);
+          if (methodNode) {
+            const patterns_found = await this.analyzeFunction(methodNode, fullFunctionName, filePath);
+            patterns.push(...patterns_found);
+          }
+        }
+      }
+    }
+    
+    // Process cached functions
+    for (const functionSymbol of cachedSymbols.functions) {
+      if (this.verbose) {
+        console.log(`[DEBUG]       🔧 Cached function: ${functionSymbol.name}`);
+      }
+      
+      const functionNode = sourceFile.getFunctions().find(f => f.getName() === functionSymbol.name);
+      if (functionNode) {
+        const patterns_found = await this.analyzeFunction(functionNode, functionSymbol.name, filePath);
+        patterns.push(...patterns_found);
+      }
+    }
+    
+    // Process cached variables (for React components)
+    for (const variableSymbol of cachedSymbols.variables) {
+      if (this.verbose) {
+        console.log(`[DEBUG]       ⚡ Cached variable: ${variableSymbol.name}`);
+      }
+      
+      const varDecl = sourceFile.getVariableDeclarations().find(v => v.getName() === variableSymbol.name);
+      if (varDecl) {
+        const initializer = varDecl.getInitializer();
+        if (initializer && (initializer.getKind() === require('ts-morph').SyntaxKind.ArrowFunction || 
+                            initializer.getKind() === require('ts-morph').SyntaxKind.FunctionExpression)) {
+          
+          // Check for useQuery calls with retry
+          const useQueryPatterns = this.detectUseQueryRetryPatterns(initializer, variableSymbol.name, filePath);
+          patterns.push(...useQueryPatterns);
+          
+          // Also analyze for standard retry patterns
+          const patterns_found = await this.analyzeFunction(initializer, variableSymbol.name, filePath);
+          patterns.push(...patterns_found);
+        }
+      }
+    }
+    
+    if (this.verbose) {
+      console.log(`[DEBUG]     📊 Total patterns found with cached symbols: ${patterns.length}`);
+    }
+    return patterns;
+  }
+
+  /**
+   * Traditional analyze method (for backward compatibility)
+   */
+  async analyze(files, language, options = {}) {
+    if (this.verbose) {
+      console.log(`[DEBUG] ⚠️ C047: Using traditional analysis (consider upgrading to Symbol Table)`);
+    }
+    return super.analyze(files, language, options);
+  }
+}
+
+module.exports = C047SemanticRule;