@sun-asterisk/sunlint 1.3.32 → 1.3.34

package/core/semantic-engine-manager.js

@@ -0,0 +1,375 @@
+/**
+ * Semantic Engine Manager
+ * Manages multiple language analyzers and provides unified access to symbol tables
+ * Following Rule C005: Single responsibility - manage language analyzers
+ * Following Rule C006: Verb-noun naming pattern
+ * Following Rule C014: Dependency injection - uses language analyzer interface
+ *
+ * This manager enables multi-language semantic analysis by:
+ * 1. Registering language-specific analyzers (TypeScript, Dart, etc.)
+ * 2. Routing file analysis to the appropriate analyzer
+ * 3. Providing unified access to symbol tables across languages
+ */
+
+const path = require('path');
+const { getRegistry } = require('./interfaces/language-analyzer.interface');
+
+class SemanticEngineManager {
+  constructor(options = {}) {
+    this.options = {
+      verbose: options.verbose || false,
+      maxSemanticFiles: options.maxSemanticFiles,
+      ...options
+    };
+
+    // Get the singleton registry
+    this.registry = getRegistry();
+    this.initialized = false;
+    this.projectPath = null;
+    this.targetFiles = null;
+
+    // Statistics
+    this.stats = {
+      totalFilesAnalyzed: 0,
+      filesByLanguage: {},
+      analysisTime: 0,
+      initializationTime: 0
+    };
+  }
+
+  /**
+   * Register a language analyzer
+   * @param {ILanguageAnalyzer} analyzer - Analyzer instance
+   */
+  registerAnalyzer(analyzer) {
+    this.registry.register(analyzer);
+    if (this.options.verbose) {
+      console.log(`📝 SemanticEngineManager: Registered ${analyzer.name} analyzer`);
+    }
+  }
+
+  /**
+   * Unregister a language analyzer
+   * @param {string} name - Analyzer name
+   */
+  unregisterAnalyzer(name) {
+    this.registry.unregister(name);
+    if (this.options.verbose) {
+      console.log(`📝 SemanticEngineManager: Unregistered ${name} analyzer`);
+    }
+  }
+
+  /**
+   * Initialize all registered analyzers
+   * @param {string} projectPath - Project root path
+   * @param {string[]} [targetFiles] - Specific files to analyze
+   * @returns {Promise<boolean>} - True if at least one analyzer initialized successfully
+   */
+  async initialize(projectPath, targetFiles = null) {
+    const startTime = Date.now();
+    this.projectPath = projectPath;
+    this.targetFiles = targetFiles;
+
+    if (this.options.verbose) {
+      console.log(`🚀 SemanticEngineManager: Initializing with ${this.registry.getNames().length} analyzers`);
+    }
+
+    // Group target files by language for each analyzer
+    const filesByAnalyzer = this.groupFilesByAnalyzer(targetFiles);
+
+    // Initialize each analyzer with its relevant files
+    const config = {
+      projectPath,
+      verbose: this.options.verbose,
+      maxSemanticFiles: this.options.maxSemanticFiles,
+      compilerOptions: this.options.compilerOptions
+    };
+
+    let anySuccess = false;
+
+    for (const [analyzerName, files] of filesByAnalyzer) {
+      const analyzer = this.registry.get(analyzerName);
+      if (!analyzer) continue;
+
+      try {
+        const analyzerConfig = {
+          ...config,
+          targetFiles: files
+        };
+
+        const success = await analyzer.initialize(analyzerConfig);
+        if (success) {
+          anySuccess = true;
+          if (this.options.verbose) {
+            console.log(`✅ ${analyzerName} analyzer initialized with ${files.length} files`);
+          }
+        }
+      } catch (error) {
+        console.error(`❌ Failed to initialize ${analyzerName} analyzer:`, error.message);
+      }
+    }
+
+    // Also initialize analyzers that don't have matching files
+    // (they might be needed for on-demand analysis)
+    for (const analyzer of this.registry.getAll()) {
+      if (!filesByAnalyzer.has(analyzer.name)) {
+        try {
+          const success = await analyzer.initialize(config);
+          if (success) {
+            anySuccess = true;
+          }
+        } catch (error) {
+          // Silently skip - no files for this analyzer
+        }
+      }
+    }
+
+    this.initialized = anySuccess;
+    this.stats.initializationTime = Date.now() - startTime;
+
+    if (this.options.verbose) {
+      console.log(`🔧 SemanticEngineManager initialized in ${this.stats.initializationTime}ms`);
+      console.log(`   📊 Active analyzers: ${this.registry.getNames().filter(n => this.registry.get(n)?.isReady()).join(', ')}`);
+    }
+
+    return anySuccess;
+  }
+
+  /**
+   * Group files by their corresponding analyzer
+   * @param {string[]|null} files - Files to group
+   * @returns {Map<string, string[]>} - Map of analyzer name to files
+   */
+  groupFilesByAnalyzer(files) {
+    const grouped = new Map();
+
+    if (!files) {
+      return grouped;
+    }
+
+    for (const file of files) {
+      const analyzer = this.registry.getForFile(file);
+      if (analyzer) {
+        if (!grouped.has(analyzer.name)) {
+          grouped.set(analyzer.name, []);
+        }
+        grouped.get(analyzer.name).push(file);
+      }
+    }
+
+    return grouped;
+  }
+
+  /**
+   * Get the analyzer for a specific file
+   * @param {string} filePath - Path to the file
+   * @returns {ILanguageAnalyzer|null} - Analyzer or null
+   */
+  getAnalyzerForFile(filePath) {
+    return this.registry.getForFile(filePath);
+  }
+
+  /**
+   * Get the Symbol Table for a file
+   * Routes to the appropriate language analyzer
+   * @param {string} filePath - Absolute path to the file
+   * @returns {Promise<Object|null>} - Symbol table or null
+   */
+  async getSymbolTable(filePath) {
+    const analyzer = this.registry.getForFile(filePath);
+    if (!analyzer || !analyzer.isReady()) {
+      if (this.options.verbose) {
+        console.warn(`⚠️ No ready analyzer for: ${path.basename(filePath)}`);
+      }
+      return null;
+    }
+
+    try {
+      return await analyzer.getSymbolTable(filePath);
+    } catch (error) {
+      console.error(`❌ Error getting symbol table for ${filePath}:`, error.message);
+      return null;
+    }
+  }
+
+  /**
+   * 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 = {}) {
+    const analyzer = this.registry.getForFile(filePath);
+    if (!analyzer || !analyzer.isReady()) {
+      if (this.options.verbose) {
+        console.warn(`⚠️ No ready analyzer for: ${path.basename(filePath)}`);
+      }
+      return [];
+    }
+
+    try {
+      const startTime = Date.now();
+      const violations = await analyzer.analyzeFile(filePath, rules, options);
+
+      this.stats.totalFilesAnalyzed++;
+      this.stats.filesByLanguage[analyzer.name] = (this.stats.filesByLanguage[analyzer.name] || 0) + 1;
+      this.stats.analysisTime += Date.now() - startTime;
+
+      return violations;
+    } catch (error) {
+      console.error(`❌ Error analyzing ${filePath}:`, error.message);
+      return [];
+    }
+  }
+
+  /**
+   * Analyze multiple files
+   * Routes each file to its appropriate analyzer
+   * @param {string[]} files - Files to analyze
+   * @param {Object[]} rules - Rules to apply
+   * @param {Object} [options] - Analysis options
+   * @returns {Promise<Object[]>} - Array of violations
+   */
+  async analyzeFiles(files, rules, options = {}) {
+    const allViolations = [];
+    const filesByAnalyzer = this.groupFilesByAnalyzer(files);
+
+    for (const [analyzerName, analyzerFiles] of filesByAnalyzer) {
+      const analyzer = this.registry.get(analyzerName);
+      if (!analyzer || !analyzer.isReady()) {
+        continue;
+      }
+
+      try {
+        const violations = await analyzer.analyzeFiles(analyzerFiles, rules, options);
+        allViolations.push(...violations);
+
+        this.stats.filesByLanguage[analyzerName] =
+          (this.stats.filesByLanguage[analyzerName] || 0) + analyzerFiles.length;
+      } catch (error) {
+        console.error(`❌ Error analyzing files with ${analyzerName}:`, error.message);
+      }
+    }
+
+    this.stats.totalFilesAnalyzed += files.length;
+    return allViolations;
+  }
+
+  /**
+   * Check if the manager is ready for analysis
+   * @returns {boolean} - True if at least one analyzer is ready
+   */
+  isReady() {
+    return this.initialized && this.registry.getAll().some(a => a.isReady());
+  }
+
+  /**
+   * Check if a file is supported
+   * @param {string} filePath - Path to the file
+   * @returns {boolean} - True if supported
+   */
+  supportsFile(filePath) {
+    return this.registry.supportsFile(filePath);
+  }
+
+  /**
+   * Get all supported extensions
+   * @returns {string[]} - Array of extensions
+   */
+  getSupportedExtensions() {
+    return this.registry.getSupportedExtensions();
+  }
+
+  /**
+   * Get analyzer by name
+   * @param {string} name - Analyzer name
+   * @returns {ILanguageAnalyzer|null} - Analyzer or null
+   */
+  getAnalyzer(name) {
+    return this.registry.get(name);
+  }
+
+  /**
+   * Get all registered analyzer names
+   * @returns {string[]} - Analyzer names
+   */
+  getAnalyzerNames() {
+    return this.registry.getNames();
+  }
+
+  /**
+   * Get statistics
+   * @returns {Object} - Statistics object
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      analyzers: this.registry.getCombinedStats()
+    };
+  }
+
+  /**
+   * Check if Symbol Table analysis is available
+   * (Backward compatibility with SemanticEngine)
+   * @returns {boolean} - True if available
+   */
+  isSymbolEngineReady() {
+    return this.isReady();
+  }
+
+  /**
+   * Cleanup all analyzers
+   * @returns {Promise<void>}
+   */
+  async cleanup() {
+    if (this.options.verbose) {
+      console.log(`🧹 SemanticEngineManager: Cleaning up ${this.registry.getNames().length} analyzers`);
+    }
+
+    await this.registry.disposeAll();
+
+    // Print final stats
+    if (this.options.verbose) {
+      console.log(`📊 SemanticEngineManager Stats:`);
+      console.log(`   📄 Files analyzed: ${this.stats.totalFilesAnalyzed}`);
+      console.log(`   ⏱️ Total analysis time: ${this.stats.analysisTime}ms`);
+      for (const [lang, count] of Object.entries(this.stats.filesByLanguage)) {
+        console.log(`   📝 ${lang}: ${count} files`);
+      }
+    }
+
+    this.initialized = false;
+  }
+}
+
+// Singleton instance
+let managerInstance = null;
+
+/**
+ * Get the singleton manager instance
+ * @param {Object} [options] - Options for initialization
+ * @returns {SemanticEngineManager}
+ */
+function getManager(options = {}) {
+  if (!managerInstance) {
+    managerInstance = new SemanticEngineManager(options);
+  }
+  return managerInstance;
+}
+
+/**
+ * Reset the singleton manager (for testing)
+ */
+function resetManager() {
+  if (managerInstance) {
+    managerInstance.cleanup().catch(console.error);
+  }
+  managerInstance = null;
+}
+
+module.exports = {
+  SemanticEngineManager,
+  getManager,
+  resetManager
+};

