code-refactor-engine

name: code-refactor-engine description: Use when refactoring implementation code to improve design while maintaining test coverage, supporting P9 recursive self-optimization

Code Refactor Engine

Overview

Refactor implementation code to improve design while maintaining test coverage. Supports P9: Recursive Self-Optimization Principle by continuously improving code quality through automated refactoring patterns.

When to Use

Implementation code exists? ─────────────┐
                                         │
Need to improve design? ─────────────────┤
                                         ├─► Use code-refactor-engine
Tests are passing? ──────────────────────┤
                                         │
Following P9 optimization principle? ────┘

Use when:

• Implementation code exists and needs design improvement
• Tests are passing and need to remain passing
• Following P9 recursive self-optimization
• Need to eliminate technical debt
• Preparing for performance optimization

Don't use when:

• Tests are failing (fix tests first)
• No tests exist (use tdd-cycle-runner first)
• Only renaming variables (use IDE refactoring)
• Architecture needs change (use architecture-pattern-selector)

Core Pattern

Refactoring Process

Current Code
    |
    v
Identify Code Smells
    |
    v
Select Refactoring Pattern
    |
    v
Apply Refactoring
    |
    v
Run Tests (Must Pass)
    |
    v
Evaluate Improvement
    |
    v
Commit or Revert

Common Refactoring Patterns

Before (Before Refactoring)

class UserController {
  async handleRequest(req: Request, res: Response) {
    const { email, password, firstName, lastName, phone, address } = req.body;
    
    // Validation
    if (!email || !email.includes('@')) {
      return res.status(400).json({ error: 'Invalid email' });
    }
    if (!password || password.length < 8) {
      return res.status(400).json({ error: 'Invalid password' });
    }
    if (!firstName || !lastName) {
      return res.status(400).json({ error: 'Name required' });
    }
    
    // Business logic
    const existingUser = await db.users.findOne({ email });
    if (existingUser) {
      return res.status(409).json({ error: 'Email exists' });
    }
    
    const hashedPassword = await bcrypt.hash(password, 10);
    const user = await db.users.create({
      email,
      password: hashedPassword,
      firstName,
      lastName,
      phone,
      address,
      createdAt: new Date()
    });
    
    // Response
    return res.status(201).json({
      id: user.id,
      email: user.email,
      firstName: user.firstName,
      lastName: user.lastName
    });
  }
}

After (After Refactoring)

// Extracted validation logic
class UserRegistrationValidator {
  validate(data: UserRegistrationRequest): ValidationResult {
    const errors: string[] = [];
    
    if (!EmailValidator.isValid(data.email)) {
      errors.push('Invalid email format');
    }
    if (!PasswordValidator.isValid(data.password)) {
      errors.push('Password must be at least 8 characters');
    }
    if (!data.firstName || !data.lastName) {
      errors.push('First and last name are required');
    }
    
    return errors.length > 0 
      ? ValidationResult.failure(errors)
      : ValidationResult.success();
  }
}

// Extracted parameter object
class UserRegistrationRequest {
  constructor(
    public readonly email: string,
    public readonly password: string,
    public readonly firstName: string,
    public readonly lastName: string,
    public readonly phone?: string,
    public readonly address?: string
  ) {}
}

// Refactored controller
class UserController {
  constructor(
    private userService: IUserService,
    private validator: UserRegistrationValidator
  ) {}
  
  async register(req: Request, res: Response) {
    const request = new UserRegistrationRequest(
      req.body.email,
      req.body.password,
      req.body.firstName,
      req.body.lastName,
      req.body.phone,
      req.body.address
    );
    
    const validation = this.validator.validate(request);
    if (!validation.isValid) {
      return res.status(400).json({ errors: validation.errors });
    }
    
    try {
      const user = await this.userService.register(request);
      return res.status(201).json(user.toResponse());
    } catch (error) {
      if (error instanceof DuplicateUserError) {
        return res.status(409).json({ error: 'Email already registered' });
      }
      throw error;
    }
  }
}

Quick Reference

Code Smells Detection

Refactoring Safety Rules

1. Tests Must Pass: All tests MUST pass before and after refactoring
2. Small Steps: Make small, incremental changes
3. Version Control: Commit after each successful refactoring
4. No Behavior Change: Refactoring MUST NOT change behavior
5. Code Review: Review refactored code for readability

Implementation

Refactoring Engine

class CodeRefactorEngine:
    def __init__(self, code, tests):
        self.code = code
        self.tests = tests
        self.smells = []
        
    def analyze(self):
        """Analyze code for smells."""
        self.smells = [
            self.detect_long_methods(),
            self.detect_large_classes(),
            self.detect_duplication(),
            self.detect_primitive_obsession(),
            self.detect_feature_envy()
        ]
        return self.smells
    
    def refactor(self, smell):
        """Apply refactoring for detected smell."""
        
        # Ensure tests pass before refactoring
        assert self.run_tests() == 'pass', "Tests must pass before refactoring"
        
        # Apply refactoring
        refactored_code = self.apply_refactoring(smell)
        
        # Ensure tests still pass
        assert self.run_tests() == 'pass', "Tests must pass after refactoring"
        
        return refactored_code
    
    def detect_long_methods(self):
        """Detect methods longer than 20 lines."""
        long_methods = []
        for method in self.code.methods:
            if method.line_count > 20:
                long_methods.append({
                    'smell': 'long_method',
                    'method': method.name,
                    'lines': method.line_count,
                    'suggestion': 'extract_method'
                })
        return long_methods
    
    def apply_refactoring(self, smell):
        """Apply appropriate refactoring pattern."""
        
        refactorings = {
            'long_method': self.extract_method,
            'large_class': self.extract_class,
            'duplication': self.remove_duplication,
            'primitive_obsession': self.introduce_value_object,
            'feature_envy': self.move_method
        }
        
        return refactorings[smell['smell']](smell)

Output Format

refactoring_report:
  target_file: "user-controller.ts"
  analysis_date: "2025-04-24T12:00:00Z"
  
  smells_detected:
    - type: "long_method"
      location: "UserController.handleRequest"
      severity: "high"
      lines: 45
      
    - type: "primitive_obsession"
      location: "UserController.handleRequest parameters"
      severity: "medium"
      
  refactorings_applied:
    - pattern: "extract_method"
      location: "UserController.handleRequest"
      description: "Extracted validation logic into UserRegistrationValidator"
      tests_status: "passing"
      
    - pattern: "introduce_parameter_object"
      location: "UserController.handleRequest"
      description: "Created UserRegistrationRequest class"
      tests_status: "passing"
      
  metrics_before:
    average_method_length: 45
    class_responsibilities: 3
    code_duplication: 15%
    
  metrics_after:
    average_method_length: 12
    class_responsibilities: 1
    code_duplication: 5%
    
  improvement:
    maintainability: "+40%"
    testability: "+30%"
    readability: "+50%"

Integration with Aether.go Methodology

• Input from: tdd-cycle-runner (implementation code), contract-driven-code-generator (generated code)
• Output to: recursive-optimizer (optimization feedback)
• Validates with: correctness-checker (behavior preservation), test-pyramid-analyzer (coverage maintenance)
• Part of: D5 Implementation Derivation Domain (L4 -> L5 optimization)

Validation Rules

• All tests MUST pass before refactoring
• All tests MUST pass after refactoring
• Behavior MUST NOT change
• Code coverage MUST NOT decrease
• Code smells MUST be reduced
• Readability MUST improve