@sun-asterisk/sunlint 1.0.6 → 1.1.3

package/rules/migration/converter.js

@@ -0,0 +1,385 @@
+/**
+ * ESLint to Heuristic Migration Converter
+ * Automated tool for migrating ESLint rules to heuristic engine
+ */
+
+const fs = require('fs');
+const path = require('path');
+const mapping = require('./mapping.json');
+
+class MigrationConverter {
+    constructor() {
+        this.mapping = mapping;
+        this.rulesDir = path.join(__dirname, '..');
+        this.eslintRulesDir = path.join(__dirname, '../../integrations/eslint/plugin/rules');
+    }
+
+    /**
+     * Get migration info for a specific rule
+     * @param {string} ruleId - Rule ID (e.g., 'C006', 'S001')
+     * @returns {Object|null} Migration info
+     */
+    getMigrationInfo(ruleId) {
+        return this.mapping.migrations.find(m => 
+            m.heuristic_rule.startsWith(ruleId)
+        );
+    }
+
+    /**
+     * Create heuristic rule directory structure
+     * @param {string} category - Rule category
+     * @param {string} ruleId - Rule ID
+     * @returns {string} Created directory path
+     */
+    createRuleStructure(category, ruleId) {
+        const ruleDir = path.join(this.rulesDir, category, ruleId);
+        
+        if (!fs.existsSync(ruleDir)) {
+            fs.mkdirSync(ruleDir, { recursive: true });
+            console.log(`✅ Created rule directory: ${ruleDir}`);
+        }
+
+        // Create rule files if they don't exist
+        const files = ['analyzer.js', 'config.json', 'test.js', 'README.md'];
+        files.forEach(file => {
+            const filePath = path.join(ruleDir, file);
+            if (!fs.existsSync(filePath)) {
+                this.createRuleFile(filePath, file, ruleId, category);
+            }
+        });
+
+        return ruleDir;
+    }
+
+    /**
+     * Create individual rule file with template content
+     * @param {string} filePath - File path to create
+     * @param {string} fileName - File name
+     * @param {string} ruleId - Rule ID
+     * @param {string} category - Rule category
+     */
+    createRuleFile(filePath, fileName, ruleId, category) {
+        let content = '';
+
+        switch (fileName) {
+            case 'analyzer.js':
+                content = this.generateAnalyzerTemplate(ruleId, category);
+                break;
+            case 'config.json':
+                content = this.generateConfigTemplate(ruleId, category);
+                break;
+            case 'test.js':
+                content = this.generateTestTemplate(ruleId, category);
+                break;
+            case 'README.md':
+                content = this.generateReadmeTemplate(ruleId, category);
+                break;
+        }
+
+        fs.writeFileSync(filePath, content);
+        console.log(`✅ Created: ${filePath}`);
+    }
+
+    /**
+     * Generate analyzer template
+     */
+    generateAnalyzerTemplate(ruleId, category) {
+        return `/**
+ * ${ruleId} - Heuristic Rule Analyzer
+ * Category: ${category}
+ * 
+ * TODO: Migrate logic from ESLint rule
+ * ESLint rule: integrations/eslint/plugin/rules/${category}/${ruleId.toLowerCase().replace('_', '-')}.js
+ */
+
+const { PatternMatcher } = require('../common/pattern-matchers');
+const { RuleHelper } = require('../common/rule-helpers');
+
+class ${ruleId}Analyzer {
+    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: '${ruleId}',
+            //         message: 'Rule violation detected',
+            //         line: match.line,
+            //         column: match.column,
+            //         severity: 'error'
+            //     }));
+            // });
+
+        } catch (error) {
+            console.warn(\`Error analyzing \${filePath} with ${ruleId}:\`, 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 = ${ruleId}Analyzer;
+`;
+    }
+
+    /**
+     * Generate config template
+     */
+    generateConfigTemplate(ruleId, category) {
+        const migration = this.getMigrationInfo(ruleId);
+        return JSON.stringify({
+            "id": ruleId,
+            "name": migration ? migration.heuristic_rule : ruleId,
+            "category": category,
+            "description": `${ruleId} heuristic rule - migrated from ESLint`,
+            "severity": "error",
+            "enabled": true,
+            "migration": {
+                "from_eslint": migration ? migration.eslint_rule : "unknown",
+                "compatibility": migration ? migration.compatibility : "pending",
+                "status": migration ? migration.status : "pending"
+            },
+            "patterns": {
+                "include": ["**/*.js", "**/*.ts"],
+                "exclude": ["**/*.test.*", "**/*.spec.*"]
+            }
+        }, null, 2);
+    }
+
+    /**
+     * Generate test template
+     */
+    generateTestTemplate(ruleId, category) {
+        return `/**
+ * ${ruleId} - Rule Tests
+ * Tests for heuristic rule analyzer
+ */
+
+const ${ruleId}Analyzer = require('./analyzer');
+
+describe('${ruleId} Heuristic Rule', () => {
+    let analyzer;
+
+    beforeEach(() => {
+        analyzer = new ${ruleId}Analyzer();
+    });
+
+    describe('Valid Code', () => {
+        test('should not report violations for valid code', () => {
+            const code = \`
+                // TODO: Add valid code examples
+            \`;
+
+            const violations = analyzer.analyze(code, 'test.js');
+            expect(violations).toHaveLength(0);
+        });
+    });
+
+    describe('Invalid Code', () => {
+        test('should report violations for invalid code', () => {
+            const code = \`
+                // TODO: Add invalid code examples
+            \`;
+
+            const violations = analyzer.analyze(code, 'test.js');
+            expect(violations.length).toBeGreaterThan(0);
+            expect(violations[0].ruleId).toBe('${ruleId}');
+        });
+    });
+
+    describe('Edge Cases', () => {
+        test('should handle empty code', () => {
+            const violations = analyzer.analyze('', 'test.js');
+            expect(violations).toHaveLength(0);
+        });
+
+        test('should handle syntax errors gracefully', () => {
+            const code = 'invalid javascript syntax {{{';
+            const violations = analyzer.analyze(code, 'test.js');
+            expect(Array.isArray(violations)).toBe(true);
+        });
+    });
+});
+`;
+    }
+
+    /**
+     * Generate README template
+     */
+    generateReadmeTemplate(ruleId, category) {
+        const migration = this.getMigrationInfo(ruleId);
+        return `# ${ruleId} - ${category.toUpperCase()} Rule
+
+## 📋 Overview
+
+**Rule ID**: \`${ruleId}\`  
+**Category**: ${category}  
+**Severity**: Error  
+**Status**: ${migration ? migration.status : 'Pending Migration'}
+
+## 🎯 Description
+
+TODO: Add rule description after migration from ESLint.
+
+${migration ? `
+## 🔄 Migration Info
+
+**ESLint Rule**: \`${migration.eslint_rule}\`  
+**Compatibility**: ${migration.compatibility}  
+**Priority**: ${migration.priority}
+` : ''}
+
+## ✅ Valid Code Examples
+
+\`\`\`javascript
+// TODO: Add valid code examples
+\`\`\`
+
+## ❌ Invalid Code Examples
+
+\`\`\`javascript  
+// TODO: Add invalid code examples that should trigger violations
+\`\`\`
+
+## ⚙️ Configuration
+
+\`\`\`json
+{
+  "rules": {
+    "${ruleId}": "error"
+  }
+}
+\`\`\`
+
+## 🧪 Testing
+
+\`\`\`bash
+# Run rule-specific tests
+npm test -- ${ruleId.toLowerCase()}
+
+# Test with SunLint CLI
+sunlint --rules=${ruleId} --input=examples/
+\`\`\`
+
+---
+
+**Migration Status**: ${migration ? migration.status : 'Pending'}  
+**Last Updated**: ${new Date().toISOString().split('T')[0]}
+`;
+    }
+
+    /**
+     * Migrate a specific rule
+     * @param {string} ruleId - Rule ID to migrate
+     * @returns {boolean} Success status
+     */
+    async migrateRule(ruleId) {
+        const migration = this.getMigrationInfo(ruleId);
+        
+        if (!migration) {
+            console.error(`❌ No migration mapping found for rule: ${ruleId}`);
+            return false;
+        }
+
+        if (migration.status === 'completed') {
+            console.log(`✅ Rule ${ruleId} already migrated`);
+            return true;
+        }
+
+        console.log(`🔄 Migrating rule: ${ruleId}`);
+        console.log(`   ESLint: ${migration.eslint_rule}`);
+        console.log(`   Category: ${migration.category}`);
+        console.log(`   Compatibility: ${migration.compatibility}`);
+
+        try {
+            // Create heuristic rule structure
+            this.createRuleStructure(migration.category, migration.heuristic_rule);
+
+            console.log(`✅ Migration template created for ${ruleId}`);
+            console.log(`📝 Next steps:`);
+            console.log(`   1. Implement analyzer logic in rules/${migration.category}/${migration.heuristic_rule}/analyzer.js`);
+            console.log(`   2. Add test cases in rules/${migration.category}/${migration.heuristic_rule}/test.js`);
+            console.log(`   3. Update rule documentation`);
+            console.log(`   4. Test against ESLint rule behavior`);
+
+            return true;
+
+        } catch (error) {
+            console.error(`❌ Migration failed for ${ruleId}:`, error.message);
+            return false;
+        }
+    }
+
+    /**
+     * Show migration statistics
+     */
+    showStats() {
+        const stats = this.mapping.migration_stats;
+        console.log('📊 Migration Statistics:');
+        console.log(`   Total Rules: ${stats.total_rules}`);
+        console.log(`   Completed: ${stats.completed}`);
+        console.log(`   Pending: ${stats.pending}`);
+        console.log('');
+        console.log('📋 By Category:');
+        Object.entries(stats.by_category).forEach(([category, data]) => {
+            console.log(`   ${category}: ${data.completed}/${data.total} completed`);
+        });
+    }
+}
+
+// CLI usage
+if (require.main === module) {
+    const converter = new MigrationConverter();
+    const args = process.argv.slice(2);
+    
+    if (args.includes('--stats')) {
+        converter.showStats();
+    } else if (args.includes('--rule')) {
+        const ruleIndex = args.indexOf('--rule');
+        const ruleId = args[ruleIndex + 1];
+        if (ruleId) {
+            converter.migrateRule(ruleId);
+        } else {
+            console.error('❌ Please specify a rule ID with --rule');
+        }
+    } else {
+        console.log('🚀 SunLint Migration Converter');
+        console.log('');
+        console.log('Usage:');
+        console.log('  node converter.js --stats          # Show migration statistics');
+        console.log('  node converter.js --rule C006     # Migrate specific rule');
+        console.log('');
+        converter.showStats();
+    }
+}
+
+module.exports = MigrationConverter;

