@sun-asterisk/sunlint 1.2.2 → 1.3.0

package/core/adapters/sunlint-rule-adapter.js

@@ -1,4 +1,5 @@
 const { SimpleRuleParser } = require('../../rules/parser/rule-parser-simple');
+const { CATEGORY_PRINCIPLE_MAP, getCategoryPrinciples } = require('../constants/categories');
 const fs = require('fs');
 const path = require('path');
 
@@ -139,7 +140,23 @@ class SunlintRuleAdapter {
       return null;
     }
 
-    // Try registry first
+    // Normalize rule ID to uppercase for consistency
+    const normalizedRuleId = ruleId.toUpperCase();
+
+    // Try registry first with normalized ID
+    if (this.registryCache && this.registryCache[normalizedRuleId]) {
+      return this.normalizeRule({
+        id: normalizedRuleId,
+        ...this.registryCache[normalizedRuleId]
+      });
+    }
+
+    // Try cache with normalized ID
+    if (this.rulesCache.has(normalizedRuleId)) {
+      return this.rulesCache.get(normalizedRuleId);
+    }
+
+    // Also try original case for backward compatibility
     if (this.registryCache && this.registryCache[ruleId]) {
       return this.normalizeRule({
         id: ruleId,
@@ -147,7 +164,6 @@ class SunlintRuleAdapter {
       });
     }
 
-    // Try cache
     if (this.rulesCache.has(ruleId)) {
       return this.rulesCache.get(ruleId);
     }
@@ -225,20 +241,9 @@ class SunlintRuleAdapter {
    * Based on actual principles in the rule catalog
    */
   getRulesByStandardCategory(category) {
-    const categoryPrincipleMap = {
-      'security': ['SECURITY'],
-      'quality': ['CODE_QUALITY'],
-      'performance': ['PERFORMANCE'],
-      'maintainability': ['MAINTAINABILITY'],
-      'testability': ['TESTABILITY'],
-      'reliability': ['RELIABILITY'],
-      'design': ['DESIGN_PATTERNS'],
-      'integration': ['INTEGRATION'],
-      'usability': ['USABILITY']
-    };
-
-    const principles = categoryPrincipleMap[category.toLowerCase()];
-    if (!principles) {
+    // Use centralized mapping instead of hardcoded
+    const principles = getCategoryPrinciples(category);
+    if (!principles || principles.length === 0) {
       console.warn(`⚠️  Unknown category: ${category}`);
       return [];
     }
@@ -276,20 +281,10 @@ class SunlintRuleAdapter {
    */
   getStandardCategoryRules(category) {
     const coreRules = this.getCoreRules();
-    const categoryPrincipleMap = {
-      'security': ['SECURITY'],
-      'quality': ['CODE_QUALITY'],
-      'performance': ['PERFORMANCE'],
-      'maintainability': ['MAINTAINABILITY'],
-      'testability': ['TESTABILITY'],
-      'reliability': ['RELIABILITY'],
-      'design': ['DESIGN_PATTERNS'],
-      'integration': ['INTEGRATION'],
-      'usability': ['USABILITY']
-    };
-
-    const principles = categoryPrincipleMap[category.toLowerCase()];
-    if (!principles) {
+    
+    // Use centralized mapping
+    const principles = getCategoryPrinciples(category);
+    if (!principles || principles.length === 0) {
       console.warn(`⚠️  Unknown standard category: ${category}`);
       return [];
     }

package/core/analysis-orchestrator.js

@@ -233,6 +233,8 @@ class AnalysisOrchestrator {
    */
   groupRulesByEngine(rulesToRun, config) {
     const groups = new Map();
+    const skippedRules = [];
+    
     if (config.verbose) {
       console.log(`📊 [Orchestrator] Grouping ${rulesToRun.length} rules by engine...`);
     }
@@ -249,6 +251,16 @@ class AnalysisOrchestrator {
       }
       
       const selectedEngine = this.selectBestEngine(enginePreference, rule, config);
+      
+      // If rule is skipped (no engine supports it when specific engine requested)
+      if (selectedEngine === null) {
+        skippedRules.push(rule);
+        if (config.verbose) {
+          console.log(`⚠️ [Orchestrator] Skipped rule ${rule.id} - not supported by requested engine`);
+        }
+        continue;
+      }
+      
       if (config.verbose) {
         console.log(`✅ [Orchestrator] Selected engine for ${rule.id}: ${selectedEngine}`);
       }
@@ -259,6 +271,12 @@ class AnalysisOrchestrator {
       groups.get(selectedEngine).push(rule);
     }
     
+    // Report skipped rules if any
+    if (skippedRules.length > 0) {
+      const skippedRuleIds = skippedRules.map(r => r.id).join(', ');
+      console.warn(`⚠️ [Orchestrator] Skipped ${skippedRules.length} rules not supported by requested engine: ${skippedRuleIds}`);
+    }
+    
     if (config.verbose) {
       console.log(`📋 [Orchestrator] Final groups:`, Array.from(groups.entries()).map(([k, v]) => [k, v.length]));
     }
@@ -273,6 +291,16 @@ class AnalysisOrchestrator {
    * @returns {string[]} Array of engine names in preference order
    */
   getEnginePreference(rule, config) {
+    // If user specified a specific engine via --engine option, use only that engine
+    if (config.requestedEngine) {
+      return [config.requestedEngine];
+    }
+
+    // Special preference for C047: Always use semantic analysis (heuristic engine)
+    if (rule.id === 'C047') {
+      return ['heuristic', 'openai'];
+    }
+
     // Check config-level rule preferences
     const ruleConfig = config.rules?.[rule.id];
     if (ruleConfig?.engines) {
@@ -306,13 +334,17 @@ class AnalysisOrchestrator {
    * @param {string[]} preferences - Engine preferences in order
    * @param {Object} rule - Rule object
    * @param {Object} config - Configuration with verbose flag
-   * @returns {string} Selected engine name
+   * @returns {string|null} Selected engine name or null if no engine supports the rule
    */
   selectBestEngine(preferences, rule, config) {
     if (config.verbose) {
       console.log(`🎯 [Orchestrator] Selecting engine for rule ${rule.id}, preferences:`, preferences);
     }
     
+    // If user specified a specific engine (--engine=eslint), only use that engine
+    // Don't fallback to other engines to maintain consistency
+    const isSpecificEngineRequested = config.requestedEngine && preferences.length === 1;
+    
     for (const engineName of preferences) {
       const engine = this.engines.get(engineName);
       if (config.verbose) {
@@ -327,11 +359,19 @@ class AnalysisOrchestrator {
       }
     }
     
+    // If specific engine is requested and it doesn't support the rule, skip fallback
+    if (isSpecificEngineRequested) {
+      if (config.verbose) {
+        console.log(`⚠️ [Orchestrator] Rule ${rule.id} not supported by requested engine ${preferences[0]}, skipping`);
+      }
+      return null; // Skip this rule
+    }
+    
     if (config.verbose) {
       console.log(`🔄 [Orchestrator] No preferred engine supports ${rule.id}, checking all engines...`);
     }
     
-    // Fallback to first available engine that supports the rule
+    // Fallback to first available engine that supports the rule (only when no specific engine requested)
     for (const [engineName, engine] of this.engines) {
       if (config.verbose) {
         console.log(`🔍 [Orchestrator] Fallback checking engine ${engineName}`);

package/core/categories.js

@@ -0,0 +1,52 @@
+/**
+ * SunLint Categories - Legacy Module
+ * @deprecated This module is deprecated. Use core/constants/categories.js instead.
+ * Maintained for backward compatibility only.
+ */
+
+// Import from the new centralized constants
+const {
+  SUNLINT_PRINCIPLES,
+  CATEGORY_PRINCIPLE_MAP,
+  CATEGORY_DESCRIPTIONS,
+  getValidCategories,
+  getCategoryPrinciples,
+  isValidCategory,
+  getCategoryDescription,
+  getDefaultCategory,
+  normalizeCategory,
+  getCategoryForPrinciple,
+  addCategoryMapping,
+  getCategoryStats
+} = require('./constants/categories');
+
+// Legacy constants for backward compatibility
+const SUNLINT_CATEGORIES = {
+  CODE_QUALITY: 'quality',
+  DESIGN_PATTERNS: 'design', 
+  INTEGRATION: 'integration',
+  MAINTAINABILITY: 'maintainability',
+  PERFORMANCE: 'performance',
+  RELIABILITY: 'reliability',
+  SECURITY: 'security',
+  TESTABILITY: 'testability',
+  USABILITY: 'usability'
+};
+
+module.exports = {
+  // Legacy exports (for backward compatibility)
+  SUNLINT_CATEGORIES,
+  CATEGORY_DESCRIPTIONS,
+  CATEGORY_PRINCIPLE_MAP,
+  
+  // Function exports (now from centralized source)
+  isValidCategory,
+  getValidCategories,
+  getCategoryDescription,
+  getCategoryPrinciples,
+  
+  // New exports from centralized system
+  SUNLINT_PRINCIPLES,
+  getDefaultCategory,
+  normalizeCategory
+};

package/core/category-constants.js

@@ -0,0 +1,39 @@
+/**
+ * SunLint Category Constants - Legacy Proxy
+ * @deprecated This file is deprecated. Use core/constants/categories.js instead.
+ * Maintained for backward compatibility only.
+ */
+
+// Import from the new centralized location
+const {
+  SUNLINT_PRINCIPLES,
+  CATEGORY_PRINCIPLE_MAP,
+  CATEGORY_DESCRIPTIONS,
+  getValidCategories,
+  getCategoryPrinciples,
+  isValidCategory,
+  getCategoryDescription,
+  getDefaultCategory,
+  normalizeCategory,
+  getCategoryForPrinciple,
+  addCategoryMapping,
+  getCategoryStats
+} = require('./constants/categories');
+
+module.exports = {
+  // Constants
+  SUNLINT_PRINCIPLES,
+  CATEGORY_PRINCIPLE_MAP,
+  CATEGORY_DESCRIPTIONS,
+  
+  // Utility functions
+  getValidCategories,
+  getCategoryPrinciples,
+  isValidCategory,
+  getCategoryDescription,
+  getDefaultCategory,
+  normalizeCategory,
+  getCategoryForPrinciple,
+  addCategoryMapping,
+  getCategoryStats
+};

package/core/cli-action-handler.js

@@ -49,7 +49,9 @@ class CliActionHandler {
 
       // Show dry run preview if requested
       if (this.options.dryRun) {
-        await this.showDryRunPreview(config);
+        // We need to get rules first for accurate dry run info
+        const rulesToRun = await this.ruleSelectionService.selectRules(config, this.options);
+        await this.showDryRunPreview(config, rulesToRun);
         return;
       }
 
@@ -129,7 +131,9 @@ class CliActionHandler {
         config: {
           ...config,
           verbose: this.options.verbose,
-          quiet: this.options.quiet
+          quiet: this.options.quiet,
+          // Pass requested engine to enable strict engine mode (no fallback)
+          requestedEngine: this.options.engine
         }
       });
 
@@ -141,7 +145,9 @@ class CliActionHandler {
       const analysisConfig = {
         ...config,
         verbose: this.options.verbose,
-        quiet: this.options.quiet
+        quiet: this.options.quiet,
+        // Pass requested engine to enable strict engine mode (no fallback)
+        requestedEngine: this.options.engine
       };
       
       return await this.orchestrator.runAnalysis(rulesToRun, this.options, analysisConfig);
@@ -329,15 +335,36 @@ class CliActionHandler {
     }
   }
 
+  /**
+   * Get preset name based on CLI options
+   */
+  getPresetName() {
+    if (this.options.all) return 'all preset';
+    if (this.options.quality) return 'quality preset';
+    if (this.options.security) return 'security preset';
+    if (this.options.category) return `${this.options.category} preset`;
+    if (this.options.rule) return 'single rule';
+    if (this.options.rules) return 'multiple rules';
+    return 'config-based';
+  }
+
   /**
    * Show dry run preview
    * Following Rule C006: Verb-noun naming
    */
-  async showDryRunPreview(config) {
+  async showDryRunPreview(config, rulesToRun = null) {
     console.log(chalk.blue('🔍 Dry Run Preview'));
     console.log(chalk.gray('This would analyze the following configuration:'));
+    
+    let rulesInfo;
+    if (rulesToRun) {
+      rulesInfo = `${rulesToRun.length} rules (${this.getPresetName()})`;
+    } else {
+      rulesInfo = this.options.rules || 'config-based';
+    }
+    
     console.log(JSON.stringify({
-      rules: this.options.rules || 'all',
+      rules: rulesInfo,
       files: this.options.targetFiles?.length || 'auto-detected',
       engines: this.determineEnabledEngines(config),
       mode: this.isModernMode ? 'modern' : 'legacy'

package/core/config-manager.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const chalk = require('chalk');
 const os = require('os');
+const { minimatch } = require('minimatch');
 
 // Rule C014: Dependency injection instead of direct instantiation
 const ConfigSourceLoader = require('./config-source-loader');
@@ -240,6 +241,19 @@ class ConfigManager {
     // 10. Validate config
     this.validator.validateConfiguration(config);
 
+    // 11. Add metadata for enhanced file targeting
+    const analysisScope = this.determineAnalysisScope(cliOptions.input);
+    config._metadata = {
+      analysisScope: analysisScope,
+      shouldBypassProjectDiscovery: this.shouldBypassProjectDiscovery(analysisScope, cliOptions),
+      targetInput: cliOptions.input,
+      hasCliRules: this.hasRuleConfigInCLI(cliOptions)
+    };
+
+    if (cliOptions.verbose) {
+      console.log(chalk.gray(`📋 Enhanced Config: Scope=${analysisScope}, Bypass=${config._metadata.shouldBypassProjectDiscovery}`));
+    }
+
     return config;
   }
 
@@ -500,6 +514,103 @@ class ConfigManager {
   validateConfig(config) {
     return this.validator.validateConfiguration(config);
   }
+
+  /**
+   * ENHANCED CONFIG STRATEGY METHODS
+   * ================================
+   */
+
+  /**
+   * Determine if CLI has rule configuration
+   */
+  hasRuleConfigInCLI(cliOptions) {
+    return !!(
+      cliOptions.rule ||
+      cliOptions.rules ||
+      cliOptions.all ||
+      cliOptions.quality ||
+      cliOptions.security ||
+      cliOptions.category
+    );
+  }
+
+  /**
+   * Determine analysis scope based on input
+   */
+  determineAnalysisScope(inputPath) {
+    if (!inputPath) return 'project';
+    
+    const resolvedPath = path.resolve(inputPath);
+    
+    if (!fs.existsSync(resolvedPath)) {
+      return 'project'; // Fallback for non-existent paths
+    }
+    
+    const stat = fs.statSync(resolvedPath);
+    
+    if (stat.isFile()) {
+      return 'file';
+    } else if (stat.isDirectory()) {
+      // More specific logic for directory scope
+      const currentDir = process.cwd();
+      
+      // If input is current directory, it's project scope
+      if (path.resolve(inputPath) === currentDir) {
+        return 'project';
+      }
+      
+      // If input is a project root (has project markers), it's project scope
+      if (this.isProjectRoot(resolvedPath)) {
+        return 'project';
+      }
+      
+      // Otherwise it's folder scope
+      return 'folder';
+    }
+    
+    return 'project';
+  }
+
+  /**
+   * Check if directory is a project root
+   */
+  isProjectRoot(dirPath) {
+    const projectMarkers = [
+      'package.json',
+      'pubspec.yaml',
+      'build.gradle',
+      'build.gradle.kts',
+      'pom.xml',
+      'Cargo.toml',
+      'go.mod',
+      '.git',
+      'tsconfig.json',
+      'angular.json',
+      'next.config.js',
+      'nuxt.config.js'
+    ];
+    
+    return projectMarkers.some(marker => 
+      fs.existsSync(path.join(dirPath, marker))
+    );
+  }
+
+  /**
+   * Determine if project discovery should be bypassed for performance
+   */
+  shouldBypassProjectDiscovery(analysisScope, cliOptions) {
+    // Single file input - always bypass
+    if (analysisScope === 'file') {
+      return true;
+    }
+    
+    // Folder scope (not project root) and has CLI rules - target folder only
+    if (analysisScope === 'folder' && this.hasRuleConfigInCLI(cliOptions)) {
+      return true;
+    }
+    
+    return false; // Use project-wide discovery
+  }
 }
 
 module.exports = ConfigManager;

package/core/config-merger.js

@@ -1,3 +1,6 @@
+const { minimatch } = require('minimatch');
+const chalk = require('chalk');
+
 /**
  * Handles configuration merging and CLI overrides
  * Rule C005: Single responsibility - chỉ merge và override config
@@ -89,6 +92,11 @@ class ConfigMerger {
     // Performance overrides
     overrides.performance = this.applyPerformanceOverrides(overrides.performance, options);
 
+    // Auto-expand include patterns if input doesn't match any existing patterns
+    const expandedOverrides = this.autoExpandIncludePatterns(overrides, options);
+    // Copy expanded properties back to overrides
+    Object.assign(overrides, expandedOverrides);
+
     return overrides;
   }
 
@@ -161,6 +169,59 @@ class ConfigMerger {
     return updatedConfig;
   }
 
+  /**
+   * Rule C006: autoExpandIncludePatterns - verb-noun naming
+   * Rule C005: Single responsibility - auto-expand include patterns for input paths
+   */
+  autoExpandIncludePatterns(config, options) {
+    if (!options.input) {
+      return config;
+    }
+
+    const result = { ...config };
+    const inputPaths = Array.isArray(options.input) ? options.input : [options.input];
+    const currentInclude = result.include || [];
+    
+    console.log(chalk.gray(`🔍 AUTO-EXPANSION: Checking input paths: ${inputPaths.join(', ')}`));
+    console.log(chalk.gray(`🔍 AUTO-EXPANSION: Current include patterns: ${currentInclude.join(', ')}`));
+    
+    let needsExpansion = false;
+    for (const inputPath of inputPaths) {
+      const matchesExisting = currentInclude.some(pattern => {
+        const match1 = minimatch(inputPath, pattern);
+        const match2 = minimatch(inputPath + '/**', pattern);
+        const match3 = minimatch('**/' + inputPath, pattern);
+        const match4 = minimatch('**/' + inputPath + '/**', pattern);
+        
+        console.log(chalk.gray(`  AUTO-EXPANSION: ${inputPath} vs ${pattern}: ${match1 || match2 || match3 || match4}`));
+        
+        return match1 || match2 || match3 || match4;
+      });
+      
+      if (!matchesExisting) {
+        needsExpansion = true;
+        console.log(chalk.gray(`  🔄 AUTO-EXPANSION: ${inputPath} needs expansion`));
+        break;
+      }
+    }
+    
+    if (needsExpansion) {
+      // Add flexible patterns for input paths
+      const expandedInclude = [...currentInclude];
+      for (const inputPath of inputPaths) {
+        expandedInclude.push(inputPath + '/**');
+        expandedInclude.push('**/' + inputPath + '/**');
+      }
+      result.include = expandedInclude;
+      
+      console.log(chalk.gray(`📁 AUTO-EXPANSION: Auto-expanded include patterns: ${expandedInclude.join(', ')}`));
+    } else {
+      console.log(chalk.gray(`✅ AUTO-EXPANSION: No expansion needed`));
+    }
+
+    return result;
+  }
+
   /**
    * Rule C006: processIgnorePatterns - verb-noun naming
    * Convert deprecated ignorePatterns to exclude for backward compatibility