@sun-asterisk/sunlint 1.0.7 → 1.1.4

package/core/cli-program.js

@@ -29,12 +29,12 @@ function createCliProgram() {
     .option('--typescript-engine <engine>', 'TypeScript analysis engine (eslint,sunlint,hybrid)', 'sunlint')
     .option('--ensure-deps', 'Ensure ESLint dependencies are installed');
 
-  // Input/Output options
+  // Input/Output options (v1.x: explicit --input required)
   program
-    .option('-i, --input <path>', 'Input file or directory to analyze', 'src')
+    .option('-i, --input <path>', 'Input file or directory to analyze (REQUIRED)')
     .option('-f, --format <format>', 'Output format (eslint,json,summary,table)', 'eslint')
     .option('-o, --output <file>', 'Output file path')
-    .option('--config <file>', 'Configuration file path', '.sunlint.json');
+    .option('--config <file>', 'Configuration file path (default: auto-discover)');
 
   // File targeting options
   program
@@ -58,12 +58,16 @@ function createCliProgram() {
 
   // Advanced options
   program
+    .option('--engine <engine>', 'Force specific analysis engine (eslint,sunlint)', '')
     .option('--dry-run', 'Show what would be analyzed without running')
     .option('--verbose', 'Enable verbose logging')
     .option('--quiet', 'Suppress non-error output')
     .option('--debug', 'Enable debug mode')
     .option('--ai', 'Enable AI-powered analysis')
-    .option('--no-ai', 'Force disable AI analysis (use heuristic only)');
+    .option('--no-ai', 'Force disable AI analysis (use heuristic only)')
+    .option('--legacy', 'Use legacy analysis architecture')
+    .option('--modern', 'Use modern plugin-based architecture (default)')
+    .option('--list-engines', 'List available analysis engines');
 
   // ESLint Integration options
   program
@@ -77,6 +81,7 @@ function createCliProgram() {
   program.addHelpText('after', `
 Examples:
   $ sunlint --rule=C019 --input=src
+  $ sunlint --rule C019 --input src
   $ sunlint --rules=C019,C006,S005 --input=src
   $ sunlint --all --input=src
   $ sunlint --quality --input=src
@@ -95,6 +100,15 @@ TypeScript Analysis (Phase 1):
   $ sunlint --rules=C019,S005 --typescript --input=src
   $ sunlint --typescript-engine=eslint --input=src
 
+Version Strategy:
+  v1.x: ESLint-first with SunLint fallback (current)
+  v2.x: SunLint-first with ESLint integration (--eslint-integration)
+
+Engine Configuration:
+  $ sunlint --all --input=src                    # Use config engine setting
+  $ sunlint --all --input=src --engine=eslint    # Force ESLint engine 
+  $ sunlint --all --input=src --engine=sunlint   # Force SunLint engine
+
 CI/CD Integration:
   $ sunlint --all --changed-files --format=summary --no-ai
   $ sunlint --all --changed-files --diff-base=origin/main --fail-on-new-violations

package/core/config-manager.js

@@ -166,7 +166,8 @@ class ConfigManager {
 
     // 4. Auto-discover project config if not explicitly provided
     let resolvedConfigPath = configPath;
-    if (!configPath || configPath === '.sunlint.json') {
+    if (!configPath) {
+      // Only auto-discover if no config path was provided
       const discoveredConfig = this.findConfigFile(cliOptions.input || process.cwd());
       if (discoveredConfig) {
         resolvedConfigPath = discoveredConfig;
@@ -174,6 +175,11 @@ class ConfigManager {
           console.log(chalk.gray(`🔍 Auto-discovered config: ${discoveredConfig}`));
         }
       }
+    } else {
+      // Use the explicitly provided config path
+      if (cliOptions.verbose) {
+        console.log(chalk.gray(`📄 Using explicit config: ${configPath}`));
+      }
     }
 
     // 5. Load project config (explicit or discovered)
@@ -331,7 +337,7 @@ class ConfigManager {
     if (extendPath.startsWith('@sun/sunlint/')) {
       // Load preset from rules registry
       const presetName = extendPath.replace('@sun/sunlint/', '');
-      const rulesRegistry = require('../config/rules-registry.json');
+      const rulesRegistry = require('../config/rules/rules-registry.json');
       return this.presetResolver.resolvePresetFromRegistry(presetName, rulesRegistry);
     } else {
       // Load from file path
@@ -357,7 +363,7 @@ class ConfigManager {
    * Rule C014: Delegate to validator
    */
   getEffectiveRuleConfiguration(ruleId, config) {
-    const rulesRegistry = require('../config/rules-registry.json');
+    const rulesRegistry = require('../config/rules/rules-registry.json');
     return this.validator.getEffectiveRuleConfiguration(ruleId, config, rulesRegistry);
   }
 

package/core/config-merger.js

@@ -14,7 +14,16 @@ class ConfigMerger {
 
     for (const [key, value] of Object.entries(override)) {
       if (key === 'rules' && typeof value === 'object') {
-        merged.rules = { ...merged.rules, ...value };
+        if (Array.isArray(value)) {
+          // Convert array of rule names to object format
+          const rulesObj = {};
+          value.forEach(rule => {
+            rulesObj[rule] = 'warn';
+          });
+          merged.rules = { ...merged.rules, ...rulesObj };
+        } else {
+          merged.rules = { ...merged.rules, ...value };
+        }
       } else if (key === 'categories' && typeof value === 'object') {
         merged.categories = { ...merged.categories, ...value };
       } else if (typeof value === 'object' && !Array.isArray(value)) {
@@ -34,6 +43,36 @@ class ConfigMerger {
   applyCLIOverrides(config, options) {
     const overrides = { ...config };
 
+    // Rules override - only override if config file didn't specify rules
+    if (options.rules && (!config.rules || Object.keys(config.rules).length === 0)) {
+      if (typeof options.rules === 'string') {
+        const ruleList = options.rules.split(',').map(r => r.trim());
+        overrides.rules = {};
+        ruleList.forEach(rule => {
+          overrides.rules[rule] = 'warn';
+        });
+      } else if (Array.isArray(options.rules)) {
+        overrides.rules = {};
+        options.rules.forEach(rule => {
+          overrides.rules[rule] = 'warn';
+        });
+      }
+    }
+
+    // Include/Input override - only if config file didn't specify
+    if (options.include && (!config.include || config.include.length === 0)) {
+      overrides.include = Array.isArray(options.include) ? options.include : [options.include];
+    }
+    if (options.input && (!config.input || config.input.length === 0)) {
+      overrides.input = Array.isArray(options.input) ? options.input : [options.input];
+    }
+
+    // Exclude override - merge with config file
+    if (options.exclude) {
+      const excludeList = Array.isArray(options.exclude) ? options.exclude : [options.exclude];
+      overrides.exclude = [...new Set([...(config.exclude || []), ...excludeList])];
+    }
+
     // Languages override
     if (options.languages) {
       overrides.languages = options.languages.split(',').map(l => l.trim());

package/core/config-validator.js

@@ -46,8 +46,8 @@ class ConfigValidator {
    * Rule C031: Specific validation logic
    */
   validateLanguagesSection(languages) {
-    if (languages && !Array.isArray(languages)) {
-      throw new Error('Config error: languages must be an array');
+    if (languages && !Array.isArray(languages) && typeof languages !== 'object') {
+      throw new Error('Config error: languages must be an array or object');
     }
   }
 

package/core/dependency-checker.js

@@ -0,0 +1,125 @@
+/**
+ * Dependency Checker
+ * Checks for optional peer dependencies and provides helpful messages
+ */
+
+class DependencyChecker {
+  constructor() {
+    this.checkedDependencies = new Set();
+  }
+
+  /**
+   * Check if a dependency is available
+   */
+  isDependencyAvailable(packageName) {
+    try {
+      require.resolve(packageName);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Check for ESLint engine dependencies
+   */
+  checkESLintDependencies() {
+    const dependencies = {
+      'eslint': { required: false, description: 'ESLint engine support' },
+      '@typescript-eslint/eslint-plugin': { required: false, description: 'TypeScript ESLint rules' },
+      '@typescript-eslint/parser': { required: false, description: 'TypeScript ESLint parsing' },
+      'typescript': { required: false, description: 'TypeScript compiler' }
+    };
+
+    const missing = [];
+    const available = [];
+
+    for (const [pkg, info] of Object.entries(dependencies)) {
+      if (this.isDependencyAvailable(pkg)) {
+        available.push(pkg);
+      } else {
+        missing.push({ pkg, ...info });
+      }
+    }
+
+    return { available, missing };
+  }
+
+  /**
+   * Check for AST parsing dependencies
+   */
+  checkASTDependencies() {
+    const dependencies = {
+      '@babel/parser': { required: false, description: 'JavaScript AST parsing' },
+      'espree': { required: false, description: 'ECMAScript AST parsing' }
+    };
+
+    const missing = [];
+    const available = [];
+
+    for (const [pkg, info] of Object.entries(dependencies)) {
+      if (this.isDependencyAvailable(pkg)) {
+        available.push(pkg);
+      } else {
+        missing.push({ pkg, ...info });
+      }
+    }
+
+    return { available, missing };
+  }
+
+  /**
+   * Show installation instructions for missing dependencies
+   */
+  showInstallationInstructions(missing, context = 'general') {
+    if (missing.length === 0) return;
+
+    console.log('\n📦 Optional dependencies not found:');
+    
+    for (const { pkg, description } of missing) {
+      console.log(`   • ${pkg} - ${description}`);
+    }
+
+    const packages = missing.map(m => m.pkg).join(' ');
+    
+    if (context === 'eslint') {
+      console.log('\n💡 To enable ESLint engine features, install:');
+      console.log(`   npm install ${packages}`);
+      console.log('\n   Or add to your project dependencies if you already have them.');
+    } else if (context === 'ast') {
+      console.log('\n💡 To enable AST analysis features, install:');
+      console.log(`   npm install ${packages}`);
+    } else {
+      console.log('\n💡 To enable full functionality, install:');
+      console.log(`   npm install ${packages}`);
+    }
+
+    console.log('\n   SunLint will continue using heuristic analysis.\n');
+  }
+
+  /**
+   * Check and notify about missing dependencies (only once per session)
+   */
+  checkAndNotify(type = 'all') {
+    const key = `checked_${type}`;
+    if (this.checkedDependencies.has(key)) return;
+    
+    this.checkedDependencies.add(key);
+
+    if (type === 'eslint' || type === 'all') {
+      const { missing } = this.checkESLintDependencies();
+      if (missing.length > 0) {
+        this.showInstallationInstructions(missing, 'eslint');
+      }
+    }
+
+    if (type === 'ast' || type === 'all') {
+      const { missing } = this.checkASTDependencies();
+      if (missing.length > 0) {
+        this.showInstallationInstructions(missing, 'ast');
+      }
+    }
+  }
+}
+
+module.exports = new DependencyChecker();

package/core/enhanced-rules-registry.js

@@ -0,0 +1,331 @@
+/**
+ * Enhanced Rules Registry
+ * Following Rule C005: Single responsibility - registry management
+ * Following Rule C015: Use domain language - clear registry terms
+ */
+
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+class EnhancedRulesRegistry {
+  constructor() {
+    this.rulesRegistry = {};
+    this.enginePreferences = new Map();
+    this.ruleAnalyzers = new Map();
+    this.aiContexts = {};
+  }
+
+  /**
+   * Load enhanced rules registry
+   * Following Rule C006: Verb-noun naming
+   * @param {Object} options - Options including verbose flag
+   */
+  async loadRegistry(options = {}) {
+    try {
+      // Load base rules registry
+      await this.loadBaseRulesRegistry(options);
+      
+      // Load AI contexts
+      await this.loadAIContexts(options);
+      
+      // Load engine preferences
+      await this.loadEnginePreferences(options);
+      
+      // Scan for existing analyzers
+      await this.scanExistingAnalyzers(options);
+      
+      if (options.verbose) {
+      if (options.verbose) {
+        console.log(chalk.green(`📋 Enhanced registry loaded: ${Object.keys(this.rulesRegistry).length} rules`));
+      }
+      }
+      
+    } catch (error) {
+      console.error('Failed to load enhanced rules registry:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Load base rules registry
+   * Following Rule C006: Verb-noun naming
+   */
+  async loadBaseRulesRegistry(options = {}) {
+    const registryPath = path.resolve(__dirname, '../config/rules/rules-registry.json');
+    
+    if (fs.existsSync(registryPath)) {
+      const registry = require(registryPath);
+      this.rulesRegistry = registry.rules || {};
+      if (options.verbose) {
+        console.log(chalk.blue(`📋 Loaded ${Object.keys(this.rulesRegistry).length} base rules`));
+      }
+    } else {
+      console.warn('⚠️ Base rules registry not found at', registryPath);
+      this.rulesRegistry = {};
+    }
+  }
+
+  /**
+   * Load AI contexts
+   * Following Rule C006: Verb-noun naming
+   */
+  async loadAIContexts(options = {}) {
+    const contextsPath = path.resolve(__dirname, '../config/defaults/ai-rules-context.json');
+    
+    if (fs.existsSync(contextsPath)) {
+      const contexts = require(contextsPath);
+      this.aiContexts = contexts.contexts || {};
+      if (options.verbose) {
+        console.log(chalk.blue(`🤖 Loaded ${Object.keys(this.aiContexts).length} AI contexts`));
+      }
+    } else {
+      console.warn('⚠️ AI contexts not found at', contextsPath);
+      this.aiContexts = {};
+    }
+  }
+
+  /**
+   * Load engine preferences
+   * Following Rule C006: Verb-noun naming
+   */
+  loadEnginePreferences(options = {}) {
+    // Define engine preferences based on rule complexity and capabilities
+    const preferences = {
+      // ESLint-friendly rules (static analysis)
+      'C001': ['eslint', 'heuristic', 'openai'],
+      'C002': ['eslint', 'heuristic', 'openai'],
+      'C003': ['heuristic', 'eslint', 'openai'],
+      'C004': ['eslint', 'heuristic', 'openai'],
+      'C006': ['eslint', 'heuristic', 'openai'],
+      'C007': ['eslint', 'heuristic', 'openai'],
+      'C014': ['eslint', 'heuristic', 'openai'],
+      'C033': ['eslint', 'heuristic'],
+      'C040': ['eslint', 'heuristic'],
+      
+      // AI-enhanced rules (complex logic analysis)
+      'C005': ['openai', 'heuristic'],
+      'C012': ['openai', 'heuristic'],
+      'C015': ['openai', 'heuristic'],
+      'C032': ['openai', 'heuristic'],
+      'C034': ['openai', 'heuristic'],
+      'C035': ['openai', 'heuristic'],
+      'C037': ['openai', 'heuristic', 'eslint'],
+      'C038': ['openai', 'heuristic']
+    };
+
+    for (const [ruleId, engines] of Object.entries(preferences)) {
+      this.enginePreferences.set(ruleId, engines);
+    }
+
+    if (options.verbose) {
+      console.log(chalk.blue(`⚙️ Loaded ${this.enginePreferences.size} engine preferences`));
+    }
+  }
+
+  /**
+   * Scan existing analyzers
+   * Following Rule C006: Verb-noun naming
+   */
+  async scanExistingAnalyzers(options = {}) {
+    const rulesDir = path.resolve(__dirname, '../rules');
+    
+    if (!fs.existsSync(rulesDir)) {
+      console.warn('⚠️ Rules directory not found');
+      return;
+    }
+
+    try {
+      const ruleFolders = fs.readdirSync(rulesDir, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name);
+
+      for (const ruleFolder of ruleFolders) {
+        const ruleId = this.extractRuleId(ruleFolder);
+        const analyzerPath = path.join(rulesDir, ruleFolder, 'analyzer.js');
+        
+        if (fs.existsSync(analyzerPath)) {
+          this.ruleAnalyzers.set(ruleId, {
+            path: analyzerPath,
+            folder: ruleFolder,
+            available: true
+          });
+        }
+      }
+
+      if (options.verbose) {
+        console.log(chalk.blue(`🔍 Found ${this.ruleAnalyzers.size} existing analyzers`));
+      }
+      
+    } catch (error) {
+      console.warn('⚠️ Failed to scan existing analyzers:', error.message);
+    }
+  }
+
+  /**
+   * Extract rule ID from folder name
+   * Following Rule C006: Verb-noun naming
+   */
+  extractRuleId(folderName) {
+    // Extract from patterns like "C019_log_level_usage" or "S005_sql_injection"
+    const match = folderName.match(/^([CST]\d{3})/);
+    return match ? match[1] : folderName;
+  }
+
+  /**
+   * Get rule information with engine preferences
+   * Following Rule C006: Verb-noun naming
+   */
+  getRuleInfo(ruleId) {
+    const baseRule = this.rulesRegistry[ruleId];
+    if (!baseRule) {
+      return null;
+    }
+
+    return {
+      ...baseRule,
+      id: ruleId,
+      enginePreferences: this.enginePreferences.get(ruleId) || ['heuristic', 'openai'],
+      hasAnalyzer: this.ruleAnalyzers.has(ruleId),
+      hasAIContext: this.aiContexts[ruleId] !== undefined,
+      aiContext: this.aiContexts[ruleId] || null,
+      analyzer: this.ruleAnalyzers.get(ruleId) || null
+    };
+  }
+
+  /**
+   * Get rules by category
+   * Following Rule C006: Verb-noun naming
+   */
+  getRulesByCategory(category) {
+    const rules = [];
+    
+    for (const [ruleId, rule] of Object.entries(this.rulesRegistry)) {
+      if (rule.category === category) {
+        rules.push(this.getRuleInfo(ruleId));
+      }
+    }
+    
+    return rules;
+  }
+
+  /**
+   * Get rules by engine preference
+   * Following Rule C006: Verb-noun naming
+   */
+  getRulesByEngine(engineId) {
+    const rules = [];
+    
+    for (const [ruleId, preferences] of this.enginePreferences.entries()) {
+      if (preferences.includes(engineId)) {
+        const ruleInfo = this.getRuleInfo(ruleId);
+        if (ruleInfo) {
+          rules.push(ruleInfo);
+        }
+      }
+    }
+    
+    return rules;
+  }
+
+  /**
+   * Get all available rules
+   * Following Rule C006: Verb-noun naming
+   */
+  getAllRules() {
+    const rules = [];
+    
+    for (const ruleId of Object.keys(this.rulesRegistry)) {
+      const ruleInfo = this.getRuleInfo(ruleId);
+      if (ruleInfo) {
+        rules.push(ruleInfo);
+      }
+    }
+    
+    return rules;
+  }
+
+  /**
+   * Get rules with analyzers
+   * Following Rule C006: Verb-noun naming
+   */
+  getRulesWithAnalyzers() {
+    return this.getAllRules().filter(rule => rule.hasAnalyzer);
+  }
+
+  /**
+   * Get rules with AI context
+   * Following Rule C006: Verb-noun naming
+   */
+  getRulesWithAIContext() {
+    return this.getAllRules().filter(rule => rule.hasAIContext);
+  }
+
+  /**
+   * Get registry statistics
+   * Following Rule C006: Verb-noun naming
+   */
+  getRegistryStats() {
+    const allRules = this.getAllRules();
+    
+    return {
+      totalRules: allRules.length,
+      rulesWithAnalyzers: allRules.filter(r => r.hasAnalyzer).length,
+      rulesWithAIContext: allRules.filter(r => r.hasAIContext).length,
+      engineCoverage: {
+        heuristic: this.getRulesByEngine('heuristic').length,
+        openai: this.getRulesByEngine('openai').length,
+        eslint: this.getRulesByEngine('eslint').length
+      },
+      categories: this.getCategoryStats(allRules)
+    };
+  }
+
+  /**
+   * Get category statistics
+   * Following Rule C006: Verb-noun naming
+   */
+  getCategoryStats(rules) {
+    const categories = {};
+    
+    for (const rule of rules) {
+      if (!categories[rule.category]) {
+        categories[rule.category] = 0;
+      }
+      categories[rule.category]++;
+    }
+    
+    return categories;
+  }
+
+  /**
+   * Display registry overview
+   * Following Rule C006: Verb-noun naming
+   */
+  displayOverview(options = {}) {
+    if (!options.verbose) return;
+    
+    const stats = this.getRegistryStats();
+    
+    console.log(chalk.blue.bold('📊 Enhanced Rules Registry Overview'));
+    console.log(chalk.gray('='.repeat(50)));
+    console.log(chalk.green(`📋 Total Rules: ${stats.totalRules}`));
+    console.log(chalk.blue(`🔍 With Analyzers: ${stats.rulesWithAnalyzers}`));
+    console.log(chalk.cyan(`🤖 With AI Context: ${stats.rulesWithAIContext}`));
+    console.log();
+    
+    console.log(chalk.yellow('🎯 Engine Coverage:'));
+    Object.entries(stats.engineCoverage).forEach(([engine, count]) => {
+      console.log(`  • ${engine}: ${count} rules`);
+    });
+    console.log();
+    
+    console.log(chalk.yellow('📂 Categories:'));
+    Object.entries(stats.categories).forEach(([category, count]) => {
+      console.log(`  • ${category}: ${count} rules`);
+    });
+    console.log();
+  }
+}
+
+module.exports = EnhancedRulesRegistry;