package/rules/migration/mapping.json

@@ -0,0 +1,164 @@
+{
+  "_description": "ESLint to Heuristic Migration Mapping - Maps ESLint plugin rules to heuristic engine equivalents",
+  "migrations": [
+    {
+      "eslint_rule": "c006-function-name-verb-noun",
+      "heuristic_rule": "C006_function_naming",
+      "category": "coding",
+      "compatibility": "full",
+      "priority": "high",
+      "status": "completed",
+      "notes": "Direct mapping - heuristic version already exists"
+    },
+    {
+      "eslint_rule": "c019-log-level-usage", 
+      "heuristic_rule": "C019_log_level_usage",
+      "category": "coding",
+      "compatibility": "full", 
+      "priority": "high",
+      "status": "completed",
+      "notes": "Direct mapping - heuristic version already exists"
+    },
+    {
+      "eslint_rule": "c029-catch-block-logging",
+      "heuristic_rule": "C029_catch_block_logging", 
+      "category": "coding",
+      "compatibility": "full",
+      "priority": "high", 
+      "status": "completed",
+      "notes": "Direct mapping - heuristic version already exists"
+    },
+    {
+      "eslint_rule": "c031-validation-separation",
+      "heuristic_rule": "C031_validation_separation",
+      "category": "coding", 
+      "compatibility": "full",
+      "priority": "high",
+      "status": "completed", 
+      "notes": "Direct mapping - heuristic version already exists"
+    },
+    
+    {
+      "eslint_rule": "c002-no-duplicate-code",
+      "heuristic_rule": "C002_no_duplicate_code", 
+      "category": "coding",
+      "compatibility": "partial",
+      "priority": "medium",
+      "status": "pending",
+      "notes": "Requires AST pattern matching for code duplication"
+    },
+    {
+      "eslint_rule": "c003-no-vague-abbreviations",
+      "heuristic_rule": "C003_no_vague_abbreviations",
+      "category": "coding",
+      "compatibility": "full", 
+      "priority": "low",
+      "status": "pending",
+      "notes": "String pattern matching for variable names"
+    },
+    
+    {
+      "eslint_rule": "s001-fail-securely",
+      "heuristic_rule": "S001_fail_securely",
+      "category": "security", 
+      "compatibility": "partial",
+      "priority": "critical",
+      "status": "pending",
+      "notes": "Complex logic analysis required for security patterns"
+    },
+    {
+      "eslint_rule": "s003-no-unvalidated-redirect", 
+      "heuristic_rule": "S003_no_unvalidated_redirect",
+      "category": "security",
+      "compatibility": "full",
+      "priority": "critical", 
+      "status": "pending",
+      "notes": "Pattern matching for redirect vulnerabilities"
+    },
+    {
+      "eslint_rule": "s012-hardcode-secret",
+      "heuristic_rule": "S012_hardcode_secret",
+      "category": "security",
+      "compatibility": "full",
+      "priority": "critical",
+      "status": "pending", 
+      "notes": "String pattern matching for hardcoded secrets"
+    },
+    
+    {
+      "eslint_rule": "t002-interface-prefix-i",
+      "heuristic_rule": "T002_interface_prefix_i",
+      "category": "typescript",
+      "compatibility": "full",
+      "priority": "medium",
+      "status": "pending", 
+      "notes": "TypeScript interface naming conventions"
+    },
+    {
+      "eslint_rule": "t003-ts-ignore-reason",
+      "heuristic_rule": "T003_ts_ignore_reason", 
+      "category": "typescript",
+      "compatibility": "full",
+      "priority": "medium",
+      "status": "pending",
+      "notes": "TypeScript comment analysis for @ts-ignore"
+    }
+  ],
+  
+  "migration_stats": {
+    "total_rules": 81,
+    "completed": 4,
+    "pending": 77,
+    "by_category": {
+      "coding": {
+        "total": 22,
+        "completed": 4, 
+        "pending": 18
+      },
+      "security": {
+        "total": 49,
+        "completed": 0,
+        "pending": 49
+      },
+      "typescript": {
+        "total": 10,
+        "completed": 0,
+        "pending": 10
+      }
+    },
+    "by_priority": {
+      "critical": 3,
+      "high": 4,
+      "medium": 12,
+      "low": 62
+    },
+    "by_compatibility": {
+      "full": 65,
+      "partial": 16,
+      "complex": 0
+    }
+  },
+  
+  "migration_phases": {
+    "phase_1": {
+      "name": "Critical Security Rules",
+      "rules": ["S001", "S003", "S012"],
+      "timeline": "Immediate post-ESLint deprecation"
+    },
+    "phase_2": {
+      "name": "High Priority Coding Rules", 
+      "rules": ["C002", "C010", "C014", "C018"],
+      "timeline": "Within 1 month"
+    },
+    "phase_3": {
+      "name": "TypeScript Rules",
+      "rules": ["T002", "T003", "T004", "T007"],
+      "timeline": "Within 2 months"
+    },
+    "phase_4": {
+      "name": "Remaining Rules",
+      "rules": "All remaining 70 rules",
+      "timeline": "Within 6 months"
+    }
+  }
+}