agentsqripts/lib/performance/recursive/analyzeRecursiveComplexity.js

Comprehensive static code analysis toolkit for identifying technical debt, security vulnerabilities, performance issues, and code quality problems

/**
 * @file Analyze recursive complexity of a function
 * @description Single responsibility: Calculate and report recursive complexity issues
 */

const findRecursiveCalls = require('./findRecursiveCalls');
const analyzeRecursionType = require('./analyzeRecursionType');

/**
 * Analyze recursive complexity of a function
 */
function analyzeRecursiveComplexity(func, content, filePath) {
  const issues = [];
  const lines = content.split('\n');
  
  // Get function body lines
  const startLine = func.node.loc ? func.node.loc.start.line : 1;
  const endLine = func.node.loc ? func.node.loc.end.line : lines.length;
  const funcContent = lines.slice(startLine - 1, endLine).join('\n');
  
  // Check for recursive calls
  const recursiveCalls = findRecursiveCalls(func.name, funcContent);
  
  if (recursiveCalls.length === 0) return issues;
  
  // Analyze recursion patterns
  const recursionType = analyzeRecursionType(funcContent, func.name);
  
  recursiveCalls.forEach(call => {
    const lineNumber = startLine + call.lineOffset;
    
    switch (recursionType) {
      case 'exponential':
        issues.push({
          type: 'exponential_recursion',
          severity: 'CRITICAL',
          category: 'Algorithm',
          location: `${filePath}:${lineNumber}`,
          line: lineNumber,
          code: call.code,
          description: `Exponential recursion detected - O(2^n) complexity`,
          summary: 'Exponential time recursion pattern',
          recommendation: 'Add memoization or convert to iterative approach',
          effort: 4,
          impact: 'Exponential to linear/polynomial time reduction',
          estimatedSavings: '99% latency reduction for recursive cases'
        });
        break;
        
      case 'quadratic':
        issues.push({
          type: 'quadratic_recursion',
          severity: 'HIGH',
          category: 'Algorithm',
          location: `${filePath}:${lineNumber}`,
          line: lineNumber,
          code: call.code,
          description: `Quadratic recursion pattern - O(n²) complexity`,
          summary: 'Quadratic recursive algorithm',
          recommendation: 'Optimize algorithm or add memoization',
          effort: 3,
          impact: 'Quadratic to linear time reduction',
          estimatedSavings: '80-95% latency reduction'
        });
        break;
        
      case 'linear_inefficient':
        issues.push({
          type: 'inefficient_recursion',
          severity: 'MEDIUM',
          category: 'Algorithm',
          location: `${filePath}:${lineNumber}`,
          line: lineNumber,
          code: call.code,
          description: 'Inefficient recursive pattern with string/array operations',
          summary: 'Inefficient recursion implementation',
          recommendation: 'Use tail recursion or convert to iterative approach',
          effort: 2,
          impact: 'Reduced memory usage and improved performance',
          estimatedSavings: '40-60% memory and performance improvement'
        });
        break;
        
      case 'no_base_case':
        issues.push({
          type: 'infinite_recursion',
          severity: 'CRITICAL',
          category: 'Algorithm',
          location: `${filePath}:${lineNumber}`,
          line: lineNumber,
          code: call.code,
          description: 'Recursive function missing base case - infinite recursion risk',
          summary: 'Missing base case in recursion',
          recommendation: 'Add proper base case to prevent stack overflow',
          effort: 1,
          impact: 'Prevents infinite recursion and stack overflow',
          estimatedSavings: 'prevents stack overflow'
        });
        break;
    }
  });
  
  return issues;
}

module.exports = analyzeRecursiveComplexity;