@sun-asterisk/sunlint 1.0.5

package/rules/C029_catch_block_logging/analyzer.js

@@ -0,0 +1,339 @@
+const fs = require('fs');
+const path = require('path');
+const AIAnalyzer = require('../../core/ai-analyzer');
+
+class C029Analyzer {
+  constructor() {
+    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 (enhanced version replacing ESLint C028)';
+    this.aiAnalyzer = null;
+  }
+
+  async analyze(files, language, config) {
+    const violations = [];
+
+    // Initialize AI analyzer if enabled
+    if (config.ai && config.ai.enabled) {
+      this.aiAnalyzer = new AIAnalyzer(config.ai);
+      console.log('🤖 AI analysis enabled for C029');
+    }
+
+    for (const filePath of files) {
+      try {
+        const fileContent = fs.readFileSync(filePath, 'utf8');
+        const fileViolations = await this.analyzeFile(filePath, fileContent, language, config);
+        violations.push(...fileViolations);
+      } catch (error) {
+        console.error(`Error analyzing file ${filePath}:`, error.message);
+      }
+    }
+
+    return violations;
+  }
+
+  async analyzeFile(filePath, content, language, config) {
+    // Fallback to pattern-based analysis
+    console.log(`🔍 Running pattern analysis on ${path.basename(filePath)}`);
+    switch (language) {
+      case 'typescript':
+      case 'javascript':
+        return this.analyzeTypeScript(filePath, content, config);
+      default:
+        return [];
+    }
+  }
+
+  async analyzeTypeScript(filePath, content, config) {
+    const violations = [];
+    const lines = content.split('\n');
+
+    // Focus on core functionality - only detect truly silent catch blocks
+    violations.push(...this.findSilentCatchBlocks(lines, filePath));
+    // Disabled strict checks to reduce false positives:
+    // violations.push(...this.findInadequateErrorLogging(lines, filePath));
+    // violations.push(...this.findMissingErrorContext(lines, filePath));
+
+    return violations;
+  }
+
+  /**
+   * Core functionality from ESLint C029 - detect silent catch blocks
+   */
+  findSilentCatchBlocks(lines, filePath) {
+    const violations = [];
+    
+    lines.forEach((line, index) => {
+      const lineNumber = index + 1;
+      const trimmedLine = line.trim();
+
+      // Detect catch block start
+      if (this.isCatchBlockStart(trimmedLine)) {
+        const catchBlockInfo = this.extractCatchBlockInfo(lines, index);
+        
+        if (catchBlockInfo.isEmpty) {
+          violations.push({
+            ruleId: this.ruleId,
+            file: filePath,
+            line: lineNumber,
+            column: line.indexOf('catch') + 1,
+            message: 'Empty catch block - error is silently ignored',
+            severity: 'error',
+            code: trimmedLine,
+            type: 'empty_catch_block',
+            confidence: 1.0,
+            suggestion: 'Add error logging or rethrowing in catch block'
+          });
+        } else if (!catchBlockInfo.hasLoggingOrRethrow) {
+          violations.push({
+            ruleId: this.ruleId,
+            file: filePath,
+            line: lineNumber,
+            column: line.indexOf('catch') + 1,
+            message: 'Catch block must log error or rethrow - silent error handling hides bugs',
+            severity: 'error',
+            code: trimmedLine,
+            type: 'silent_catch_block',
+            confidence: 0.9,
+            suggestion: 'Add error logging (console.error, logger.error) or rethrow the error'
+          });
+        }
+      }
+    });
+
+    return violations;
+  }
+
+  /**
+   * SunLint enhanced functionality - detect inadequate error logging
+   */
+  findInadequateErrorLogging(lines, filePath) {
+    const violations = [];
+    
+    lines.forEach((line, index) => {
+      const lineNumber = index + 1;
+      const trimmedLine = line.trim();
+
+      if (this.isCatchBlockStart(trimmedLine)) {
+        const catchBlockInfo = this.extractCatchBlockInfo(lines, index);
+        
+        if (catchBlockInfo.hasLoggingOrRethrow && !catchBlockInfo.hasAdequateLogging) {
+          violations.push({
+            ruleId: this.ruleId,
+            file: filePath,
+            line: lineNumber,
+            column: line.indexOf('catch') + 1,
+            message: 'Error logging should include error message, stack trace, and context',
+            severity: 'warning',
+            code: trimmedLine,
+            type: 'inadequate_error_logging',
+            confidence: 0.8,
+            suggestion: 'Include error.message, error.stack, and relevant context in error logging'
+          });
+        }
+      }
+    });
+
+    return violations;
+  }
+
+  /**
+   * SunLint enhanced functionality - detect missing error context
+   * DISABLED: Too strict, causing false positives
+   */
+  findMissingErrorContext(lines, filePath) {
+    // Disabled to reduce false positives
+    return [];
+    
+    /* Original strict implementation:
+    const violations = [];
+    
+    lines.forEach((line, index) => {
+      const lineNumber = index + 1;
+      const trimmedLine = line.trim();
+
+      if (this.isCatchBlockStart(trimmedLine)) {
+        const catchBlockInfo = this.extractCatchBlockInfo(lines, index);
+        
+        if (catchBlockInfo.hasLoggingOrRethrow && !catchBlockInfo.hasContextualLogging) {
+          violations.push({
+            ruleId: this.ruleId,
+            file: filePath,
+            line: lineNumber,
+            column: line.indexOf('catch') + 1,
+            message: 'Error logging should include operational context (function name, input parameters)',
+            severity: 'info',
+            code: trimmedLine,
+            type: 'missing_error_context',
+            confidence: 0.7,
+            suggestion: 'Include function name, input parameters, and operational context in error logging'
+          });
+        }
+      }
+    });
+
+    return violations;
+    */
+  }
+
+  isCatchBlockStart(line) {
+    return line.includes('catch (') || line.includes('catch(');
+  }
+
+  extractCatchBlockInfo(lines, startIndex) {
+    const catchBlockLines = [];
+    let braceDepth = 0;
+    let foundCatchBrace = false;
+
+    for (let i = startIndex; i < lines.length; i++) {
+      const line = lines[i];
+      catchBlockLines.push(line);
+      
+      // Check if this is the catch line with opening brace
+      if (this.isCatchBlockStart(line.trim())) {
+        // Count braces in the catch line itself
+        for (const char of line) {
+          if (char === '{') {
+            foundCatchBrace = true;
+            braceDepth = 1; // Start counting from 1 for the catch block
+          }
+        }
+      } else if (foundCatchBrace) {
+        // Count braces in subsequent lines
+        for (const char of line) {
+          if (char === '{') {
+            braceDepth++;
+          } else if (char === '}') {
+            braceDepth--;
+          }
+        }
+        
+        // If we've closed all braces, we're done
+        if (braceDepth === 0) {
+          break;
+        }
+      }
+    }
+
+    const content = catchBlockLines.join('\n').toLowerCase();
+    const originalContent = catchBlockLines.join('\n');
+    
+    return {
+      isEmpty: this.isCatchBlockEmpty(catchBlockLines),
+      hasLoggingOrRethrow: this.hasLoggingOrRethrow(content, originalContent),
+      hasAdequateLogging: this.hasAdequateErrorLogging(content, originalContent),
+      hasContextualLogging: this.hasContextualErrorLogging(content, originalContent)
+    };
+  }
+
+  isCatchBlockEmpty(catchBlockLines) {
+    if (catchBlockLines.length === 0) return true;
+    
+    // Join all lines and find the content between braces
+    const fullContent = catchBlockLines.join('\n');
+    
+    // Find the opening brace and closing brace
+    let openBraceIndex = fullContent.indexOf('{');
+    let closeBraceIndex = fullContent.lastIndexOf('}');
+    
+    if (openBraceIndex === -1 || closeBraceIndex === -1) {
+      return true; // Malformed catch block
+    }
+    
+    // Extract body content between braces
+    const bodyContent = fullContent.substring(openBraceIndex + 1, closeBraceIndex).trim();
+    
+    // Remove comments and whitespace
+    const cleanedBody = bodyContent
+      .replace(/\/\*[\s\S]*?\*\//g, '') // Remove block comments
+      .replace(/\/\/.*$/gm, '') // Remove line comments
+      .replace(/\s+/g, ' ') // Normalize whitespace
+      .trim();
+    
+    return cleanedBody.length === 0;
+  }
+
+  hasLoggingOrRethrow(content, originalContent) {
+    // Check for throw statements
+    if (content.includes('throw ') || content.includes('throw;')) {
+      return true;
+    }
+
+    // Check for logging patterns (expanded from original)
+    const loggingPatterns = [
+      'console.error',
+      'console.log',
+      'console.warn',
+      'logger.error',
+      'log.error',
+      'logger.warn',
+      'log.warn',
+      'winston.error',
+      'bunyan.error',
+      'pino.error',
+      '.error(',
+      '.warn(',
+      '.log('
+    ];
+
+    // Accept basic error logging - don't require context
+    const hasBasicLogging = loggingPatterns.some(pattern => 
+      content.includes(pattern) || originalContent.includes(pattern)
+    );
+
+    return hasBasicLogging;
+  }
+
+  hasAdequateErrorLogging(content, originalContent) {
+    // Check for error properties being logged
+    const errorProperties = [
+      'error.message',
+      'error.stack',
+      'err.message',
+      'err.stack',
+      'e.message',
+      'e.stack',
+      'error.name',
+      'error.cause'
+    ];
+
+    const hasErrorProperties = errorProperties.some(prop => 
+      content.includes(prop) || originalContent.includes(prop)
+    );
+
+    // Check for comprehensive error logging
+    const hasLogging = this.hasLoggingOrRethrow(content, originalContent);
+    
+    return hasLogging && hasErrorProperties;
+  }
+
+  hasContextualErrorLogging(content, originalContent) {
+    // Check for contextual information in logging
+    const contextualPatterns = [
+      'function',
+      'method',
+      'operation',
+      'input',
+      'parameters',
+      'context',
+      'state',
+      'request',
+      'response',
+      'userId',
+      'sessionId',
+      'transactionId'
+    ];
+
+    // Check if logging includes contextual information
+    const hasContextualInfo = contextualPatterns.some(pattern => 
+      content.includes(pattern) || originalContent.includes(pattern)
+    );
+
+    // Check for template literals or string concatenation (indicates contextual logging)
+    const hasTemplateLogging = originalContent.includes('${') || originalContent.includes('" + ') || originalContent.includes("' + ");
+
+    return hasContextualInfo || hasTemplateLogging;
+  }
+}
+
+module.exports = new C029Analyzer();

package/rules/C029_catch_block_logging/config.json

@@ -0,0 +1,59 @@
+{
+  "ruleId": "C029",
+  "name": "Catch Block Error Logging",
+  "description": "Mọi catch block phải log nguyên nhân lỗi đầy đủ",
+  "category": "error-handling",
+  "severity": "error",
+  "languages": ["typescript", "dart", "kotlin", "javascript"],
+  "version": "1.0.0",
+  "status": "activated",
+  "tags": ["error-handling", "logging", "debugging", "monitoring"],
+  "examples": {
+    "typescript": {
+      "violations": [
+        "try { riskyOperation(); } catch (error) { return null; }",
+        "catch (e) { /* empty */ }",
+        "catch (error) { throw new Error('Failed'); }"
+      ],
+      "valid": [
+        "catch (error) { console.error('Operation failed:', error); }",
+        "catch (e) { logger.error('Error in process:', e); }",
+        "catch (error) { console.error(error); throw error; }"
+      ]
+    },
+    "dart": {
+      "violations": [
+        "try { riskyOperation(); } catch (e) { return null; }",
+        "on Exception catch (e) { /* empty */ }"
+      ],
+      "valid": [
+        "catch (e) { print('Error: $e'); }",
+        "on Exception catch (e) { log.severe('Failed:', e); }"
+      ]
+    },
+    "kotlin": {
+      "violations": [
+        "try { riskyOperation() } catch (e: Exception) { return null }",
+        "catch (e: Exception) { /* empty */ }"
+      ],
+      "valid": [
+        "catch (e: Exception) { Log.e(TAG, 'Error:', e) }",
+        "catch (e: Exception) { logger.error('Failed', e) }"
+      ]
+    }
+  },
+  "configuration": {
+    "requiredLoggingMethods": [
+      "console.error",
+      "console.log", 
+      "logger.error",
+      "log.error",
+      "print",
+      "log.severe",
+      "Log.e",
+      "timber.e"
+    ],
+    "allowEmptyWhenRethrow": true,
+    "checkErrorParameter": true
+  }
+}

package/rules/C031_validation_separation/README.md

@@ -0,0 +1,72 @@
+# Rule C031 - Validation Logic Separation
+
+## Description
+Logic kiểm tra dữ liệu (validate) phải nằm riêng biệt khỏi business logic.
+
+## Rationale
+Tách biệt validation logic giúp:
+- Code dễ đọc và maintain
+- Validation có thể reuse
+- Testing dễ dàng hơn
+- Tuân thủ Single Responsibility Principle
+
+## Examples
+
+### ❌ Bad - Validation mixed with business logic
+```javascript
+function processOrder(order) {
+    // Validation mixed with business logic
+    if (!order.customerId) {
+        throw new Error('Customer ID is required');
+    }
+    if (!order.items || order.items.length === 0) {
+        throw new Error('Order must have items');
+    }
+    if (order.total < 0) {
+        throw new Error('Total cannot be negative');
+    }
+    
+    // Business logic
+    const discount = calculateDiscount(order);
+    const tax = calculateTax(order);
+    return processPayment(order, discount, tax);
+}
+```
+
+### ✅ Good - Separate validation
+```javascript
+function validateOrder(order) {
+    if (!order.customerId) {
+        throw new Error('Customer ID is required');
+    }
+    if (!order.items || order.items.length === 0) {
+        throw new Error('Order must have items');
+    }
+    if (order.total < 0) {
+        throw new Error('Total cannot be negative');
+    }
+}
+
+function processOrder(order) {
+    validateOrder(order);
+    
+    // Pure business logic
+    const discount = calculateDiscount(order);
+    const tax = calculateTax(order);
+    return processPayment(order, discount, tax);
+}
+```
+
+## Configuration
+```json
+{
+    "C031": {
+        "enabled": true,
+        "severity": "warning",
+        "options": {
+            "maxValidationStatementsInFunction": 3,
+            "requireSeparateValidationFunction": true
+        }
+    }
+}
+```

package/rules/C031_validation_separation/analyzer.js

@@ -0,0 +1,186 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Rule C031 - Validation Logic Separation
+ * Kiểm tra logic validation có bị trộn lẫn với business logic không
+ */
+class ValidationSeparationAnalyzer {
+    constructor() {
+        this.ruleId = 'C031';
+        this.ruleName = 'Validation Logic Separation';
+        this.category = 'architecture';
+        this.severity = 'warning';
+        this.description = 'Logic kiểm tra dữ liệu (validate) phải nằm riêng biệt';
+    }
+
+    analyzeFile(filePath, options = {}) {
+        const violations = [];
+        
+        try {
+            if (!fs.existsSync(filePath)) {
+                return violations;
+            }
+
+            const content = fs.readFileSync(filePath, 'utf8');
+            const lines = content.split('\n');
+            
+            // Detect functions with mixed validation and business logic
+            const functions = this.extractFunctions(content);
+            
+            for (const func of functions) {
+                const validationCount = this.countValidationStatements(func.body);
+                const businessLogicCount = this.countBusinessLogicStatements(func.body);
+                
+                // If both validation and business logic exist in same function
+                if (validationCount > 0 && businessLogicCount > 0) {
+                    const maxValidationAllowed = options.maxValidationStatementsInFunction || 3;
+                    
+                    if (validationCount > maxValidationAllowed) {
+                        violations.push({
+                            line: func.startLine,
+                            column: 1,
+                            message: `Function '${func.name}' has ${validationCount} validation statements mixed with business logic. Consider separating validation logic.`,
+                            ruleId: this.ruleId,
+                            severity: this.severity,
+                            source: lines[func.startLine - 1]?.trim() || ''
+                        });
+                    }
+                }
+            }
+            
+        } catch (error) {
+            console.error(`Error analyzing ${filePath}:`, error.message);
+        }
+        
+        return violations;
+    }
+
+    extractFunctions(content) {
+        const functions = [];
+        const lines = content.split('\n');
+        
+        // Simple function detection patterns
+        const functionPatterns = [
+            /function\s+(\w+)\s*\(/g,
+            /const\s+(\w+)\s*=\s*\(/g,
+            /(\w+)\s*\(\s*[^)]*\s*\)\s*=>/g,
+            /(\w+)\s*:\s*function\s*\(/g
+        ];
+        
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            
+            for (const pattern of functionPatterns) {
+                const matches = line.matchAll(pattern);
+                for (const match of matches) {
+                    const functionName = match[1];
+                    const startLine = i + 1;
+                    
+                    // Extract function body (simple approach)
+                    const body = this.extractFunctionBody(lines, i);
+                    
+                    functions.push({
+                        name: functionName,
+                        startLine,
+                        body
+                    });
+                }
+            }
+        }
+        
+        return functions;
+    }
+
+    extractFunctionBody(lines, startIndex) {
+        let body = '';
+        let braceCount = 0;
+        let inFunction = false;
+        
+        for (let i = startIndex; i < lines.length; i++) {
+            const line = lines[i];
+            
+            if (line.includes('{')) {
+                braceCount += (line.match(/\{/g) || []).length;
+                inFunction = true;
+            }
+            
+            if (inFunction) {
+                body += line + '\n';
+            }
+            
+            if (line.includes('}')) {
+                braceCount -= (line.match(/\}/g) || []).length;
+                if (braceCount <= 0 && inFunction) {
+                    break;
+                }
+            }
+        }
+        
+        return body;
+    }
+
+    countValidationStatements(code) {
+        const validationPatterns = [
+            /if\s*\(\s*!.*\)\s*\{?\s*throw/g,
+            /if\s*\(.*\.\s*length\s*[<>=]\s*\d+\)/g,
+            /if\s*\(.*\s*==\s*null\s*\||\s*.*\s*==\s*undefined\)/g,
+            /if\s*\(.*\s*!\s*=\s*null\s*&&\s*.*\s*!\s*=\s*undefined\)/g,
+            /throw\s+new\s+Error\s*\(/g,
+            /assert\s*\(/g,
+            /validate\w*\s*\(/g,
+            /check\w*\s*\(/g
+        ];
+        
+        let count = 0;
+        for (const pattern of validationPatterns) {
+            const matches = code.match(pattern);
+            if (matches) {
+                count += matches.length;
+            }
+        }
+        
+        return count;
+    }
+
+    countBusinessLogicStatements(code) {
+        const businessLogicPatterns = [
+            /calculate\w*\s*\(/g,
+            /process\w*\s*\(/g,
+            /save\w*\s*\(/g,
+            /update\w*\s*\(/g,
+            /delete\w*\s*\(/g,
+            /send\w*\s*\(/g,
+            /return\s+\w+\s*\(/g,
+            /await\s+\w+\s*\(/g
+        ];
+        
+        let count = 0;
+        for (const pattern of businessLogicPatterns) {
+            const matches = code.match(pattern);
+            if (matches) {
+                count += matches.length;
+            }
+        }
+        
+        return count;
+    }
+
+    // Main analyze method expected by CLI
+    async analyze(files, language, config) {
+        const violations = [];
+        
+        for (const filePath of files) {
+            try {
+                const fileViolations = this.analyzeFile(filePath, config);
+                violations.push(...fileViolations);
+            } catch (error) {
+                console.error(`Error analyzing file ${filePath}:`, error.message);
+            }
+        }
+        
+        return violations;
+    }
+}
+
+module.exports = new ValidationSeparationAnalyzer();