@sun-asterisk/sunlint 1.3.2 → 1.3.4

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;
@@ -156,6 +164,20 @@ class CliActionHandler {
   determineEnabledEngines(config) {
     // If specific engine is requested via --engine option, use only that engine
     if (this.options.engine) {
+      // Handle "auto" engine selection
+      if (this.options.engine === 'auto') {
+        // Auto-select best engines: default to heuristic for compatibility
+        const autoEngines = ['heuristic'];
+        
+        // Add ESLint for JS/TS files if available
+        if (this.hasJavaScriptTypeScriptFiles() || config.eslint?.enabled !== false) {
+          autoEngines.push('eslint');
+        }
+        
+        return autoEngines;
+      }
+      
+      // Return specific engine as requested
       return [this.options.engine];
     }
 
@@ -264,7 +286,7 @@ class CliActionHandler {
   validateInput(config) {
     // Validate engine option if specified (check this first, always)
     if (this.options.engine) {
-      const validEngines = ['eslint', 'heuristic', 'openai'];
+      const validEngines = ['auto', 'eslint', 'heuristic', 'openai'];
       if (!validEngines.includes(this.options.engine)) {
         throw new Error(
           chalk.red(`❌ Invalid engine: ${this.options.engine}\n`) +

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

package/core/performance-optimizer.js

@@ -0,0 +1,271 @@
+/**
+ * Performance Optimization Module for SunLint v1.3.2
+ * Comprehensive optimizations to handle large projects efficiently
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { DEFAULT_PERFORMANCE } = require('./constants/defaults');
+
+class PerformanceOptimizer {
+  constructor() {
+    this.excludePatterns = DEFAULT_PERFORMANCE.HIGH_PERFORMANCE_EXCLUDES;
+    this.fileSizeLimits = {
+      maxFileSize: DEFAULT_PERFORMANCE.MAX_FILE_SIZE,
+      maxTotalFiles: DEFAULT_PERFORMANCE.MAX_TOTAL_FILES
+    };
+    this.config = {};
+    this.initialized = false;
+  }
+
+  /**
+   * Initialize performance optimizer with configuration
+   */
+  async initialize(config = {}) {
+    this.config = {
+      ...DEFAULT_PERFORMANCE,
+      ...config
+    };
+    this.initialized = true;
+  }
+
+  /**
+   * Main optimization method called by analysis orchestrator
+   */
+  async optimizeAnalysis(files, rules, config) {
+    const startTime = Date.now();
+    
+    // Filter files for performance
+    const optimizedFiles = this.config.enableFileFiltering !== false 
+      ? await this.smartFileFilter(files)
+      : files;
+    
+    // Apply rule batching if enabled
+    const optimizedRules = this.config.enableBatching !== false
+      ? rules
+      : rules;
+    
+    const performanceMetrics = {
+      originalFiles: files.length,
+      optimizedFiles: optimizedFiles.length,
+      filteredFiles: files.length - optimizedFiles.length,
+      originalRules: rules.length,
+      optimizedRules: optimizedRules.length,
+      ruleBatches: this.calculateBatchCount(rules, config),
+      optimizationTime: Date.now() - startTime
+    };
+
+    if (config.verbose) {
+      console.log(`⚡ Performance optimization: ${performanceMetrics.filteredFiles} files filtered, ${performanceMetrics.ruleBatches} batches`);
+    }
+
+    return {
+      optimizedFiles,
+      optimizedRules,
+      performanceMetrics
+    };
+  }
+
+  /**
+   * Calculate number of batches for rules
+   */
+  calculateBatchCount(rules, config) {
+    const batchSize = config.ruleBatchSize || this.config.RULE_BATCH_SIZE;
+    return Math.ceil(rules.length / batchSize);
+  }
+
+  /**
+   * Smart file filtering to exclude performance-heavy directories
+   */
+  async smartFileFilter(files) {
+    const filtered = [];
+    let totalSize = 0;
+    
+    for (const file of files) {
+      // Skip if matches exclude patterns
+      if (this.shouldExcludeFile(file)) {
+        continue;
+      }
+      
+      try {
+        const stats = await fs.promises.stat(file);
+        
+        // Skip large files
+        if (stats.size > this.fileSizeLimits.maxFileSize) {
+          if (this.config.verbose) {
+            console.log(`⚠️ Skipping large file: ${path.basename(file)} (${(stats.size / 1024 / 1024).toFixed(1)}MB)`);
+          }
+          continue;
+        }
+        
+        // Check total size limit
+        if (totalSize + stats.size > this.fileSizeLimits.maxTotalSize) {
+          if (this.config.verbose) {
+            console.log(`⚠️ Reached total size limit, stopping at ${filtered.length} files`);
+          }
+          break;
+        }
+        
+        // Check file count limit
+        if (filtered.length >= this.fileSizeLimits.maxTotalFiles) {
+          if (this.config.verbose) {
+            console.log(`⚠️ Reached file count limit: ${this.fileSizeLimits.maxTotalFiles} files`);
+          }
+          break;
+        }
+        
+        filtered.push(file);
+        totalSize += stats.size;
+        
+      } catch (error) {
+        // Skip files we can't read
+        if (this.config.verbose) {
+          console.warn(`⚠️ Cannot read file ${file}: ${error.message}`);
+        }
+        continue;
+      }
+    }
+    
+    if (this.config.verbose) {
+      console.log(`📊 Performance filter: ${filtered.length}/${files.length} files (${(totalSize / 1024 / 1024).toFixed(1)}MB)`);
+    }
+    return filtered;
+  }
+
+  shouldExcludeFile(filePath) {
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    
+    return this.excludePatterns.some(pattern => {
+      const regex = this.globToRegex(pattern);
+      const match = regex.test(normalizedPath);
+      return match;
+    });
+  }
+
+  globToRegex(glob) {
+    // Simple but effective glob to regex conversion
+    let regex = glob
+      .replace(/\./g, '\\.')                   // Escape dots
+      .replace(/\*\*/g, '___DOUBLE_STAR___')   // Temp placeholder
+      .replace(/\*/g, '[^/]*')                 // Single * matches within path segment
+      .replace(/___DOUBLE_STAR___/g, '.*')     // ** matches across path segments
+      .replace(/\?/g, '[^/]');                 // ? matches single character
+    
+    // Ensure pattern matches anywhere in the path
+    if (!regex.startsWith('.*')) {
+      regex = '.*' + regex;
+    }
+    if (!regex.endsWith('.*')) {
+      regex = regex + '.*';
+    }
+    
+    return new RegExp(regex, 'i');
+  }
+
+  /**
+   * Adaptive timeout based on file count and rules
+   */
+  calculateAdaptiveTimeout(fileCount, ruleCount, baseTimeout = 30000) {
+    const perFileMs = this.config.TIMEOUT_PER_FILE_MS || 100;
+    const perRuleMs = this.config.TIMEOUT_PER_RULE_MS || 1000;
+    const maxTimeout = this.config.MAX_TIMEOUT_MS || 120000;
+    
+    const adaptiveTimeout = Math.min(
+      baseTimeout + (fileCount * perFileMs) + (ruleCount * perRuleMs),
+      maxTimeout
+    );
+    
+    if (this.config.verbose) {
+      console.log(`⏱️ Adaptive timeout: ${(adaptiveTimeout / 1000).toFixed(1)}s for ${fileCount} files, ${ruleCount} rules`);
+    }
+    return adaptiveTimeout;
+  }
+
+  /**
+   * Memory-aware rule batching
+   */
+  createRuleBatches(rules, config = {}) {
+    const fileCount = config.fileCount || 100;
+    const batchSize = config.ruleBatchSize || (fileCount > 100 ? 5 : 10);
+    const batches = [];
+    
+    for (let i = 0; i < rules.length; i += batchSize) {
+      batches.push(rules.slice(i, i + batchSize));
+    }
+    
+    if (this.config.verbose) {
+      console.log(`📦 Created ${batches.length} rule batches (${batchSize} rules each)`);
+    }
+    return batches;
+  }
+
+  /**
+   * Enhanced error recovery with context
+   */
+  handleAnalysisError(error, context = {}) {
+    const errorInfo = {
+      message: error.message,
+      shouldRetry: false,
+      retryWithReducedBatch: false,
+      context
+    };
+
+    // Determine if error is recoverable
+    if (error.message.includes('timeout') || 
+        error.message.includes('timed out') ||
+        error.message.includes('Maximum call stack size exceeded')) {
+      errorInfo.shouldRetry = true;
+      errorInfo.retryWithReducedBatch = true;
+    }
+
+    if (error.message.includes('ENOMEM') || 
+        error.message.includes('memory')) {
+      errorInfo.shouldRetry = true;
+      errorInfo.retryWithReducedBatch = true;
+    }
+
+    return errorInfo;
+  }
+
+  /**
+   * Execute operation with error recovery
+   */
+  async executeWithRecovery(operation, context = {}) {
+    const maxRetries = this.config.MAX_RETRIES || 2;
+    const retryDelay = this.config.RETRY_DELAY_MS || 1000;
+    
+    for (let attempt = 1; attempt <= maxRetries + 1; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        if (attempt > maxRetries) {
+          throw error; // Final attempt failed
+        }
+        
+        const errorInfo = this.handleAnalysisError(error, context);
+        
+        if (!errorInfo.shouldRetry) {
+          throw error; // Not recoverable
+        }
+        
+        if (this.config.verbose) {
+          console.warn(`⚠️ Attempt ${attempt} failed, retrying in ${retryDelay}ms...`);
+        }
+        
+        // Wait before retry
+        await new Promise(resolve => setTimeout(resolve, retryDelay));
+      }
+    }
+  }
+
+  /**
+   * Cleanup resources
+   */
+  async cleanup() {
+    // Perform any necessary cleanup
+    this.initialized = false;
+    this.config = {};
+  }
+}
+
+module.exports = PerformanceOptimizer;