@sun-asterisk/sunlint 1.3.0 → 1.3.2

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
@@ -675,7 +679,7 @@
 
 - **Objective**: Protect sensitive application data, avoid security risks, and comply with security standards. Exposing sensitive information can lead to serious security and privacy issues.
 
-- **Details**
+- **Details**:
   - Use environment variables or separate config files to store secrets
   - Add secret files to `.gitignore` to prevent committing them
   - Use secret management tools such as Vault or AWS Secrets Manager
@@ -692,7 +696,7 @@
 
 - **Objective**: Ensure clarity and readability by making boolean variables self-explanatory. This naming convention improves code maintainability and documentation.
 
-- **Details**
+- **Details**:
   - Use `is` for state attributes (e.g., `isActive`, `isEnabled`)
   - Use `has` for ownership (e.g., `hasPermission`, `hasChildren`)
   - Use `should` for decision flags (e.g., `shouldUpdate`, `shouldRetry`)
@@ -709,7 +713,7 @@
 
 - **Objective**: Ensure logging is done in a controlled and effective manner in production. Using `print` or `console.log` can lead to performance issues, security risks, and log management difficulties.
 
-- **Details**
+- **Details**:
   - Use a dedicated logging framework instead of `print` or `console.log`
   - Set appropriate log levels for each environment (debug, info, warn, error)
   - Ensure logs contain useful metadata like timestamp, level, and context
@@ -726,7 +730,7 @@
 
 - **Objective**: Leverage well-tested, optimized, and community-maintained libraries to reduce bugs and improve development efficiency.
 
-- **Details**
+- **Details**:
   - Prefer using standard language libraries
   - Use trusted and popular community libraries
   - Evaluate library compatibility and performance
@@ -743,7 +747,7 @@
 
 - **Objective**: Ensure APIs return appropriate HTTP status codes so clients can handle errors effectively. HTTP 500 should be reserved for unexpected system errors.
 
-- **Details**
+- **Details**:
   - Use specific HTTP status codes based on error type:
     - 400 for validation errors
     - 401 for authentication failures
@@ -763,7 +767,7 @@
 
 - **Objective**: Keep code readable, maintainable, and efficient by avoiding the use of overly complex regular expressions in business-critical logic.
 
-- **Details**
+- **Details**:
   - Move complex regex into constants or helper functions
   - Prefer string manipulation libraries over complex regex
   - Break down complex regex into simpler processing steps
@@ -781,7 +785,7 @@
 
 - **Objective**: Centralize retry logic to improve consistency, maintainability, and observability of error handling and retry mechanisms.
 
-- **Details**
+- **Details**:
   - Create a dedicated utility class or service for retry logic
   - Centralize retry policy configuration (retry count, delay, backoff)
   - Use decorator pattern or AOP to apply retry logic
@@ -799,7 +803,7 @@
 
 - **Objective**: Maintain a clear layered architecture, ensuring logic and data flow are well-structured and maintainable.
 
