@sun-asterisk/sunlint 1.2.2 → 1.3.0

package/rules/common/C047_no_duplicate_retry_logic/symbol-config.json

@@ -0,0 +1,71 @@
+{
+  "knownRetryFunctions": [
+    "axios.get",
+    "axios.post", 
+    "axios.put",
+    "axios.delete",
+    "axios.patch",
+    "axios.request",
+    "axios.head",
+    "axios.options",
+    
+    "useQuery",
+    "useMutation", 
+    "useInfiniteQuery",
+    "queryClient.fetchQuery",
+    "queryClient.prefetchQuery",
+    
+    "apolloClient.query",
+    "apolloClient.mutate", 
+    "apolloClient.watchQuery",
+    "useLazyQuery",
+    
+    "apiService.get",
+    "apiService.post",
+    "apiService.put", 
+    "apiService.delete",
+    "apiService.patch",
+    "httpClient.get",
+    "httpClient.post",
+    "httpClient.request",
+    
+    "retryAsync",
+    "withRetry", 
+    "retry",
+    "p-retry",
+    "exponentialBackoff",
+    "retryPromise",
+    
+    "fetch",
+    "fetch-retry",
+    "node-fetch",
+    "got",
+    "superagent", 
+    "request-promise"
+  ],
+  
+  "layerPatterns": {
+    "ui": ["component", "view", "page", "modal", "form", "screen", "widget", "/ui/", "/components/"],
+    "usecase": ["usecase", "use-case", "usecases", "service", "business", "/usecases/", "/services/"],
+    "repository": ["repository", "repo", "dao", "store", "persistence", "/repositories/", "/data/"],
+    "api": ["api", "client", "adapter", "gateway", "connector", "/api/", "/clients/", "/gateways/"]
+  },
+  
+  "retryDetectionPatterns": {
+    "exceptionRetry": {
+      "description": "Detect retry logic in try-catch blocks",
+      "enabled": true
+    },
+    "emptyDataRetry": {
+      "description": "Detect retry logic when data is empty/null",
+      "enabled": true
+    },
+    "knownRetryConflict": {
+      "description": "Detect manual retry conflicting with built-in retry",
+      "enabled": true
+    }
+  },
+  
+  "_description": "Configuration for Symbol-Based Analysis of retry functions using ts-morph",
+  "_usage": "Add functions that have built-in retry mechanisms to avoid false positives"
+}

package/rules/index.js

@@ -15,6 +15,13 @@ const path = require('path');
  */
 function loadRule(category, ruleId) {
     try {
+        // Special case for C047: Use semantic analyzer by default
+        if (ruleId === 'C047_no_duplicate_retry_logic') {
+            const semanticPath = path.join(__dirname, category, ruleId, 'c047-semantic-rule.js');
+            console.log(`🔬 Loading C047 semantic analyzer: ${semanticPath}`);
+            return require(semanticPath);
+        }
+        
         const rulePath = path.join(__dirname, category, ruleId, 'analyzer.js');
         return require(rulePath);
     } catch (error) {

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

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*