@sun-asterisk/sunlint 1.0.5

package/examples/.github/workflows/code-quality.yml

@@ -0,0 +1,111 @@
+name: Code Quality & Security Check
+
+on:
+  pull_request:
+    branches: [main, develop]
+  push:
+    branches: [main]
+
+jobs:
+  # Parallel execution for faster CI
+  eslint:
+    name: ESLint Check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+          cache: 'npm'
+      
+      - name: Install dependencies
+        run: npm ci
+      
+      - name: Run ESLint on changed files
+        if: github.event_name == 'pull_request'
+        run: |
+          CHANGED_FILES=$(git diff --name-only --diff-filter=AM origin/${{ github.base_ref }} | grep -E '\.(js|ts|tsx)$' | tr '\n' ' ')
+          if [ ! -z "$CHANGED_FILES" ]; then
+            npx eslint $CHANGED_FILES
+          else
+            echo "No JS/TS files changed"
+          fi
+      
+      - name: Run ESLint full scan
+        if: github.event_name == 'push'
+        run: npm run lint:eslint
+
+  sunlint:
+    name: SunLint Security & Quality Check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+          cache: 'npm'
+      
+      - name: Install dependencies
+        run: npm ci
+      
+      - name: Install SunLint
+        run: npm install -g @sun/sunlint
+      
+      - name: Run SunLint on changed files (PR)
+        if: github.event_name == 'pull_request'
+        run: |
+          sunlint --all --changed-files --diff-base=origin/${{ github.base_ref }} \
+                  --format=github --fail-on-new-violations
+      
+      - name: Run SunLint full scan (Main)
+        if: github.event_name == 'push'
+        run: |
+          sunlint --all --input=. --format=json \
+                  --save-baseline=sunlint-baseline.json --output=sunlint-report.json
+      
+      - name: Upload SunLint Baseline
+        if: github.event_name == 'push'
+        uses: actions/upload-artifact@v4
+        with:
+          name: sunlint-baseline
+          path: sunlint-baseline.json
+      
+      - name: Upload SunLint Report
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: sunlint-report
+          path: sunlint-report.json
+
+  # Combined summary job  
+  quality-gate:
+    name: Quality Gate
+    runs-on: ubuntu-latest
+    needs: [eslint, sunlint]
+    if: always()
+    steps:
+      - name: Check ESLint Status
+        if: needs.eslint.result != 'success'
+        run: |
+          echo "❌ ESLint check failed"
+          exit 1
+      
+      - name: Check SunLint Status  
+        if: needs.sunlint.result != 'success'
+        run: |
+          echo "❌ SunLint check failed"
+          exit 1
+      
+      - name: Quality Gate Passed
+        run: |
+          echo "✅ All quality checks passed!"
+          echo "📊 ESLint: ${{ needs.eslint.result }}"
+          echo "🔒 SunLint: ${{ needs.sunlint.result }}"

package/examples/.sunlint.json

@@ -0,0 +1,42 @@
+{
+  "extends": ["@sun/sunlint/recommended"],
+  "rules": {
+    // SunLint Security Rules
+    "S003": "warn",  // URL Redirect Validation  
+    "S047": "warn",  // Secure Random Password Generation
+    "S055": "warn",  // REST Content-Type Verification
+    "C006": "error", // Function Naming Convention
+    "C019": "error"  // Log Level Usage
+  },
+  "eslint": {
+    "enabled": true,
+    "runBefore": true,
+    "configPath": ".eslintrc.js",
+    "rules": {
+      // Keep existing ESLint rules
+      "no-unused-vars": "error",
+      "prefer-const": "error", 
+      "no-var": "error",
+      "@typescript-eslint/no-explicit-any": "warn"
+    }
+  },
+  "ignorePatterns": [
+    "**/node_modules/**",
+    "**/dist/**", 
+    "**/build/**",
+    "**/coverage/**",
+    "**/*.d.ts"
+  ],
+  "languages": ["typescript", "javascript"],
+  "include": ["src/**", "tests/**"],
+  "exclude": ["**/node_modules/**"],
+  "output": {
+    "format": "eslint",
+    "console": true,
+    "summary": true
+  },
+  "ai": {
+    "enabled": false,
+    "fallbackToPattern": true
+  }
+}

package/examples/README.md

