sinapse-ai 1.12.2 → 1.14.0

package/.sinapse-ai/development/scripts/refactoring-suggester.js

@@ -1,1148 +0,0 @@
-const fs = require('fs').promises;
-const path = require('path');
-const chalk = require('chalk');
-
-// INS-4.12: Optional dev-time deps — wrap in try-catch for brownfield installs
-let parse, traverse, generate, _t;
-try { ({ parse } = require('@babel/parser')); } catch { parse = null; }
-try { traverse = require('@babel/traverse').default; } catch { traverse = null; }
-try { generate = require('@babel/generator').default; } catch { generate = null; }
-try { _t = require('@babel/types'); } catch { _t = null; }
-
-/**
- * Automated refactoring suggestion system
- * Analyzes code and suggests refactoring opportunities
- */
-class RefactoringSuggester {
-  constructor(options = {}) {
-    this.rootPath = options.rootPath || process.cwd();
-    this.suggestions = [];
-    this.refactoringPatterns = new Map();
-    this.codeMetrics = new Map();
-    this.initializePatterns();
-  }
-
-  /**
-   * Initialize refactoring patterns
-   */
-  initializePatterns() {
-    // Method extraction pattern
-    this.refactoringPatterns.set('extract_method', {
-      name: 'Extract Method',
-      description: 'Extract long methods into smaller, focused methods',
-      detector: this.detectLongMethods.bind(this),
-      suggester: this.suggestMethodExtraction.bind(this),
-      priority: 'high'
-    });
-
-    // Variable extraction pattern
-    this.refactoringPatterns.set('extract_variable', {
-      name: 'Extract Variable',
-      description: 'Extract complex expressions into named variables',
-      detector: this.detectComplexExpressions.bind(this),
-      suggester: this.suggestVariableExtraction.bind(this),
-      priority: 'medium'
-    });
-
-    // Parameter object pattern
-    this.refactoringPatterns.set('introduce_parameter_object', {
-      name: 'Introduce Parameter Object',
-      description: 'Group related parameters into an object',
-      detector: this.detectLongParameterLists.bind(this),
-      suggester: this.suggestParameterObject.bind(this),
-      priority: 'medium'
-    });
-
-    // Replace conditional with polymorphism
-    this.refactoringPatterns.set('replace_conditional', {
-      name: 'Replace Conditional with Polymorphism',
-      description: 'Replace complex conditionals with polymorphic behavior',
-      detector: this.detectComplexConditionals.bind(this),
-      suggester: this.suggestPolymorphism.bind(this),
-      priority: 'high'
-    });
-
-    // Inline temp pattern
-    this.refactoringPatterns.set('inline_temp', {
-      name: 'Inline Temporary Variable',
-      description: 'Replace temporary variables used only once',
-      detector: this.detectSingleUseTempVariables.bind(this),
-      suggester: this.suggestInlineTemp.bind(this),
-      priority: 'low'
-    });
-
-    // Remove dead code
-    this.refactoringPatterns.set('remove_dead_code', {
-      name: 'Remove Dead Code',
-      description: 'Remove unreachable or unused code',
-      detector: this.detectDeadCode.bind(this),
-      suggester: this.suggestDeadCodeRemoval.bind(this),
-      priority: 'high'
-    });
-
-    // Consolidate duplicate code
-    this.refactoringPatterns.set('consolidate_duplicates', {
-      name: 'Consolidate Duplicate Code',
-      description: 'Extract duplicate code into shared functions',
-      detector: this.detectDuplicateCode.bind(this),
-      suggester: this.suggestCodeConsolidation.bind(this),
-      priority: 'high'
-    });
-
-    // Simplify nested conditionals
-    this.refactoringPatterns.set('simplify_conditionals', {
-      name: 'Simplify Nested Conditionals',
-      description: 'Flatten deeply nested if-else chains',
-      detector: this.detectNestedConditionals.bind(this),
-      suggester: this.suggestConditionalSimplification.bind(this),
-      priority: 'medium'
-    });
-
-    // Replace magic numbers
-    this.refactoringPatterns.set('replace_magic_numbers', {
-      name: 'Replace Magic Numbers',
-      description: 'Replace hard-coded numbers with named constants',
-      detector: this.detectMagicNumbers.bind(this),
-      suggester: this.suggestConstantExtraction.bind(this),
-      priority: 'low'
-    });
-
-    // Decompose complex class
-    this.refactoringPatterns.set('decompose_class', {
-      name: 'Decompose Complex Class',
-      description: 'Split large classes into smaller, focused classes',
-      detector: this.detectLargeClasses.bind(this),
-      suggester: this.suggestClassDecomposition.bind(this),
-      priority: 'high'
-    });
-  }
-
-  /**
-   * Analyze code and suggest refactorings
-   */
-  async analyzeCode(filePath, options = {}) {
-    // INS-4.12: Guard — @babel deps may not be available in brownfield installs
-    if (!parse || !traverse) {
-      console.warn(chalk.yellow('⚠️  @babel/parser or @babel/traverse not available — refactoring analysis disabled'));
-      return { filePath, suggestions: [], error: '@babel dependencies not installed' };
-    }
-
-    console.log(chalk.blue(`🔍 Analyzing: ${filePath}`));
-
-    try {
-      const _content = await fs.readFile(filePath, 'utf-8');
-      const fileType = path.extname(filePath);
-
-      if (!['.js', '.jsx', '.ts', '.tsx'].includes(fileType)) {
-        return {
-          filePath,
-          suggestions: [],
-          error: 'Unsupported file type'
-        };
-      }
-
-      // Parse code
-      const _ast = this.parseCode(_content, filePath);
-      
-      // Calculate code metrics
-      const _metrics = this.calculateCodeMetrics(_ast, content);
-      this.codeMetrics.set(filePath, metrics);
-
-      // Clear previous suggestions
-      this.suggestions = [];
-
-      // Run all refactoring detectors
-      for (const [patternId, pattern] of this.refactoringPatterns) {
-        if (options.patterns && !options.patterns.includes(patternId)) {
-          continue; // Skip if not in requested patterns
-        }
-
-        try {
-          const detected = await pattern.detector(_ast, _content, metrics);
-          if (detected && detected.length > 0) {
-            for (const _detection of detected) {
-              const suggestion = await pattern.suggester(_detection, _ast, content);
-              if (suggestion) {
-                this.suggestions.push({
-                  ...suggestion,
-                  patternId,
-                  pattern: pattern.name,
-                  priority: pattern.priority,
-                  filePath
-                });
-              }
-            }
-          }
-        } catch (error) {
-          console.warn(chalk.yellow(`Failed to run ${pattern.name}: ${error.message}`));
-        }
-      }
-
-      // Sort suggestions by priority and impact
-      this.suggestions.sort((a, b) => {
-        const priorityOrder = { high: 3, medium: 2, low: 1 };
-        const priorityDiff = priorityOrder[b.priority] - priorityOrder[a.priority];
-        if (priorityDiff !== 0) return priorityDiff;
-        return (b.impact || 0) - (a.impact || 0);
-      });
-
-      return {
-        filePath,
-        _metrics,
-        suggestions: this.suggestions
-      };
-
-    } catch (error) {
-      return {
-        filePath,
-        suggestions: [],
-        error: error.message
-      };
-    }
-  }
-
-  /**
-   * Parse code into AST
-   */
-  parseCode(_content, filePath) {
-    const parserOptions = {
-      sourceType: 'module',
-      plugins: [
-        'jsx',
-        'typescript',
-        'decorators-legacy',
-        'classProperties',
-        'asyncGenerators',
-        'dynamicImport',
-        'optionalChaining',
-        'nullishCoalescingOperator'
-      ],
-      errorRecovery: true
-    };
-
-    try {
-      return parse(_content, parserOptions);
-    } catch (error) {
-      console.warn(chalk.yellow(`Parse error in ${filePath}: ${error.message}`));
-      // Try with more lenient options
-      return parse(_content, { ...parserOptions, errorRecovery: true });
-    }
-  }
-
-  /**
-   * Calculate code metrics
-   */
-  calculateCodeMetrics(_ast, content) {
-    const _metrics = {
-      lines: content.split('\n').length,
-      functions: 0,
-      classes: 0,
-      complexity: 0,
-      maxNesting: 0,
-      duplicateBlocks: 0,
-      comments: 0,
-      imports: 0
-    };
-
-    let currentNesting = 0;
-
-    traverse(_ast, {
-      FunctionDeclaration: () => metrics.functions++,
-      FunctionExpression: () => metrics.functions++,
-      ArrowFunctionExpression: () => metrics.functions++,
-      ClassDeclaration: () => metrics.classes++,
-      ImportDeclaration: () => metrics.imports++,
-      
-      IfStatement: {
-        enter: () => {
-          metrics.complexity++;
-          currentNesting++;
-          metrics.maxNesting = Math.max(metrics.maxNesting, currentNesting);
-        },
-        exit: () => currentNesting--
-      },
-      
-      SwitchStatement: () => metrics.complexity += 2,
-      ForStatement: () => metrics.complexity++,
-      WhileStatement: () => metrics.complexity++,
-      DoWhileStatement: () => metrics.complexity++,
-      ConditionalExpression: () => metrics.complexity++,
-      LogicalExpression: (path) => {
-        if (path.node.operator === '&&' || path.node.operator === '||') {
-          metrics.complexity++;
-        }
-      },
-      
-      Comment: () => metrics.comments++
-    });
-
-    return metrics;
-  }
-
-  // Refactoring detectors
-
-  async detectLongMethods(_ast, _content, metrics) {
-    const longMethods = [];
-    const methodSizeThreshold = 30; // lines
-
-    traverse(_ast, {
-      'FunctionDeclaration|FunctionExpression|ArrowFunctionExpression': (path) => {
-        const start = path.node.loc.start.line;
-        const end = path.node.loc.end.line;
-        const methodLines = end - start + 1;
-
-        if (methodLines > methodSizeThreshold) {
-          const methodName = this.getMethodName(path);
-          longMethods.push({
-            type: 'long_method',
-            node: path.node,
-            path: path,
-            name: methodName,
-            lines: methodLines,
-            startLine: start,
-            endLine: end,
-            complexity: this.calculateMethodComplexity(path)
-          });
-        }
-      }
-    });
-
-    return longMethods;
-  }
-
-  async detectComplexExpressions(_ast, _content, metrics) {
-    const complexExpressions = [];
-    const complexityThreshold = 3; // nesting/chaining depth
-
-    traverse(_ast, {
-      Expression: (path) => {
-        const complexity = this.calculateExpressionComplexity(path.node);
-        if (complexity > complexityThreshold) {
-          complexExpressions.push({
-            type: 'complex_expression',
-            node: path.node,
-            path: path,
-            complexity: complexity,
-            startLine: path.node.loc?.start.line,
-            endLine: path.node.loc?.end.line
-          });
-        }
-      }
-    });
-
-    return complexExpressions;
-  }
-
-  async detectLongParameterLists(_ast, _content, metrics) {
-    const longParameterLists = [];
-    const parameterThreshold = 4;
-
-    traverse(_ast, {
-      'FunctionDeclaration|FunctionExpression|ArrowFunctionExpression': (path) => {
-        const params = path.node.params;
-        if (params.length > parameterThreshold) {
-          const methodName = this.getMethodName(path);
-          longParameterLists.push({
-            type: 'long_parameter_list',
-            node: path.node,
-            path: path,
-            name: methodName,
-            parameterCount: params.length,
-            parameters: params.map(p => p.name || 'unknown'),
-            startLine: path.node.loc?.start.line
-          });
-        }
-      }
-    });
-
-    return longParameterLists;
-  }
-
-  async detectComplexConditionals(_ast, _content, metrics) {
-    const complexConditionals = [];
-    const branchThreshold = 4;
-
-    traverse(_ast, {
-      IfStatement: (path) => {
-        const branches = this.countConditionalBranches(path);
-        if (branches > branchThreshold) {
-          complexConditionals.push({
-            type: 'complex_conditional',
-            node: path.node,
-            path: path,
-            branches: branches,
-            startLine: path.node.loc?.start.line,
-            endLine: path.node.loc?.end.line
-          });
-        }
-      },
-      
-      SwitchStatement: (path) => {
-        const cases = path.node.cases.length;
-        if (cases > branchThreshold) {
-          complexConditionals.push({
-            type: 'complex_switch',
-            node: path.node,
-            path: path,
-            cases: cases,
-            startLine: path.node.loc?.start.line,
-            endLine: path.node.loc?.end.line
-          });
-        }
-      }
-    });
-
-    return complexConditionals;
-  }
-
-  async detectSingleUseTempVariables(_ast, _content, metrics) {
-    const singleUseVars = [];
-    const varUsage = new Map();
-
-    // First pass: collect all variable declarations and usages
-    traverse(_ast, {
-      VariableDeclarator: (path) => {
-        if (path.node.id.type === 'Identifier') {
-          const varName = path.node.id.name;
-          if (!varUsage.has(varName)) {
-            varUsage.set(varName, {
-              declaration: path,
-              uses: []
-            });
-          }
-        }
-      },
-      
-      Identifier: (path) => {
-        if (path.isReferencedIdentifier()) {
-          const varName = path.node.name;
-          if (varUsage.has(varName)) {
-            varUsage.get(varName).uses.push(path);
-          }
-        }
-      }
-    });
-
-    // Second pass: find single-use variables
-    for (const [varName, usage] of varUsage) {
-      if (usage.uses.length === 1 && usage.declaration.node.init) {
-        singleUseVars.push({
-          type: 'single_use_temp',
-          name: varName,
-          declaration: usage.declaration,
-          use: usage.uses[0],
-          startLine: usage.declaration.node.loc?.start.line
-        });
-      }
-    }
-
-    return singleUseVars;
-  }
-
-  async detectDeadCode(_ast, _content, metrics) {
-    const deadCode = [];
-
-    traverse(_ast, {
-      // Unreachable code after return/throw
-      'ReturnStatement|ThrowStatement': (path) => {
-        const parent = path.parent;
-        if (parent.type === 'BlockStatement') {
-          const siblings = parent.body;
-          const currentIndex = siblings.indexOf(path.node);
-          
-          for (let i = currentIndex + 1; i < siblings.length; i++) {
-            deadCode.push({
-              type: 'unreachable_code',
-              node: siblings[i],
-              reason: 'after_return_throw',
-              startLine: siblings[i].loc?.start.line
-            });
-          }
-        }
-      },
-      
-      // Unused functions
-      FunctionDeclaration: (path) => {
-        const functionName = path.node.id?.name;
-        if (functionName && !this.isFunctionUsed(functionName, ast)) {
-          deadCode.push({
-            type: 'unused_function',
-            node: path.node,
-            name: functionName,
-            startLine: path.node.loc?.start.line
-          });
-        }
-      },
-      
-      // Always false conditions
-      IfStatement: (path) => {
-        if (path.node.test.type === 'BooleanLiteral' && !path.node.test.value) {
-          deadCode.push({
-            type: 'dead_branch',
-            node: path.node.consequent,
-            reason: 'always_false',
-            startLine: path.node.loc?.start.line
-          });
-        }
-      }
-    });
-
-    return deadCode;
-  }
-
-  async detectDuplicateCode(_ast, _content, metrics) {
-    const duplicates = [];
-    const codeBlocks = new Map();
-    const minBlockSize = 5; // minimum lines for duplicate detection
-
-    traverse(_ast, {
-      BlockStatement: (path) => {
-        if (path.node.body.length >= minBlockSize) {
-          const blockHash = this.hashCodeBlock(path.node);
-          
-          if (codeBlocks.has(blockHash)) {
-            const original = codeBlocks.get(blockHash);
-            duplicates.push({
-              type: 'duplicate_code',
-              original: original,
-              duplicate: path,
-              startLine: path.node.loc?.start.line,
-              endLine: path.node.loc?.end.line,
-              lines: path.node.loc?.end.line - path.node.loc?.start.line + 1
-            });
-          } else {
-            codeBlocks.set(blockHash, path);
-          }
-        }
-      }
-    });
-
-    return duplicates;
-  }
-
-  async detectNestedConditionals(_ast, _content, metrics) {
-    const nestedConditionals = [];
-    const nestingThreshold = 3;
-
-    const checkNesting = (path, depth = 0) => {
-      if (depth > nestingThreshold) {
-        nestedConditionals.push({
-          type: 'nested_conditional',
-          node: path.node,
-          path: path,
-          depth: depth,
-          startLine: path.node.loc?.start.line,
-          endLine: path.node.loc?.end.line
-        });
-      }
-
-      // Check nested ifs
-      traverse(path.node, {
-        IfStatement: (innerPath) => {
-          if (innerPath.node !== path.node) {
-            checkNesting(innerPath, depth + 1);
-            innerPath.skip();
-          }
-        }
-      }, path.scope, path);
-    };
-
-    traverse(_ast, {
-      IfStatement: (path) => checkNesting(path, 1)
-    });
-
-    return nestedConditionals;
-  }
-
-  async detectMagicNumbers(_ast, _content, metrics) {
-    const magicNumbers = [];
-    const ignoredNumbers = new Set([0, 1, -1, 2, 10, 100, 1000]);
-
-    traverse(_ast, {
-      NumericLiteral: (path) => {
-        const value = path.node.value;
-        
-        // Skip common/obvious numbers
-        if (ignoredNumbers.has(value)) return;
-        
-        // Skip array indices
-        if (path.parent.type === 'MemberExpression' && path.parent.computed) return;
-        
-        // Skip in constant declarations
-        if (path.findParent(p => p.isVariableDeclarator() && 
-            p.parent.kind === 'const')) return;
-
-        magicNumbers.push({
-          type: 'magic_number',
-          node: path.node,
-          path: path,
-          value: value,
-          context: path.parent.type,
-          startLine: path.node.loc?.start.line
-        });
-      }
-    });
-
-    return magicNumbers;
-  }
-
-  async detectLargeClasses(_ast, _content, metrics) {
-    const largeClasses = [];
-    const methodThreshold = 10;
-    const propertyThreshold = 15;
-
-    traverse(_ast, {
-      ClassDeclaration: (path) => {
-        const methods = path.node.body.body.filter(m => 
-          m.type === 'ClassMethod' || m.type === 'ClassProperty'
-        );
-        
-        const methodCount = methods.filter(m => m.type === 'ClassMethod').length;
-        const propertyCount = methods.filter(m => m.type === 'ClassProperty').length;
-
-        if (methodCount > methodThreshold || propertyCount > propertyThreshold) {
-          largeClasses.push({
-            type: 'large_class',
-            node: path.node,
-            path: path,
-            name: path.node.id?.name,
-            methodCount: methodCount,
-            propertyCount: propertyCount,
-            totalMembers: methods.length,
-            startLine: path.node.loc?.start.line,
-            endLine: path.node.loc?.end.line
-          });
-        }
-      }
-    });
-
-    return largeClasses;
-  }
-
-  // Refactoring suggesters
-
-  async suggestMethodExtraction(_detection, _ast, content) {
-    const suggestion = {
-      type: 'extract_method',
-      description: `Extract method '${detection.name}' (${detection.lines} lines)`,
-      location: {
-        start: detection.startLine,
-        end: detection.endLine
-      },
-      impact: Math.min(10, Math.floor(detection.lines / 10) + Math.floor(detection.complexity / 5)),
-      details: `Method has ${detection.lines} lines and complexity of ${detection.complexity}. Consider extracting logical sections into separate methods.`,
-      suggestedRefactoring: this.generateMethodExtractionSuggestion(_detection)
-    };
-
-    return suggestion;
-  }
-
-  async suggestVariableExtraction(_detection, _ast, content) {
-    const suggestion = {
-      type: 'extract_variable',
-      description: 'Extract complex expression into variable',
-      location: {
-        start: detection.startLine,
-        end: detection.endLine
-      },
-      impact: Math.min(5, detection.complexity - 2),
-      details: `Expression has complexity of ${detection.complexity}. Extract into a named variable for better readability.`,
-      suggestedRefactoring: this.generateVariableExtractionSuggestion(_detection)
-    };
-
-    return suggestion;
-  }
-
-  async suggestParameterObject(_detection, _ast, content) {
-    const suggestion = {
-      type: 'introduce_parameter_object',
-      description: `Group ${detection.parameterCount} parameters in '${detection.name}'`,
-      location: {
-        start: detection.startLine,
-        end: detection.startLine
-      },
-      impact: Math.min(7, detection.parameterCount - 3),
-      details: `Method has ${detection.parameterCount} parameters: ${detection.parameters.join(', ')}. Consider grouping related parameters into an object.`,
-      suggestedRefactoring: this.generateParameterObjectSuggestion(_detection)
-    };
-
-    return suggestion;
-  }
-
-  async suggestPolymorphism(_detection, _ast, content) {
-    const suggestion = {
-      type: 'replace_conditional',
-      description: `Replace ${detection.type === 'complex_switch' ? 'switch' : 'conditional'} with polymorphism`,
-      location: {
-        start: detection.startLine,
-        end: detection.endLine
-      },
-      impact: Math.min(8, detection.branches || detection.cases),
-      details: `Complex ${detection.type === 'complex_switch' ? 'switch' : 'conditional'} with ${detection.branches || detection.cases} branches. Consider using polymorphism or strategy pattern.`,
-      suggestedRefactoring: this.generatePolymorphismSuggestion(_detection)
-    };
-
-    return suggestion;
-  }
-
-  async suggestInlineTemp(_detection, _ast, content) {
-    const suggestion = {
-      type: 'inline_temp',
-      description: `Inline temporary variable '${detection.name}'`,
-      location: {
-        start: detection.startLine,
-        end: detection.startLine
-      },
-      impact: 2,
-      details: `Variable '${detection.name}' is used only once. Consider inlining it.`,
-      suggestedRefactoring: this.generateInlineTempSuggestion(_detection)
-    };
-
-    return suggestion;
-  }
-
-  async suggestDeadCodeRemoval(_detection, _ast, content) {
-    const suggestion = {
-      type: 'remove_dead_code',
-      description: `Remove ${detection.type.replace('_', ' ')}${detection.name ? `: ${detection.name}` : ''}`,
-      location: {
-        start: detection.startLine,
-        end: detection.node.loc?.end.line || detection.startLine
-      },
-      impact: 5,
-      details: `${detection.type === 'unreachable_code' ? 'Code is unreachable' : detection.type === 'unused_function' ? 'Function is never called' : 'Code is dead'}`,
-      suggestedRefactoring: {
-        action: 'delete',
-        lines: [detection.startLine, detection.node.loc?.end.line || detection.startLine]
-      }
-    };
-
-    return suggestion;
-  }
-
-  async suggestCodeConsolidation(_detection, _ast, content) {
-    const suggestion = {
-      type: 'consolidate_duplicates',
-      description: `Extract duplicate code block (${detection.lines} lines)`,
-      location: {
-        start: detection.startLine,
-        end: detection.endLine
-      },
-      impact: Math.min(9, detection.lines),
-      details: `Found duplicate code block. Extract into a shared function.`,
-      suggestedRefactoring: this.generateConsolidationSuggestion(_detection)
-    };
-
-    return suggestion;
-  }
-
-  async suggestConditionalSimplification(_detection, _ast, content) {
-    const suggestion = {
-      type: 'simplify_conditionals',
-      description: `Simplify nested conditionals (depth: ${detection.depth})`,
-      location: {
-        start: detection.startLine,
-        end: detection.endLine
-      },
-      impact: Math.min(7, detection.depth * 2),
-      details: `Deeply nested conditionals (${detection.depth} levels). Consider early returns or guard clauses.`,
-      suggestedRefactoring: this.generateConditionalSimplificationSuggestion(_detection)
-    };
-
-    return suggestion;
-  }
-
-  async suggestConstantExtraction(_detection, _ast, content) {
-    const suggestion = {
-      type: 'replace_magic_numbers',
-      description: `Replace magic number ${detection.value}`,
-      location: {
-        start: detection.startLine,
-        end: detection.startLine
-      },
-      impact: 3,
-      details: `Magic number ${detection.value} found in ${detection.context}. Extract to named constant.`,
-      suggestedRefactoring: this.generateConstantExtractionSuggestion(_detection)
-    };
-
-    return suggestion;
-  }
-
-  async suggestClassDecomposition(_detection, _ast, content) {
-    const suggestion = {
-      type: 'decompose_class',
-      description: `Decompose large class '${detection.name}' (${detection.totalMembers} members)`,
-      location: {
-        start: detection.startLine,
-        end: detection.endLine
-      },
-      impact: Math.min(10, Math.floor(detection.totalMembers / 5)),
-      details: `Class has ${detection.methodCount} methods and ${detection.propertyCount} properties. Consider splitting into smaller, focused classes.`,
-      suggestedRefactoring: this.generateClassDecompositionSuggestion(_detection)
-    };
-
-    return suggestion;
-  }
-
-  // Helper methods
-
-  getMethodName(path) {
-    if (path.node.id) {
-      return path.node.id.name;
-    }
-    
-    // Check if it's a method in a class
-    if (path.parent.type === 'ClassMethod') {
-      return path.parent.key.name;
-    }
-    
-    // Check if it's assigned to a variable
-    if (path.parent.type === 'VariableDeclarator') {
-      return path.parent.id.name;
-    }
-    
-    // Check if it's a property
-    if (path.parent.type === 'ObjectProperty') {
-      return path.parent.key.name || path.parent.key.value;
-    }
-    
-    return 'anonymous';
-  }
-
-  calculateMethodComplexity(path) {
-    let complexity = 1;
-    
-    traverse(path.node, {
-      IfStatement: () => complexity++,
-      ConditionalExpression: () => complexity++,
-      SwitchCase: () => complexity++,
-      WhileStatement: () => complexity++,
-      ForStatement: () => complexity++,
-      DoWhileStatement: () => complexity++,
-      LogicalExpression: (innerPath) => {
-        if (innerPath.node.operator === '&&' || innerPath.node.operator === '||') {
-          complexity++;
-        }
-      }
-    }, path.scope, path);
-    
-    return complexity;
-  }
-
-  calculateExpressionComplexity(node, depth = 0) {
-    if (!node) return depth;
-    
-    let maxDepth = depth;
-    
-    // Check different expression types
-    if (node.type === 'CallExpression') {
-      maxDepth = Math.max(maxDepth, this.calculateExpressionComplexity(node.callee, depth + 1));
-      for (const arg of node.arguments) {
-        maxDepth = Math.max(maxDepth, this.calculateExpressionComplexity(arg, depth + 1));
-      }
-    } else if (node.type === 'MemberExpression') {
-      maxDepth = Math.max(maxDepth, this.calculateExpressionComplexity(node.object, depth + 1));
-    } else if (node.type === 'ConditionalExpression') {
-      maxDepth = Math.max(maxDepth, 
-        this.calculateExpressionComplexity(node.test, depth + 1),
-        this.calculateExpressionComplexity(node.consequent, depth + 1),
-        this.calculateExpressionComplexity(node.alternate, depth + 1)
-      );
-    } else if (node.type === 'BinaryExpression' || node.type === 'LogicalExpression') {
-      maxDepth = Math.max(maxDepth,
-        this.calculateExpressionComplexity(node.left, depth + 1),
-        this.calculateExpressionComplexity(node.right, depth + 1)
-      );
-    }
-    
-    return maxDepth;
-  }
-
-  countConditionalBranches(path) {
-    let branches = 1; // Initial if branch
-    
-    let current = path.node;
-    while (current.alternate) {
-      branches++;
-      if (current.alternate.type === 'IfStatement') {
-        current = current.alternate;
-      } else {
-        break;
-      }
-    }
-    
-    return branches;
-  }
-
-  isFunctionUsed(functionName, ast) {
-    let used = false;
-    
-    traverse(_ast, {
-      CallExpression: (path) => {
-        if (path.node.callee.type === 'Identifier' && 
-            path.node.callee.name === functionName) {
-          used = true;
-          path.stop();
-        }
-      },
-      Identifier: (path) => {
-        if (path.node.name === functionName && 
-            path.isReferencedIdentifier() &&
-            !path.isFunction()) {
-          used = true;
-          path.stop();
-        }
-      }
-    });
-    
-    return used;
-  }
-
-  hashCodeBlock(node) {
-    // Simple hash based on code structure
-    const code = generate(node, { compact: true }).code;
-    return code.replace(/\s+/g, ' ').trim();
-  }
-
-  // Suggestion generators
-
-  generateMethodExtractionSuggestion(_detection) {
-    return {
-      action: 'extract_method',
-      extractedMethods: [
-        {
-          name: `extracted${detection.name.charAt(0).toUpperCase() + detection.name.slice(1)}Part1`,
-          description: 'Extract first logical section',
-          suggestedLines: [detection.startLine + 5, detection.startLine + 15]
-        },
-        {
-          name: `extracted${detection.name.charAt(0).toUpperCase() + detection.name.slice(1)}Part2`,
-          description: 'Extract second logical section',
-          suggestedLines: [detection.startLine + 16, detection.endLine - 5]
-        }
-      ]
-    };
-  }
-
-  generateVariableExtractionSuggestion(_detection) {
-    return {
-      action: 'extract_variable',
-      variableName: 'extractedExpression',
-      insertBefore: detection.startLine
-    };
-  }
-
-  generateParameterObjectSuggestion(_detection) {
-    return {
-      action: 'introduce_parameter_object',
-      objectName: `${detection.name}Options`,
-      groupedParameters: detection.parameters.slice(2), // Keep first 2 params separate
-      keepParameters: detection.parameters.slice(0, 2)
-    };
-  }
-
-  generatePolymorphismSuggestion(_detection) {
-    return {
-      action: 'replace_with_polymorphism',
-      strategyPattern: true,
-      suggestedClasses: ['BaseHandler', 'TypeAHandler', 'TypeBHandler'],
-      interfaceMethod: 'handle'
-    };
-  }
-
-  generateInlineTempSuggestion(_detection) {
-    return {
-      action: 'inline_variable',
-      variableName: detection.name,
-      declarationLine: detection.declaration.node.loc?.start.line,
-      usageLine: detection.use.node.loc?.start.line
-    };
-  }
-
-  generateConsolidationSuggestion(_detection) {
-    return {
-      action: 'extract_shared_function',
-      functionName: 'extractedSharedFunction',
-      originalLocations: [
-        {
-          start: detection.original.node.loc?.start.line,
-          end: detection.original.node.loc?.end.line
-        },
-        {
-          start: detection.duplicate.node.loc?.start.line,
-          end: detection.duplicate.node.loc?.end.line
-        }
-      ]
-    };
-  }
-
-  generateConditionalSimplificationSuggestion(_detection) {
-    return {
-      action: 'simplify_nested_conditionals',
-      techniques: ['early_return', 'guard_clauses', 'extract_condition'],
-      suggestedStructure: 'Use guard clauses for edge cases and early returns'
-    };
-  }
-
-  generateConstantExtractionSuggestion(_detection) {
-    const constantName = this.suggestConstantName(detection.value, detection.context);
-    return {
-      action: 'extract_constant',
-      constantName: constantName,
-      value: detection.value,
-      scope: 'module' // or 'class' depending on context
-    };
-  }
-
-  generateClassDecompositionSuggestion(_detection) {
-    return {
-      action: 'decompose_class',
-      suggestedClasses: [
-        {
-          name: `${detection.name}Core`,
-          description: 'Core functionality',
-          methods: 'Core business logic methods'
-        },
-        {
-          name: `${detection.name}Utils`,
-          description: 'Utility methods',
-          methods: 'Helper and utility methods'
-        },
-        {
-          name: `${detection.name}Config`,
-          description: 'Configuration and setup',
-          methods: 'Configuration-related methods'
-        }
-      ]
-    };
-  }
-
-  suggestConstantName(value, context) {
-    // Generate meaningful constant names based on value and context
-    const contextMap = {
-      'BinaryExpression': 'THRESHOLD',
-      'IfStatement': 'CONDITION',
-      'ForStatement': 'LIMIT',
-      'CallExpression': 'PARAMETER'
-    };
-    
-    const baseContext = contextMap[context] || 'VALUE';
-    return `${baseContext}_${Math.abs(value).toString().replace('.', '_')}`;
-  }
-
-  /**
-   * Apply refactoring suggestion
-   */
-  async applySuggestion(suggestion, options = {}) {
-    console.log(chalk.blue(`🔧 Applying ${suggestion.type} refactoring...`));
-    
-    try {
-      // This would integrate with the actual refactoring implementation
-      // For now, it's a placeholder showing the structure
-      
-      const result = {
-        success: false,
-        changes: [],
-        error: null
-      };
-
-      switch (suggestion.type) {
-        case 'extract_method':
-          result.changes = await this.applyMethodExtraction(suggestion);
-          break;
-        case 'extract_variable':
-          result.changes = await this.applyVariableExtraction(suggestion);
-          break;
-        case 'inline_temp':
-          result.changes = await this.applyInlineTemp(suggestion);
-          break;
-        case 'remove_dead_code':
-          result.changes = await this.applyDeadCodeRemoval(suggestion);
-          break;
-        default:
-          throw new Error(`Refactoring type ${suggestion.type} not implemented`);
-      }
-
-      result.success = true;
-      return result;
-
-    } catch (error) {
-      console.error(chalk.red(`Failed to apply refactoring: ${error.message}`));
-      return {
-        success: false,
-        changes: [],
-        error: error.message
-      };
-    }
-  }
-
-  // Placeholder methods for applying refactorings
-  async applyMethodExtraction(suggestion) {
-    // Implementation would use AST transformation
-    return [{
-      type: 'extract_method',
-      file: suggestion.filePath,
-      description: `Extracted method from lines ${suggestion.location.start}-${suggestion.location.end}`
-    }];
-  }
-
-  async applyVariableExtraction(suggestion) {
-    return [{
-      type: 'extract_variable',
-      file: suggestion.filePath,
-      description: `Extracted variable at line ${suggestion.location.start}`
-    }];
-  }
-
-  async applyInlineTemp(suggestion) {
-    return [{
-      type: 'inline_temp',
-      file: suggestion.filePath,
-      description: `Inlined variable at line ${suggestion.location.start}`
-    }];
-  }
-
-  async applyDeadCodeRemoval(suggestion) {
-    return [{
-      type: 'remove_dead_code',
-      file: suggestion.filePath,
-      description: `Removed dead code at lines ${suggestion.location.start}-${suggestion.location.end}`
-    }];
-  }
-
-  /**
-   * Get refactoring statistics
-   */
-  getStatistics() {
-    const stats = {
-      totalSuggestions: this.suggestions.length,
-      byType: {},
-      byPriority: {
-        high: 0,
-        medium: 0,
-        low: 0
-      },
-      averageImpact: 0
-    };
-
-    let totalImpact = 0;
-    
-    for (const suggestion of this.suggestions) {
-      // By type
-      stats.byType[suggestion.type] = (stats.byType[suggestion.type] || 0) + 1;
-      
-      // By priority
-      stats.byPriority[suggestion.priority]++;
-      
-      // Impact
-      totalImpact += suggestion.impact || 0;
-    }
-
-    stats.averageImpact = stats.totalSuggestions > 0 ? 
-      (totalImpact / stats.totalSuggestions).toFixed(2) : 0;
-
-    return stats;
-  }
-}
-
-module.exports = RefactoringSuggester;