@sun-asterisk/sunlint 1.2.2 → 1.3.1

package/rules/common/C029_catch_block_logging/pattern-learning-analyzer.js

@@ -1,568 +0,0 @@
-/**
- * C029 Pattern Learning Analyzer
- * 
- * Uses machine learning techniques to learn from codebase patterns
- * and adapt detection rules based on project-specific conventions
- * 
- * Technology Showcase: Adaptive rule learning from codebase patterns
- */
-
-class C029PatternLearningAnalyzer {
-  constructor() {
-    this.ruleId = 'C029';
-    this.ruleName = 'Pattern Learning Enhanced Catch Analysis';
-    this.description = 'Learns from codebase patterns to adapt error handling detection';
-    
-    // Pattern learning state
-    this.learnedPatterns = {
-      validErrorHandling: new Map(),    // Pattern -> frequency
-      invalidErrorHandling: new Map(),  // Pattern -> frequency
-      contextPatterns: new Map(),       // Context -> handling style
-      projectConventions: new Map()     // Convention -> confidence
-    };
-    
-    // Learning configuration
-    this.learningConfig = {
-      minPatternFrequency: 3,           // Minimum occurrences to learn pattern
-      contextWindowSize: 5,             // Lines of context for pattern learning
-      adaptationThreshold: 0.7,         // Confidence threshold for pattern adaptation
-      maxPatternsToLearn: 100           // Prevent memory bloat
-    };
-  }
-
-  async analyze(files, language, options = {}) {
-    const violations = [];
-    console.log(`🤖 C029 Pattern Learning: Analyzing ${files.length} files with adaptive learning...`);
-
-    // Phase 1: Learn patterns from codebase
-    const learningPhase = await this.learnPatternsFromCodebase(files, language);
-    console.log(`🧠 Learned ${learningPhase.patternsLearned} patterns from codebase`);
-
-    // Phase 2: Apply learned patterns for detection
-    for (const filePath of files) {
-      try {
-        const content = require('fs').readFileSync(filePath, 'utf8');
-        const patternViolations = await this.analyzeWithLearnedPatterns(content, filePath, language);
-        violations.push(...patternViolations);
-
-      } catch (error) {
-        console.warn(`C029 Pattern Learning skipping ${filePath}: ${error.message}`);
-      }
-    }
-
-    // Phase 3: Report learning insights
-    this.reportLearningInsights();
-
-    return violations;
-  }
-
-  /**
-   * Learn patterns from the entire codebase
-   */
-  async learnPatternsFromCodebase(files, language) {
-    console.log(`🔍 Learning phase: Analyzing ${files.length} files for patterns...`);
-    
-    let patternsLearned = 0;
-    const patternCandidates = new Map();
-    
-    for (const filePath of files) {
-      try {
-        const content = require('fs').readFileSync(filePath, 'utf8');
-        const catchBlocks = this.extractCatchBlocksWithContext(content);
-        
-        for (const catchBlock of catchBlocks) {
-          // Extract and categorize patterns
-          const patterns = this.extractPatterns(catchBlock, content);
-          
-          for (const pattern of patterns) {
-            const key = pattern.signature;
-            if (!patternCandidates.has(key)) {
-              patternCandidates.set(key, {
-                pattern,
-                frequency: 0,
-                examples: [],
-                contexts: []
-              });
-            }
-            
-            const candidate = patternCandidates.get(key);
-            candidate.frequency++;
-            
-            if (candidate.examples.length < 5) {
-              candidate.examples.push({
-                file: filePath,
-                code: catchBlock.code,
-                lineNumber: catchBlock.lineNumber
-              });
-            }
-            
-            candidate.contexts.push(pattern.context);
-          }
-        }
-        
-      } catch (error) {
-        // Skip problematic files during learning
-      }
-    }
-    
-    // Promote candidates to learned patterns
-    for (const [key, candidate] of patternCandidates) {
-      if (candidate.frequency >= this.learningConfig.minPatternFrequency) {
-        this.promoteToLearnedPattern(candidate);
-        patternsLearned++;
-      }
-    }
-    
-    // Learn project conventions
-    this.learnProjectConventions(patternCandidates);
-    
-    return { patternsLearned };
-  }
-
-  /**
-   * Extract patterns from catch block for learning
-   */
-  extractPatterns(catchBlock, fullContent) {
-    const patterns = [];
-    const content = catchBlock.content;
-    const context = catchBlock.context;
-    
-    // 1. Error handling style patterns
-    patterns.push(...this.extractHandlingStylePatterns(content, context));
-    
-    // 2. Naming convention patterns
-    patterns.push(...this.extractNamingPatterns(content, context));
-    
-    // 3. Context-specific patterns
-    patterns.push(...this.extractContextPatterns(content, context, catchBlock));
-    
-    // 4. Framework-specific patterns
-    patterns.push(...this.extractFrameworkPatterns(content, fullContent));
-    
-    return patterns;
-  }
-
-  /**
-   * Extract error handling style patterns
-   */
-  extractHandlingStylePatterns(content, context) {
-    const patterns = [];
-    
-    // Pattern: Logging style
-    if (/console\.(log|error|warn)/.test(content)) {
-      patterns.push({
-        type: 'handling_style',
-        subtype: 'console_logging',
-        signature: 'console_logging',
-        confidence: 0.8,
-        context: context
-      });
-    }
-    
-    // Pattern: Rethrowing style
-    if (/throw/.test(content)) {
-      patterns.push({
-        type: 'handling_style',
-        subtype: 'rethrowing',
-        signature: 'rethrowing',
-        confidence: 0.9,
-        context: context
-      });
-    }
-    
-    // Pattern: Silent handling with return
-    if (/return\s+(null|undefined|false|\[\]|\{\})/.test(content)) {
-      patterns.push({
-        type: 'handling_style',
-        subtype: 'silent_return',
-        signature: 'silent_return',
-        confidence: 0.7,
-        context: context
-      });
-    }
-    
-    // Pattern: State management
-    if (/setState|dispatch|commit/.test(content)) {
-      patterns.push({
-        type: 'handling_style',
-        subtype: 'state_management',
-        signature: 'state_management',
-        confidence: 0.8,
-        context: context
-      });
-    }
-    
-    return patterns;
-  }
-
-  /**
-   * Extract naming convention patterns
-   */
-  extractNamingPatterns(content, context) {
-    const patterns = [];
-    
-    // Extract error parameter names
-    const errorParamMatch = content.match(/catch\s*\(\s*(\w+)\s*\)/);
-    if (errorParamMatch) {
-      const paramName = errorParamMatch[1];
-      
-      patterns.push({
-        type: 'naming_convention',
-        subtype: 'error_parameter',
-        signature: `error_param_${paramName}`,
-        paramName,
-        confidence: 0.6,
-        context: context
-      });
-    }
-    
-    return patterns;
-  }
-
-  /**
-   * Extract context-specific patterns
-   */
-  extractContextPatterns(content, context, catchBlock) {
-    const patterns = [];
-    
-    // Pattern: Function context
-    const functionContext = this.extractFunctionContext(context);
-    if (functionContext) {
-      patterns.push({
-        type: 'context_pattern',
-        subtype: 'function_context',
-        signature: `function_${functionContext.type}`,
-        functionType: functionContext.type,
-        confidence: 0.7,
-        context: context
-      });
-    }
-    
-    // Pattern: Class method context
-    if (/class\s+\w+/.test(context.before)) {
-      patterns.push({
-        type: 'context_pattern',
-        subtype: 'class_method',
-        signature: 'class_method_error_handling',
-        confidence: 0.8,
-        context: context
-      });
-    }
-    
-    return patterns;
-  }
-
-  /**
-   * Extract framework-specific patterns
-   */
-  extractFrameworkPatterns(content, fullContent) {
-    const patterns = [];
-    
-    // React patterns
-    if (/import.*react/i.test(fullContent)) {
-      if (/setState|setError|setLoading/.test(content)) {
-        patterns.push({
-          type: 'framework_pattern',
-          subtype: 'react_error_handling',
-          signature: 'react_state_error',
-          confidence: 0.9,
-          framework: 'react'
-        });
-      }
-    }
-    
-    // Redux patterns
-    if (/rejectWithValue|dispatch/.test(content)) {
-      patterns.push({
-        type: 'framework_pattern',
-        subtype: 'redux_error_handling',
-        signature: 'redux_thunk_error',
-        confidence: 0.9,
-        framework: 'redux'
-      });
-    }
-    
-    // Express.js patterns
-    if (/req\.|res\.|next\(/.test(content)) {
-      patterns.push({
-        type: 'framework_pattern',
-        subtype: 'express_error_handling',
-        signature: 'express_middleware_error',
-        confidence: 0.8,
-        framework: 'express'
-      });
-    }
-    
-    return patterns;
-  }
-
-  /**
-   * Promote pattern candidate to learned pattern
-   */
-  promoteToLearnedPattern(candidate) {
-    const pattern = candidate.pattern;
-    const key = pattern.signature;
-    
-    // Determine if pattern represents valid or invalid handling
-    const validity = this.assessPatternValidity(candidate);
-    
-    if (validity.isValid) {
-      this.learnedPatterns.validErrorHandling.set(key, {
-        pattern,
-        frequency: candidate.frequency,
-        confidence: validity.confidence,
-        examples: candidate.examples.slice(0, 3) // Keep top examples
-      });
-    } else {
-      this.learnedPatterns.invalidErrorHandling.set(key, {
-        pattern,
-        frequency: candidate.frequency,
-        confidence: validity.confidence,
-        examples: candidate.examples.slice(0, 3)
-      });
-    }
-  }
-
-  /**
-   * Learn project-wide conventions
-   */
-  learnProjectConventions(patternCandidates) {
-    const conventions = new Map();
-    
-    // Learn error parameter naming conventions
-    const errorParamNames = new Map();
-    for (const [key, candidate] of patternCandidates) {
-      if (candidate.pattern.type === 'naming_convention') {
-        const paramName = candidate.pattern.paramName;
-        errorParamNames.set(paramName, (errorParamNames.get(paramName) || 0) + candidate.frequency);
-      }
-    }
-    
-    // Find dominant naming convention
-    const dominantParamName = [...errorParamNames.entries()]
-      .sort((a, b) => b[1] - a[1])[0];
-    
-    if (dominantParamName && dominantParamName[1] >= 5) {
-      conventions.set('error_param_naming', {
-        convention: dominantParamName[0],
-        confidence: Math.min(dominantParamName[1] / 20, 0.9)
-      });
-    }
-    
-    // Learn logging preferences
-    const loggingStyles = new Map();
-    for (const [key, candidate] of patternCandidates) {
-      if (candidate.pattern.subtype === 'console_logging') {
-        loggingStyles.set('console', (loggingStyles.get('console') || 0) + candidate.frequency);
-      }
-    }
-    
-    this.learnedPatterns.projectConventions = conventions;
-  }
-
-  /**
-   * Analyze file using learned patterns
-   */
-  async analyzeWithLearnedPatterns(content, filePath, language) {
-    const violations = [];
-    const isTestFile = this.isTestFile(filePath);
-    
-    const catchBlocks = this.extractCatchBlocksWithContext(content);
-    
-    for (const catchBlock of catchBlocks) {
-      const analysis = this.analyzeBlockWithPatterns(catchBlock, content, isTestFile);
-      
-      if (analysis.isViolation) {
-        violations.push({
-          ruleId: this.ruleId,
-          file: filePath,
-          line: catchBlock.lineNumber,
-          column: 1,
-          message: analysis.message,
-          severity: analysis.severity,
-          code: catchBlock.code,
-          type: analysis.type,
-          confidence: analysis.confidence,
-          suggestion: analysis.suggestion,
-          learnedPattern: analysis.matchedPattern,
-          adaptiveInsight: analysis.insight
-        });
-      }
-    }
-    
-    return violations;
-  }
-
-  /**
-   * Analyze catch block using learned patterns
-   */
-  analyzeBlockWithPatterns(catchBlock, fullContent, isTestFile) {
-    const blockPatterns = this.extractPatterns(catchBlock, fullContent);
-    
-    // Check against learned valid patterns
-    for (const pattern of blockPatterns) {
-      const validMatch = this.learnedPatterns.validErrorHandling.get(pattern.signature);
-      if (validMatch && validMatch.confidence >= this.learningConfig.adaptationThreshold) {
-        return {
-          isViolation: false,
-          reason: 'matches_learned_valid_pattern',
-          matchedPattern: validMatch.pattern
-        };
-      }
-    }
-    
-    // Check against learned invalid patterns
-    for (const pattern of blockPatterns) {
-      const invalidMatch = this.learnedPatterns.invalidErrorHandling.get(pattern.signature);
-      if (invalidMatch && invalidMatch.confidence >= this.learningConfig.adaptationThreshold) {
-        return {
-          isViolation: true,
-          type: 'learned_invalid_pattern',
-          message: `Error handling matches learned invalid pattern: ${pattern.signature}`,
-          severity: 'warning',
-          confidence: invalidMatch.confidence,
-          suggestion: this.generateAdaptiveSuggestion(invalidMatch),
-          matchedPattern: invalidMatch.pattern,
-          insight: `Pattern seen ${invalidMatch.frequency} times in codebase`
-        };
-      }
-    }
-    
-    // Apply project conventions
-    const conventionViolation = this.checkProjectConventions(catchBlock, blockPatterns);
-    if (conventionViolation) {
-      return conventionViolation;
-    }
-    
-    // Default analysis if no learned patterns match
-    return this.defaultPatternAnalysis(catchBlock, isTestFile);
-  }
-
-  /**
-   * Assess whether a pattern represents valid error handling
-   */
-  assessPatternValidity(candidate) {
-    const pattern = candidate.pattern;
-    const examples = candidate.examples;
-    
-    // Heuristic-based validity assessment
-    let validityScore = 0.5;
-    
-    // Positive indicators
-    if (pattern.subtype === 'console_logging') validityScore += 0.2;
-    if (pattern.subtype === 'rethrowing') validityScore += 0.3;
-    if (pattern.subtype === 'state_management') validityScore += 0.2;
-    
-    // Negative indicators
-    if (pattern.subtype === 'silent_return') validityScore -= 0.3;
-    if (pattern.signature.includes('empty')) validityScore -= 0.4;
-    
-    // Context indicators
-    if (pattern.framework) validityScore += 0.1; // Framework-specific patterns often valid
-    
-    return {
-      isValid: validityScore > 0.6,
-      confidence: Math.min(Math.abs(validityScore - 0.5) * 2, 0.9)
-    };
-  }
-
-  /**
-   * Report learning insights
-   */
-  reportLearningInsights() {
-    const totalValid = this.learnedPatterns.validErrorHandling.size;
-    const totalInvalid = this.learnedPatterns.invalidErrorHandling.size;
-    const conventions = this.learnedPatterns.projectConventions.size;
-    
-    console.log(`📊 Pattern Learning Results:`);
-    console.log(`  ✅ Valid patterns learned: ${totalValid}`);
-    console.log(`  ❌ Invalid patterns learned: ${totalInvalid}`);
-    console.log(`  📏 Project conventions: ${conventions}`);
-    
-    // Report top patterns
-    const topValid = [...this.learnedPatterns.validErrorHandling.entries()]
-      .sort((a, b) => b[1].frequency - a[1].frequency)
-      .slice(0, 3);
-    
-    if (topValid.length > 0) {
-      console.log(`  🔝 Top valid patterns:`);
-      for (const [signature, data] of topValid) {
-        console.log(`    - ${signature}: ${data.frequency} occurrences`);
-      }
-    }
-  }
-
-  // Helper methods (simplified implementations)
-  extractCatchBlocksWithContext(content) {
-    // Reuse from previous implementations
-    return [];
-  }
-
-  extractFunctionContext(context) {
-    if (/async\s+function/.test(context.before)) {
-      return { type: 'async_function' };
-    }
-    if (/function/.test(context.before)) {
-      return { type: 'regular_function' };
-    }
-    return null;
-  }
-
-  generateAdaptiveSuggestion(invalidMatch) {
-    const pattern = invalidMatch.pattern;
-    
-    switch (pattern.subtype) {
-      case 'silent_return':
-        return 'Consider adding error logging before returning fallback value';
-      case 'empty_catch':
-        return 'Add error handling or explicit ignore with documentation';
-      default:
-        return `Improve error handling - pattern "${pattern.signature}" found to be problematic in this codebase`;
-    }
-  }
-
-  checkProjectConventions(catchBlock, patterns) {
-    // Check naming conventions
-    const namingConvention = this.learnedPatterns.projectConventions.get('error_param_naming');
-    if (namingConvention) {
-      const errorParamPattern = patterns.find(p => p.type === 'naming_convention');
-      if (errorParamPattern && errorParamPattern.paramName !== namingConvention.convention) {
-        return {
-          isViolation: true,
-          type: 'naming_convention_violation',
-          message: `Error parameter naming inconsistent with project convention (expected: ${namingConvention.convention})`,
-          severity: 'info',
-          confidence: namingConvention.confidence,
-          suggestion: `Use '${namingConvention.convention}' for error parameter to match project convention`
-        };
-      }
-    }
-    
-    return null;
-  }
-
-  defaultPatternAnalysis(catchBlock, isTestFile) {
-    // Fallback to simple analysis if no patterns learned
-    const content = catchBlock.content;
-    
-    if (!content || content.trim().length === 0) {
-      return {
-        isViolation: true,
-        type: 'empty_catch_default',
-        message: 'Empty catch block - no learned patterns to validate against',
-        severity: 'error',
-        confidence: 0.8,
-        suggestion: 'Add error handling or learn from similar patterns in codebase'
-      };
-    }
-    
-    return { isViolation: false, reason: 'no_learned_patterns_default_pass' };
-  }
-
-  isTestFile(filePath) {
-    const testPatterns = ['__tests__', '.test.', '.spec.', '/test/', '/tests/'];
-    return testPatterns.some(pattern => filePath.includes(pattern));
-  }
-}
-
-module.exports = new C029PatternLearningAnalyzer();