Tdd Refactoring Assistant

--- model: claude-opus-4-1 --- Refactor code with confidence using comprehensive test safety net: [Extended thinking: This tool uses the tdd-orchestrator agent (opus model) for sophisticated refactoring while maintaining all tests green. It applies design patterns, improves code quality, and optimizes performance with the safety of comprehensive test coverage.] ## Refactoring Process Use Task tool with subagent_type="tdd-orchestrator" to perform safe refactoring. Prompt: "Refactor this code while keeping all tests green: $ARGUMENTS. Apply TDD refactor phase excellence: 1. **Pre-Refactoring Assessment** - Analyze current code structure and identify code smells - Review test coverage to ensure safety net is comprehensive - Identify refactoring opportunities and prioritize by impact - Run all tests to establish green baseline - Document current performance metrics for comparison - Create refactoring plan with incremental steps 2. **Code Smell Detection** - **Duplicated Code**: Extract methods, pull up to base classes - **Long Methods**: Decompose into smaller, focused functions - **Large Classes**: Split responsibilities, extract classes - **Long Parameter Lists**: Introduce parameter objects - **Feature Envy**: Move methods to appropriate classes - **Data Clumps**: Group related data into objects - **Primitive Obsession**: Replace with value objects - **Switch Statements**: Replace with polymorphism - **Parallel Inheritance**: Merge hierarchies - **Dead Code**: Remove unused code paths 3. **Design Pattern Application** - **Creational Patterns**: Factory, Builder, Singleton where appropriate - **Structural Patterns**: Adapter, Facade, Decorator for flexibility - **Behavioral Patterns**: Strategy, Observer, Command for decoupling - **Domain Patterns**: Repository, Service, Value Objects - **Architecture Patterns**: Hexagonal, Clean Architecture principles - Apply patterns only where they add clear value - Avoid pattern overuse and unnecessary complexity 4. **SOLID Principles Enforcement** - **Single Responsibility**: One reason to change per class - **Open/Closed**: Open for extension, closed for modification - **Liskov Substitution**: Subtypes must be substitutable - **Interface Segregation**: Small, focused interfaces - **Dependency Inversion**: Depend on abstractions - Balance principles with pragmatic simplicity 5. **Refactoring Techniques Catalog** - **Extract Method**: Isolate code blocks into named methods - **Inline Method**: Remove unnecessary indirection - **Extract Variable**: Name complex expressions - **Rename**: Improve names for clarity and intent - **Move Method/Field**: Relocate to appropriate classes - **Extract Interface**: Define contracts explicitly - **Replace Magic Numbers**: Use named constants - **Encapsulate Field**: Add getters/setters for control - **Replace Conditional with Polymorphism**: Object-oriented solutions - **Introduce Null Object**: Eliminate null checks 6. **Performance Optimization** - Profile code to identify actual bottlenecks - Optimize algorithms and data structures - Implement caching where beneficial - Reduce database queries and network calls - Lazy loading and pagination strategies - Memory usage optimization - Always measure before and after changes - Keep optimizations that provide measurable benefit 7. **Code Quality Improvements** - **Naming**: Clear, intentional, domain-specific names - **Comments**: Remove obvious, add why not what - **Formatting**: Consistent style throughout codebase - **Error Handling**: Explicit, recoverable, informative - **Logging**: Strategic placement, appropriate levels - **Documentation**: Update to reflect changes - **Type Safety**: Strengthen types where possible 8. **Incremental Refactoring Steps** - Make small, atomic changes - Run tests after each modification - Commit after each successful refactoring - Use IDE refactoring tools when available - Manual refactoring for complex transformations - Keep refactoring separate from behavior changes - Create temporary scaffolding when needed 9. **Architecture Evolution** - Layer separation and dependency management - Module boundaries and interface definition - Service extraction for microservices preparation - Event-driven patterns for decoupling - Async patterns for scalability - Database access patterns optimization - API design improvements 10. **Quality Metrics Tracking** - **Cyclomatic Complexity**: Reduce decision points - **Code Coverage**: Maintain or improve percentage - **Coupling**: Decrease interdependencies - **Cohesion**: Increase related functionality grouping - **Technical Debt**: Measure reduction achieved - **Performance**: Response time and resource usage - **Maintainability Index**: Track improvement - **Code Duplication**: Percentage reduction 11. **Safety Verification** - Run full test suite after each change - Use mutation testing to verify test effectiveness - Performance regression testing - Integration testing for architectural changes - Manual exploratory testing for UX changes - Code review checkpoint documentation - Rollback plan for each major change 12. **Advanced Refactoring Patterns** - **Strangler Fig**: Gradual legacy replacement - **Branch by Abstraction**: Large-scale changes - **Parallel Change**: Expand-contract pattern - **Mikado Method**: Dependency graph navigation - **Preparatory Refactoring**: Enable feature addition - **Feature Toggles**: Safe production deployment Output should include: - Refactored code with all improvements applied - Test results confirming all tests remain green - Before/after metrics comparison - List of applied refactoring techniques - Performance improvement measurements - Code quality metrics improvement - Documentation of architectural changes - Remaining technical debt assessment - Recommendations for future refactoring" ## Refactoring Safety Checklist Before committing refactored code: 1. ✓ All tests pass (100% green) 2. ✓ No functionality regression 3. ✓ Performance metrics acceptable 4. ✓ Code coverage maintained/improved 5. ✓ Documentation updated 6. ✓ Team code review completed ## Recovery Process If tests fail during refactoring: - Immediately revert last change - Identify which refactoring broke tests - Apply smaller, incremental changes - Consider if tests need updating (behavior change) - Use version control for safe experimentation - Leverage IDE's undo functionality ## Integration Points - Follows from tdd-green.md implementation - Coordinates with test-automator for test updates - Integrates with static analysis tools - Triggers performance benchmarks - Updates architecture documentation - Links to CI/CD for deployment readiness ## Best Practices - Refactor in small, safe steps - Keep tests green throughout process - Commit after each successful refactoring - Don't mix refactoring with feature changes - Use tools but understand manual techniques - Focus on high-impact improvements first - Leave code better than you found it - Document why, not just what changed Code to refactor: $ARGUMENTS