@sun-asterisk/sunlint 1.2.1 → 1.3.0

package/scripts/category-manager.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+
+/**
+ * SunLint Category Management CLI
+ * Utility for managing categories and principles
+ * 
+ * Usage:
+ *   node scripts/category-manager.js list
+ *   node scripts/category-manager.js add <category> <principle> <description>
+ *   node scripts/category-manager.js validate
+ *   node scripts/category-manager.js stats
+ */
+
+const path = require('path');
+const {
+  getValidCategories,
+  getCategoryPrinciples,
+  getCategoryDescription,
+  getCategoryStats,
+  isValidCategory,
+  addCategoryMapping
+} = require('../core/constants/categories');
+
+const command = process.argv[2];
+
+switch (command) {
+  case 'list':
+    listCategories();
+    break;
+    
+  case 'validate':
+    validateCategories();
+    break;
+    
+  case 'stats':
+    showStats();
+    break;
+    
+  case 'add':
+    addCategory(process.argv[3], process.argv[4], process.argv[5]);
+    break;
+    
+  case 'check':
+    checkCategory(process.argv[3]);
+    break;
+    
+  default:
+    showHelp();
+}
+
+function listCategories() {
+  console.log('📋 SunLint Categories & Principles\n');
+  
+  const categories = getValidCategories();
+  categories.forEach(category => {
+    const principles = getCategoryPrinciples(category);
+    const description = getCategoryDescription(category);
+    
+    console.log(`🏷️  ${category.toUpperCase()}`);
+    console.log(`   Principles: ${principles.join(', ')}`);
+    console.log(`   Description: ${description}`);
+    console.log('');
+  });
+}
+
+function validateCategories() {
+  console.log('🔍 Validating Category System\n');
+  
+  const stats = getCategoryStats();
+  console.log(`✅ Total Categories: ${stats.totalCategories}`);
+  console.log(`✅ Total Principles: ${stats.totalPrinciples}`);
+  
+  // Check for missing principles
+  const allPrinciples = Object.values(SUNLINT_PRINCIPLES);
+  const mappedPrinciples = Object.values(CATEGORY_PRINCIPLE_MAP).flat();
+  
+  const missingPrinciples = allPrinciples.filter(p => !mappedPrinciples.includes(p));
+  
+  if (missingPrinciples.length > 0) {
+    console.log(`⚠️  Unmapped Principles: ${missingPrinciples.join(', ')}`);
+  } else {
+    console.log('✅ All principles mapped to categories');
+  }
+  
+  console.log('\n📊 Category Mapping:');
+  Object.entries(CATEGORY_PRINCIPLE_MAP).forEach(([category, principles]) => {
+    console.log(`   ${category} -> ${principles.join(', ')}`);
+  });
+}
+
+function showStats() {
+  const stats = getCategoryStats();
+  console.log('📊 Category Statistics\n');
+  console.log(JSON.stringify(stats, null, 2));
+}
+
+function addCategory(category, principle, description) {
+  if (!category || !principle || !description) {
+    console.error('❌ Usage: add <category> <principle> <description>');
+    return;
+  }
+  
+  console.log(`🔄 Adding category: ${category}`);
+  console.log(`   Principle: ${principle}`);
+  console.log(`   Description: ${description}`);
+  console.log('\n⚠️  This would require updating category-constants.js manually');
+  console.log('   Add the following to CATEGORY_PRINCIPLE_MAP:');
+  console.log(`   '${category.toLowerCase()}': ['${principle.toUpperCase()}'],`);
+}
+
+function checkCategory(category) {
+  if (!category) {
+    console.error('❌ Usage: check <category>');
+    return;
+  }
+  
+  console.log(`🔍 Checking category: ${category}\n`);
+  
+  const isValid = isValidCategory(category);
+  console.log(`Valid: ${isValid ? '✅' : '❌'}`);
+  
+  if (isValid) {
+    const principles = getCategoryPrinciples(category);
+    const description = getCategoryDescription(category);
+    
+    console.log(`Principles: ${principles.join(', ')}`);
+    console.log(`Description: ${description}`);
+  } else {
+    console.log(`Valid categories: ${getValidCategories().join(', ')}`);
+  }
+}
+
+function showHelp() {
+  console.log(`
+🛠️  SunLint Category Manager
+
+Commands:
+  list      Show all categories and their principles
+  validate  Validate the category system consistency
+  stats     Show category statistics
+  check     Check if a specific category is valid
+  add       Add a new category (manual step required)
+
+Examples:
+  node scripts/category-manager.js list
+  node scripts/category-manager.js check security
+  node scripts/category-manager.js validate
+  node scripts/category-manager.js add accessibility ACCESSIBILITY "Accessibility guidelines"
+`);
+}

