@sun-asterisk/sunlint 1.0.5

package/docs/RULE-RESPONSIBILITY-MATRIX.md

@@ -0,0 +1,204 @@
+# Rule Responsibility Matrix
+
+## Overview
+This document defines clear responsibilities between ESLint and SunLint to avoid duplication and maximize efficiency.
+
+## Current Rule Distribution
+
+### ESLint Custom Rules (29 rules)
+**Primary Responsibilities:**
+- ✅ Syntactic/structural checks
+- ✅ IDE integration & fast feedback
+- ✅ Standard coding conventions
+- ✅ TypeScript-specific features
+
+| Rule ID | Name | Type | Rationale |
+|---------|------|------|-----------|
+| C002 | no-duplicate-code | Structural | AST-based duplicate detection |
+| C003 | no-vague-abbreviations | Naming | Simple naming convention |
+| C006 | function-name-verb-noun | Naming | **ACTIVE** - Simple naming check |
+| C008 | declare-variables-near-usage | Structural | Scope analysis |
+| C010 | limit-block-nesting | Structural | Nesting depth check |
+| C013 | no-dead-code | Structural | Dead code detection |
+| C014 | abstract-dependency-preferred | Structural | DI pattern detection |
+| C017 | limit-constructor-logic | Structural | Constructor complexity |
+| C018 | no-generic-throw | Structural | Error handling pattern |
+| C023 | no-duplicate-variable-name | Structural | Variable naming |
+| C024 | no-hardcode-constants | Structural | Constant extraction |
+| C027 | limit-function-nesting | Structural | Function nesting |
+| C028 | no-silent-catch | Structural | **DEPRECATED** - Use SunLint C029 |
+| C030 | use-custom-error-classes | Structural | Error class pattern |
+| C034 | no-implicit-return | Structural | Return statement check |
+| C035 | no-empty-catch | Structural | Empty catch detection |
+| C037 | error-handler-log-input | Structural | Error logging pattern |
+| C041 | no-config-inline | Structural | Configuration separation |
+| C042 | boolean-name-prefix | Naming | Boolean naming convention |
+| C043 | no-console-or-print | Structural | Console usage detection |
+| C047 | no-duplicate-retry-logic | Structural | Retry pattern detection |
+| C048 | no-var-declaration | Structural | Variable declaration |
+| C076 | one-assert-per-test | Test | Test assertion pattern |
+| T002 | interface-prefix-i | TypeScript | Interface naming |
+| T003 | ts-ignore-reason | TypeScript | TypeScript ignore usage |
+| T004 | interface-public-only | TypeScript | Interface structure |
+| T007 | no-fn-in-constructor | TypeScript | Constructor pattern |
+| T011 | no-real-time-dependency | Test | Test isolation |
+| T019 | no-empty-type | TypeScript | Type definition |
+| T025 | no-nested-union-tuple | TypeScript | Type complexity |
+| T026 | limit-nested-generics | TypeScript | Generic complexity |
+
+### SunLint Rules (4 rules)
+**Primary Responsibilities:**
+- ✅ Complex semantic analysis
+- ✅ Cross-file/project analysis  
+- ✅ Performance-critical batch processing
+- ✅ Business rule logic
+
+| Rule ID | Name | Type | Rationale |
+|---------|------|------|-----------|
+| C006 | function_naming | Naming | **DISABLED** - Use ESLint version |
+| C019 | log_level_usage | Semantic | **ACTIVE** - Complex log context analysis |
+| C029 | catch_block_logging | Semantic | **ACTIVE** - Enhanced error context analysis |
+| C031 | validation_separation | Architectural | **ACTIVE** - Cross-function validation pattern |
+
+## Rule Overlap Resolution
+
+### ✅ Resolved Overlaps
+
+#### C006 - Function Naming
+- **Decision**: Use ESLint version
+- **Rationale**: Simple naming check, better IDE integration
+- **Action**: SunLint C006 disabled in config
+
+#### C028/C029 - Catch Block Logging  
+- **Decision**: Use SunLint C029
+- **Rationale**: More sophisticated error context analysis
+- **Action**: ESLint C028 should be deprecated in favor of SunLint C029
+
+### 🔄 Planned Enhancements
+
+#### C029 - Enhanced Catch Block Logging
+Current SunLint C029 should be enhanced to fully replace ESLint C028:
+
+**ESLint C028 capabilities:**
+- Detects silent catch blocks
+- Basic error logging requirements
+
+**SunLint C029 enhancements needed:**
+- All C028 functionality
+- Context-aware error logging
+- Stack trace preservation analysis
+- Error correlation tracking
+
+## Integration Strategy
+
+### Phase 1: Current State (Implemented)
+```json
+// .eslintrc.cjs - ESLint handles most rules
+{
+  "rules": {
+    "custom/c006": "warn",  // Active in ESLint
+    "custom/c029": "warn",  // Will be deprecated
+    // ... other ESLint rules
+  }
+}
+
+// .sunlint.json - SunLint handles specialized rules
+{
+  "rules": {
+    "C006": "off",      // Disabled - use ESLint
+    "C019": true,       // Active - unique to SunLint
+    "C029": "error",    // Active - enhanced version
+    "C031": true        // Active - unique to SunLint
+  }
+}
+```
+
+### Phase 2: ESLint Adapter (Planned)
+```json
+// .sunlint.json - Unified configuration
+{
+  "rules": {
+    "C019": true,
+    "C029": true, 
+    "C031": true,
+    // ESLint rules via adapter
+    "eslint:custom/c003": true,
+    "eslint:custom/c006": true,
+    "eslint:custom/c042": true
+  },
+  "eslintAdapter": {
+    "configPath": ".eslintrc.cjs",
+    "rules": ["custom/c003", "custom/c006", "custom/c042"]
+  }
+}
+```
+
+## Migration Guidelines
+
+### Rules to Keep in ESLint
+**Criteria:**
+- Simple syntactic checks
+- IDE integration critical
+- TypeScript-specific features
+- Standard conventions
+
+**Examples:**
+- C003 (Variable naming)
+- C042 (Boolean naming)  
+- T002 (Interface prefix)
+- T003 (TypeScript ignore)
+
+### Rules to Migrate to SunLint
+**Criteria:**
+- Complex semantic analysis
+- Cross-file analysis needed
+- Performance-critical
+- Business rule logic
+
+**Candidates:**
+- C014 (Dependency Injection) - Cross-file analysis
+- C034 (Data fetching separation) - Service layer analysis
+- C040 (File execution order) - Project-level analysis
+
+### Rules to Enhance in SunLint
+**Current:**
+- C029 (Catch block logging) - Enhance to replace C028
+- C031 (Validation separation) - Add cross-file validation
+
+## Testing Strategy
+
+### Rule Compatibility Testing
+1. **Overlap Testing**: Ensure no conflicting reports
+2. **Performance Testing**: Compare combined vs individual execution
+3. **Accuracy Testing**: Validate rule logic equivalence
+
+### Integration Testing
+1. **CI/CD Pipeline**: Test unified reporting
+2. **IDE Integration**: Verify ESLint feedback still works
+3. **Configuration**: Test rule enable/disable scenarios
+
+## Monitoring & Maintenance
+
+### Performance Metrics
+- Combined analysis time
+- Memory usage comparison
+- CI/CD pipeline impact
+
+### Quality Metrics
+- Rule coverage completeness
+- False positive rates
+- Developer satisfaction
+
+### Process Metrics
+- Configuration complexity
+- Maintenance overhead
+- Team adoption rate
+
+## Decision Log
+
+| Date | Decision | Rationale |
+|------|----------|-----------|
+| 2024-01-XX | Disable SunLint C006 | ESLint version sufficient, better IDE integration |
+| 2024-01-XX | Keep SunLint C019 | Unique semantic analysis capability |
+| 2024-01-XX | Enhance SunLint C029 | Replace ESLint C028 with better analysis |
+| 2024-01-XX | Keep SunLint C031 | Unique architectural analysis |

