@sun-asterisk/sunlint 1.3.33 → 1.3.34

package/core/adapters/index.js

@@ -0,0 +1,102 @@
+/**
+ * Language Analyzer Adapters - Registration Module
+ * Automatically registers all available language analyzers
+ *
+ * Following Rule C005: Single responsibility - analyzer registration
+ */
+
+const { getRegistry } = require('../interfaces/language-analyzer.interface');
+const TypeScriptAnalyzer = require('./typescript-analyzer');
+const DartAnalyzer = require('./dart-analyzer');
+
+/**
+ * Register all built-in language analyzers
+ * @param {Object} [options] - Options
+ * @param {boolean} [options.verbose] - Enable verbose logging
+ * @returns {LanguageAnalyzerRegistry} - The registry with registered analyzers
+ */
+function registerBuiltInAnalyzers(options = {}) {
+  const registry = getRegistry();
+  const { verbose = false } = options;
+
+  // Register TypeScript/JavaScript analyzer
+  if (!registry.has('typescript')) {
+    const tsAnalyzer = new TypeScriptAnalyzer();
+    registry.register(tsAnalyzer);
+    if (verbose) {
+      console.log(`📝 Registered TypeScript/JavaScript analyzer`);
+    }
+  }
+
+  // Register Dart analyzer
+  if (!registry.has('dart')) {
+    const dartAnalyzer = new DartAnalyzer();
+    registry.register(dartAnalyzer);
+    if (verbose) {
+      console.log(`📝 Registered Dart analyzer`);
+    }
+  }
+
+  return registry;
+}
+
+/**
+ * Get supported languages info
+ * @returns {Object[]} - Array of language info objects
+ */
+function getSupportedLanguages() {
+  return [
+    {
+      name: 'typescript',
+      displayName: 'TypeScript',
+      extensions: ['.ts', '.tsx', '.mts', '.cts'],
+      analyzerClass: TypeScriptAnalyzer
+    },
+    {
+      name: 'javascript',
+      displayName: 'JavaScript',
+      extensions: ['.js', '.jsx', '.mjs', '.cjs'],
+      analyzerClass: TypeScriptAnalyzer // Shares analyzer with TypeScript
+    },
+    {
+      name: 'dart',
+      displayName: 'Dart',
+      extensions: ['.dart'],
+      analyzerClass: DartAnalyzer
+    }
+  ];
+}
+
+/**
+ * Get analyzer class for a language
+ * @param {string} language - Language name
+ * @returns {Class|null} - Analyzer class or null
+ */
+function getAnalyzerClass(language) {
+  const langLower = language.toLowerCase();
+
+  switch (langLower) {
+    case 'typescript':
+    case 'javascript':
+    case 'ts':
+    case 'js':
+      return TypeScriptAnalyzer;
+    case 'dart':
+      return DartAnalyzer;
+    default:
+      return null;
+  }
+}
+
+module.exports = {
+  // Registration
+  registerBuiltInAnalyzers,
+
+  // Analyzer classes
+  TypeScriptAnalyzer,
+  DartAnalyzer,
+
+  // Utilities
+  getSupportedLanguages,
+  getAnalyzerClass
+};

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

@@ -55,7 +55,6 @@ class SunlintRuleAdapter {
       }
 
       this.isInitialized = true;