package/scripts/generate-rules-registry.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { SimpleRuleParser } = require('../rules/parser/rule-parser-simple');
+
+/**
+ * Generate rules registry from origin-rules
+ * This script creates config/rules/rules-registry-generated.json
+ * from all *-en.md files in origin-rules/ directory
+ */
+
+console.log('📋 Generating rules registry from origin-rules...');
+
+try {
+  const parser = new SimpleRuleParser();
+  const originRulesDir = path.join(__dirname, '..', 'origin-rules');
+  const targetPath = path.join(__dirname, '..', 'config', 'rules', 'rules-registry-generated.json');
+  
+  console.log(`Source: ${originRulesDir}`);
+  console.log(`Target: ${targetPath}`);
+  
+  // Parse all rules from origin-rules
+  const allRules = parser.parseAllRules(originRulesDir);
+  
+  if (allRules.length === 0) {
+    console.error('❌ No rules found in origin-rules directory');
+    process.exit(1);
+  }
+  
+  // Convert to registry format
+  const registry = {
+    rules: {}
+  };
+  
+  allRules.forEach(rule => {
+    if (rule.id) {
+      registry.rules[rule.id] = {
+        name: rule.title || `${rule.id} Rule`,
+        description: rule.description || 'No description available',
+        category: rule.category || 'quality',
+        severity: rule.severity || 'major',
+        languages: rule.language ? [rule.language] : ['All languages'],
+        version: rule.version || '1.0.0',
+        status: rule.status || 'draft',
+        tags: [rule.category || 'quality', 'readability', 'code-quality'],
+        tools: rule.tools || [],
+        framework: rule.framework || 'All',
+        principles: rule.principles || []
+      };
+    }
+  });
+  
+  // Ensure target directory exists
+  const targetDir = path.dirname(targetPath);
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+  
+  // Write registry file
+  fs.writeFileSync(targetPath, JSON.stringify(registry, null, 2), 'utf8');
+  
+  const rulesCount = Object.keys(registry.rules).length;
+  const fileSize = (fs.statSync(targetPath).size / 1024).toFixed(1);
+  
+  console.log(`✅ Generated registry with ${rulesCount} rules`);
+  console.log(`📁 File: ${targetPath} (${fileSize} KB)`);
+  console.log('');
+  console.log('📊 Rules by category:');
+  
+  // Stats by category
+  const categories = {};
+  Object.values(registry.rules).forEach(rule => {
+    const cat = rule.category || 'unknown';
+    categories[cat] = (categories[cat] || 0) + 1;
+  });
+  
+  Object.entries(categories)
+    .sort(([,a], [,b]) => b - a)
+    .forEach(([category, count]) => {
+      console.log(`   ${category}: ${count} rules`);
+    });
+    
+} catch (error) {
+  console.error('❌ Error generating registry:', error.message);
+  console.error(error.stack);
+  process.exit(1);
+}