-- **Details**
+- **Details**:
   - Controllers should only call Services, not Repositories directly
   - Services should only call Repositories, not Controllers
   - Repositories should only handle data access, not call Services

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sun-asterisk/sunlint",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "☀️ SunLint - Multi-language static analysis tool for code quality and security | Sun* Engineering Standards",
   "main": "cli.js",
   "bin": {

package/rules/common/C002_no_duplicate_code/analyzer.js

@@ -1,64 +1,362 @@
 /**
- * C002_no_duplicate_code - Heuristic Rule Analyzer
+ * C002_no_duplicate_code - Enhanced Regex-based Rule Analyzer
  * Category: coding
  * 
- * TODO: Migrate logic from ESLint rule
- * ESLint rule: integrations/eslint/plugin/rules/coding/c002-no_duplicate_code.js
+ * Detects duplicate code blocks longer than specified threshold (default: 10 lines)
+ * Uses regex-based approach with proper comment filtering for multi-language support
  */
 
-const ts = require('typescript');
-const { PatternMatcher } = require('../../utils/pattern-matchers');
-const { RuleHelper } = require('../../utils/rule-helpers');
+const fs = require('fs');
+const path = require('path');
+const { CommentDetector } = require('../../utils/rule-helpers');
 
 class C002_no_duplicate_codeAnalyzer {
     constructor(config = {}) {
-        this.config = config;
-        this.patternMatcher = new PatternMatcher();
-        this.helper = new RuleHelper();
+        this.config = {
+            minLines: config.minLines || 5,
+            ignoreComments: config.ignoreComments !== false,
+            ignoreWhitespace: config.ignoreWhitespace !== false,
+            ignoreEmptyLines: config.ignoreEmptyLines !== false,
+            similarityThreshold: config.similarityThreshold || 0.80, // 80% similarity
+            ...config
+        };
+        this.codeBlocks = new Map();
+        this.reportedBlocks = new Set();
     }
 
     /**
-     * Analyze code content for rule violations
-     * @param {string} content - File content
-     * @param {string} filePath - File path
-     * @param {Object} context - Analysis context
+     * Analyze files for duplicate code violations (heuristic engine interface)
+     * @param {Array} files - Array of file paths
+     * @param {string} language - Programming language
+     * @param {Object} options - Analysis options
      * @returns {Array} Array of violations
      */
-    analyze(content, filePath, context = {}) {
+    analyze(files, language, options = {}) {
         const violations = [];
 
-        // TODO: Implement heuristic analysis logic
-        // This should replicate the ESLint rule behavior using pattern matching
-        
         try {
-            // Example pattern-based analysis
-            // const patterns = this.getViolationPatterns();
-            // const matches = this.patternMatcher.findMatches(content, patterns);
-            // 
-            // matches.forEach(match => {
-            //     violations.push(this.helper.createViolation({
-            //         ruleId: 'C002_no_duplicate_code',
-            //         message: 'Rule violation detected',
-            //         line: match.line,
-            //         column: match.column,
-            //         severity: 'error'
-            //     }));
-            // });
+                console.log(`[C002 DEBUG] Analyzing ${files.length} files for duplicate code`);
+            
+            // Reset state for new analysis
+            this.reset();
+            
+            // Collect all code blocks from all files
+            const allCodeBlocks = [];
+            
+            for (const filePath of files) {
+                console.log(`[C002 DEBUG] Processing file: ${filePath}`);
+                const content = this.readFileContent(filePath);
+                if (content) {
+                    console.log(`[C002 DEBUG] File content length: ${content.length}`);
+                    const codeBlocks = this.extractCodeBlocks(content, filePath);
+                    console.log(`[C002 DEBUG] Extracted ${codeBlocks.length} code blocks from ${filePath}`);
+                    codeBlocks.forEach((block, i) => {
+                        console.log(`[C002 DEBUG] Block ${i}: ${block.type} at lines ${block.startLine}-${block.endLine} (${block.lineCount} lines)`);
+                    });
+                    allCodeBlocks.push(...codeBlocks);
+                }
+            }
+            
+            console.log(`[C002 DEBUG] Total code blocks: ${allCodeBlocks.length}`);
+            
+            // Find duplicates across all files
+            const duplicates = this.findDuplicates(allCodeBlocks);
+            console.log(`[C002 DEBUG] Found ${duplicates.length} duplicate groups`);
+            
+            // Generate violations for each file
+            files.forEach(filePath => {
+                duplicates.forEach(duplicate => {
+                    const fileViolations = this.createViolations(duplicate, filePath);
+                    console.log(`[C002 DEBUG] Created ${fileViolations.length} violations for ${filePath}`);
+                    violations.push(...fileViolations);
+                });
+            });
 
         } catch (error) {
-            console.warn(`Error analyzing ${filePath} with C002_no_duplicate_code:`, error.message);
+            console.warn(`Error analyzing files with C002:`, error.message, error.stack);
         }
 
+        console.log(`[C002 DEBUG] Total violations: ${violations.length}`);
         return violations;
     }
 
     /**
-     * Get violation patterns for this rule
-     * @returns {Array} Array of patterns to match
+     * Read file content safely
+     * @param {string} filePath - Path to file
+     * @returns {string|null} File content or null if error
+     */
+    readFileContent(filePath) {
+        try {
+            return fs.readFileSync(filePath, 'utf8');
+        } catch (error) {
+            console.warn(`C002: Cannot read file ${filePath}:`, error.message);
+            return null;
+        }
+    }
+
+    /**
+     * Extract code blocks from content
+     * @param {string} content - File content
+     * @param {string} filePath - File path for context
+     * @returns {Array} Array of code blocks with metadata
+     */
+    extractCodeBlocks(content, filePath) {
+        const lines = content.split('\n');
+        const blocks = [];
+        
+        // Extract function blocks, class methods, etc.
+        const functionPattern = /^\s*(function\s+\w+|const\s+\w+\s*=\s*(async\s+)?\([^)]*\)\s*=>|class\s+\w+|\w+\s*\([^)]*\)\s*:\s*[^{]*\{)/;
+        let currentBlock = null;
+        let braceLevel = 0;
+        
+        lines.forEach((line, index) => {
+            const lineNum = index + 1;
+            const trimmedLine = line.trim();
+            
+            // Use CommentDetector to filter out comments
+            const filteredLines = CommentDetector.filterCommentLines([line]);
+            if (filteredLines[0].isComment) {
+                return;
+            }
+            
+            // Skip empty lines if configured
+            if (this.config.ignoreEmptyLines && !trimmedLine) {
+                return;
+            }
+            
+            // Detect function/method/class start
+            if (functionPattern.test(trimmedLine)) {
+                currentBlock = {
+                    startLine: lineNum,
+                    lines: [line],
+                    filePath: filePath,
+                    type: this.detectBlockType(trimmedLine)
+                };
+                braceLevel = (line.match(/{/g) || []).length - (line.match(/}/g) || []).length;
+            } else if (currentBlock) {
+                currentBlock.lines.push(line);
+                braceLevel += (line.match(/{/g) || []).length - (line.match(/}/g) || []).length;
+                
+                // End of block
+                if (braceLevel <= 0) {
+                    currentBlock.endLine = lineNum;
+                    currentBlock.lineCount = currentBlock.lines.length;
+                    
+                    // Only consider blocks that meet minimum line requirement
+                    if (currentBlock.lineCount >= this.config.minLines) {
+                        currentBlock.normalizedCode = this.normalizeCode(currentBlock.lines.join('\n'));
+                        if (currentBlock.normalizedCode.length > 20) { // Skip if too short after normalization
+                            blocks.push(currentBlock);
+                        }
+                    }
+                    currentBlock = null;
+                    braceLevel = 0;
+                }
+            }
+        });
+        
+        return blocks;
+    }
+
+    /**
+     * Detect the type of code block
+     * @param {string} line - First line of the block
+     * @returns {string} Block type
+     */
+    detectBlockType(line) {
+        if (line.includes('function')) return 'function';
+        if (line.includes('class')) return 'class';
+        if (line.includes('interface')) return 'interface';
+        if (line.includes('=>')) return 'arrow-function';
+        return 'method';
+    }
+
+    /**
+     * Normalize code for comparison
+     * @param {string} code - Raw code
+     * @returns {string} Normalized code
+     */
+    normalizeCode(code) {
+        let normalized = code;
+        
+        if (this.config.ignoreComments) {
+            // Remove single line comments (// comments)
+            normalized = normalized.replace(/\/\/.*$/gm, '');
+            // Remove multi-line comments (/* comments */)
+            normalized = normalized.replace(/\/\*[\s\S]*?\*\//g, '');
+            // Remove # comments (for other languages)
+            normalized = normalized.replace(/#.*$/gm, '');
+        }
+        
+        if (this.config.ignoreWhitespace) {
+            // Normalize whitespace
+            normalized = normalized
+                .replace(/\s+/g, ' ')           // Multiple spaces to single space
+                .replace(/\s*{\s*/g, '{')       // Remove spaces around braces
+                .replace(/\s*}\s*/g, '}')
+                .replace(/\s*;\s*/g, ';')       // Remove spaces around semicolons
+                .replace(/\s*,\s*/g, ',')       // Remove spaces around commas
+                .trim();
+        }
+        
+        if (this.config.ignoreEmptyLines) {
+            // Remove empty lines
+            normalized = normalized
+                .split('\n')
+                .filter(line => line.trim().length > 0)
+                .join('\n');
+        }
+        
+        console.log(`[C002 DEBUG] Normalized code block:
+${normalized}
+---`);
+        
+        return normalized;
+    }
+
+    /**
+     * Find duplicate code blocks
+     * @param {Array} blocks - Array of code blocks
+     * @returns {Array} Array of duplicate groups
+     */
+    findDuplicates(blocks) {
+        const duplicateGroups = [];
+        const processedBlocks = new Set();
+        
+        for (let i = 0; i < blocks.length; i++) {
+            if (processedBlocks.has(i)) continue;
+            
+            const currentBlock = blocks[i];
+            const duplicates = [currentBlock];
+            
+            for (let j = i + 1; j < blocks.length; j++) {
+                if (processedBlocks.has(j)) continue;
+                
+                const otherBlock = blocks[j];
+                const similarity = this.calculateSimilarity(
+                    currentBlock.normalizedCode, 
+                    otherBlock.normalizedCode
+                );
+                
+                if (similarity >= this.config.similarityThreshold) {
+                    duplicates.push(otherBlock);
+                    processedBlocks.add(j);
+                }
+            }
+            
+            if (duplicates.length > 1) {
+                duplicateGroups.push(duplicates);
+                processedBlocks.add(i);
+            }
+        }
+        
+        return duplicateGroups;
+    }
+
+    /**
+     * Calculate similarity between two code strings
+     * @param {string} code1 - First code string
+     * @param {string} code2 - Second code string
+     * @returns {number} Similarity ratio (0-1)
+     */
+    calculateSimilarity(code1, code2) {
+        if (code1 === code2) return 1.0;
+        
+        // Use Levenshtein distance for similarity calculation
+        const longer = code1.length > code2.length ? code1 : code2;
+        const shorter = code1.length > code2.length ? code2 : code1;
+        
+        if (longer.length === 0) return 1.0;
+        
+        const distance = this.levenshteinDistance(longer, shorter);
+        return (longer.length - distance) / longer.length;
+    }
+
+    /**
+     * Calculate Levenshtein distance between two strings
+     * @param {string} str1 - First string
+     * @param {string} str2 - Second string
+     * @returns {number} Edit distance
+     */
+    levenshteinDistance(str1, str2) {
+        const matrix = Array(str2.length + 1).fill().map(() => Array(str1.length + 1).fill(0));
+        
+        for (let i = 0; i <= str1.length; i++) matrix[0][i] = i;
+        for (let j = 0; j <= str2.length; j++) matrix[j][0] = j;
+        
+        for (let j = 1; j <= str2.length; j++) {
+            for (let i = 1; i <= str1.length; i++) {
+                const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
+                matrix[j][i] = Math.min(
+                    matrix[j - 1][i] + 1,     // deletion
+                    matrix[j][i - 1] + 1,     // insertion
+                    matrix[j - 1][i - 1] + cost // substitution
+                );
+            }
+        }
+        
+        return matrix[str2.length][str1.length];
+    }
+
+    /**
+     * Create violation objects for duplicate code
+     * @param {Array} duplicateGroup - Group of duplicate blocks
+     * @param {string} filePath - Current file path
+     * @returns {Array} Array of violation objects
+     */
+    createViolations(duplicateGroup, filePath) {
+        const violations = [];
+        
+        duplicateGroup.forEach((block, index) => {
+            // Skip if not in current file or already reported
+            if (block.filePath !== filePath) return;
+            
+            const blockId = `${block.filePath}:${block.startLine}-${block.endLine}`;
+            if (this.reportedBlocks.has(blockId)) return;
+            
+            this.reportedBlocks.add(blockId);
+            
+            violations.push({
+                ruleId: 'C002',
+                severity: 'error',
+                message: `Duplicate ${block.type} found (${block.lineCount} lines). Consider extracting into a shared function or module. Found ${duplicateGroup.length} similar blocks.`,
+                line: block.startLine,
+                column: 1,
+                endLine: block.endLine,
+                endColumn: 1,
+                filePath: filePath, // Add filePath field for engine compatibility
+                data: {
+                    lineCount: block.lineCount,
+                    blockType: block.type,
+                    duplicateCount: duplicateGroup.length,
+                    locations: duplicateGroup.map(b => `${path.basename(b.filePath)}:${b.startLine}-${b.endLine}`)
+                }
+            });
+        });
+        
+        return violations;
+    }
+
+    /**
+     * Reset analyzer state for new analysis session
+     */
+    reset() {
+        this.codeBlocks.clear();
+        this.reportedBlocks.clear();
+    }
+
+    /**
+     * Get configuration for this rule
+     * @returns {Object} Configuration object
      */
-    getViolationPatterns() {
-        // TODO: Define patterns based on ESLint rule logic
-        return [];
+    getConfig() {
+        return {
+            minLines: this.config.minLines,
+            ignoreComments: this.config.ignoreComments,
+            ignoreWhitespace: this.config.ignoreWhitespace,
+            ignoreEmptyLines: this.config.ignoreEmptyLines,
+            similarityThreshold: this.config.similarityThreshold
+        };
     }
 }