-      console.log(`✅ SunlintRuleAdapter initialized with ${this.getAllRuleIds().length} rules`);
       return true;
 
     } catch (error) {
@@ -74,7 +73,6 @@ class SunlintRuleAdapter {
       if (fs.existsSync(registryPath)) {
         const registryData = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
         this.registryCache = registryData.rules || {};
-        console.log(`📊 Loaded ${Object.keys(this.registryCache).length} rules from registry`);
         return true;
       }
       

package/core/adapters/typescript-analyzer.js

@@ -0,0 +1,277 @@
+/**
+ * TypeScript/JavaScript Analyzer
+ * Implements ILanguageAnalyzer for TypeScript and JavaScript files
+ * Wraps the existing SemanticEngine (ts-morph) functionality
+ *
+ * Following Rule C005: Single responsibility - TypeScript/JS analysis only
+ * Following Rule C014: Dependency injection - implements ILanguageAnalyzer
+ */
+
+const path = require('path');
+const { ILanguageAnalyzer } = require('../interfaces/language-analyzer.interface');
+const SemanticEngine = require('../semantic-engine');
+
+class TypeScriptAnalyzer extends ILanguageAnalyzer {
+  /**
+   * Create a TypeScript/JavaScript analyzer
+   */
+  constructor() {
+    super('typescript', ['.ts', '.tsx', '.js', '.jsx', '.mts', '.cts', '.mjs', '.cjs']);
+
+    // The underlying ts-morph based engine
+    this.semanticEngine = null;
+    this.projectPath = null;
+
+    // Cache for quick lookups
+    this.fileCache = new Map();
+  }
+
+  /**
+   * Initialize the TypeScript analyzer
+   * @param {Object} config - Configuration
+   * @param {string} config.projectPath - Project root path
+   * @param {string[]} [config.targetFiles] - Specific files to analyze
+   * @param {number} [config.maxSemanticFiles] - Max files to load
+   * @param {boolean} [config.verbose] - Enable verbose logging
+   * @returns {Promise<boolean>} - True if initialization succeeded
+   */
+  async initialize(config) {
+    try {
+      const {
+        projectPath = process.cwd(),
+        targetFiles = null,
+        maxSemanticFiles,
+        verbose = false,
+        compilerOptions = {}
+      } = config;
+
+      this.projectPath = projectPath;
+      this.verbose = verbose;
+
+      // Filter only TypeScript/JavaScript files from targetFiles
+      const tsFiles = targetFiles
+        ? targetFiles.filter(f => this.supportsFile(f))
+        : null;
+
+      if (verbose) {
+        console.log(`🔷 TypeScriptAnalyzer: Initializing for ${projectPath}`);
+        if (tsFiles) {
+          console.log(`   📄 Target files: ${tsFiles.length} TypeScript/JavaScript files`);
+        }
+      }
+
+      // Create and initialize the underlying semantic engine
+      this.semanticEngine = new SemanticEngine({
+        maxSemanticFiles,
+        verbose,
+        compilerOptions: {
+          target: 99, // Latest
+          allowJs: true,
+          checkJs: false,
+          skipLibCheck: true,
+          skipDefaultLibCheck: true,
+          ...compilerOptions
+        },
+        enableCaching: true
+      });
+
+      // Initialize with filtered files
+      const success = await this.semanticEngine.initialize(projectPath, tsFiles);
+
+      if (success) {
+        this.initialized = true;
+        if (verbose) {
+          console.log(`✅ TypeScriptAnalyzer initialized successfully`);
+        }
+      } else {
+        if (verbose) {
+          console.warn(`⚠️ TypeScriptAnalyzer: ts-morph initialization failed, using fallback mode`);
+        }
+        // Still mark as initialized for fallback regex-based analysis
+        this.initialized = true;
+      }
+
+      return true;
+    } catch (error) {
+      console.error(`❌ TypeScriptAnalyzer initialization failed:`, error.message);
+      // Initialize anyway for fallback mode
+      this.initialized = true;
+      return false;
+    }
+  }
+
+  /**
+   * Analyze a single file
+   * @param {string} filePath - Path to the file
+   * @param {Object[]} rules - Rules to apply
+   * @param {Object} [options] - Analysis options
+   * @returns {Promise<Object[]>} - Array of violations
+   */
+  async analyzeFile(filePath, rules, options = {}) {
+    if (!this.initialized) {
+      console.warn(`⚠️ TypeScriptAnalyzer not initialized`);
+      return [];
+    }
+
+    if (!this.supportsFile(filePath)) {
+      return [];
+    }
+
+    const violations = [];
+    const startTime = Date.now();
+
+    try {
+      // Get symbol table for this file
+      const symbolTable = await this.getSymbolTable(filePath);
+
+      // Process each rule
+      for (const rule of rules) {
+        // Skip rules not applicable to TypeScript/JavaScript
+        if (rule.languages && !this.isRuleApplicable(rule)) {
+          continue;
+        }
+
+        // Semantic rules use the symbol table
+        if (rule.analyzeWithSymbolTable && symbolTable) {
+          try {
+            const ruleViolations = await rule.analyzeWithSymbolTable(symbolTable, {
+              filePath,
+              ...options
+            });
+            violations.push(...(ruleViolations || []));
+          } catch (error) {
+            if (this.verbose) {
+              console.warn(`⚠️ Rule ${rule.ruleId} failed on ${path.basename(filePath)}:`, error.message);
+            }
+          }
+        }
+      }
+
+      this.stats.filesAnalyzed++;
+      this.stats.totalAnalysisTime += Date.now() - startTime;
+
+    } catch (error) {
+      console.error(`❌ Error analyzing ${filePath}:`, error.message);
+    }
+
+    return violations;
+  }
+
+  /**
+   * Get the Symbol Table for a file
+   * @param {string} filePath - Absolute path to the file
+   * @returns {Promise<Object|null>} - Symbol table or null
+   */
+  async getSymbolTable(filePath) {
+    if (!this.semanticEngine || !this.semanticEngine.isSymbolEngineReady()) {
+      return null;
+    }
+
+    // Check cache
+    const absolutePath = path.resolve(filePath);
+    if (this.fileCache.has(absolutePath)) {
+      this.stats.cacheHits++;
+      return this.fileCache.get(absolutePath);
+    }
+
+    try {
+      this.stats.cacheMisses++;
+      const symbolTable = await this.semanticEngine.getSymbolTable(absolutePath);
+
+      // Cache the result
+      if (symbolTable) {
+        this.fileCache.set(absolutePath, symbolTable);
+      }
+
+      return symbolTable;
+    } catch (error) {
+      if (this.verbose) {
+        console.warn(`⚠️ Failed to get symbol table for ${path.basename(filePath)}:`, error.message);
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Check if a rule is applicable to TypeScript/JavaScript
+   * @param {Object} rule - Rule definition
+   * @returns {boolean} - True if applicable
+   */
+  isRuleApplicable(rule) {
+    if (!rule.languages || rule.languages.length === 0) {
+      return true; // No language restriction
+    }
+
+    const applicableLanguages = ['typescript', 'javascript', 'all'];
+    return rule.languages.some(lang => applicableLanguages.includes(lang.toLowerCase()));
+  }
+
+  /**
+   * Get the underlying semantic engine
+   * For backward compatibility with existing code
+   * @returns {SemanticEngine|null}
+   */
+  getSemanticEngine() {
+    return this.semanticEngine;
+  }
+
+  /**
+   * Check if Symbol Table is ready
+   * For backward compatibility
+   * @returns {boolean}
+   */
+  isSymbolEngineReady() {
+    return this.semanticEngine?.isSymbolEngineReady() || false;
+  }
+
+  /**
+   * Get ts-morph project
+   * For advanced use cases
+   * @returns {Project|null}
+   */
+  getProject() {
+    return this.semanticEngine?.project || null;
+  }
+
+  /**
+   * Get source file from ts-morph
+   * @param {string} filePath - Path to the file
+   * @returns {SourceFile|null}
+   */
+  getSourceFile(filePath) {
+    const project = this.getProject();
+    if (!project) return null;
+
+    const absolutePath = path.resolve(filePath);
+    return project.getSourceFile(absolutePath) || null;
+  }
+
+  /**
+   * Clear the file cache
+   */
+  clearCache() {
+    this.fileCache.clear();
+  }
+
+  /**
+   * Cleanup resources
+   * @returns {Promise<void>}
+   */
+  async dispose() {
+    if (this.semanticEngine) {
+      await this.semanticEngine.cleanup();
+      this.semanticEngine = null;
+    }
+
+    this.fileCache.clear();
+    this.initialized = false;
+
+    if (this.verbose) {
+      console.log(`🧹 TypeScriptAnalyzer disposed`);
+      console.log(`   📊 Files analyzed: ${this.stats.filesAnalyzed}`);
+      console.log(`   🎯 Cache hits: ${this.stats.cacheHits}`);
+    }
+  }
+}
+
+module.exports = TypeScriptAnalyzer;

package/core/analysis-orchestrator.js

@@ -185,13 +185,30 @@ class AnalysisOrchestrator {
         );
 
       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 category
+        const rulesByCategory = this.groupRulesByCategory(optimizedRules);
+        const categoryBreakdown = Object.entries(rulesByCategory)
+          .map(([cat, rules]) => `${cat}:${rules.length}`)
+          .join(' · ');
+
+        // Professional startup display
+        console.log();
+        console.log(chalk.cyan(`  ➜  Rules   `) + chalk.white(`${optimizedRules.length}`) + chalk.gray(` (${categoryBreakdown})`));
+        console.log(chalk.cyan(`  ➜  Files   `) + chalk.white(`${optimizedFiles.length}`) + chalk.gray(` targeted`));
+
+        // Display rules by category with truncation
+        for (const [category, rules] of Object.entries(rulesByCategory)) {
+          const ruleIds = rules.map(r => r.id || r).sort();
+          const displayRules = ruleIds.length > 8
+            ? ruleIds.slice(0, 8).join(', ') + chalk.gray(` +${ruleIds.length - 8} more`)
+            : ruleIds.join(', ');
+          console.log(chalk.cyan(`  ➜  ${category}       `) + chalk.gray(displayRules));
         }
+
+        // Separator before progress
+        console.log();
+        console.log(chalk.gray('  ─────────────────────────────────────────────────────────────'));
+        console.log();
       }
 
       // Group rules by their preferred engines
@@ -206,21 +223,28 @@ class AnalysisOrchestrator {
         totalBatches += ruleBatches.length;
       }
 
-      if (!options.quiet) {
-        console.log(chalk.cyan(`🚀 Running analysis across ${engineGroups.size} engines (${totalBatches} batches total)...`));
-      }
-
       // Run analysis on each engine with batching
       const results = [];
       let completedBatches = 0;
+      let totalViolationsFound = 0;
+      const startTime = Date.now();
+      let currentEngineName = null;
 
       for (const [engineName, rules] of engineGroups) {
         const engine = this.engines.get(engineName);
         if (!engine) {
-          console.warn(chalk.yellow(`⚠️ Engine ${engineName} not found, skipping ${rules.length} rules`));
           continue;
         }
 
+        // Display engine header when switching to new engine
+        if (!options.quiet && engineName !== currentEngineName) {
+          currentEngineName = engineName;
+          const engineLabel = this.getEngineDisplayName(engineName);
+          const engineRulesCount = rules.length;
+          console.log();
+          console.log(chalk.cyan(`  ⚙  ${engineLabel}`) + chalk.gray(` · ${engineRulesCount} rules · ${optimizedFiles.length} files`));
+        }
+
         // Get pre-calculated batches
         const ruleBatches = engineBatchInfo.get(engineName);
 
@@ -228,13 +252,15 @@ class AnalysisOrchestrator {
           const batch = ruleBatches[i];
           const batchNumber = i + 1;
           const overallProgress = Math.round((completedBatches / totalBatches) * 100);
+          const batchStartTime = Date.now();
 
+          // Log batch start - multi-line format for easier debugging
           if (!options.quiet) {
-            if (ruleBatches.length > 1) {
-              console.log(chalk.blue(`⚙️ [${overallProgress}%] ${engineName} - Batch ${batchNumber}/${ruleBatches.length}: ${batch.length} rules (${optimizedFiles.length} files)`));
-            } else {
-              console.log(chalk.blue(`⚙️ [${overallProgress}%] Running ${batch.length} rules on ${engineName} engine (${optimizedFiles.length} files)...`));
-            }
+            const batchLabel = `Batch ${completedBatches + 1}/${totalBatches}`;
+            console.log();
+            console.log(chalk.gray(`  ┌─ ${batchLabel} `) + chalk.dim(`(${overallProgress}%)`));
+            // Display each rule on separate line
+            this.displayBatchRulesMultiLine(batch);
           }
 
           try {
@@ -253,33 +279,45 @@ class AnalysisOrchestrator {
               ...engineResult
             });
 
+            const batchViolations = this.countViolations(engineResult);
             completedBatches++;
-            const newProgress = Math.round((completedBatches / totalBatches) * 100);
+            totalViolationsFound += batchViolations;
+            const batchDuration = ((Date.now() - batchStartTime) / 1000).toFixed(2);
 
+            // Log batch result
             if (!options.quiet) {
-              const violationCount = this.countViolations(engineResult);
-              console.log(chalk.green(`✅ [${newProgress}%] ${engineName} batch ${batchNumber}/${ruleBatches.length}: ${violationCount} violations found`));
+              if (batchViolations > 0) {
+                console.log(chalk.gray(`  └─ `) + chalk.yellow(`⚠ ${batchViolations} issues`) + chalk.gray(` · ${batchDuration}s`));
+              } else {
+                console.log(chalk.gray(`  └─ `) + chalk.green(`✓ passed`) + chalk.gray(` · ${batchDuration}s`));
+              }
             }
+
           } 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
+            completedBatches++;
+            const batchDuration = ((Date.now() - batchStartTime) / 1000).toFixed(2);
+            if (!options.quiet) {
+              console.log(chalk.gray(`  └─ `) + chalk.red(`✗ Error: ${error.message}`) + chalk.gray(` · ${batchDuration}s`));
             }
-            // Continue with other batches instead of failing completely
           }
         }
       }
 
+      // Show final result
+      if (!options.quiet) {
+        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+        console.log();
+        console.log(chalk.gray('  ─────────────────────────────────────────────────────────────'));
+        console.log();
+
+        if (totalViolationsFound === 0) {
+          console.log('  ' + chalk.green('✓ All checks passed') + chalk.gray(` · ${elapsed}s`));
+        } else {
+          console.log('  ' + chalk.yellow(`⚠ ${totalViolationsFound} issues`) + chalk.gray(` · ${elapsed}s`));
+        }
+        console.log();
+      }
+
       // Merge results and add performance metrics
       const mergedResults = this.mergeEngineResults(results, options, optimizedFiles.length);
       mergedResults.performance = performanceMetrics;
@@ -340,12 +378,6 @@ 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]));
     }