package/scripts/generate_insights.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { SimpleRuleParser } = require('../rules/parser/rule-parser-simple.js');
+
+class SunLintInsightGenerator {
+    constructor() {
+        this.parser = new SimpleRuleParser();
+        this.heuristicRulesPath = path.join(__dirname, '../rules/common');
+    }
+
+    // Get implemented rules
+    getImplementedRules() {
+        const implemented = new Set();
+        if (fs.existsSync(this.heuristicRulesPath)) {
+            const dirs = fs.readdirSync(this.heuristicRulesPath);
+            dirs.forEach(dir => {
+                const match = dir.match(/^([A-Z]\d+)_/);
+                if (match) {
+                    implemented.add(match[1]);
+                }
+            });
+        }
+        return implemented;
+    }
+
+    // Assess priority based on rule content
+    assessPriority(rule) {
+        const text = `${rule.title} ${rule.description} ${rule.detail || ''}`.toLowerCase();
+        const principles = rule.principles || [];
+        
+        if (principles.includes('SECURITY')) return 'High';
+        if (principles.includes('PERFORMANCE')) return 'High';
+        if (principles.includes('RELIABILITY')) return 'Medium-High';
+        
+        const impactKeywords = {
+            high: ['security', 'memory', 'performance', 'crash', 'null pointer', 'xss', 'injection', 'vulnerability', 'race condition'],
+            medium: ['testability', 'maintainability', 'readability', 'coupling', 'cohesion', 'dependency'],
+            low: ['naming', 'style', 'convention', 'formatting', 'comment']
+        };
+        
+        for (const keyword of impactKeywords.high) {
+            if (text.includes(keyword)) return 'High';
+        }
+        for (const keyword of impactKeywords.medium) {
+            if (text.includes(keyword)) return 'Medium';
+        }
+        for (const keyword of impactKeywords.low) {
+            if (text.includes(keyword)) return 'Low';
+        }
+        
+        return 'Medium';
+    }
+
+    // Generate actionable insights
+    generateInsights() {
+        console.log('🔍 Analyzing SunLint rules...');
+        const allRules = this.parser.parseAllRules();
+        const activatedRules = this.parser.filterRules(allRules, { status: 'activated' });
+        const implementedRules = this.getImplementedRules();
+        
+        console.log('\n📊 === SUNLINT HEURISTIC ENGINE ANALYSIS ===\n');
+        
+        // Overall statistics
+        const totalImplemented = activatedRules.filter(rule => implementedRules.has(rule.id)).length;
+        const implementationRate = ((totalImplemented / activatedRules.length) * 100).toFixed(1);
+        
+        console.log(`🎯 **Current Implementation Status:**`);
+        console.log(`   • Total Activated Rules: ${activatedRules.length}`);
+        console.log(`   • Implemented in Heuristic: ${totalImplemented} (${implementationRate}%)`);
+        console.log(`   • Remaining to Implement: ${activatedRules.length - totalImplemented}\n`);
+
+        // Priority analysis
+        const priorities = { 'High': 0, 'Medium-High': 0, 'Medium': 0, 'Low': 0 };
+        const notImplementedByPriority = { 'High': [], 'Medium-High': [], 'Medium': [], 'Low': [] };
+        
+        activatedRules.forEach(rule => {
+            const priority = this.assessPriority(rule);
+            priorities[priority]++;
+            
+            if (!implementedRules.has(rule.id)) {
+                notImplementedByPriority[priority].push(rule);
+            }
+        });
+
+        console.log(`🔥 **Priority Breakdown:**`);
+        Object.entries(priorities).forEach(([priority, count]) => {
+            const missing = notImplementedByPriority[priority].length;
+            const implemented = count - missing;
+            const rate = count > 0 ? ((implemented / count) * 100).toFixed(1) : '0.0';
+            console.log(`   • ${priority}: ${implemented}/${count} implemented (${rate}%) - ${missing} missing`);
+        });
+
+        // Category analysis
+        console.log(`\n📂 **Implementation by Category:**`);
+        const categories = {
+            'C': 'Common Code Quality',
+            'T': 'TypeScript',
+            'R': 'ReactJS',
+            'S': 'Security',
+            'J': 'Java',
+            'K': 'Kotlin Mobile',
+            'D': 'Dart/Flutter',
+            'SW': 'Swift'
+        };
+
+        Object.entries(categories).forEach(([prefix, name]) => {
+            const categoryRules = activatedRules.filter(rule => rule.id.startsWith(prefix));
+            const categoryImplemented = categoryRules.filter(rule => implementedRules.has(rule.id)).length;
+            const rate = categoryRules.length > 0 ? ((categoryImplemented / categoryRules.length) * 100).toFixed(1) : '0.0';
+            console.log(`   • ${name}: ${categoryImplemented}/${categoryRules.length} (${rate}%)`);
+        });
+
+        // Top missing high-priority rules
+        console.log(`\n🚨 **Top 10 Missing High-Priority Rules:**`);
+        notImplementedByPriority['High'].slice(0, 10).forEach((rule, i) => {
+            console.log(`   ${i+1}. ${rule.id}: ${rule.title}`);
+            console.log(`      → ${rule.description?.substring(0, 80)}...`);
+        });
+
+        // Quick wins (easy to implement)
+        console.log(`\n⚡ **Quick Wins (Low Complexity, High Impact):**`);
+        const quickWins = notImplementedByPriority['High'].filter(rule => {
+            const text = rule.title.toLowerCase();
+            return text.includes('console.log') || text.includes('print') || 
+                   text.includes('hardcode') || text.includes('sensitive');
+        });
+        
+        quickWins.slice(0, 5).forEach((rule, i) => {
+            console.log(`   ${i+1}. ${rule.id}: ${rule.title} - Text/Regex patterns`);
+        });
+
+        // Performance impact rules
+        console.log(`\n⚡ **Performance-Critical Missing Rules:**`);
+        const perfRules = notImplementedByPriority['High'].filter(rule => 
+            rule.principles?.includes('PERFORMANCE') || 
+            rule.description?.toLowerCase().includes('performance')
+        );
+        
+        perfRules.slice(0, 5).forEach((rule, i) => {
+            console.log(`   ${i+1}. ${rule.id}: ${rule.title}`);
+        });
+
+        // Security rules
+        console.log(`\n🔒 **Security-Critical Missing Rules:**`);
+        const securityRules = notImplementedByPriority['High'].filter(rule => 
+            rule.principles?.includes('SECURITY') ||
+            rule.description?.toLowerCase().includes('security')
+        );
+        
+        securityRules.slice(0, 5).forEach((rule, i) => {
+            console.log(`   ${i+1}. ${rule.id}: ${rule.title}`);
+        });
+
+        // Recommendations
+        console.log(`\n💡 **Actionable Recommendations:**`);
+        console.log(`   1. Focus on High Priority rules first: ${notImplementedByPriority['High'].length} rules remaining`);
+        console.log(`   2. Implement Common (C) rules first - highest coverage impact`);
+        console.log(`   3. Start with Low complexity rules using text/regex patterns`);
+        console.log(`   4. Performance rules should be prioritized for production impact`);
+        console.log(`   5. Security rules are critical for safe code practices`);
+        console.log(`   6. Consider AST analysis for complex rules (Medium-High complexity)`);
+        
+        console.log(`\n📈 **ROI Analysis:**`);
+        const commonMissing = notImplementedByPriority['High'].filter(rule => rule.id.startsWith('C')).length;
+        console.log(`   • Common rules impact: All languages (${commonMissing} High-priority missing)`);
+        console.log(`   • Language-specific rules: Limited scope but deep impact`);
+        console.log(`   • Implementation effort: Low complexity rules = 1-2 days, High = 1-2 weeks`);
+        
+        return {
+            total: activatedRules.length,
+            implemented: totalImplemented,
+            missing: activatedRules.length - totalImplemented,
+            highPriorityMissing: notImplementedByPriority['High'].length,
+            quickWins: quickWins.length,
+            recommendations: notImplementedByPriority
+        };
+    }
+}
+
+// Run analysis
+if (require.main === module) {
+    const analyzer = new SunLintInsightGenerator();
+    analyzer.generateInsights();
+}
+
+module.exports = SunLintInsightGenerator;

