onbuzz 3.3.0

package/src/analyzers/codeCloneDetector/analyzer.js

@@ -0,0 +1,344 @@
+/**
+ * Analyzes clones and provides refactoring recommendations
+ */
+export class RefactoringAnalyzer {
+  constructor(config) {
+    this.config = config;
+  }
+
+  /**
+   * Analyze clones and provide refactoring advice
+   * @param {Array} clones - Array of detected clones
+   * @returns {Array} Enriched clones with refactoring advice
+   */
+  analyzeClones(clones) {
+    console.log('Analyzing clones for refactoring opportunities...');
+    
+    return clones.map((clone, index) => {
+      const metrics = this.calculateMetrics(clone);
+      const advice = this.generateRefactoringAdvice(clone, metrics);
+      
+      return {
+        id: `clone-${index + 1}`,
+        type: clone.type,
+        confidence: clone.confidence,
+        instances: clone.blocks.map(block => ({
+          file: block.file,
+          startLine: block.startLine,
+          endLine: block.endLine,
+          code: this.truncateCode(block.code),
+          fullCode: block.code,
+          blockType: block.type
+        })),
+        metrics,
+        refactoringAdvice: advice
+      };
+    }).sort((a, b) => b.metrics.impactScore - a.metrics.impactScore);
+  }
+
+  /**
+   * Calculate metrics for a clone
+   */
+  calculateMetrics(clone) {
+    const blocks = clone.blocks;
+    const tokenCount = clone.tokenCount;
+    const lineCount = this.averageLineCount(blocks);
+    const instanceCount = blocks.length;
+    
+    // Calculate impact score (higher = more important to refactor)
+    const impactScore = this.calculateImpactScore(
+      tokenCount,
+      lineCount,
+      instanceCount,
+      clone.confidence
+    );
+    
+    // Calculate duplication overhead
+    const duplicatedLines = lineCount * (instanceCount - 1);
+    const duplicatedTokens = tokenCount * (instanceCount - 1);
+    
+    return {
+      tokenCount,
+      lineCount,
+      instanceCount,
+      duplicatedLines,
+      duplicatedTokens,
+      impactScore: parseFloat(impactScore.toFixed(2)),
+      filesCovered: new Set(blocks.map(b => b.file)).size
+    };
+  }
+
+  /**
+   * Calculate impact score for prioritization
+   */
+  calculateImpactScore(tokenCount, lineCount, instanceCount, confidence) {
+    // Weighted formula:
+    // - Size matters (more tokens = more important)
+    // - Instances matter (more copies = more important)
+    // - Confidence matters
+    // - Line count matters (user visibility)
+    
+    const sizeScore = Math.log10(tokenCount + 1) * 2;
+    const instanceScore = Math.log2(instanceCount + 1) * 3;
+    const confidenceScore = confidence * 2;
+    const lineScore = Math.min(lineCount / 10, 3);
+    
+    return sizeScore + instanceScore + confidenceScore + lineScore;
+  }
+
+  /**
+   * Generate refactoring advice
+   */
+  generateRefactoringAdvice(clone, metrics) {
+    const strategy = this.determineRefactoringStrategy(clone, metrics);
+    const priority = this.determinePriority(metrics);
+    const suggestedName = this.suggestName(clone);
+    const reasoning = this.generateReasoning(clone, metrics, strategy);
+    const estimatedEffort = this.estimateEffort(metrics, strategy);
+    const benefits = this.describeBenefits(metrics);
+    
+    return {
+      priority,
+      strategy,
+      suggestedName,
+      reasoning,
+      estimatedEffort,
+      benefits,
+      actionableSteps: this.generateActionableSteps(strategy, suggestedName, metrics)
+    };
+  }
+
+  /**
+   * Determine refactoring strategy
+   */
+  determineRefactoringStrategy(clone, metrics) {
+    const { tokenCount, lineCount, instanceCount, filesCovered } = metrics;
+    const blockTypes = clone.blocks.map(b => b.type);
+    
+    // Check if it's a function/method
+    const isFunctionLike = blockTypes.some(type => 
+      type.includes('Function') || type.includes('Method')
+    );
+    
+    // Check if it's a class
+    const isClassLike = blockTypes.some(type => 
+      type.includes('Class')
+    );
+    
+    // Decision tree
+    if (isClassLike && lineCount > 50) {
+      return 'extract-module';
+    } else if (filesCovered > 2 && tokenCount > 100) {
+      return 'extract-module';
+    } else if (isFunctionLike || (lineCount >= 10 && lineCount <= 50)) {
+      return 'extract-function';
+    } else if (lineCount > 50) {
+      return 'extract-class';
+    } else if (lineCount < 10) {
+      return 'extract-constant-or-utility';
+    } else {
+      return 'extract-function';
+    }
+  }
+
+  /**
+   * Determine priority level
+   */
+  determinePriority(metrics) {
+    const { impactScore } = metrics;
+    
+    if (impactScore >= 8) return 'high';
+    if (impactScore >= 5) return 'medium';
+    return 'low';
+  }
+
+  /**
+   * Suggest a name based on code analysis
+   */
+  suggestName(clone) {
+    // Extract common words from the code
+    const allCode = clone.blocks.map(b => b.code).join(' ');
+    
+    // Look for common identifiers
+    const identifiers = allCode.match(/[a-zA-Z_$][a-zA-Z0-9_$]*/g) || [];
+    const frequency = {};
+    
+    identifiers.forEach(id => {
+      // Skip common keywords
+      if (['const', 'let', 'var', 'function', 'return', 'if', 'else', 'for', 'while'].includes(id)) {
+        return;
+      }
+      frequency[id] = (frequency[id] || 0) + 1;
+    });
+    
+    // Find most common meaningful identifier
+    const sorted = Object.entries(frequency)
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 3);
+    
+    if (sorted.length > 0) {
+      // Create a descriptive name from top identifiers
+      const topWords = sorted.map(([word]) => word);
+      return this.createFunctionName(topWords);
+    }
+    
+    return 'extractedFunction';
+  }
+
+  /**
+   * Create a function name from words
+   */
+  createFunctionName(words) {
+    if (words.length === 0) return 'extractedFunction';
+    
+    // Convert to camelCase
+    return words[0] + words.slice(1).map(w => 
+      w.charAt(0).toUpperCase() + w.slice(1)
+    ).join('');
+  }
+
+  /**
+   * Generate reasoning for refactoring
+   */
+  generateReasoning(clone, metrics, strategy) {
+    const { instanceCount, duplicatedLines, filesCovered } = metrics;
+    
+    let reasoning = `This ${clone.type} code pattern appears ${instanceCount} times`;
+    
+    if (filesCovered > 1) {
+      reasoning += ` across ${filesCovered} different files`;
+    }
+    
+    reasoning += `, resulting in ${duplicatedLines} duplicated lines. `;
+    
+    reasoning += `Refactoring to ${strategy.replace(/-/g, ' ')} would improve maintainability`;
+    
+    if (instanceCount >= 3) {
+      reasoning += ', reduce bugs from inconsistent changes';
+    }
+    
+    reasoning += ', and reduce code size';
+    
+    if (metrics.impactScore >= 8) {
+      reasoning += '. This is a high-impact refactoring opportunity';
+    }
+    
+    return reasoning + '.';
+  }
+
+  /**
+   * Estimate effort for refactoring
+   */
+  estimateEffort(metrics, strategy) {
+    const { lineCount, instanceCount, filesCovered } = metrics;
+    
+    let effortPoints = 0;
+    
+    // Base effort on size
+    effortPoints += Math.min(lineCount / 10, 5);
+    
+    // Effort increases with instances
+    effortPoints += instanceCount * 0.5;
+    
+    // Effort increases with file spread
+    effortPoints += filesCovered * 0.5;
+    
+    // Strategy-specific effort
+    if (strategy === 'extract-module') {
+      effortPoints += 3;
+    } else if (strategy === 'extract-class') {
+      effortPoints += 2;
+    } else if (strategy === 'extract-function') {
+      effortPoints += 1;
+    }
+    
+    if (effortPoints <= 3) return 'low';
+    if (effortPoints <= 7) return 'medium';
+    return 'high';
+  }
+
+  /**
+   * Describe benefits of refactoring
+   */
+  describeBenefits(metrics) {
+    const benefits = [];
+    
+    benefits.push(`Eliminate ${metrics.duplicatedLines} duplicated lines of code`);
+    benefits.push(`Improve maintainability by centralizing logic in one place`);
+    
+    if (metrics.instanceCount >= 3) {
+      benefits.push(`Reduce risk of inconsistent changes across ${metrics.instanceCount} locations`);
+    }
+    
+    if (metrics.filesCovered > 2) {
+      benefits.push(`Improve code organization across ${metrics.filesCovered} files`);
+    }
+    
+    benefits.push('Make future changes easier and less error-prone');
+    
+    return benefits;
+  }
+
+  /**
+   * Generate actionable steps
+   */
+  generateActionableSteps(strategy, suggestedName, metrics) {
+    const steps = [];
+    
+    switch (strategy) {
+      case 'extract-function':
+        steps.push(`1. Create a new function named '${suggestedName}'`);
+        steps.push('2. Move the duplicated logic into this function');
+        steps.push('3. Identify parameters needed from the surrounding context');
+        steps.push('4. Replace all instances with calls to the new function');
+        steps.push('5. Test to ensure behavior is preserved');
+        break;
+        
+      case 'extract-class':
+        steps.push(`1. Create a new class to encapsulate this functionality`);
+        steps.push('2. Move related methods and properties into the class');
+        steps.push('3. Update all instances to use the new class');
+        steps.push('4. Consider dependency injection for better testability');
+        break;
+        
+      case 'extract-module':
+        steps.push(`1. Create a new module/file for this shared functionality`);
+        steps.push('2. Move the duplicated code into the new module');
+        steps.push('3. Export the necessary functions/classes');
+        steps.push('4. Update all files to import from the new module');
+        steps.push('5. Update any build configurations if needed');
+        break;
+        
+      default:
+        steps.push(`1. Extract the duplicated code using ${strategy.replace(/-/g, ' ')}`);
+        steps.push('2. Replace all instances with the extracted version');
+        steps.push('3. Test thoroughly');
+    }
+    
+    return steps;
+  }
+
+  /**
+   * Truncate code for display
+   */
+  truncateCode(code, maxLines = 10) {
+    const lines = code.split('\n');
+    
+    if (lines.length <= maxLines) {
+      return code;
+    }
+    
+    return lines.slice(0, maxLines).join('\n') + '\n... (truncated)';
+  }
+
+  /**
+   * Calculate average line count
+   */
+  averageLineCount(blocks) {
+    const totalLines = blocks.reduce((sum, block) => 
+      sum + (block.endLine - block.startLine + 1), 0
+    );
+    
+    return Math.round(totalLines / blocks.length);
+  }
+}

