@sun-asterisk/sunlint 1.2.1 → 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.1",
+  "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",
@@ -74,6 +75,7 @@
     "config/",
     "engines/",
     "integrations/",
+    "rules/",
     "scripts/",
     "docs/",
     ".sunlint.json",
@@ -98,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"
@@ -125,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/README.md

@@ -0,0 +1,252 @@
+# SunLint Heuristic Rules System
+
+Enhanced heuristic rules engine with organized rule categories and migration support.
+
+## 📁 Structure
+
+```
+rules/
+├── # SunLint Heuristic Rules Structure
+
+## 📁 Clean Rule Organization
+
+```
+rules/
+├── 📚 docs/                    # Rule documentation
+│   ├── C002_no_duplicate_code.md
+│   └── C031_validation_separation.md
+├── 🧪 tests/                   # Rule unit tests  
+│   └── C002_no_duplicate_code.test.js
+├── 🛠️ utils/                   # Shared utilities
+│   ├── ast-utils.js           # AST parsing helpers
+│   ├── pattern-matchers.js    # Pattern matching utilities
+│   └── rule-helpers.js        # Rule helper functions
+├── 🔹 common/                  # C-series rules (Common standards)
+│   ├── C002_no_duplicate_code/
+│   │   ├── analyzer.js        # 🔍 Core analysis logic
+│   │   └── config.json        # ⚙️ Rule configuration
+│   ├── C006_function_naming/
+│   ├── C019_log_level_usage/
+│   ├── C029_catch_block_logging/
+│   └── C031_validation_separation/
+├── 🔒 security/               # S-series rules (Security standards)
+└── 📘 typescript/             # T-series rules (TypeScript specific)
+```
+
+## ✅ Key Improvements
+
+### **1. Clean Rule Folders**
+- **Before**: `README.md`, `test.js`, `analyzer.js`, `config.json` mixed together
+- **After**: Only **core files** in rule folders (`analyzer.js`, `config.json`)
+
+### **2. Centralized Documentation**
+- **Before**: README scattered in each rule folder
+- **After**: All docs in `rules/docs/[RuleId].md`
+
+### **3. Centralized Testing**  
+- **Before**: `test.js` in each rule folder
+- **After**: All tests in `rules/tests/[RuleId].test.js`
+
+### **4. Correct Categorization**
+- **Before**: ❌ `rules/coding/` (incorrect - C ≠ Coding)
+- **After**: ✅ `rules/common/` (correct - C = Common)
+
+## 🔍 Rule Analyzer Structure
+
+Each rule analyzer follows a clean structure:
+
+```javascript
+// rules/common/C019_log_level_usage/analyzer.js
+class C019Analyzer {
+  constructor() {
+    this.ruleId = 'C019';
+    this.ruleName = 'Log Level Usage';
+    // ...
+  }
+
+  async analyze(files, language, config) {
+    // Core analysis logic only
+  }
+}
+```
+
+```json
+// rules/common/C019_log_level_usage/config.json
+{
+  "ruleId": "C019",
+  "name": "Log Level Usage",
+  "description": "Don't use error level for non-critical issues",
+  "severity": "warning",
+  "languages": ["typescript", "javascript", "dart"]
+}
+```
+
+## 🚀 Benefits
+
+1. **Clean Separation**: Core logic separated from docs/tests
+2. **Easy Maintenance**: Find docs/tests in centralized locations
+3. **Correct Semantics**: C = Common (not Coding)
+4. **Scalable**: Easy to add new rules/categories
+5. **Engine Compatible**: Heuristic engine auto-discovers all rules
+
+## 📊 Migration Summary
+
+| **Aspect** | **Before** | **After** |
+|------------|------------|-----------|
+| **Rule Folders** | Mixed content | Core only (`analyzer.js`, `config.json`) |
+| **Documentation** | Scattered | Centralized in `docs/` |
+| **Tests** | Scattered | Centralized in `tests/` |
+| **Categories** | ❌ `coding/` | ✅ `common/` |
+| **Structure** | Flat | Nested by category |
+| **Discoverable Rules** | 0 (broken) | 5 (working) |
+
+---
+*Rules structure cleaned and optimized for maintainability! 🎉*
+├── index.js                     # Rule registry and loader
+├── common/                      # 🛠️ Shared utilities
+│   ├── ast-utils.js            # AST parsing utilities
+│   ├── pattern-matchers.js     # Common pattern matching
+│   └── rule-helpers.js         # Rule development helpers
+├── coding/                      # 🔹 C-series: Coding standards (4 → expanding)
+│   ├── C006_function_naming/   # Function naming conventions
+│   ├── C019_log_level_usage/   # Log level usage patterns
+│   ├── C029_catch_block_logging/ # Exception logging standards
+│   └── C031_validation_separation/ # Input validation separation
+├── security/                    # 🔒 S-series: Security rules (0 → 49 planned)
+│   └── (ready for migration from ESLint)
+├── typescript/                  # 📘 T-series: TypeScript rules (0 → 10 planned)
+│   └── (ready for migration from ESLint)
+└── migration/                   # 🔄 ESLint → Heuristic migration
+    ├── mapping.json            # Rule mapping configuration
+    ├── converter.js            # Auto-migration tool
+    └── compatibility.js        # Compatibility layer
+```
+
+## 🎯 Current Status
+
+### ✅ **Active Heuristic Rules (4)**
+| Rule ID | Name | Type | Status |
+|---------|------|------|--------|
+| **C006** | Function Naming | Coding | ✅ Production |
+| **C019** | Log Level Usage | Coding | ✅ Production |
+| **C029** | Catch Block Logging | Coding | ✅ Production |  
+| **C031** | Validation Separation | Coding | ✅ Production |
+
+### 🚀 **Migration Pipeline (77 rules)**
+| Category | ESLint Rules | Heuristic Target | Status |
+|----------|--------------|------------------|--------|
+| **Coding** | 22 rules | rules/coding/ | 🔄 Ready for migration |
+| **Security** | 49 rules | rules/security/ | 🔄 Ready for migration |
+| **TypeScript** | 10 rules | rules/typescript/ | 🔄 Ready for migration |
+
+## 🛠️ Rule Development
+
+### **Heuristic Rule Structure**
+Each rule follows this standard structure:
+```
+rules/{category}/{RULE_ID}/
+├── analyzer.js          # Core heuristic logic
+├── config.json         # Rule configuration
+├── test.js            # Rule-specific tests  
+└── README.md          # Rule documentation
+```
+
+### **Rule Development Helpers**
+Use shared utilities in `rules/common/`:
+- `ast-utils.js` - AST traversal and analysis
+- `pattern-matchers.js` - Common code pattern detection
+- `rule-helpers.js` - Rule configuration and reporting
+
+### **Example: Adding New Rule**
+```bash
+# Create new coding rule
+mkdir rules/coding/C045_new_rule/
+cd rules/coding/C045_new_rule/
+
+# Create rule files
+touch analyzer.js config.json test.js README.md
+```
+
+## 🔄 Migration Process
+
+### **ESLint → Heuristic Migration**
+
+1. **Mapping**: Define rule equivalencies in `migration/mapping.json`
+```json
+{
+  "eslint": "c006-function-name-verb-noun",  
+  "heuristic": "C006_function_naming",
+  "compatibility": "partial",
+  "migration_priority": "high"
+}
+```
+
+2. **Conversion**: Use `migration/converter.js` for automated migration
+```bash
+node rules/migration/converter.js --rule=C006 --target=heuristic
+```
+
+3. **Testing**: Validate against existing ESLint rule behavior
+```bash
+node rules/migration/compatibility.js --test=C006
+```
+
+## 🚀 Future Expansion
+
+### **Phase 2A: Security Rules Migration**
+Target: Migrate 49 security rules to heuristic engine
+- Priority: S001, S003, S012 (critical security)
+- Timeline: After ESLint deprecation decision
+
+### **Phase 2B: TypeScript Rules Migration**  
+Target: Migrate 10 TypeScript rules to heuristic engine
+- Priority: T002, T003, T004 (interface standards)
+- Timeline: Post security migration
+
+### **Phase 3: Advanced Heuristics**
+- Multi-file analysis capabilities
+- Cross-language rule support
+- AI-assisted pattern detection
+
+## 📊 Engine Comparison
+
+| Feature | ESLint Engine | Heuristic Engine | Status |
+|---------|---------------|------------------|--------|
+| **Rules Count** | 81 rules | 4 → 81 rules | 🔄 Migration |
+| **Performance** | AST heavy | Pattern optimized | 🚀 Faster |
+| **Languages** | JS/TS only | Multi-language | 🌟 Flexible |
+| **Customization** | Limited | Full control | ✅ Better |
+| **Maintenance** | ESLint dependent | Self-contained | 🛡️ Stable |
+
+## 🎯 Integration
+
+### **Engine Loading**
+The heuristic engine automatically loads rules from this structure:
+```javascript
+// core/analysis-orchestrator.js
+const heuristicRules = require('../rules/index.js');
+```
+
+### **Rule Registry**
+All rules are registered in `rules/index.js`:
+```javascript
+module.exports = {
+  coding: {
+    C006: require('./coding/C006_function_naming/analyzer.js'),
+    C019: require('./coding/C019_log_level_usage/analyzer.js'),
+    // ...
+  },
+  security: {
+    // Ready for S-series rules
+  },
+  typescript: {
+    // Ready for T-series rules  
+  }
+};
+```
+
+---
+
+**🏗️ Architecture**: Scalable, organized, migration-ready  
+**🎯 Goal**: 81 heuristic rules (ESLint independence)  
+**🚀 Status**: 4 active, 77 ready for migration