@@ -610,6 +642,103 @@ class AnalysisOrchestrator {
     return mergedResults;
   }
 
+  /**
+   * Create a visual progress bar
+   * @param {number} percent - Progress percentage (0-100)
+   * @returns {string} Progress bar string
+   */
+  createProgressBar(percent) {
+    const width = 20;
+    const filled = Math.round((percent / 100) * width);
+    const empty = width - filled;
+    return '[' + '█'.repeat(filled) + '░'.repeat(empty) + ']';
+  }
+
+  /**
+   * Get human-readable display name for an engine
+   * Following Rule C006: Verb-noun naming
+   * @param {string} engineName - Engine identifier
+   * @returns {string} Display name for the engine
+   */
+  getEngineDisplayName(engineName) {
+    const displayNames = {
+      'heuristic': 'Heuristic Engine',
+      'eslint': 'ESLint Engine',
+      'openai': 'AI Engine',
+      'ai': 'AI Engine',
+      'typescript': 'TypeScript Engine',
+      'semantic': 'Semantic Engine'
+    };
+    return displayNames[engineName] || `${engineName.charAt(0).toUpperCase()}${engineName.slice(1)} Engine`;
+  }
+
+  /**
+   * Format batch rules display with IDs and names
+   * Following Rule C006: Verb-noun naming
+   * @param {Object[]} batch - Array of rule objects
+   * @returns {string} Formatted rules display string
+   */
+  formatBatchRulesDisplay(batch) {
+    const maxLength = 60;
+    const ruleDisplays = batch.map(rule => {
+      const id = rule.id || rule;
+      const name = rule.name || rule.title;
+      if (name) {
+        // Truncate long rule names
+        const shortName = name.length > 25 ? name.substring(0, 25) + '…' : name;
+        return `${id}: ${shortName}`;
+      }
+      return id;
+    });
+
+    // Join and truncate if too long
+    const fullDisplay = ruleDisplays.join(' │ ');
+    if (fullDisplay.length > maxLength) {
+      return fullDisplay.substring(0, maxLength) + '…';
+    }
+    return fullDisplay;
+  }
+
+  /**
+   * Display batch rules in multi-line format for easier debugging
+   * Following Rule C006: Verb-noun naming
+   * @param {Object[]} batch - Array of rule objects
+   */
+  displayBatchRulesMultiLine(batch) {
+    for (let i = 0; i < batch.length; i++) {
+      const rule = batch[i];
+      const id = rule.id || rule;
+      const name = rule.name || rule.title || '';
+      const isLast = i === batch.length - 1;
+      const prefix = isLast ? '  │  └─' : '  │  ├─';
+
+      if (name) {
+        console.log(chalk.gray(prefix) + ' ' + chalk.cyan(id) + chalk.gray(': ') + chalk.white(name));
+      } else {
+        console.log(chalk.gray(prefix) + ' ' + chalk.cyan(id));
+      }
+    }
+  }
+
+  /**
+   * Group rules by category prefix (C, S, T, R, etc.)
+   * Following Rule C006: Verb-noun naming
+   * @param {Object[]} rules - Rules to group
+   * @returns {Object} Object with category arrays
+   */
+  groupRulesByCategory(rules) {
+    const groups = {};
+    for (const rule of rules) {
+      const ruleId = rule.id || rule;
+      const category = ruleId.charAt(0); // Get first character (C, S, T, R, etc.)
+      if (!groups[category]) {
+        groups[category] = [];
+      }
+      groups[category].push(rule);
+    }
+    return groups;
+  }
+
   /**
    * Count violations in engine results
    * Following Rule C006: Verb-noun naming
@@ -690,7 +819,6 @@ class AnalysisOrchestrator {
     }
     
     this.initialized = false;
-    console.log(chalk.blue('🧹 Engine cleanup completed'));
   }
 }