@sun-asterisk/sunlint 1.2.2 → 1.3.1

package/rules/common/C029_catch_block_logging/analyzer-fixed.js

@@ -1,130 +0,0 @@
-/**
- * C029 Analyzer - Smart Pipeline Integration
- * 
- * This analyzer forwards to the Smart Pipeline for superior accuracy and performance
- */
-
-const fs = require('fs');
-const path = require('path');
-
-class C029Analyzer {
-  constructor() {
-    this.ruleId = 'C029';
-    this.ruleName = 'Enhanced Catch Block Error Logging';
-    this.description = 'Mọi catch block phải log nguyên nhân lỗi đầy đủ và bảo toàn context (Smart Pipeline 3-stage analysis)';
-    
-    // Load Smart Pipeline as primary analyzer
-    this.smartPipeline = null;
-    
-    try {
-      const SmartPipelineClass = require('./analyzer-smart-pipeline.js');
-      this.smartPipeline = new SmartPipelineClass();
-      console.log('🎯 C029: Smart Pipeline loaded (3-stage: Regex → AST → Data Flow)');
-    } catch (error) {
-      console.warn('⚠️ C029: Smart Pipeline failed, using fallback:', error.message);
-      this.smartPipeline = null;
-    }
-  }
-
-  async analyze(files, language, options = {}) {
-    // Use Smart Pipeline as primary choice
-    if (this.smartPipeline) {
-      console.log('🎯 C029: Using Smart Pipeline (3-stage analysis)...');
-      return await this.smartPipeline.analyze(files, language, options);
-    } else {
-      console.log('🔍 C029: Using fallback regex analysis...');
-      return await this.analyzeWithRegex(files, language, options);
-    }
-  }
-
-  async analyzeWithRegex(files, language, options = {}) {
-    const violations = [];
-    
-    for (const filePath of files) {
-      if (options.verbose) {
-        console.log(`🔍 C029 Regex: Processing ${path.basename(filePath)}...`);
-      }
-      
-      try {
-        const content = fs.readFileSync(filePath, 'utf8');
-        const fileViolations = await this.analyzeFile(filePath, content, language);
-        violations.push(...fileViolations);
-      } catch (error) {
-        console.warn(`⚠️ C029: Error processing ${filePath}:`, error.message);
-      }
-    }
-    
-    return violations;
-  }
-
-  async analyzeFile(filePath, content, language) {
-    const violations = [];
-    const lines = content.split('\n');
-    
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      
-      // Simple catch block detection
-      if (line.includes('catch') && line.includes('(')) {
-        const catchBlock = this.extractCatchBlock(lines, i);
-        
-        if (this.isCatchBlockEmpty(catchBlock.content)) {
-          violations.push({
-            file: filePath,
-            line: i + 1,
-            column: line.indexOf('catch') + 1,
-            message: 'Empty catch block detected',
-            severity: 'error',
-            ruleId: this.ruleId,
-            type: 'empty_catch'
-          });
-        }
-      }
-    }
-    
-    return violations;
-  }
-
-  extractCatchBlock(lines, startIndex) {
-    const content = [];
-    let braceCount = 0;
-    let inBlock = false;
-    
-    for (let i = startIndex; i < lines.length; i++) {
-      const line = lines[i];
-      content.push(line);
-      
-      for (const char of line) {
-        if (char === '{') {
-          braceCount++;
-          inBlock = true;
-        } else if (char === '}') {
-          braceCount--;
-          if (braceCount === 0 && inBlock) {
-            return { content, endIndex: i };
-          }
-        }
-      }
-    }
-    
-    return { content, endIndex: startIndex };
-  }
-
-  isCatchBlockEmpty(content) {
-    const blockContent = content.join('\n');
-    
-    // Remove comments and whitespace
-    const cleanContent = blockContent
-      .replace(/\/\*[\s\S]*?\*\//g, '') // Remove multi-line comments
-      .replace(/\/\/.*$/gm, '') // Remove single-line comments
-      .replace(/\s+/g, ' ') // Normalize whitespace
-      .trim();
-    
-    // Check if only contains catch declaration and braces
-    const hasOnlyStructure = /^catch\s*\([^)]*\)\s*\{\s*\}$/.test(cleanContent);
-    
-    return hasOnlyStructure;
-  }
-}
-
-module.exports = C029Analyzer;

