@sun-asterisk/sunlint 1.2.2 → 1.3.1

package/config/rules/rules-registry.json

@@ -59,6 +59,18 @@
       "status": "experimental",
       "tags": ["validation", "separation", "architecture"]
     },
+    "C035": {
+      "name": "Error Logging Context",
+      "description": "Khi xử lý lỗi, phải ghi log đầy đủ thông tin liên quan - structured logging with context",
+      "category": "logging",
+      "severity": "warning",
+      "languages": ["typescript", "javascript"],
+      "analyzer": "./rules/common/C035_error_logging_context/analyzer.js",
+      "config": "./rules/common/C035_error_logging_context/config.json",
+      "version": "1.0.0",
+      "status": "experimental",
+      "tags": ["logging", "error-handling", "context", "structured-logging"]
+    },
     "C043": {
       "name": "No Console Or Print",
       "description": "Do not use console.log or print in production code",
@@ -651,7 +663,7 @@
     "quality": {
       "name": "Code Quality",
       "description": "Rules for code quality improvement",
-      "rules": ["C002", "C003", "C006", "C010", "C013", "C014", "C017", "C018", "C023", "C029", "C030", "C035", "C041", "C042", "C043", "C047", "C072", "C075", "C076", "T002", "T003", "T004", "T007", "T010", "T019", "T020", "T021", "R001", "R002", "R003", "R004", "R005", "R006"],
+      "rules": ["C002", "C003", "C006", "C010", "C013", "C014", "C017", "C018", "C023", "C029", "C030", "C035", "C041", "C042", "C043", "C047", "C072", "C075", "T002", "T003", "T004", "T007", "T010", "T019", "T020", "T021", "R001", "R002", "R003", "R004", "R005", "R006"],
       "severity": "warning"
     },
     "security": {

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;
       }
 
@@ -107,21 +109,29 @@ class CliActionHandler {
   }
 
   /**
-   * Run analysis with modern orchestrator
-   * Following Rule C006: Verb-noun naming
-   * Following Rule C012: Command Query Separation - analysis is a command
+   * Run analysis using modern orchestrator
    */
   async runModernAnalysis(rulesToRun, files, config) {
     if (this.isModernMode) {
       console.log(chalk.blue('🚀 Using modern engine architecture'));
       
-      // Initialize orchestrator with configuration
+      // Initialize orchestrator with configuration including targetFiles for optimization
       await this.orchestrator.initialize({
         enabledEngines: this.determineEnabledEngines(config),
         aiConfig: config.ai || {},
         eslintConfig: config.eslint || {},
-        heuristicConfig: config.heuristic || {}
+        heuristicConfig: { 
+          ...config.heuristic || {},
+          targetFiles: this.options.targetFiles,  // Pass filtered files for semantic optimization
+          maxSemanticFiles: this.options.maxSemanticFiles !== undefined ? parseInt(this.options.maxSemanticFiles) : 1000,  // Configurable semantic file limit
+          verbose: this.options.verbose  // Pass verbose for debugging
+        }
       });
+      
+      if (this.options.verbose) {
+        console.log(`🔧 Debug: maxSemanticFiles option = ${this.options.maxSemanticFiles}`);
+        console.log(`🔧 Debug: parsed maxSemanticFiles = ${this.options.maxSemanticFiles !== undefined ? parseInt(this.options.maxSemanticFiles) : 1000}`);
+      }
 
       // Run analysis with new orchestrator
       const results = await this.orchestrator.analyze(files, rulesToRun, {
@@ -129,22 +139,12 @@ 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
         }
       });
-
       return results;
-    } else {
-      console.log(chalk.yellow('🔄 Using legacy orchestrator'));
-      
-      // Ensure verbose/quiet flags are in config
-      const analysisConfig = {
-        ...config,
-        verbose: this.options.verbose,
-        quiet: this.options.quiet
-      };
-      
-      return await this.orchestrator.runAnalysis(rulesToRun, this.options, analysisConfig);
     }
   }
 
@@ -262,6 +262,17 @@ class CliActionHandler {
    * Following Rule C031: Separate validation logic
    */
   validateInput(config) {
+    // Validate engine option if specified (check this first, always)
+    if (this.options.engine) {
+      const validEngines = ['eslint', 'heuristic', 'openai'];
+      if (!validEngines.includes(this.options.engine)) {
+        throw new Error(
+          chalk.red(`❌ Invalid engine: ${this.options.engine}\n`) +
+          chalk.gray(`Valid engines: ${validEngines.join(', ')}`)
+        );
+      }
+    }
+
     // Priority 1: CLI --input parameter (highest priority)
     if (this.options.input) {
       // Validate CLI input path exists
@@ -296,17 +307,6 @@ class CliActionHandler {
       }
       return;
     }
-
-    // Validate engine option if specified
-    if (this.options.engine) {
-      const validEngines = ['eslint', 'sunlint', 'heuristic'];
-      if (!validEngines.includes(this.options.engine)) {
-        throw new Error(
-          chalk.red(`❌ Invalid engine: ${this.options.engine}\n`) +
-          chalk.gray(`Valid engines: ${validEngines.join(', ')}`)
-        );
-      }
-    }
   }
 
   /**
@@ -329,15 +329,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/cli-program.js

@@ -26,7 +26,7 @@ function createCliProgram() {
   // TypeScript specific options (Phase 1 focus)
   program
     .option('--typescript', 'Enable TypeScript-specific analysis')
-    .option('--typescript-engine <engine>', 'TypeScript analysis engine (eslint,sunlint,hybrid)', 'sunlint')
+    .option('--typescript-engine <engine>', 'TypeScript analysis engine (eslint,heuristic,hybrid)', 'heuristic')
     .option('--ensure-deps', 'Ensure ESLint dependencies are installed');
 
   // Input/Output options (v1.x: explicit --input required)
@@ -58,7 +58,7 @@ function createCliProgram() {
 
   // Advanced options
   program
-    .option('--engine <engine>', 'Force specific analysis engine (eslint,sunlint)', '')
+    .option('--engine <engine>', 'Force specific analysis engine (eslint,heuristic)', '')
     .option('--dry-run', 'Show what would be analyzed without running')
     .option('--verbose', 'Enable verbose logging')
     .option('--quiet', 'Suppress non-error output')
@@ -67,6 +67,7 @@ function createCliProgram() {
     .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('--max-semantic-files <number>', 'Control semantic analysis scope: 0=disable, -1=unlimited, >0=limit (default: 1000)', '1000')
     .option('--list-engines', 'List available analysis engines');
 
   // ESLint Integration options
@@ -107,7 +108,7 @@ Version Strategy:
 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
+  $ sunlint --all --input=src --engine=heuristic # Force Heuristic engine
 
 CI/CD Integration:
   $ sunlint --all --changed-files --format=summary --no-ai
@@ -127,6 +128,13 @@ Advanced File Targeting:
   $ sunlint --languages=typescript,dart --include="src/**,packages/**" --input=.
   $ sunlint --all --only-source --exclude-tests --languages=typescript --input=.
 
+Large Project Optimization:
+  $ sunlint --all --input=. --max-semantic-files=500    # Conservative analysis
+  $ sunlint --all --input=. --max-semantic-files=2000   # Comprehensive analysis  
+  $ sunlint --all --input=. --max-semantic-files=-1     # Unlimited (all files)
+  $ sunlint --all --input=. --max-semantic-files=0      # Disable semantic analysis
+  $ sunlint --all --changed-files --max-semantic-files=300  # Fast CI analysis
+
 Sun* Engineering - Coding Standards Made Simple ☀️
 `);
 

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;