package/src/analyzers/codeCloneDetector/detector.js

@@ -0,0 +1,250 @@
+/**
+ * Detects code clones across files (async, non-blocking)
+ */
+export class CloneDetector {
+  constructor(config, parser) {
+    this.config = config;
+    this.parser = parser;
+    this.comparisonBatchSize = config.comparisonBatchSize || 1000; // Yield after this many comparisons
+  }
+
+  /**
+   * Find all clones in parsed files (async)
+   * @param {Array} parsedFiles - Array of parsed file objects
+   * @returns {Promise<Array>} Array of clone groups
+   */
+  async detectClones(parsedFiles) {
+    console.log('Detecting clones...');
+
+    const clones = [];
+    const allBlocks = [];
+
+    // Collect all code blocks
+    for (const file of parsedFiles) {
+      allBlocks.push(...file.blocks);
+    }
+
+    console.log(`Analyzing ${allBlocks.length} code blocks`);
+
+    // Group blocks by hash for exact clones
+    const hashGroups = this.groupByHash(allBlocks);
+
+    // Find exact clones
+    for (const [hash, blocks] of Object.entries(hashGroups)) {
+      if (blocks.length > 1) {
+        clones.push({
+          type: 'exact',
+          confidence: 1.0,
+          blocks,
+          tokenCount: blocks[0].tokens.length
+        });
+      }
+    }
+
+    // Find similar clones (more expensive) - now async
+    const similarClones = await this.findSimilarClones(allBlocks);
+    clones.push(...similarClones);
+
+    console.log(`Found ${clones.length} clone groups`);
+    return clones;
+  }
+
+  /**
+   * Group blocks by hash
+   */
+  groupByHash(blocks) {
+    const groups = {};
+
+    for (const block of blocks) {
+      if (block.tokens.length < this.config.minTokens) continue;
+
+      if (!groups[block.hash]) {
+        groups[block.hash] = [];
+      }
+      groups[block.hash].push(block);
+    }
+
+    return groups;
+  }
+
+  /**
+   * Find similar (but not exact) clones - async with batching
+   */
+  async findSimilarClones(blocks) {
+    const similarClones = [];
+    const processed = new Set();
+
+    // Filter blocks that meet minimum size
+    const eligibleBlocks = blocks.filter(b =>
+      b.tokens.length >= this.config.minTokens
+    );
+
+    let comparisonCount = 0;
+    const totalPossibleComparisons = (eligibleBlocks.length * (eligibleBlocks.length - 1)) / 2;
+
+    // Log progress periodically
+    const logInterval = Math.max(1000, Math.floor(totalPossibleComparisons / 10));
+    let lastLogCount = 0;
+
+    for (let i = 0; i < eligibleBlocks.length; i++) {
+      const block1 = eligibleBlocks[i];
+      const cloneGroup = [block1];
+
+      if (processed.has(block1.id)) continue;
+
+      for (let j = i + 1; j < eligibleBlocks.length; j++) {
+        const block2 = eligibleBlocks[j];
+
+        if (processed.has(block2.id)) continue;
+
+        // Skip if already exact match
+        if (block1.hash === block2.hash) continue;
+
+        // Calculate similarity
+        const similarity = this.calculateBlockSimilarity(block1, block2);
+        comparisonCount++;
+
+        if (similarity >= this.config.similarityThreshold) {
+          cloneGroup.push(block2);
+          processed.add(block2.id);
+        }
+
+        // Yield to event loop periodically to prevent blocking
+        if (comparisonCount % this.comparisonBatchSize === 0) {
+          await new Promise(resolve => setImmediate(resolve));
+
+          // Log progress
+          if (comparisonCount - lastLogCount >= logInterval) {
+            const progress = ((comparisonCount / totalPossibleComparisons) * 100).toFixed(1);
+            console.log(`Clone detection progress: ${progress}% (${comparisonCount}/${totalPossibleComparisons} comparisons)`);
+            lastLogCount = comparisonCount;
+          }
+        }
+      }
+
+      if (cloneGroup.length > 1) {
+        processed.add(block1.id);
+
+        similarClones.push({
+          type: 'similar',
+          confidence: this.calculateGroupConfidenceFast(cloneGroup),
+          blocks: cloneGroup,
+          tokenCount: Math.max(...cloneGroup.map(b => b.tokens.length))
+        });
+      }
+    }
+
+    return similarClones;
+  }
+
+  /**
+   * Calculate similarity between two blocks
+   */
+  calculateBlockSimilarity(block1, block2) {
+    const tokens1 = block1.tokens;
+    const tokens2 = block2.tokens;
+
+    // Length similarity check (quick rejection)
+    const lengthRatio = Math.min(tokens1.length, tokens2.length) /
+                       Math.max(tokens1.length, tokens2.length);
+
+    if (lengthRatio < 0.7) return 0; // Too different in size
+
+    // Token sequence similarity using longest common subsequence
+    const lcs = this.longestCommonSubsequence(tokens1, tokens2);
+    const lcsRatio = (2 * lcs) / (tokens1.length + tokens2.length);
+
+    return lcsRatio;
+  }
+
+  /**
+   * Longest common subsequence length - optimized
+   */
+  longestCommonSubsequence(seq1, seq2) {
+    const m = seq1.length;
+    const n = seq2.length;
+
+    // Use approximate version for large sequences (lower threshold for performance)
+    if (m * n > 10000) {
+      return this.approximateLCS(seq1, seq2);
+    }
+
+    // Space-optimized LCS using only two rows
+    let prev = new Array(n + 1).fill(0);
+    let curr = new Array(n + 1).fill(0);
+
+    for (let i = 1; i <= m; i++) {
+      for (let j = 1; j <= n; j++) {
+        if (seq1[i - 1] === seq2[j - 1]) {
+          curr[j] = prev[j - 1] + 1;
+        } else {
+          curr[j] = Math.max(prev[j], curr[j - 1]);
+        }
+      }
+      // Swap rows
+      [prev, curr] = [curr, prev];
+    }
+
+    return prev[n];
+  }
+
+  /**
+   * Approximate LCS for large sequences - faster heuristic
+   */
+  approximateLCS(seq1, seq2) {
+    // Use set intersection as a fast approximation
+    const set1 = new Set(seq1);
+    const set2 = new Set(seq2);
+
+    let commonTokens = 0;
+    for (const token of set1) {
+      if (set2.has(token)) {
+        commonTokens++;
+      }
+    }
+
+    // Scale by average occurrence frequency
+    const avgLen = (seq1.length + seq2.length) / 2;
+    const uniqueAvg = (set1.size + set2.size) / 2;
+    const frequencyFactor = avgLen / uniqueAvg;
+
+    return Math.min(commonTokens * frequencyFactor, Math.min(seq1.length, seq2.length));
+  }
+
+  /**
+   * Calculate confidence for a clone group - fast version without full pairwise comparison
+   */
+  calculateGroupConfidenceFast(blocks) {
+    if (blocks.length < 2) return 0;
+
+    // Sample-based confidence instead of full pairwise
+    const first = blocks[0];
+    let totalSimilarity = 0;
+
+    for (let i = 1; i < Math.min(blocks.length, 5); i++) {
+      totalSimilarity += this.calculateBlockSimilarity(first, blocks[i]);
+    }
+
+    return totalSimilarity / Math.min(blocks.length - 1, 4);
+  }
+
+  /**
+   * Calculate confidence for a clone group (original full version)
+   */
+  calculateGroupConfidence(blocks) {
+    if (blocks.length === 0) return 0;
+
+    // Calculate average pairwise similarity
+    let totalSimilarity = 0;
+    let comparisons = 0;
+
+    for (let i = 0; i < blocks.length; i++) {
+      for (let j = i + 1; j < blocks.length; j++) {
+        totalSimilarity += this.calculateBlockSimilarity(blocks[i], blocks[j]);
+        comparisons++;
+      }
+    }
+
+    return comparisons > 0 ? totalSimilarity / comparisons : 0;
+  }
+}