@sun-asterisk/sunlint 1.3.1 → 1.3.3

package/config/rules/rules-registry-generated.json

@@ -441,7 +441,7 @@
     },
     "C019": {
       "name": "Do not use `error` log level for non-critical issues",
-      "description": "Avoid noisy logs and false alarms; ensure meaningful log levels.",
+      "description": "Prevent noisy logs and false alarms; ensure consistent and meaningful log levels across the system.",
       "category": "Common",
       "severity": "major",
       "languages": [

package/core/analysis-orchestrator.js

@@ -10,6 +10,7 @@ const path = require('path');
 const fs = require('fs');
 const AnalysisEngineInterface = require('./interfaces/analysis-engine.interface');
 const SunlintRuleAdapter = require('./adapters/sunlint-rule-adapter');
+const PerformanceOptimizer = require('./performance-optimizer');
 
 class AnalysisOrchestrator {
   constructor() {
@@ -18,6 +19,7 @@ class AnalysisOrchestrator {
     this.defaultTimeout = 30000; // 30 seconds default timeout
     this.ruleAdapter = SunlintRuleAdapter.getInstance();
     this.enginesConfigPath = path.join(__dirname, '..', 'config', 'engines', 'engines.json');
+    this.performanceOptimizer = new PerformanceOptimizer();
   }
 
   /**
@@ -171,14 +173,35 @@ class AnalysisOrchestrator {
         throw new Error('No analysis engines registered');
       }
 
+      // Initialize performance optimizer
+      await this.performanceOptimizer.initialize(config);
+
+      // Apply performance optimizations to files and rules
+      const { optimizedFiles, optimizedRules, performanceMetrics } = 
+        await this.performanceOptimizer.optimizeAnalysis(
+          options.files || [options.input], 
+          rulesToRun, 
+          config
+        );
+
+      if (!options.quiet) {
+        console.log(chalk.cyan(`🔍 Analyzing ${optimizedRules.length} rules on ${optimizedFiles.length} files...`));
+        if (performanceMetrics.filteredFiles > 0) {
+          console.log(chalk.gray(`   📦 Filtered ${performanceMetrics.filteredFiles} files for performance`));
+        }
+        if (performanceMetrics.ruleBatches > 1) {
+          console.log(chalk.gray(`   🔄 Using ${performanceMetrics.ruleBatches} rule batches`));
+        }
+      }
+
       // Group rules by their preferred engines
-      const engineGroups = this.groupRulesByEngine(rulesToRun, config);
+      const engineGroups = this.groupRulesByEngine(optimizedRules, config);
       
       if (!options.quiet) {
-        console.log(chalk.cyan(`🔍 Analyzing ${rulesToRun.length} rules across ${engineGroups.size} engines...`));
+        console.log(chalk.cyan(`🚀 Running analysis across ${engineGroups.size} engines...`));
       }
 
-      // Run analysis on each engine
+      // Run analysis on each engine with batching
       const results = [];
       for (const [engineName, rules] of engineGroups) {
         const engine = this.engines.get(engineName);
@@ -187,35 +210,64 @@ class AnalysisOrchestrator {
           continue;
         }
 
-        if (!options.quiet) {
-          console.log(chalk.blue(`⚙️ Running ${rules.length} rules on ${engineName} engine...`));
-        }
-
-        try {
-          const engineResult = await this.runEngineWithTimeout(
-            engine, 
-            options.files || [options.input], 
-            rules, 
-            options
-          );
-          
-          results.push({
-            engine: engineName,
-            rules: rules.map(r => r.id),
-            ...engineResult
-          });
+        // Process rules in batches for performance
+        const ruleBatches = this.performanceOptimizer.createRuleBatches(rules, config);
+        
+        for (let i = 0; i < ruleBatches.length; i++) {
+          const batch = ruleBatches[i];
+          const batchNumber = i + 1;
           
-          if (!options.quiet) {
-            const violationCount = this.countViolations(engineResult);
-            console.log(chalk.blue(`✅ ${engineName}: ${violationCount} violations found`));
+          if (!options.quiet && ruleBatches.length > 1) {
+            console.log(chalk.blue(`⚙️ ${engineName} - Batch ${batchNumber}/${ruleBatches.length}: ${batch.length} rules`));
+          } else if (!options.quiet) {
+            console.log(chalk.blue(`⚙️ Running ${batch.length} rules on ${engineName} engine...`));
+          }
+
+          try {
+            const engineResult = await this.runEngineWithOptimizations(
+              engine, 
+              optimizedFiles, 
+              batch, 
+              options,
+              { batchNumber, totalBatches: ruleBatches.length }
+            );
+            
+            results.push({
+              engine: engineName,
+              batch: batchNumber,
+              rules: batch.map(r => r.id),
+              ...engineResult
+            });
+            
+            if (!options.quiet) {
+              const violationCount = this.countViolations(engineResult);
+              console.log(chalk.blue(`✅ ${engineName} batch ${batchNumber}: ${violationCount} violations found`));
+            }
+          } catch (error) {
+            // Enhanced error recovery with batch context
+            const errorInfo = this.performanceOptimizer.handleAnalysisError(error, {
+              engine: engineName,
+              batch: batchNumber,
+              rules: batch.map(r => r.id),
+              files: optimizedFiles.length
+            });
+            
+            console.error(chalk.red(`❌ Engine ${engineName} batch ${batchNumber} failed:`), errorInfo.message);
+            
+            if (errorInfo.shouldRetry && !options.noRetry) {
+              console.log(chalk.yellow(`🔄 Retrying with reduced batch size...`));
+              // Split batch and retry - implement recursive retry logic here
+            }
+            // Continue with other batches instead of failing completely
           }
-        } catch (error) {
-          console.error(chalk.red(`❌ Engine ${engineName} failed:`), error.message);
-          // Continue with other engines instead of failing completely
         }
       }
 
-      return this.mergeEngineResults(results, options);
+      // Merge results and add performance metrics
+      const mergedResults = this.mergeEngineResults(results, options);
+      mergedResults.performance = performanceMetrics;
+      
+      return mergedResults;
       
     } catch (error) {
       console.error(chalk.red('❌ Analysis orchestration failed:'), error.message);
@@ -393,23 +445,68 @@ class AnalysisOrchestrator {
   }
 
   /**
-   * Run engine analysis with timeout protection
+   * Run engine analysis with timeout protection and performance optimizations
    * Following Rule C006: Verb-noun naming
    * @param {AnalysisEngineInterface} engine - Engine to run
    * @param {string[]} files - Files to analyze
    * @param {Object[]} rules - Rules to apply
    * @param {Object} options - Analysis options
+   * @param {Object} batchInfo - Batch context information
    * @returns {Promise<Object>} Engine results
    */
-  async runEngineWithTimeout(engine, files, rules, options) {
-    const timeout = options.timeout || this.defaultTimeout;
+  async runEngineWithOptimizations(engine, files, rules, options, batchInfo = {}) {
+    // Dynamic timeout based on file count and rules
+    const adaptiveTimeout = this.performanceOptimizer.calculateAdaptiveTimeout(
+      files.length, 
+      rules.length, 
+      options.timeout || this.defaultTimeout
+    );
     
-    return Promise.race([
-      engine.analyze(files, rules, options),
-      new Promise((_, reject) => 
-        setTimeout(() => reject(new Error(`Engine ${engine.name} timed out after ${timeout}ms`)), timeout)
-      )
-    ]);
+    const enhancedOptions = {
+      ...options,
+      timeout: adaptiveTimeout,
+      batchInfo
+    };
+
+    try {
+      return await Promise.race([
+        engine.analyze(files, rules, enhancedOptions),
+        new Promise((_, reject) => 
+          setTimeout(() => reject(new Error(
+            `Engine ${engine.name} batch ${batchInfo.batchNumber || 1} timed out after ${adaptiveTimeout}ms`
+          )), adaptiveTimeout)
+        )
+      ]);
+    } catch (error) {
+      // Enhanced error context for debugging
+      const errorContext = {
+        engine: engine.name,
+        filesCount: files.length,
+        rulesCount: rules.length,
+        timeout: adaptiveTimeout,
+        batch: batchInfo
+      };
+      
+      // Wrap error with context
+      const enhancedError = new Error(`${error.message} (Context: ${JSON.stringify(errorContext)})`);
+      enhancedError.originalError = error;
+      enhancedError.context = errorContext;
+      
+      throw enhancedError;
+    }
+  }
+
+  /**
+   * Run engine analysis with timeout protection (legacy method for backward compatibility)
+   * Following Rule C006: Verb-noun naming
+   * @param {AnalysisEngineInterface} engine - Engine to run
+   * @param {string[]} files - Files to analyze
+   * @param {Object[]} rules - Rules to apply
+   * @param {Object} options - Analysis options
+   * @returns {Promise<Object>} Engine results
+   */
+  async runEngineWithTimeout(engine, files, rules, options) {
+    return this.runEngineWithOptimizations(engine, files, rules, options);
   }
 
   /**
@@ -425,6 +522,7 @@ class AnalysisOrchestrator {
       results: [],
       summary: {
         totalEngines: engineResults.length,
+        totalBatches: engineResults.length,
         totalViolations: 0,
         totalFiles: 0,
         engines: {}
@@ -436,8 +534,13 @@ class AnalysisOrchestrator {
       }
     };
 
+    // Track unique engines for summary
+    const uniqueEngines = new Set();
+
     // Combine results from all engines
     for (const engineResult of engineResults) {
+      uniqueEngines.add(engineResult.engine);
+      
       // Add engine-specific results
       if (engineResult.results) {
         mergedResults.results.push(...engineResult.results);
@@ -445,16 +548,30 @@ class AnalysisOrchestrator {
       
       // Track engine statistics
       const violationCount = this.countViolations(engineResult);
-      mergedResults.summary.engines[engineResult.engine] = {
-        rules: engineResult.rules || [],
-        violations: violationCount,
-        files: engineResult.filesAnalyzed || 0
-      };
+      const engineName = engineResult.engine;
+      
+      if (!mergedResults.summary.engines[engineName]) {
+        mergedResults.summary.engines[engineName] = {
+          rules: [],
+          violations: 0,
+          files: 0,
+          batches: 0
+        };
+      }
+      
+      // Accumulate engine statistics across batches
+      mergedResults.summary.engines[engineName].rules.push(...(engineResult.rules || []));
+      mergedResults.summary.engines[engineName].violations += violationCount;
+      mergedResults.summary.engines[engineName].files += engineResult.filesAnalyzed || 0;
+      mergedResults.summary.engines[engineName].batches += 1;
       
       mergedResults.summary.totalViolations += violationCount;
       mergedResults.summary.totalFiles += engineResult.filesAnalyzed || 0;
     }
 
+    // Update unique engine count
+    mergedResults.summary.totalEngines = uniqueEngines.size;
+
     return mergedResults;
   }
 
@@ -517,7 +634,7 @@ class AnalysisOrchestrator {
   }
 
   /**
-   * Cleanup all engines
+   * Cleanup all engines and performance optimizer
    * Following Rule C006: Verb-noun naming
    * @returns {Promise<void>}
    */
@@ -529,6 +646,14 @@ class AnalysisOrchestrator {
         console.warn(chalk.yellow(`⚠️ Failed to cleanup engine ${engine.id}:`), error.message);
       }
     }
+    
+    // Cleanup performance optimizer
+    try {
+      await this.performanceOptimizer.cleanup();
+    } catch (error) {
+      console.warn(chalk.yellow(`⚠️ Failed to cleanup performance optimizer:`), error.message);
+    }
+    
     this.initialized = false;
     console.log(chalk.blue('🧹 Engine cleanup completed'));
   }

package/core/auto-performance-manager.js

@@ -0,0 +1,243 @@
+/**
+ * 🚀 Auto Performance Manager for SunLint
+ * Automatically detects optimal performance settings based on project characteristics
+ * GOAL: Simplify CLI by reducing user choices while maintaining performance
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class AutoPerformanceManager {
+  constructor() {
+    // Smart defaults based on project analysis
+    this.performanceProfiles = {
+      auto: {
+        name: 'Auto-Detect',
+        detect: true,
+        description: 'Automatically choose best settings based on project size'
+      },
+      fast: {
+        name: 'Fast',
+        timeout: 30000,        // 30s
+        batchSize: 20,
+        maxFiles: 500,
+        description: 'Quick analysis for small projects (<100 files)'
+      },
+      careful: {
+        name: 'Careful', 
+        timeout: 120000,       // 2 minutes
+        batchSize: 10,
+        maxFiles: 1500,
+        progressiveResults: true,
+        description: 'Thorough analysis for large projects (>500 files)'
+      }
+    };
+  }
+
+  /**
+   * 🎯 Get optimal performance settings with minimal user input
+   * Clarifies the difference between max-files and max-semantic-files:
+   * - max-files: Total files to analyze (performance limit)
+   * - max-semantic-files: Files to load into TypeScript symbol table (memory limit)
+   */
+  getOptimalSettings(options, targetFiles = []) {
+    const mode = options.performance || 'auto';
+    
+    if (mode === 'auto') {
+      return this.autoDetectSettings(options, targetFiles);
+    }
+    
+    return this.getProfileSettings(mode, options);
+  }
+
+  /**
+   * 🤖 Auto-detect optimal settings based on project characteristics
+   */
+  autoDetectSettings(options, targetFiles) {
+    const projectAnalysis = this.analyzeProject(options, targetFiles);
+    const profile = this.selectOptimalProfile(projectAnalysis);
+    
+    if (options.verbose) {
+      console.log(`🤖 Auto-detected performance profile: ${profile.name}`);
+      console.log(`   📊 Project: ${projectAnalysis.fileCount} files, ${projectAnalysis.size} size`);
+      console.log(`   ⚡ Settings: ${profile.timeout/1000}s timeout, ${profile.batchSize} rules/batch`);
+    }
+    
+    return {
+      ...profile,
+      autoDetected: true,
+      projectAnalysis
+    };
+  }
+
+  /**
+   * 📊 Analyze project to determine optimal settings
+   */
+  analyzeProject(options, targetFiles) {
+    const fileCount = targetFiles.length;
+    const inputPath = options.input || process.cwd();
+    
+    // Estimate project complexity
+    const hasNodeModules = fs.existsSync(path.join(inputPath, 'node_modules'));
+    const hasPackageJson = fs.existsSync(path.join(inputPath, 'package.json'));
+    const hasTsConfig = fs.existsSync(path.join(inputPath, 'tsconfig.json'));
+    const hasGitIgnore = fs.existsSync(path.join(inputPath, '.gitignore'));
+    
+    // Simple heuristics for project size
+    let size = 'small';
+    let complexity = 'simple';
+    
+    if (fileCount > 1000) {
+      size = 'enterprise';
+      complexity = 'complex';
+    } else if (fileCount > 500) {
+      size = 'large';
+      complexity = hasNodeModules && hasTsConfig ? 'complex' : 'medium';
+    } else if (fileCount > 100) {
+      size = 'medium';
+      complexity = hasTsConfig ? 'medium' : 'simple';
+    }
+    
+    return {
+      fileCount,
+      size,
+      complexity,
+      hasNodeModules,
+      hasPackageJson,
+      hasTsConfig,
+      hasGitIgnore,
+      inputPath
+    };
+  }
+
+  /**
+   * 🎯 Select optimal profile based on project analysis
+   */
+  selectOptimalProfile(analysis) {
+    if (analysis.fileCount <= 100) {
+      return {
+        name: 'Auto-Fast',
+        timeout: 30000,
+        batchSize: 20,
+        maxFiles: 200,                    // Analysis limit
+        maxSemanticFiles: 100,            // Symbol table limit (smaller for memory)
+        description: `Small project (${analysis.fileCount} files) - fast analysis`
+      };
+    }
+    
+    if (analysis.fileCount <= 500) {
+      return {
+        name: 'Auto-Balanced',
+        timeout: 60000,
+        batchSize: 15,
+        maxFiles: 600,                    // Analysis limit
+        maxSemanticFiles: 300,            // Symbol table limit
+        progressiveResults: true,
+        description: `Medium project (${analysis.fileCount} files) - balanced analysis`
+      };
+    }
+    
+    if (analysis.fileCount <= 1000) {
+      return {
+        name: 'Auto-Careful',
+        timeout: 120000,
+        batchSize: 10,
+        maxFiles: 1200,                   // Analysis limit
+        maxSemanticFiles: 500,            // Symbol table limit
+        progressiveResults: true,
+        streamingAnalysis: analysis.complexity === 'complex',
+        description: `Large project (${analysis.fileCount} files) - careful analysis`
+      };
+    }
+    
+    // Enterprise projects
+    return {
+      name: 'Auto-Enterprise',
+      timeout: 300000,
+      batchSize: 5,
+      maxFiles: 1500,                     // Analysis limit
+      maxSemanticFiles: 300,              // Conservative symbol table limit
+      progressiveResults: true,
+      streamingAnalysis: true,
+      smartSampling: true,
+      description: `Enterprise project (${analysis.fileCount} files) - conservative analysis`
+    };
+  }
+
+  /**
+   * ⚙️ Get predefined profile settings
+   */
+  getProfileSettings(mode, options) {
+    const profile = this.performanceProfiles[mode];
+    
+    if (!profile) {
+      console.warn(`⚠️  Unknown performance mode: ${mode}, using auto-detect`);
+      return this.autoDetectSettings(options, []);
+    }
+    
+    // Override with user-specified options
+    const settings = { ...profile };
+    
+    if (options.timeout && options.timeout !== '0') {
+      settings.timeout = parseInt(options.timeout);
+    }
+    
+    if (options.maxFiles && options.maxFiles !== '1000') {
+      settings.maxFiles = parseInt(options.maxFiles);
+    }
+    
+    return settings;
+  }
+
+  /**
+   * 📋 Get user-friendly performance recommendations
+   */
+  getPerformanceRecommendations(options, targetFiles) {
+    const analysis = this.analyzeProject(options, targetFiles);
+    const profile = this.selectOptimalProfile(analysis);
+    
+    const recommendations = [
+      `🎯 Recommended: sunlint --all --input=${options.input || 'src'} --performance=auto`
+    ];
+    
+    if (analysis.fileCount > 500) {
+      recommendations.push(`💡 For faster results: sunlint --all --input=${options.input || 'src'} --performance=fast --max-files=300`);
+    }
+    
+    if (analysis.complexity === 'complex') {
+      recommendations.push(`⚡ For thorough analysis: sunlint --all --input=${options.input || 'src'} --performance=careful --verbose`);
+    }
+    
+    return {
+      analysis,
+      profile,
+      recommendations
+    };
+  }
+
+  /**
+   * 🎛️ Show simplified CLI usage for common scenarios
+   */
+  static getSimplifiedUsageExamples() {
+    return {
+      quickStart: [
+        'sunlint --all --input=src',                           // Auto-detect everything
+        'sunlint --rules=C019,C041,S027 --input=src',        // Specific rules
+        'sunlint --quality --input=src'                       // Quality rules only
+      ],
+      performance: [
+        'sunlint --all --input=src --performance=auto',       // Auto-detect (default)
+        'sunlint --all --input=src --performance=fast',       // Quick scan
+        'sunlint --all --input=src --performance=careful',    // Thorough analysis
+        'sunlint --all --input=src --timeout=60000'           // Custom timeout
+      ],
+      advanced: [
+        'sunlint --all --input=src --verbose',                // See detailed progress
+        'sunlint --all --input=src --dry-run',               // Preview analysis
+        'sunlint --all --input=src --format=json'            // JSON output
+      ]
+    };
+  }
+}
+
+module.exports = AutoPerformanceManager;

package/core/cli-action-handler.js

@@ -136,12 +136,20 @@ class CliActionHandler {
       // Run analysis with new orchestrator
       const results = await this.orchestrator.analyze(files, rulesToRun, {
         ...this.options,
+        timeout: parseInt(this.options.timeout) || 30000,
         config: {
           ...config,
           verbose: this.options.verbose,
           quiet: this.options.quiet,
           // Pass requested engine to enable strict engine mode (no fallback)
-          requestedEngine: this.options.engine
+          requestedEngine: this.options.engine,
+          // Performance optimization settings
+          performanceMode: this.options.performanceMode,
+          ruleBatchSize: parseInt(this.options.ruleBatchSize) || 10,
+          fileBatchSize: parseInt(this.options.fileBatchSize) || 50,
+          maxFiles: parseInt(this.options.maxFiles) || 1000,
+          enableFileFiltering: !this.options.noFileFiltering,
+          enableBatching: !this.options.noBatching
         }
       });
       return results;

package/core/cli-program.js

@@ -56,18 +56,22 @@ function createCliProgram() {
     .option('--save-baseline <file>', 'Save current results as baseline')
     .option('--fail-on-new-violations', 'Exit with error only on new violations (not existing)');
 
+  // Performance options (SIMPLIFIED)
+  program
+    .option('--timeout <milliseconds>', 'Analysis timeout in milliseconds (default: auto)', '0')
+    .option('--max-files <count>', 'Maximum files to analyze (default: auto-detect)', '0')
+    .option('--performance <mode>', 'Performance mode: auto, fast, careful (default: auto)', 'auto');
+
   // Advanced options
   program
-    .option('--engine <engine>', 'Force specific analysis engine (eslint,heuristic)', '')
+    .option('--engine <engine>', 'Analysis engine (eslint,heuristic,auto)', 'auto')
     .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('--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('--no-ai', 'Force disable AI analysis')
+    .option('--max-semantic-files <number>', 'Symbol table file limit for TypeScript analysis (default: auto)', '0')
     .option('--list-engines', 'List available analysis engines');
 
   // ESLint Integration options
@@ -91,6 +95,16 @@ Examples:
 
 File Targeting:
   $ sunlint --all --include="src/**/*.ts" --exclude="**/*.test.*" --input=.
+
+Performance (SIMPLIFIED):
+  $ sunlint --all --input=src --performance=auto        # Auto-detect best settings
+  $ sunlint --all --input=src --performance=fast        # Quick scan
+  $ sunlint --all --input=src --performance=careful     # Thorough analysis
+  $ sunlint --all --input=src --timeout=60000           # Custom timeout (60s)
+
+File Limits (when needed):
+  $ sunlint --all --input=src --max-files=500           # Limit total files analyzed
+  $ sunlint --all --input=src --max-semantic-files=200  # Limit TypeScript symbol table
   $ sunlint --all --languages=typescript,dart --input=src
   $ sunlint --typescript --exclude-tests --input=src
   $ sunlint --all --only-source --include="src/**,lib/**" --input=.

package/core/constants/defaults.js

@@ -91,6 +91,61 @@ const DEFAULT_LIMITS = {
   MAX_OUTPUT_LINES: 1000         // Limit output to 1000 lines
 };
 
+/**
+ * Performance optimization defaults
+ */
+const DEFAULT_PERFORMANCE = {
+  // File filtering
+  ENABLE_FILE_FILTERING: true,
+  MAX_FILE_SIZE: 2 * 1024 * 1024,  // 2MB per file
+  MAX_TOTAL_FILES: 1000,           // Max 1000 files per analysis
+  
+  // Batch processing
+  ENABLE_BATCHING: true,
+  RULE_BATCH_SIZE: 10,             // Process 10 rules per batch
+  FILE_BATCH_SIZE: 50,             // Process 50 files per batch
+  
+  // Concurrency
+  MAX_CONCURRENT_BATCHES: 3,       // Max 3 batches running simultaneously
+  
+  // Memory management
+  ENABLE_MEMORY_MONITORING: true,
+  MAX_HEAP_SIZE_MB: 512,           // 512MB heap limit
+  GC_THRESHOLD_MB: 256,            // Trigger GC at 256MB
+  
+  // Timeouts (adaptive)
+  BASE_TIMEOUT_MS: 30000,          // 30s base timeout
+  TIMEOUT_PER_FILE_MS: 100,        // +100ms per file
+  TIMEOUT_PER_RULE_MS: 1000,       // +1s per rule
+  MAX_TIMEOUT_MS: 120000,          // 2 minutes max timeout
+  
+  // Error recovery
+  ENABLE_ERROR_RECOVERY: true,
+  MAX_RETRIES: 2,                  // Retry failed batches up to 2 times
+  RETRY_DELAY_MS: 1000,            // 1s delay between retries
+  
+  // Exclusion patterns for performance
+  HIGH_PERFORMANCE_EXCLUDES: [
+    '**/node_modules/**',
+    '**/.next/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/coverage/**',
+    '**/.git/**',
+    '**/target/**',
+    '**/out/**',
+    '**/*.min.js',
+    '**/*.bundle.js',
+    '**/vendor/**',
+    '**/lib/**',
+    '**/libs/**',
+    '**/.vscode/**',
+    '**/.idea/**',
+    '**/tmp/**',
+    '**/temp/**'
+  ]
+};
+
 /**
  * Default language extensions mapping
  */
@@ -155,6 +210,7 @@ module.exports = {
   DEFAULT_SEVERITIES,
   DEFAULT_TIMEOUTS,
   DEFAULT_LIMITS,
+  DEFAULT_PERFORMANCE,
   DEFAULT_LANGUAGE_EXTENSIONS,
   
   // Utility functions