package/scripts/migrate-rule-registry.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+
+/**
+ * Rule Registry Migration Script
+ * Merges all rule mappings into Unified Rule Registry
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+console.log('🔄 RULE REGISTRY MIGRATION');
+console.log('='.repeat(50));
+
+// Load existing data
+const rulesRegistry = JSON.parse(fs.readFileSync('./config/rules/rules-registry.json', 'utf8'));
+const eslintMapping = JSON.parse(fs.readFileSync('./config/eslint-rule-mapping.json', 'utf8'));
+const engineMapping = JSON.parse(fs.readFileSync('./config/engines/eslint-rule-mapping.json', 'utf8'));
+const strategies = require('./config/rule-analysis-strategies.js');
+
+// Current unified registry
+const { UnifiedRuleRegistry } = require('./core/unified-rule-registry.js');
+const registry = new UnifiedRuleRegistry();
+
+async function migrateRuleData() {
+  console.log('📥 Loading current unified registry...');
+  await registry.initialize({ verbose: true });
+  
+  console.log('🔍 Analyzing missing rules...');
+  
+  // Get all rule IDs from different sources
+  const registryRules = Object.keys(rulesRegistry.rules || {});
+  const eslintRules = Object.keys(eslintMapping.mappings || {});
+  const engineRules = Object.keys(engineMapping || {});
+  
+  // Find missing rules in unified registry
+  const missingFromEslint = eslintRules.filter(ruleId => 
+    !registryRules.includes(ruleId)
+  );
+  
+  console.log(`📊 Found ${missingFromEslint.length} rules missing from registry:`, 
+    missingFromEslint.slice(0, 10).join(', '));
+  
+  // Extend unified registry with missing rules
+  const enhancedRegistry = { ...rulesRegistry };
+  
+  missingFromEslint.forEach(ruleId => {
+    console.log(`➕ Adding missing rule: ${ruleId}`);
+    
+    enhancedRegistry.rules[ruleId] = {
+      id: ruleId,
+      name: `Rule ${ruleId}`, // Will be improved
+      description: `Auto-migrated rule ${ruleId} from ESLint mapping`,
+      category: inferCategory(ruleId),
+      severity: 'warning',
+      languages: ['typescript', 'javascript'],
+      version: '1.0.0',
+      status: 'migrated',
+      tags: ['migrated'],
+      
+      // ESLint engine mapping
+      engineMappings: {
+        eslint: eslintMapping.mappings[ruleId] || []
+      },
+      
+      // Analysis strategy
+      strategy: {
+        preferred: inferStrategy(ruleId),
+        fallbacks: ['regex'],
+        accuracy: {}
+      }
+    };
+  });
+  
+  // Add missing engine mappings
+  console.log('🔧 Adding engine mappings...');
+  Object.entries(engineMapping).forEach(([ruleId, eslintRules]) => {
+    if (enhancedRegistry.rules[ruleId]) {
+      enhancedRegistry.rules[ruleId].engineMappings = enhancedRegistry.rules[ruleId].engineMappings || {};
+      enhancedRegistry.rules[ruleId].engineMappings.eslint = eslintRules;
+    }
+  });
+  
+  // Add analysis strategies
+  console.log('📈 Adding analysis strategies...');
+  Object.entries(strategies.astPreferred || {}).forEach(([ruleId, config]) => {
+    if (enhancedRegistry.rules[ruleId]) {
+      enhancedRegistry.rules[ruleId].strategy = {
+        preferred: 'ast',
+        fallbacks: config.methods || ['regex'],
+        accuracy: config.accuracy || {}
+      };
+    }
+  });
+  
+  Object.entries(strategies.regexOptimal || {}).forEach(([ruleId, config]) => {
+    if (enhancedRegistry.rules[ruleId]) {
+      enhancedRegistry.rules[ruleId].strategy = {
+        preferred: 'regex', 
+        fallbacks: config.methods || [],
+        accuracy: config.accuracy || {}
+      };
+    }
+  });
+  
+  console.log('💾 Saving enhanced registry...');
+  
+  // Save enhanced registry
+  fs.writeFileSync(
+    './config/rules/enhanced-rules-registry.json',
+    JSON.stringify(enhancedRegistry, null, 2)
+  );
+  
+  console.log(`✅ Enhanced registry saved with ${Object.keys(enhancedRegistry.rules).length} rules`);
+  
+  // Generate migration summary
+  const summary = {
+    originalRules: registryRules.length,
+    migratedRules: missingFromEslint.length,
+    totalRules: Object.keys(enhancedRegistry.rules).length,
+    eslintMappings: Object.keys(eslintMapping.mappings).length,
+    engineMappings: Object.keys(engineMapping).length
+  };
+  
+  fs.writeFileSync(
+    './migration-summary.json',
+    JSON.stringify(summary, null, 2)
+  );
+  
+  console.log('📄 Migration summary:', summary);
+}
+
+// Helper functions
+function inferCategory(ruleId) {
+  if (ruleId.startsWith('S')) return 'security';
+  if (ruleId.startsWith('T')) return 'typescript';
+  if (ruleId.startsWith('R')) return 'react';
+  
+  // Infer from common patterns
+  if (ruleId.includes('naming') || ruleId.includes('name')) return 'naming';
+  if (ruleId.includes('error') || ruleId.includes('exception')) return 'error-handling';
+  if (ruleId.includes('log')) return 'logging';
+  if (ruleId.includes('complexity')) return 'complexity';
+  
+  return 'general';
+}
+
+function inferStrategy(ruleId) {
+  // Rules that typically need AST analysis
+  const astRules = ['C010', 'C012', 'C015', 'C017'];
+  if (astRules.includes(ruleId)) return 'ast';
+  
+  // Most rules can start with regex
+  return 'regex';
+}
+
+// Run migration
+migrateRuleData().catch(console.error);

package/scripts/validate-system.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+/**
+ * Quick validation that unified rule registry system is working
+ */
+
+const { getInstance } = require('./core/unified-rule-registry');
+
+async function validateUnifiedSystem() {
+  console.log('🔍 Validating unified rule registry system...\n');
+  
+  try {
+    const registry = getInstance();
+    await registry.initialize();
+    
+    console.log(`✅ Registry loaded: ${registry.rules.size} rules`);
+    
+    // Test specific rules
+    const testRules = ['C006', 'C047', 'C002'];
+    console.log('\n📋 Testing specific rules:');
+    
+    for (const ruleId of testRules) {
+      const rule = registry.rules.get(ruleId);
+      if (rule) {
+        console.log(`   ✅ ${ruleId}: ${rule.title}`);
+        if (rule.engineMappings?.eslint) {
+          console.log(`      ESLint: ${JSON.stringify(rule.engineMappings.eslint)}`);
+        }
+        if (rule.engineMappings?.heuristic) {
+          console.log(`      Heuristic: ${rule.engineMappings.heuristic.implementation}`);
+        }
+      } else {
+        console.log(`   ❌ ${ruleId}: NOT FOUND`);
+      }
+    }
+    
+    console.log('\n🎉 Unified rule registry system is working correctly!');
+    
+  } catch (error) {
+    console.error('❌ Validation failed:', error.message);
+  }
+}
+
+if (require.main === module) {
+  validateUnifiedSystem();
+}
+
+module.exports = { validateUnifiedSystem };

package/.sunlint.json

@@ -1,35 +0,0 @@
-{
-  "extends": "@sun/sunlint/recommended",
-  "rules": {
-    "C019": "warn",
-    "C006": "warn", 
-    "C029": "error",
-    "C031": "warn",
-    "S001": "warn",
-    "S002": "warn",
-    "S007": "warn",
-    "S013": "warn",
-    "T019": "error",
-    "T020": "warn",
-    "T021": "error"
-  },
-  "include": ["**/*.js", "**/*.ts", "**/*.jsx", "**/*.tsx"],
-  "exclude": [
-    "node_modules/**",
-    "coverage/**",
-    "**/*.min.*",
-    ".git/**",
-    "dist/**",
-    "build/**"
-  ],
-  "engine": "eslint",
-  "languages": ["typescript", "javascript"],
-  "output": {
-    "format": "summary",
-    "console": true
-  },
-  "fileTargeting": {
-    "followSymlinks": false,
-    "maxDepth": 10
-  }
-}