agentsqripts/lib/wet-code/ast/refactoring/generateUtilityFunctionRecommendation.js

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

/**
 * @file Generate utility function extraction recommendation
 * @description Single responsibility: Create recommendation for extracting utility functions
 */

const inferFunctionName = require('./inferFunctionName');
const determineBestLocation = require('./determineBestLocation');
const analyzeDifferences = require('./analyzeDifferences');
const inferRequiredParameters = require('./inferRequiredParameters');
const generateUtilityFunctionCode = require('./generateUtilityFunctionCode');
const generateUsageExamples = require('./generateUsageExamples');
const calculateLinesReduced = require('./calculateLinesReduced');
const estimateRefactoringEffort = require('./estimateRefactoringEffort');
const generateImportStatements = require('./generateImportStatements');

/**
 * Generate utility function extraction recommendation
 */
function generateUtilityFunctionRecommendation(group, projectContext) {
  const { blocks } = group;
  const firstBlock = blocks[0];
  const suggestedName = inferFunctionName(firstBlock);
  const suggestedLocation = determineBestLocation(blocks, projectContext);
  
  // Analyze what makes blocks different
  const differences = analyzeDifferences(blocks);
  const parameters = inferRequiredParameters(blocks, differences);
  
  // Generate example refactored code with safe name
  const safeSuggestedName = suggestedName || 'extractedFunction';
  const exampleCode = generateUtilityFunctionCode(firstBlock, safeSuggestedName, parameters);
  const usageExamples = generateUsageExamples(blocks, safeSuggestedName, parameters);
  
  return {
    type: 'EXTRACT_UTILITY_FUNCTION',
    title: `Extract shared ${firstBlock.type}: ${safeSuggestedName}`,
    description: `${blocks.length} occurrences of similar ${firstBlock.type} logic can be consolidated`,
    
    impact: {
      linesReduced: calculateLinesReduced(blocks),
      filesAffected: new Set(blocks.map(b => b.file)).size,
      maintainability: 'HIGH',
      effort: estimateRefactoringEffort(blocks, 'EXTRACT_UTILITY_FUNCTION')
    },
    
    implementation: {
      suggestedName: safeSuggestedName,
      suggestedLocation,
      parameters,
      
      step1: {
        action: 'Create utility function',
        location: suggestedLocation,
        code: exampleCode
      },
      
      step2: {
        action: 'Replace duplicates with calls',
        examples: usageExamples
      },
      
      step3: {
        action: 'Update imports',
        imports: generateImportStatements(blocks, suggestedLocation)
      }
    },
    
    affectedFiles: blocks.map(b => ({
      file: b.file,
      lines: `${b.startLine}-${b.endLine}`
    })),
    
    benefits: [
      'Single source of truth for logic',
      'Easier to maintain and update',
      'Reduced code duplication',
      'Better testability'
    ]
  };
}

module.exports = generateUtilityFunctionRecommendation;