@sun-asterisk/sunlint 1.2.2 → 1.3.1

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/prepare-release.sh

@@ -135,7 +135,7 @@ sunlint --rule=C006 --input=src --format=summary
 
 # TypeScript Analysis
 --typescript               # Enable TypeScript analysis
---typescript-engine <type> # Engine: eslint, sunlint, hybrid
+--typescript-engine <type> # Engine: eslint, heuristic, hybrid
 
 # Output Control
 --format <format>          # Output: eslint, json, summary, table

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
-  }
-}

package/config/README.md

@@ -1,88 +0,0 @@
-# SunLint Configuration Structure
-
-This folder contains all configuration files for SunLint, organized for clarity and maintainability.
-
-## 📁 Structure Overview
-
-```
-config/
-├── schemas/                    # JSON schemas for validation
-│   └── sunlint-schema.json    # Main SunLint config schema
-├── engines/                    # Analysis engine configurations
-│   ├── engines.json           # Available engines (ESLint, TypeScript, etc.)
-│   └── eslint-rule-mapping.json  # ESLint rule mappings
-├── presets/                    # Pre-defined rule configurations
-│   ├── beginner.json          # Beginner-friendly preset
-│   ├── ci.json                # CI/CD optimized preset
-│   ├── recommended.json       # Recommended preset
-│   └── strict.json            # Strict coding standards
-├── integrations/              # Integration-specific configs
-│   └── eslint/
-│       ├── base.config.js     # Base ESLint configuration
-│       ├── typescript.config.js  # TypeScript ESLint config
-│       └── simple.config.js   # Simplified ESLint config
-├── rules/                     # Rule definitions and registry
-│   └── rules-registry.json   # Master rule registry
-├── defaults/                  # Default configurations
-│   ├── default.json          # Default SunLint settings
-│   └── ai-rules-context.json # AI analysis context
-└── testing/                   # Test configurations and samples
-    └── test-s005-working.ts  # Test file for S005 rule
-```
-
-## 🎯 Key Improvements
-
-### ✅ Eliminated Duplicates
-- **Before**: ESLint configs in both `config/typescript/` and `integrations/eslint/`
-- **After**: All ESLint configs consolidated in `config/integrations/eslint/`
-
-### ✅ Logical Organization
-- **Schemas**: All JSON schemas in one place
-- **Engines**: Engine-specific configurations separated
-- **Presets**: User-facing preset configurations grouped
-- **Integrations**: Third-party integration configs organized by tool
-
-### ✅ Reduced Complexity
-- **Before**: 10+ files scattered in root config/
-- **After**: Organized into 6 logical categories
-
-## 📋 Usage
-
-### For ESLint Integration
-```bash
-# Use the consolidated TypeScript ESLint config
-npx eslint --config config/integrations/eslint/typescript.config.js src/
-
-# Use the base ESLint config
-npx eslint --config config/integrations/eslint/base.config.js src/
-```
-
-### For Rule Presets
-```json
-{
-  "extends": "config/presets/recommended.json"
-}
-```
-
-### For Schema Validation
-```json
-{
-  "$schema": "config/schemas/sunlint-schema.json"
-}
-```
-
-## 🔧 Migration Notes
-
-- **Old `config/typescript/`**: ❌ Removed (duplicated functionality)
-- **ESLint configs**: ✅ Moved to `config/integrations/eslint/`
-- **Default configs**: ✅ Moved to `config/defaults/`
-- **Engine configs**: ✅ Moved to `config/engines/`
-
-## 🚀 Next Steps
-
-1. Update documentation references to new paths
-2. Update CI/CD scripts to use new config locations
-3. Consider adding more integration-specific configs as needed
-
----
-*Last updated: July 21, 2025 | SunLint Config Refactor*

package/config/engines/eslint-rule-mapping.json

@@ -1,74 +0,0 @@
-{
-  "C005": [
-    "max-statements-per-line",
-    "complexity"
-  ],
-  "C006": [
-    "func-names",
-    "func-name-matching",
-    "@typescript-eslint/naming-convention"
-  ],
-  "C007": [
-    "spaced-comment",
-    "no-inline-comments",
-    "no-warning-comments"
-  ],
-  "C012": [
-    "consistent-return",
-    "no-void",
-    "@typescript-eslint/no-confusing-void-expression"
-  ],
-  "C014": [
-    "no-new",
-    "no-new-wrappers",
-    "@typescript-eslint/no-unnecessary-constructor"
-  ],
-  "C015": [
-    "@typescript-eslint/naming-convention",
-    "camelcase"
-  ],
-  "C019": [
-    "no-console",
-    "no-alert",
-    "no-debugger"
-  ],
-  "C031": [
-    "no-implicit-coercion",
-    "eqeqeq",
-    "@typescript-eslint/strict-boolean-expressions"
-  ],
-  "C032": [
-    "no-new",
-    "@typescript-eslint/no-floating-promises",
-    "no-constructor-return"
-  ],
-  "C033": [
-    "prefer-const",
-    "no-var",
-    "@typescript-eslint/prefer-readonly"
-  ],
-  "C034": [
-    "no-global-assign",
-    "no-implicit-globals",
-    "@typescript-eslint/no-namespace"
-  ],
-  "C035": [
-    "no-empty-catch",
-    "@typescript-eslint/no-unused-vars"
-  ],
-  "C037": [
-    "consistent-return",
-    "@typescript-eslint/explicit-function-return-type",
-    "@typescript-eslint/explicit-module-boundary-types"
-  ],
-  "C038": [
-    "import/no-dynamic-require",
-    "import/order",
-    "@typescript-eslint/no-var-requires"
-  ],
-  "C040": [
-    "no-duplicate-imports",
-    "import/no-duplicates",
-    "@typescript-eslint/no-duplicate-imports"
-  ]
-}

package/config/testing/test-s005-working.ts

@@ -1,22 +0,0 @@
-function doAdminTask() {}
-function doAction() {}
-function isAuthenticated(req: any): boolean {
-  return true;
-}
-
-function doPost(request: any, response: any) { // ❌
-  const origin = request.getHeader("Origin");
-
-  if (origin === "https://admin.example.com") {
-    doAdminTask();
-  }
-}
-
-function doPost_safe(request: any, response: any) { // ✅
-  const origin = request.getHeader("Origin");
-  console.log("Origin:", origin);
-
-  if (isAuthenticated(request)) {
-    doAction();
-  }
-}