package/eslint-integration/.eslintrc.js

@@ -0,0 +1,98 @@
+// ESLint Legacy Configuration for SunLint (ESLint v8.x compatibility)
+// Following Rule C005: Single responsibility - ESLint configuration
+module.exports = {
+  env: {
+    es2022: true,
+    node: true,
+    browser: true
+  },
+  
+  parser: '@typescript-eslint/parser',
+  
+  parserOptions: {
+    ecmaVersion: 2022,
+    sourceType: 'module',
+    project: 'eslint-integration/tsconfig.json'
+  },
+  
+  plugins: [
+    'custom',
+    '@typescript-eslint'
+  ],
+  
+  globals: {
+    console: 'readonly',
+    process: 'readonly',
+    eval: 'readonly'
+  },
+  
+  rules: {
+    // Rule C019: No console.error for non-critical errors
+    'no-console': ['warn', { allow: ['warn', 'log'] }],
+    
+    // Code quality rules
+    'no-unused-vars': 'warn',
+    'prefer-const': 'warn',
+    'no-var': 'error',
+    'no-undef': 'warn',
+    
+    // Rule C005: Single responsibility principle
+    'max-lines-per-function': ['warn', { max: 50 }],
+    'complexity': ['warn', { max: 10 }],
+    
+    // Rule C014: Avoid direct new instantiation patterns
+    'no-new': 'warn',
+    
+    // Security and best practices
+    'no-eval': 'error',
+    'no-implied-eval': 'error',
+    'no-new-func': 'error',
+    'eqeqeq': 'error',
+    'curly': 'error',
+    
+    // Security rules from custom plugin (dynamic loading based on category)
+    'custom/typescript_s003': 'off', // Will be enabled dynamically
+    'custom/typescript_s005': 'off', // Will be enabled dynamically
+    'custom/typescript_s006': 'off',
+    'custom/typescript_s008': 'off',
+    'custom/typescript_s009': 'off',
+    'custom/typescript_s010': 'off',
+    'custom/typescript_s011': 'off',
+    'custom/typescript_s012': 'off',
+    'custom/typescript_s014': 'off',
+    'custom/typescript_s015': 'off',
+    'custom/typescript_s016': 'off',
+    'custom/typescript_s017': 'off',
+    'custom/typescript_s018': 'off',
+    'custom/typescript_s019': 'off',
+    'custom/typescript_s020': 'off',
+    'custom/typescript_s022': 'off',
+    'custom/typescript_s023': 'off',
+    'custom/typescript_s025': 'off',
+    'custom/typescript_s026': 'off',
+    'custom/typescript_s027': 'off',
+    'custom/typescript_s029': 'off',
+    'custom/typescript_s030': 'off',
+    'custom/typescript_s033': 'off',
+    'custom/typescript_s034': 'off',
+    'custom/typescript_s035': 'off',
+    'custom/typescript_s036': 'off',
+    'custom/typescript_s037': 'off',
+    'custom/typescript_s038': 'off',
+    'custom/typescript_s039': 'off',
+    'custom/typescript_s041': 'off',
+    'custom/typescript_s042': 'off',
+    'custom/typescript_s043': 'off',
+    'custom/typescript_s044': 'off',
+    'custom/typescript_s045': 'off',
+    'custom/typescript_s046': 'off',
+    'custom/typescript_s047': 'off',
+    'custom/typescript_s048': 'off',
+    'custom/typescript_s050': 'off',
+    'custom/typescript_s052': 'off',
+    'custom/typescript_s054': 'off',
+    'custom/typescript_s055': 'off',
+    'custom/typescript_s057': 'off',
+    'custom/typescript_s058': 'off'
+  }
+};