@@ -0,0 +1,47 @@
+# SunLint Configuration Examples
+
+This directory contains example configurations and workflows for SunLint integration.
+
+## Configuration Examples
+
+### 📋 **Project Configuration**
+- **`.sunlint.json`** - Complete project configuration example
+- **`package.json`** - NPM scripts and dependencies setup
+
+### 🚀 **CI/CD Examples**  
+- **`.github/workflows/code-quality.yml`** - GitHub Actions workflow
+
+## Usage
+
+### Copy Configuration
+```bash
+# Copy base configuration to your project
+cp examples/.sunlint.json your-project/.sunlint.json
+
+# Copy GitHub Actions workflow
+cp examples/.github/workflows/code-quality.yml .github/workflows/
+```
+
+### Customize Rules
+```json
+{
+  "extends": ["@sun/sunlint/recommended"],
+  "rules": {
+    "C006": "error",  // Function naming
+    "C019": "error",  // Log level usage
+    "S005": "warn",   // Security rules
+    "S012": "error"   // No hardcoded secrets
+  }
+}
+```
+
+## Integration Patterns
+
+1. **TypeScript Projects**: Use with ESLint integration
+2. **CI/CD**: GitHub Actions with changed files only
+3. **Pre-commit**: Staged files validation
+4. **Full scan**: Baseline creation for large projects
+
+---
+
+**For test projects, see `test/` directory**