package/rules/common/C002_no_duplicate_code/analyzer.js

@@ -0,0 +1,65 @@
+/**
+ * C002_no_duplicate_code - Heuristic Rule Analyzer
+ * Category: coding
+ * 
+ * TODO: Migrate logic from ESLint rule
+ * ESLint rule: integrations/eslint/plugin/rules/coding/c002-no_duplicate_code.js
+ */
+
+const ts = require('typescript');
+const { PatternMatcher } = require('../../utils/pattern-matchers');
+const { RuleHelper } = require('../../utils/rule-helpers');
+
+class C002_no_duplicate_codeAnalyzer {
+    constructor(config = {}) {
+        this.config = config;
+        this.patternMatcher = new PatternMatcher();
+        this.helper = new RuleHelper();
+    }
+
+    /**
+     * Analyze code content for rule violations
+     * @param {string} content - File content
+     * @param {string} filePath - File path
+     * @param {Object} context - Analysis context
+     * @returns {Array} Array of violations
+     */
+    analyze(content, filePath, context = {}) {
+        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'
+            //     }));
+            // });
+
+        } catch (error) {
+            console.warn(`Error analyzing ${filePath} with C002_no_duplicate_code:`, error.message);
+        }
+
+        return violations;
+    }
+
+    /**
+     * Get violation patterns for this rule
+     * @returns {Array} Array of patterns to match
+     */
+    getViolationPatterns() {
+        // TODO: Define patterns based on ESLint rule logic
+        return [];
+    }
+}
+
+module.exports = C002_no_duplicate_codeAnalyzer;

package/rules/common/C002_no_duplicate_code/config.json

@@ -0,0 +1,23 @@
+{
+  "id": "C002_no_duplicate_code",
+  "name": "C002_no_duplicate_code",
+  "category": "coding",
+  "description": "C002_no_duplicate_code heuristic rule - migrated from ESLint",
+  "severity": "error",
+  "enabled": true,
+  "migration": {
+    "from_eslint": "c002-no-duplicate-code",
+    "compatibility": "partial",
+    "status": "pending"
+  },
+  "patterns": {
+    "include": [
+      "**/*.js",
+      "**/*.ts"
+    ],
+    "exclude": [
+      "**/*.test.*",
+      "**/*.spec.*"
+    ]
+  }
+}