@sun-asterisk/sunlint 1.1.7 → 1.2.0

package/scripts/copy-rules.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Copy all rules files for packaging
+ * This script copies all .md rules from ../sunlint/rules/ to ./origin-rules/ for production builds
+ */
+
+const sourceRulesDir = path.join(__dirname, '..', '..', '..', 'rules');
+const targetRulesDir = path.join(__dirname, '..', 'origin-rules');
+
+console.log('📋 Copying all rules for packaging...');
+console.log(`Source: ${sourceRulesDir}`);
+console.log(`Target: ${targetRulesDir}`);
+
+try {
+  // Check if source directory exists
+  if (!fs.existsSync(sourceRulesDir)) {
+    console.error('❌ Source rules directory not found:', sourceRulesDir);
+    console.log('⚠️  Skipping rules copy - will use existing local rules if available');
+    process.exit(0); // Don't fail build, just warn
+  }
+
+  // Create target directory if it doesn't exist
+  if (!fs.existsSync(targetRulesDir)) {
+    fs.mkdirSync(targetRulesDir, { recursive: true });
+  }
+
+  // Copy only English rule files (*-en.md) - skip empty base files and catalogs
+  const allFiles = fs.readdirSync(sourceRulesDir);
+  
+  const ruleFiles = allFiles.filter(file => {
+    // Only include English versions of rule files
+    return file.endsWith('-en.md');
+  });
+
+  let copiedCount = 0;
+
+  console.log(`📁 Found ${ruleFiles.length} English rule files to copy (ignoring empty base files and catalogs)...`);
+
+  ruleFiles.forEach(fileName => {
+    const sourcePath = path.join(sourceRulesDir, fileName);
+    const targetPath = path.join(targetRulesDir, fileName);
+
+    try {
+      fs.copyFileSync(sourcePath, targetPath);
+      console.log(`✅ Copied: ${fileName}`);
+      copiedCount++;
+    } catch (error) {
+      console.error(`❌ Failed to copy ${fileName}:`, error.message);
+    }
+  });
+
+  // Also copy any CSV or other rule-related files (if they have content)
+  const csvFiles = allFiles.filter(file => file.endsWith('.csv'));
+  csvFiles.forEach(fileName => {
+    const sourcePath = path.join(sourceRulesDir, fileName);
+    const targetPath = path.join(targetRulesDir, fileName);
+    
+    try {
+      // Check if file has content
+      const stats = fs.statSync(sourcePath);
+      if (stats.size > 0) {
+        fs.copyFileSync(sourcePath, targetPath);
+        console.log(`✅ Copied CSV: ${fileName}`);
+        copiedCount++;
+      } else {
+        console.log(`⚠️ Skipped empty CSV: ${fileName}`);
+      }
+    } catch (error) {
+      console.log(`⚠️ Could not copy ${fileName}: ${error.message}`);
+    }
+  });
+
+  if (copiedCount > 0) {
+    console.log(`✅ Successfully copied ${copiedCount} rule files to ${targetRulesDir}`);
+  } else {
+    console.log('⚠️ No files were copied');
+  }
+
+} catch (error) {
+  console.error('❌ Error during rules copy:', error.message);
+  process.exit(1);
+}

package/rules/README.md

@@ -1,252 +0,0 @@
-# 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

@@ -1,65 +0,0 @@
-/**
- * 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

@@ -1,23 +0,0 @@
-{
-  "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.*"
-    ]
-  }
-}