package/examples/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "example-project",
+  "version": "1.0.0",
+  "scripts": {
+    "lint": "npm run lint:eslint && npm run lint:sunlint",
+    "lint:eslint": "eslint src/",
+    "lint:sunlint": "sunlint --all --input=src",
+    "lint:changed": "npm run lint:eslint:changed && npm run lint:sunlint:changed",
+    "lint:eslint:changed": "eslint $(git diff --name-only --diff-filter=AM origin/main | grep -E '\\.(js|ts|tsx)$' | tr '\\n' ' ')",
+    "lint:sunlint:changed": "sunlint --all --changed-files --diff-base=origin/main",
+    "lint:fix": "npm run lint:eslint:fix && npm run lint:sunlint:fix",
+    "lint:eslint:fix": "eslint src/ --fix",
+    "lint:sunlint:fix": "sunlint --all --input=src --fix"
+  },
+  "devDependencies": {
+    "@sun/sunlint": "^1.0.5",
+    "eslint": "^8.57.0"
+  },
+  "sunlint": {
+    "extends": ["@sun/sunlint/recommended"],
+    "rules": {
+      "S003": "warn",
+      "C006": "error",
+      "S047": "warn"
+    },
+    "ignorePatterns": ["**/test/**", "**/cypress/**"],
+    "eslint": {
+      "enabled": true,
+      "runBefore": true,
+      "configPath": ".eslintrc.js"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,100 @@
+{
+  "name": "@sun-asterisk/sunlint",
+  "version": "1.0.5",
+  "description": "☀️ Sun Lint - Universal Coding Standards | Multi-rule Quality & Security Analysis with ESLint Integration",
+  "main": "cli.js",
+  "bin": {
+    "sunlint": "./cli.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sun-asterisk/engineer-excellence.git",
+    "directory": "coding-quality/extensions/sunlint"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "scripts": {
+    "test": "npm run test:unit && npm run test:integration",
+    "test:unit": "node test/unit/test-runner.js",
+    "test:integration": "node test/integration/test-runner.js",
+    "test:c019": "node cli.js --rule=C019 --input=test/fixtures --format=eslint",
+    "test:c006": "node cli.js --rule=C006 --input=test/fixtures --format=eslint",
+    "test:c029": "node cli.js --rule=C029 --input=test/fixtures/c029 --format=eslint",
+    "test:multi": "node cli.js --rules=C019,C006,C029 --input=test/fixtures --format=eslint",
+    "test:all": "node cli.js --all --input=test/fixtures --format=eslint",
+    "test:quality": "node cli.js --category=quality --input=test/fixtures --format=eslint",
+    "test:security": "node cli.js --category=security --input=test/fixtures --format=eslint",
+    "demo": "./demo.sh",
+    "demo:single": "node cli.js --rule=C019 --input=test/fixtures/typescript --format=eslint",
+    "demo:multi": "node cli.js --rules=C019,C006 --input=test/fixtures --format=summary",
+    "demo:quality": "node cli.js --quality --input=test/fixtures --format=summary",
+    "demo:security": "node cli.js --security --input=test/fixtures --format=summary",
+    "demo:all": "node cli.js --all --input=test/fixtures --format=summary",
+    "demo:config": "node cli.js --config=.sunlint.json --input=test/fixtures",
+    "demo:eslint-integration": "./demo-eslint-integration.sh",
+    "lint": "node cli.js --config=.sunlint.json --input=.",
+    "lint:eslint-integration": "node cli.js --all --eslint-integration --input=.",
+    "build": "echo 'No build step required for Node.js CLI'",
+    "clean": "rm -rf coverage/ *.log reports/ *.tgz",
+    "start": "node cli.js --help",
+    "version": "node cli.js --version",
+    "pack": "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"
+  },
+  "keywords": [
+    "linting",
+    "code-quality",
+    "security",
+    "typescript",
+    "eslint",
+    "eslint-integration",
+    "coding-standards",
+    "static-analysis",
+    "git-integration",
+    "ci-cd",
+    "sun-asterisk"
+  ],
+  "author": "Sun* Engineering Team",
+  "license": "MIT",
+  "files": [
+    "cli.js",
+    "cli-legacy.js",
+    "core/",
+    "rules/",
+    "config/",
+    "eslint-integration/",
+    "docs/",
+    "examples/",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=18.18.0"
+  },
+  "dependencies": {
+    "@typescript-eslint/eslint-plugin": "^8.36.0",
+    "@typescript-eslint/parser": "^8.36.0",
+    "chalk": "^4.1.2",
+    "commander": "^12.1.0",
+    "eslint": "^9.30.0",
+    "glob": "^11.0.0",
+    "minimatch": "^10.0.3",
+    "node-fetch": "^3.3.2",
+    "table": "^6.8.2",
+    "typescript": "^5.7.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.1",
+    "jest": "^29.7.0"
+  },
+  "bugs": {
+    "url": "https://github.com/sun-asterisk/engineer-excellence/issues"
+  },
+  "homepage": "https://github.com/sun-asterisk/engineer-excellence/tree/main/coding-quality/extensions/sunlint#readme"
+}

package/rules/C006_function_naming/analyzer.js

@@ -0,0 +1,338 @@
+const fs = require('fs');
+const path = require('path');
+const ts = require('typescript');
+
+class C006Analyzer {
+  constructor() {
+    this.ruleId = 'C006';
+    this.ruleName = 'Function Naming Convention';
+    this.description = 'Tên hàm phải là động từ/verb-noun pattern';
+  }
+
+  async analyze(files, language, config) {
+    const violations = [];
+
+    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) {
+    switch (language) {
+      case 'typescript':
+      case 'javascript':
+        return this.analyzeTypeScript(filePath, content, config);
+      case 'dart':
+        return this.analyzeDart(filePath, content, config);
+      case 'kotlin':
+        return this.analyzeKotlin(filePath, content, config);
+      default:
+        return [];
+    }
+  }
+
+  async analyzeTypeScript(filePath, content, config) {
+    const violations = [];
+    const lines = content.split('\n');
+
+    // Parse TypeScript/JavaScript code
+    const sourceFile = ts.createSourceFile(
+      filePath,
+      content,
+      ts.ScriptTarget.Latest,
+      true
+    );
+
+    const visit = (node) => {
+      // Check function declarations (skip declare statements without body)
+      if (ts.isFunctionDeclaration(node) && node.name && node.body) {
+        const functionName = node.name.text;
+        const analysis = this.analyzeFunctionName(functionName);
+        
+        if (analysis.isViolation) {
+          const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+          const column = sourceFile.getLineAndCharacterOfPosition(node.getStart()).character + 1;
+          const lineText = lines[line - 1]?.trim() || '';
+          
+          violations.push({
+            ruleId: this.ruleId,
+            file: filePath,
+            line,
+            column,
+            message: analysis.reason,
+            severity: analysis.severity || 'warning',
+            code: lineText,
+            type: analysis.type,
+            confidence: analysis.confidence || 0.8,
+            suggestion: analysis.suggestion
+          });
+        }
+      }
+
+      // Check method declarations
+      if (ts.isMethodDeclaration(node) && node.name) {
+        const methodName = node.name.text;
+        const analysis = this.analyzeFunctionName(methodName);
+        
+        if (analysis.isViolation) {
+          const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+          const column = sourceFile.getLineAndCharacterOfPosition(node.getStart()).character + 1;
+          const lineText = lines[line - 1]?.trim() || '';
+          
+          violations.push({
+            ruleId: this.ruleId,
+            file: filePath,
+            line,
+            column,
+            message: analysis.reason,
+            severity: analysis.severity || 'warning',
+            code: lineText,
+            type: analysis.type,
+            confidence: analysis.confidence || 0.8,
+            suggestion: analysis.suggestion
+          });
+        }
+      }
+
+      // Check arrow functions assigned to variables
+      if (ts.isVariableDeclaration(node) && node.name && ts.isIdentifier(node.name) && 
+          node.initializer && ts.isArrowFunction(node.initializer)) {
+        const functionName = node.name.text;
+        const analysis = this.analyzeFunctionName(functionName);
+        
+        if (analysis.isViolation) {
+          const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+          const column = sourceFile.getLineAndCharacterOfPosition(node.getStart()).character + 1;
+          const lineText = lines[line - 1]?.trim() || '';
+          
+          violations.push({
+            ruleId: this.ruleId,
+            file: filePath,
+            line,
+            column,
+            message: analysis.reason,
+            severity: analysis.severity || 'warning',
+            code: lineText,
+            type: analysis.type,
+            confidence: analysis.confidence || 0.8,
+            suggestion: analysis.suggestion
+          });
+        }
+      }
+      
+      ts.forEachChild(node, visit);
+    };
+
+    visit(sourceFile);
+    return violations;
+  }
+
+  async analyzeDart(filePath, content, config) {
+    const violations = [];
+    const lines = content.split('\n');
+
+    // Pattern-based analysis for Dart function declarations
+    const functionPattern = /^\s*(\w+\s+)?(\w+)\s*\([^)]*\)\s*\{?/;
+
+    lines.forEach((line, index) => {
+      const lineNumber = index + 1;
+      const match = line.match(functionPattern);
+      
+      if (match) {
+        const functionName = match[2];
+        
+        // Skip constructors, getters, setters, and built-in methods
+        if (this.isSpecialFunction(functionName)) {
+          return;
+        }
+        
+        const analysis = this.analyzeFunctionName(functionName);
+        
+        if (analysis.isViolation) {
+          violations.push({
+            ruleId: this.ruleId,
+            file: filePath,
+            line: lineNumber,
+            column: line.indexOf(functionName) + 1,
+            message: analysis.reason,
+            severity: analysis.severity || 'warning',
+            code: line.trim(),
+            type: analysis.type,
+            confidence: analysis.confidence || 0.7,
+            suggestion: analysis.suggestion
+          });
+        }
+      }
+    });
+
+    return violations;
+  }
+
+  async analyzeKotlin(filePath, content, config) {
+    const violations = [];
+    const lines = content.split('\n');
+
+    // Pattern-based analysis for Kotlin function declarations
+    const functionPattern = /^\s*(?:fun|private\s+fun|public\s+fun|internal\s+fun|override\s+fun)\s+(\w+)\s*\(/;
+
+    lines.forEach((line, index) => {
+      const lineNumber = index + 1;
+      const match = line.match(functionPattern);
+      
+      if (match) {
+        const functionName = match[1];
+        
+        // Skip constructors and built-in methods
+        if (this.isSpecialFunction(functionName)) {
+          return;
+        }
+        
+        const analysis = this.analyzeFunctionName(functionName);
+        
+        if (analysis.isViolation) {
+          violations.push({
+            ruleId: this.ruleId,
+            file: filePath,
+            line: lineNumber,
+            column: line.indexOf(functionName) + 1,
+            message: analysis.reason,
+            severity: analysis.severity || 'warning',
+            code: line.trim(),
+            type: analysis.type,
+            confidence: analysis.confidence || 0.7,
+            suggestion: analysis.suggestion
+          });
+        }
+      }
+    });
+
+    return violations;
+  }
+
+  analyzeFunctionName(functionName) {
+    // Skip special functions
+    if (this.isSpecialFunction(functionName)) {
+      return { isViolation: false };
+    }
+
+    // Common verbs for function names
+    const commonVerbs = [
+      'get', 'set', 'is', 'has', 'can', 'should', 'will',
+      'create', 'build', 'make', 'generate', 'construct',
+      'update', 'modify', 'change', 'edit', 'alter',
+      'delete', 'remove', 'destroy', 'clean', 'clear',
+      'load', 'save', 'fetch', 'retrieve', 'find', 'search',
+      'validate', 'verify', 'check', 'confirm', 'ensure',
+      'calculate', 'compute', 'process', 'handle', 'manage',
+      'send', 'receive', 'transmit', 'broadcast', 'emit',
+      'parse', 'format', 'transform', 'convert', 'map',
+      'filter', 'sort', 'group', 'merge', 'split',
+      'connect', 'disconnect', 'open', 'close', 'start', 'stop',
+      'show', 'hide', 'display', 'render', 'draw', 'paint',
+      'add', 'append', 'insert', 'push', 'pop', 'shift',
+      'test', 'debug', 'log', 'trace', 'monitor', 'watch',
+      'count', 'execute', 'perform', 'run', 'invoke', 'call',
+      'reset', 'initialize', 'setup', 'configure', 'prepare',
+      'refresh', 'restore', 'reload', 'retry', 'resume', 'redirect',
+      'select', 'toggle', 'switch', 'enable', 'disable', 'activate',
+      'expand', 'collapse', 'scroll', 'navigate', 'submit', 'cancel'
+    ];
+
+    // Check if function name starts with a verb
+    const startsWithVerb = commonVerbs.some(verb => {
+      const verbPattern = new RegExp(`^${verb}[A-Z]?`, 'i');
+      return verbPattern.test(functionName);
+    });
+
+    if (startsWithVerb) {
+      return { isViolation: false };
+    }
+
+    // Check for camelCase pattern that might be verb-noun
+    const camelCasePattern = /^[a-z][a-zA-Z0-9]*$/;
+    const pascalCasePattern = /^[A-Z][a-zA-Z0-9]*$/;
+    
+    // PascalCase functions (likely React components) - different rules
+    if (pascalCasePattern.test(functionName)) {
+      // For React components, we can be more lenient but still suggest verb patterns where appropriate
+      return {
+        isViolation: true,
+        reason: 'PascalCase function should be a React component or use verb-noun pattern',
+        severity: 'info',
+        type: 'react_component_naming',
+        confidence: 0.5,
+        suggestion: `If this is a React component, consider using descriptive names. If it's a function, use camelCase with verb-noun pattern.`
+      };
+    }
+    
+    if (!camelCasePattern.test(functionName)) {
+      return {
+        isViolation: true,
+        reason: 'Function name should follow camelCase and verb-noun pattern',
+        severity: 'warning',
+        type: 'naming_convention',
+        confidence: 0.9,
+        suggestion: 'Use camelCase with verb-noun pattern (e.g., getUserData, validateInput)'
+      };
+    }
+
+    // Check for noun-only patterns (likely violations)
+    const nounOnlyPatterns = [
+      /^[a-z]+$/,  // simple lowercase (e.g., 'user', 'data')
+      /^[a-z]+[A-Z][a-z]+$/,  // simple camelCase noun (e.g., 'userData', 'userInfo')
+    ];
+
+    const isNounOnly = nounOnlyPatterns.some(pattern => pattern.test(functionName));
+    
+    if (isNounOnly) {
+      return {
+        isViolation: true,
+        reason: 'Function name appears to be a noun - should start with a verb',
+        severity: 'warning',
+        type: 'missing_verb',
+        confidence: 0.8,
+        suggestion: `Consider renaming to use verb-noun pattern (e.g., get${functionName.charAt(0).toUpperCase() + functionName.slice(1)})`
+      };
+    }
+
+    // If it's a complex name without obvious verb, flag as potential violation
+    if (functionName.length > 3 && !functionName.match(/^[a-z]+[A-Z]/)) {
+      return {
+        isViolation: true,
+        reason: 'Function name should follow verb-noun pattern for clarity',
+        severity: 'info',
+        type: 'unclear_naming',
+        confidence: 0.6,
+        suggestion: 'Consider using verb-noun pattern for better readability'
+      };
+    }
+
+    return { isViolation: false };
+  }
+
+  isSpecialFunction(name) {
+    const specialFunctions = [
+      'constructor', 'toString', 'valueOf', 'toJSON',
+      'main', 'init', 'setup', 'teardown', 'build',
+      'onCreate', 'onDestroy', 'onStart', 'onStop',
+      'onPause', 'onResume', 'onSaveInstanceState',
+      'equals', 'hashCode', 'compareTo', 'clone',
+      'finalize', 'notify', 'notifyAll', 'wait'
+    ];
+
+    return specialFunctions.includes(name) || 
+           name.startsWith('_') || 
+           name.startsWith('$');
+           // Removed: || name.match(/^[A-Z]/); // Allow checking React components
+  }
+}
+
+module.exports = new C006Analyzer();