package/rules/common/C029_catch_block_logging/analyzer-multi-tech.js

@@ -1,487 +0,0 @@
-/**
- * C029 Catch Block Logging Analyzer
- * 
- * Enhanced multi-technology analyzer combining:
- * - Regex pattern matching (basic detection)
- * - AST-based analysis (structural understanding)
- * - Data flow analysis (variable tracking)
- * - Control flow analysis (execution path understanding)
- * - Semantic analysis (intent understanding)
- * - Pattern learning (adaptive rules)
- * - Multi-language support (cross-language compatibility)
- * 
- * Technology Showcase: Demonstrates SunLint's advanced analysis capabilities
- */
-
-const fs = require('fs');
-const path = require('path');
-
-class C029CatchBlockAnalyzer {
-  constructor() {
-    this.ruleId = 'C029';
-    this.ruleName = 'Advanced Catch Block Logging';
-    this.description = 'Multi-technology analysis for catch block error handling';
-    
-    // Load analyzers with graceful fallback
-    this.analyzers = this.loadAnalyzers();
-    
-    // Technology orchestration configuration
-    this.analysisConfig = {
-      enableRegex: true,
-      enableAST: true,
-      enableDataflow: true,
-      enableControlflow: true,
-      enableSemantic: true,
-      enablePatternLearning: true,
-      enableMultiLanguage: true,
-      confidenceThreshold: 0.5,
-      combinationStrategy: 'weighted_voting'  // Options: 'union', 'intersection', 'weighted_voting'
-    };
-    
-    // Technology weights for voting
-    this.technologyWeights = {
-      regex: 0.15,
-      ast: 0.25,
-      dataflow: 0.20,
-      controlflow: 0.15,
-      semantic: 0.15,
-      patternLearning: 0.10
-    };
-    
-    // Performance tracking
-    this.performanceMetrics = {
-      technologyExecutionTimes: new Map(),
-      accuracyComparisons: new Map(),
-      combinationEffectiveness: new Map()
-    };
-  }
-
-  /**
-   * Load all available analyzers with graceful fallback
-   */
-  loadAnalyzers() {
-    const analyzers = {};
-    
-    const analyzerConfigs = [
-      { name: 'ast', path: './ast-analyzer.js', description: 'AST-based analysis' },
-      { name: 'dataflow', path: './dataflow-analyzer.js', description: 'Data flow analysis' },
-      { name: 'cfg', path: './cfg-analyzer.js', description: 'Control flow analysis' },
-      { name: 'semantic', path: './semantic-analyzer.js', description: 'Semantic analysis' },
-      { name: 'patternLearning', path: './pattern-learning-analyzer.js', description: 'Pattern learning' },
-      { name: 'multiLanguage', path: './multi-language-ast-engine.js', description: 'Multi-language support' }
-    ];
-    
-    for (const config of analyzerConfigs) {
-      try {
-        analyzers[config.name] = require(config.path);
-        console.log(`✅ C029: ${config.description} loaded`);
-      } catch (error) {
-        console.warn(`⚠️ C029: ${config.description} not available:`, error.message);
-        analyzers[config.name] = null;
-      }
-    }
-    
-    return analyzers;
-  }
-
-  async analyze(files, language, options = {}) {
-    console.log(`🔬 C029 Multi-Technology Analysis: Processing ${files.length} files with advanced techniques...`);
-    
-    const startTime = Date.now();
-    const allResults = new Map(); // technology -> violations
-    const executionTimes = new Map();
-    
-    // Run all available technologies in parallel
-    const analysisPromises = [];
-    
-    // 1. Regex Analysis (always available)
-    if (this.analysisConfig.enableRegex) {
-      analysisPromises.push(
-        this.runTechnologyAnalysis('regex', () => this.analyzeWithRegex(files, language, options))
-      );
-    }
-    
-    // 2. AST Analysis
-    if (this.analysisConfig.enableAST && this.analyzers.ast) {
-      analysisPromises.push(
-        this.runTechnologyAnalysis('ast', () => this.analyzers.ast.analyze(files, language, options))
-      );
-    }
-    
-    // 3. Data Flow Analysis
-    if (this.analysisConfig.enableDataflow && this.analyzers.dataflow) {
-      analysisPromises.push(
-        this.runTechnologyAnalysis('dataflow', () => this.analyzers.dataflow.analyze(files, language, options))
-      );
-    }
-    
-    // 4. Control Flow Analysis
-    if (this.analysisConfig.enableControlflow && this.analyzers.cfg) {
-      analysisPromises.push(
-        this.runTechnologyAnalysis('controlflow', () => this.analyzers.cfg.analyze(files, language, options))
-      );
-    }
-    
-    // 5. Semantic Analysis
-    if (this.analysisConfig.enableSemantic && this.analyzers.semantic) {
-      analysisPromises.push(
-        this.runTechnologyAnalysis('semantic', () => this.analyzers.semantic.analyze(files, language, options))
-      );
-    }
-    
-    // 6. Pattern Learning Analysis
-    if (this.analysisConfig.enablePatternLearning && this.analyzers.patternLearning) {
-      analysisPromises.push(
-        this.runTechnologyAnalysis('patternLearning', () => this.analyzers.patternLearning.analyze(files, language, options))
-      );
-    }
-    
-    // 7. Multi-Language Analysis
-    if (this.analysisConfig.enableMultiLanguage && this.analyzers.multiLanguage) {
-      analysisPromises.push(
-        this.runTechnologyAnalysis('multiLanguage', () => this.analyzers.multiLanguage.analyze(files, language, options))
-      );
-    }
-    
-    // Wait for all analyses to complete
-    const results = await Promise.allSettled(analysisPromises);
-    
-    // Process results
-    for (const result of results) {
-      if (result.status === 'fulfilled') {
-        const { technology, violations, executionTime } = result.value;
-        allResults.set(technology, violations);
-        executionTimes.set(technology, executionTime);
-        console.log(`✅ ${technology}: ${violations.length} issues found (${executionTime}ms)`);
-      } else {
-        console.error(`❌ Analysis failed:`, result.reason);
-      }
-    }
-    
-    // Combine results using configured strategy
-    const finalViolations = this.combineResults(allResults, executionTimes);
-    
-    const totalTime = Date.now() - startTime;
-    console.log(`🎯 C029 Final Results: ${finalViolations.length} issues identified (${totalTime}ms total)`);
-    
-    // Update performance metrics
-    this.updatePerformanceMetrics(allResults, executionTimes, totalTime);
-    
-    return finalViolations;
-  }
-
-  /**
-   * Run a technology analysis with timing and error handling
-   */
-  async runTechnologyAnalysis(technology, analysisFunction) {
-    const startTime = Date.now();
-    
-    try {
-      const violations = await analysisFunction();
-      const executionTime = Date.now() - startTime;
-      
-      return {
-        technology,
-        violations: violations || [],
-        executionTime,
-        success: true
-      };
-    } catch (error) {
-      const executionTime = Date.now() - startTime;
-      console.error(`❌ ${technology} analysis failed:`, error.message);
-      
-      return {
-        technology,
-        violations: [],
-        executionTime,
-        success: false,
-        error: error.message
-      };
-    }
-  }
-
-  /**
-   * Combine results from multiple technologies
-   */
-  combineResults(allResults, executionTimes) {
-    switch (this.analysisConfig.combinationStrategy) {
-      case 'union':
-        return this.combineUnion(allResults);
-      
-      case 'intersection':
-        return this.combineIntersection(allResults);
-      
-      case 'weighted_voting':
-      default:
-        return this.combineWeightedVoting(allResults);
-    }
-  }
-
-  /**
-   * Union strategy: Include all violations from all technologies
-   */
-  combineUnion(allResults) {
-    const allViolations = [];
-    const seenViolations = new Set();
-    
-    for (const [technology, violations] of allResults) {
-      for (const violation of violations) {
-        const key = `${violation.file}:${violation.line}:${violation.type}`;
-        
-        if (!seenViolations.has(key)) {
-          seenViolations.add(key);
-          allViolations.push({
-            ...violation,
-            detectedBy: [technology],
-            combinationStrategy: 'union'
-          });
-        } else {
-          // Find existing violation and add technology
-          const existing = allViolations.find(v => 
-            v.file === violation.file && 
-            v.line === violation.line && 
-            v.type === violation.type
-          );
-          if (existing) {
-            existing.detectedBy.push(technology);
-          }
-        }
-      }
-    }
-    
-    return allViolations;
-  }
-
-  /**
-   * Intersection strategy: Only include violations found by multiple technologies
-   */
-  combineIntersection(allResults) {
-    const violationCounts = new Map();
-    const violationData = new Map();
-    
-    // Count how many technologies detected each violation
-    for (const [technology, violations] of allResults) {
-      for (const violation of violations) {
-        const key = `${violation.file}:${violation.line}:${violation.type}`;
-        
-        violationCounts.set(key, (violationCounts.get(key) || 0) + 1);
-        
-        if (!violationData.has(key)) {
-          violationData.set(key, {
-            ...violation,
-            detectedBy: [technology],
-            combinationStrategy: 'intersection'
-          });
-        } else {
-          violationData.get(key).detectedBy.push(technology);
-        }
-      }
-    }
-    
-    // Only return violations detected by at least 2 technologies
-    const minDetections = Math.max(2, Math.floor(allResults.size / 2));
-    return Array.from(violationData.values())
-      .filter(violation => violationCounts.get(`${violation.file}:${violation.line}:${violation.type}`) >= minDetections);
-  }
-
-  /**
-   * Weighted voting strategy: Use confidence scores and technology weights
-   */
-  combineWeightedVoting(allResults) {
-    const violationScores = new Map();
-    const violationData = new Map();
-    
-    // Calculate weighted scores for each violation
-    for (const [technology, violations] of allResults) {
-      const weight = this.technologyWeights[technology] || 0.1;
-      
-      for (const violation of violations) {
-        const key = `${violation.file}:${violation.line}:${violation.type}`;
-        const score = (violation.confidence || 0.7) * weight;
-        
-        violationScores.set(key, (violationScores.get(key) || 0) + score);
-        
-        if (!violationData.has(key)) {
-          violationData.set(key, {
-            ...violation,
-            detectedBy: [technology],
-            weightedScore: score,
-            combinationStrategy: 'weighted_voting'
-          });
-        } else {
-          const existing = violationData.get(key);
-          existing.detectedBy.push(technology);
-          existing.weightedScore = violationScores.get(key);
-          
-          // Use highest confidence message
-          if ((violation.confidence || 0.7) > (existing.confidence || 0.7)) {
-            existing.message = violation.message;
-            existing.suggestion = violation.suggestion;
-          }
-        }
-      }
-    }
-    
-    // Return violations above confidence threshold
-    return Array.from(violationData.values())
-      .filter(violation => violation.weightedScore >= this.analysisConfig.confidenceThreshold)
-      .sort((a, b) => b.weightedScore - a.weightedScore);
-  }
-
-  /**
-   * Regex-based analysis (fallback)
-   */
-  async analyzeWithRegex(files, language, options = {}) {
-    const violations = [];
-    console.log(`📄 C029 Regex: Analyzing ${files.length} files with pattern matching...`);
-    
-    for (const filePath of files) {
-      try {
-        const content = fs.readFileSync(filePath, 'utf8');
-        const regexViolations = this.findCatchBlocksRegex(content, filePath);
-        violations.push(...regexViolations);
-      } catch (error) {
-        console.warn(`C029 Regex skipping ${filePath}: ${error.message}`);
-      }
-    }
-    
-    return violations;
-  }
-
-  /**
-   * Find catch blocks using regex patterns
-   */
-  findCatchBlocksRegex(content, filePath) {
-    const violations = [];
-    const lines = content.split('\n');
-    
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      
-      // Basic catch block detection
-      if (/catch\s*\([^)]*\)\s*\{/.test(line)) {
-        const catchBlock = this.extractCatchBlock(lines, i);
-        
-        if (this.isCatchBlockViolation(catchBlock, filePath)) {
-          violations.push({
-            ruleId: this.ruleId,
-            file: filePath,
-            line: i + 1,
-            column: 1,
-            message: 'Empty or inadequate error handling in catch block',
-            severity: 'error',
-            code: catchBlock.code,
-            type: 'regex_catch_violation',
-            confidence: 0.6,
-            suggestion: 'Add error logging or appropriate error handling',
-            detectedBy: ['regex']
-          });
-        }
-      }
-    }
-    
-    return violations;
-  }
-
-  /**
-   * Extract catch block content
-   */
-  extractCatchBlock(lines, startIndex) {
-    let braceCount = 0;
-    let content = '';
-    let endIndex = startIndex;
-    
-    for (let i = startIndex; i < lines.length; i++) {
-      const line = lines[i];
-      content += line + '\n';
-      
-      braceCount += (line.match(/\{/g) || []).length;
-      braceCount -= (line.match(/\}/g) || []).length;
-      
-      if (braceCount === 0 && i > startIndex) {
-        endIndex = i;
-        break;
-      }
-    }
-    
-    return {
-      code: content.trim(),
-      startLine: startIndex + 1,
-      endLine: endIndex + 1,
-      content: content.trim()
-    };
-  }
-
-  /**
-   * Check if catch block is a violation
-   */
-  isCatchBlockViolation(catchBlock, filePath) {
-    const content = catchBlock.content;
-    
-    // Empty catch block
-    if (!content || content.replace(/[{}\s]/g, '').length === 0) {
-      return true;
-    }
-    
-    // Check for logging patterns
-    const hasLogging = /console\.(log|error|warn|debug)|logger?\.(error|warn|info|debug)|print/.test(content);
-    
-    // Skip test files (less strict)
-    const isTestFile = /(__tests__|\.test\.|\.spec\.|\/test\/|\/tests\/)/.test(filePath);
-    
-    return !hasLogging && !isTestFile;
-  }
-
-  /**
-   * Update performance metrics for analysis
-   */
-  updatePerformanceMetrics(allResults, executionTimes, totalTime) {
-    // Track execution times
-    for (const [technology, time] of executionTimes) {
-      if (!this.performanceMetrics.technologyExecutionTimes.has(technology)) {
-        this.performanceMetrics.technologyExecutionTimes.set(technology, []);
-      }
-      this.performanceMetrics.technologyExecutionTimes.get(technology).push(time);
-    }
-    
-    // Track accuracy comparisons (simplified)
-    const technologiesUsed = Array.from(allResults.keys());
-    for (let i = 0; i < technologiesUsed.length; i++) {
-      for (let j = i + 1; j < technologiesUsed.length; j++) {
-        const tech1 = technologiesUsed[i];
-        const tech2 = technologiesUsed[j];
-        const pair = `${tech1}-${tech2}`;
-        
-        const violations1 = allResults.get(tech1).length;
-        const violations2 = allResults.get(tech2).length;
-        const agreement = Math.abs(violations1 - violations2) / Math.max(violations1, violations2, 1);
-        
-        if (!this.performanceMetrics.accuracyComparisons.has(pair)) {
-          this.performanceMetrics.accuracyComparisons.set(pair, []);
-        }
-        this.performanceMetrics.accuracyComparisons.get(pair).push(agreement);
-      }
-    }
-  }
-
-  /**
-   * Get performance insights
-   */
-  getPerformanceInsights() {
-    const insights = {
-      averageExecutionTimes: new Map(),
-      technologiesUsed: Array.from(this.performanceMetrics.technologyExecutionTimes.keys()),
-      totalAnalysesRun: 0
-    };
-    
-    for (const [technology, times] of this.performanceMetrics.technologyExecutionTimes) {
-      const avg = times.reduce((sum, time) => sum + time, 0) / times.length;
-      insights.averageExecutionTimes.set(technology, avg);
-      insights.totalAnalysesRun += times.length;
-    }
-    
-    return insights;
-  }
-}
-
-module.exports = new C029CatchBlockAnalyzer();