package/eslint-integration/cli.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+/**
+ * SunLint CLI Entry Point
+ * Main CLI entry point with modular architecture
+ * Following Rule C005: Single responsibility - only handle CLI bootstrapping
+ * Following Rule C014: Dependency injection for services
+ */
+
+const chalk = require('chalk');
+const { createCliProgram } = require('./core/cli-program');
+const CliActionHandler = require('./core/cli-action-handler');
+
+// Create CLI program
+const program = createCliProgram();
+
+// Set up main action handler
+program.action(async (options) => {
+  const actionHandler = new CliActionHandler(options);
+  await actionHandler.execute();
+});
+
+// Global error handling
+process.on('unhandledRejection', (reason, promise) => {
+  console.error(chalk.red('Sun Lint - Unhandled Rejection:'), promise, chalk.red('reason:'), reason);
+  process.exit(1);
+});
+
+process.on('uncaughtException', (error) => {
+  console.error(chalk.red('Sun Lint - Uncaught Exception:'), error);
+  process.exit(1);
+});
+
+// Parse CLI arguments
+program.parse();

package/eslint-integration/eslint-plugin-custom/c002-no-duplicate-code.js

@@ -0,0 +1,204 @@
+/**
+ * Custom ESLint rule for: C002 – Không để trùng lặp code > 10 dòng
+ * Rule ID: custom/c002
+ * Purpose: Detect duplicate code blocks longer than 10 lines to maintain DRY principle
+ */
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Detect duplicate code blocks longer than 10 lines",
+      recommended: false
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          minLines: {
+            type: "number",
+            minimum: 1,
+            default: 10
+          },
+          ignoreComments: {
+            type: "boolean",
+            default: true
+          },
+          ignoreWhitespace: {
+            type: "boolean", 
+            default: true
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      duplicateCode: "Duplicate code block found ({{lines}} lines). Consider extracting into a shared function or module."
+    }
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    const minLines = options.minLines || 10;
+    const ignoreComments = options.ignoreComments !== false;
+    const ignoreWhitespace = options.ignoreWhitespace !== false;
+    
+    const sourceCode = context.getSourceCode();
+    const codeBlocks = new Map();
+    
+    function normalizeCode(text) {
+      let normalized = text;
+      
+      if (ignoreWhitespace) {
+        // Remove extra whitespace and normalize spacing
+        normalized = normalized
+          .replace(/\s+/g, ' ')
+          .trim();
+      }
+      
+      if (ignoreComments) {
+        // Remove single line comments
+        normalized = normalized.replace(/\/\/.*$/gm, '');
+        // Remove multi-line comments
+        normalized = normalized.replace(/\/\*[\s\S]*?\*\//g, '');
+      }
+      
+      return normalized;
+    }
+    
+    function getCodeLines(node) {
+      const startLine = node.loc.start.line;
+      const endLine = node.loc.end.line;
+      const lines = [];
+      
+      for (let i = startLine; i <= endLine; i++) {
+        const line = sourceCode.lines[i - 1];
+        if (line !== undefined) {
+          lines.push(line);
+        }
+      }
+      
+      return lines;
+    }
+    
+    function analyzeNode(node) {
+      const lines = getCodeLines(node);
+      
+      if (lines.length < minLines) {
+        return;
+      }
+      
+      const codeText = lines.join('\n');
+      const normalizedCode = normalizeCode(codeText);
+      
+      // Skip if normalized code is too short after cleaning
+      if (normalizedCode.length < 20) {
+        return;
+      }
+      
+      const codeHash = normalizedCode;
+      
+      if (codeBlocks.has(codeHash)) {
+        const existingNodes = codeBlocks.get(codeHash);
+        
+        // Report duplicate for current node
+        context.report({
+          node,
+          messageId: "duplicateCode",
+          data: {
+            lines: lines.length
+          }
+        });
+        
+        // Also report the first occurrence if not already reported
+        existingNodes.forEach(existingNode => {
+          if (!existingNode.reported) {
+            context.report({
+              node: existingNode.node,
+              messageId: "duplicateCode", 
+              data: {
+                lines: existingNode.lines
+              }
+            });
+            existingNode.reported = true;
+          }
+        });
+        
+        existingNodes.push({ node, lines: lines.length, reported: true });
+      } else {
+        codeBlocks.set(codeHash, [{ node, lines: lines.length, reported: false }]);
+      }
+    }
+    
+    return {
+      // Check function declarations
+      FunctionDeclaration(node) {
+        if (node.body) {
+          analyzeNode(node.body);
+        }
+      },
+      
+      // Check function expressions  
+      FunctionExpression(node) {
+        if (node.body) {
+          analyzeNode(node.body);
+        }
+      },
+      
+      // Check arrow functions
+      ArrowFunctionExpression(node) {
+        if (node.body && node.body.type === 'BlockStatement') {
+          analyzeNode(node.body);
+        }
+      },
+      
+      // Check method definitions
+      MethodDefinition(node) {
+        if (node.value && node.value.body) {
+          analyzeNode(node.value.body);
+        }
+      },
+      
+      // Check block statements (general code blocks)
+      BlockStatement(node) {
+        // Only analyze block statements that are not function bodies
+        const parent = node.parent;
+        if (parent && 
+            parent.type !== 'FunctionDeclaration' &&
+            parent.type !== 'FunctionExpression' &&
+            parent.type !== 'ArrowFunctionExpression' &&
+            parent.type !== 'MethodDefinition') {
+          analyzeNode(node);
+        }
+      },
+      
+      // Check if/else statements
+      IfStatement(node) {
+        if (node.consequent && node.consequent.type === 'BlockStatement') {
+          analyzeNode(node.consequent);
+        }
+        if (node.alternate && node.alternate.type === 'BlockStatement') {
+          analyzeNode(node.alternate);
+        }
+      },
+      
+      // Check loop bodies
+      ForStatement(node) {
+        if (node.body && node.body.type === 'BlockStatement') {
+          analyzeNode(node.body);
+        }
+      },
+      
+      WhileStatement(node) {
+        if (node.body && node.body.type === 'BlockStatement') {
+          analyzeNode(node.body);
+        }
+      },
+      
+      DoWhileStatement(node) {
+        if (node.body && node.body.type === 'BlockStatement') {
+          analyzeNode(node.body);
+        }
+      }
+    };
+  }
+};