package/core/semantic-engine.js

@@ -101,12 +101,7 @@ class SemanticEngine {
         /\.(ts|tsx|js|jsx)$/i.test(filePath)
       );
       
-      if (targetFiles) {
-        console.log(`🎯 Targeted files received: ${targetFiles.length} total, ${semanticFiles.length} TypeScript/JavaScript files (TS/TSX/JS/JSX)`);
-        if (semanticFiles.length < 10) {
-          console.log(`   Files: ${semanticFiles.map(f => path.basename(f)).join(', ')}`);
-        }
-      }
+      // Silent file targeting - no verbose log needed
       
       // Adaptive loading strategy based on project size and user preference
       const userMaxFiles = this.options.maxSemanticFiles;
@@ -115,21 +110,15 @@ class SemanticEngine {
       if (userMaxFiles === -1) {
         // Unlimited: Load all files
         maxFiles = semanticFiles.length;
-        console.log(`🔧 Semantic Engine config: UNLIMITED analysis (all ${semanticFiles.length} files)`);
       } else if (userMaxFiles === 0) {
         // Disable semantic analysis
         maxFiles = 0;
-        console.log(`🔧 Semantic Engine config: DISABLED semantic analysis (heuristic only mode)`);
-        console.log(`   💡 Semantic analysis explicitly disabled with --max-semantic-files=0`);
-        console.log(`   💡 To enable: omit the option (default: 1000) or use --max-semantic-files=1000 (or higher)`);
       } else if (userMaxFiles > 0) {
         // User-specified limit
         maxFiles = Math.min(userMaxFiles, semanticFiles.length);
-        console.log(`🔧 Semantic Engine config: USER limit ${maxFiles} files (requested: ${userMaxFiles})`);
       } else {
         // Auto-detect based on project size
         maxFiles = semanticFiles.length > 1000 ? 1000 : semanticFiles.length;
-        console.log(`🔧 Semantic Engine config: AUTO limit ${maxFiles} files (project has ${semanticFiles.length} files)`);
       }
       
       if (this.options.verbose) {
@@ -142,64 +131,28 @@ class SemanticEngine {
       
       // Skip semantic analysis if disabled
       if (maxFiles === 0) {
-        console.log(`⚠️  Semantic analysis DISABLED - using heuristic rules only`);
-        console.log(`💡 To enable semantic analysis, use --max-semantic-files=1000 (or higher)`);
         this.initialized = true;
         return true;
       }
       
       if (semanticFiles.length > maxFiles && maxFiles !== semanticFiles.length) {
-        console.warn(`⚠️  Large semantic project detected (${semanticFiles.length} files)`);
-        console.warn(`⚠️  Loading ${maxFiles} files for memory optimization (${Math.round(maxFiles/semanticFiles.length*100)}% coverage)`);
-        if (userMaxFiles !== -1) {
-          console.warn(`⚠️  Use --max-semantic-files=-1 to analyze ALL files (unlimited)`);
-          console.warn(`⚠️  Use --max-semantic-files=${semanticFiles.length} to analyze exactly this project`);
-        }
-        
         const filesToLoad = semanticFiles.slice(0, maxFiles);
-        
+
         // Load files one by one to handle any parse errors gracefully
-        let successCount = 0;
-        let errorCount = 0;
-        
         for (const filePath of filesToLoad) {
           try {
             if (require('fs').existsSync(filePath)) {
               this.project.addSourceFileAtPath(filePath);
-              successCount++;
-            } else {
-              errorCount++;
             }
           } catch (error) {
-            if (this.options.verbose) {
-              console.warn(`❌ Failed to load: ${path.basename(filePath)} - ${error.message}`);
-            }
-            errorCount++;
+            // Silent error handling
           }
         }
-        
-        console.log(`📊 Semantic analysis: ${successCount} files loaded, ${errorCount} skipped`);
-        
       } else {
-        console.log(`📊 Loading all ${semanticFiles.length} files for complete semantic analysis`);
         // For projects within limits, load all files
         this.project.addSourceFilesAtPaths(semanticFiles);
       }
       
-      // Debug what ts-morph actually loaded
-      const actualFiles = this.project.getSourceFiles();
-      console.log(`📊 ts-morph loaded: ${actualFiles.length} files (expected: ${semanticFiles.length})`);
-      if (actualFiles.length > semanticFiles.length * 2) {
-        console.warn(`⚠️  ts-morph auto-discovered additional files (dependency resolution)`);
-      }
-      
-      console.log(`🔧 Semantic Engine initialized (Memory Optimized):`);
-      console.log(`   📁 Project: ${projectPath}`);
-      console.log(`   📋 TS Config: ${tsConfigPath || 'default (minimal)'}`);
-      console.log(`   📄 Files loaded: ${this.project.getSourceFiles().length}`);
-      console.log(`   🎯 Targeting mode: ${targetFiles ? 'Filtered files' : 'Auto-discovery'}`);
-      console.log(`   💾 Memory mode: Optimized for large projects`);
-      
       this.initialized = true;
       return true;
       
@@ -587,7 +540,7 @@ class SemanticEngine {
         }
       }
       
-      console.log(`📁 File discovery: ${targetFiles.length}/${allFiles.length} files selected (memory optimized)`);
+      // Silent file discovery
       return targetFiles;
       
     } catch (error) {
@@ -626,12 +579,6 @@ class SemanticEngine {
       // Clear caches
       this.fileCache.clear();
       this.symbolTable.clear();
-      
-      console.log(`📊 Semantic Engine Stats:`);
-      console.log(`   📄 Files analyzed: ${this.stats.filesAnalyzed}`);
-      console.log(`   🎯 Cache hits: ${this.stats.cacheHits}`);
-      console.log(`   ❌ Cache misses: ${this.stats.cacheMisses}`);
-      console.log(`   💾 Memory usage: ${Math.round(this.stats.memoryUsage / 1024 / 1024)}MB`);
     }
   }
 

package/core/unified-rule-registry.js

@@ -172,23 +172,41 @@ class UnifiedRuleRegistry {
       
       if (matchingFolder) {
         const rulePath = path.join(commonRulesDir, matchingFolder);
-        
-        // Check for different analyzer files
+        const tsSubPath = path.join(rulePath, 'typescript');
+
+        // Check for different analyzer files - first at root, then in typescript/
         const analyzerFiles = {
           semantic: path.join(rulePath, 'semantic-analyzer.js'),
           ast: path.join(rulePath, 'ast-analyzer.js'),
           regex: path.join(rulePath, 'regex-analyzer.js'),
-          legacy: path.join(rulePath, 'analyzer.js')
+          legacy: path.join(rulePath, 'analyzer.js'),
+          router: path.join(rulePath, 'index.js')  // Multi-language router
         };
-        
+
+        // Also check typescript/ subfolder for multi-language rules
+        const tsAnalyzerFiles = {
+          semantic: path.join(tsSubPath, 'semantic-analyzer.js'),
+          ast: path.join(tsSubPath, 'ast-analyzer.js'),
+          regex: path.join(tsSubPath, 'regex-analyzer.js'),
+          legacy: path.join(tsSubPath, 'analyzer.js')
+        };
+
+        // First check root level
         for (const [type, filePath] of Object.entries(analyzerFiles)) {
           if (fs.existsSync(filePath)) {
             analyzers[type] = filePath;
           }
         }
+
+        // Then check typescript/ subfolder (only if not found at root)
+        for (const [type, filePath] of Object.entries(tsAnalyzerFiles)) {
+          if (!analyzers[type] && fs.existsSync(filePath)) {
+            analyzers[type] = filePath;
+          }
+        }
       }
     }
-    
+
     // Also check other category directories (security, typescript, etc.)
     const otherDirs = ['security', 'typescript', 'react'];
     for (const categoryDir of otherDirs) {
@@ -202,20 +220,38 @@ class UnifiedRuleRegistry {
         
         if (matchingFolder) {
           const rulePath = path.join(categoryPath, matchingFolder);
-          
+          const tsSubPath = path.join(rulePath, 'typescript');
+
           const analyzerFiles = {
             semantic: path.join(rulePath, 'semantic-analyzer.js'),
             ast: path.join(rulePath, 'ast-analyzer.js'),
             regex: path.join(rulePath, 'regex-analyzer.js'),
-            legacy: path.join(rulePath, 'analyzer.js')
+            legacy: path.join(rulePath, 'analyzer.js'),
+            router: path.join(rulePath, 'index.js')  // Multi-language router
           };
-          
+
+          // Also check typescript/ subfolder
+          const tsAnalyzerFiles = {
+            semantic: path.join(tsSubPath, 'semantic-analyzer.js'),
+            ast: path.join(tsSubPath, 'ast-analyzer.js'),
+            regex: path.join(tsSubPath, 'regex-analyzer.js'),
+            legacy: path.join(tsSubPath, 'analyzer.js')
+          };
+
+          // First check root level
           for (const [type, filePath] of Object.entries(analyzerFiles)) {
             if (fs.existsSync(filePath)) {
               analyzers[type] = filePath;
             }
           }
-          
+
+          // Then check typescript/ subfolder (only if not found at root)
+          for (const [type, filePath] of Object.entries(tsAnalyzerFiles)) {
+            if (!analyzers[type] && fs.existsSync(filePath)) {
+              analyzers[type] = filePath;
+            }
+          }
+
           // If we found analyzers, stop searching
           if (Object.keys(analyzers).length > 0) {
             break;
@@ -223,7 +259,7 @@ class UnifiedRuleRegistry {
         }
       }
     }
-    
+
     return analyzers;
   }
 
@@ -410,7 +446,12 @@ class UnifiedRuleRegistry {
     if (analyzers.legacy && (capabilities.includes('regex') || capabilities.includes('ast'))) {
       return analyzers.legacy;
     }
-    
+
+    // Fall back to router (index.js) for multi-language support
+    if (analyzers.router) {
+      return analyzers.router;
+    }
+
     return null;
   }
 

package/core/upload-service.js

@@ -24,15 +24,49 @@ class UploadService {
       }
 
       const uploadResult = await this.executeUploadCommand(filePath, apiUrl, options);
-      
-      console.log(chalk.green(`✅ Report uploaded successfully!`));
-      return {
-        success: true,
-        url: apiUrl,
-        filePath: filePath,
-        response: uploadResult.response,
-        statusCode: uploadResult.statusCode
-      };
+
+      // Check if upload was actually successful based on HTTP status code
+      const statusCode = uploadResult.statusCode;
+      const isSuccess = statusCode >= 200 && statusCode < 300;
+
+      if (isSuccess) {
+        console.log(chalk.green(`✅ Report uploaded successfully!`));
+        console.log(chalk.green(`📡 HTTP Status: ${statusCode}`));
+        return {
+          success: true,
+          url: apiUrl,
+          filePath: filePath,
+          response: uploadResult.response,
+          statusCode: statusCode
+        };
+      } else {
+        // Handle non-success HTTP status codes
+        const errorMessages = {
+          401: 'Unauthorized - Authentication required. Make sure OIDC token is configured correctly.',
+          403: 'Forbidden - Access denied. Check your permissions.',
+          404: 'Not Found - API endpoint does not exist.',
+          500: 'Internal Server Error - Server-side issue.',
+          502: 'Bad Gateway - Server is temporarily unavailable.',
+          503: 'Service Unavailable - Server is overloaded or under maintenance.'
+        };
+
+        const errorMessage = errorMessages[statusCode] || `HTTP Error ${statusCode}`;
+        console.error(chalk.red(`❌ Upload failed: ${errorMessage}`));
+        console.error(chalk.red(`📡 HTTP Status: ${statusCode}`));
+
+        if (uploadResult.response) {
+          console.error(chalk.yellow(`📄 Response: ${uploadResult.response}`));
+        }
+
+        return {
+          success: false,
+          url: apiUrl,
+          filePath: filePath,
+          response: uploadResult.response,
+          statusCode: statusCode,
+          error: errorMessage
+        };
+      }
       
     } catch (error) {
       const errorContext = {