Initial commit

plugins/tdd-workflows/commands/tdd-refactor.md

@@ -0,0 +1,165 @@
+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.]
+
+## Usage
+
+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:
+
+## Core Process
+
+**1. Pre-Assessment**
+- Run tests to establish green baseline
+- Analyze code smells and test coverage
+- Document current performance metrics
+- Create incremental refactoring plan
+
+**2. Code Smell Detection**
+- Duplicated code → Extract methods/classes
+- Long methods → Decompose into focused functions
+- Large classes → Split responsibilities
+- Long parameter lists → Parameter objects
+- Feature Envy → Move methods to appropriate classes
+- Primitive Obsession → Value objects
+- Switch statements → Polymorphism
+- Dead code → Remove
+
+**3. Design Patterns**
+- Apply Creational (Factory, Builder, Singleton)
+- Apply Structural (Adapter, Facade, Decorator)
+- Apply Behavioral (Strategy, Observer, Command)
+- Apply Domain (Repository, Service, Value Objects)
+- Use patterns only where they add clear value
+
+**4. SOLID Principles**
+- Single Responsibility: One reason to change
+- Open/Closed: Open for extension, closed for modification
+- Liskov Substitution: Subtypes substitutable
+- Interface Segregation: Small, focused interfaces
+- Dependency Inversion: Depend on abstractions
+
+**5. Refactoring Techniques**
+- Extract Method/Variable/Interface
+- Inline unnecessary indirection
+- Rename for clarity
+- Move Method/Field to appropriate classes
+- Replace Magic Numbers with constants
+- Encapsulate fields
+- Replace Conditional with Polymorphism
+- Introduce Null Object
+
+**6. Performance Optimization**
+- Profile to identify bottlenecks
+- Optimize algorithms and data structures
+- Implement caching where beneficial
+- Reduce database queries (N+1 elimination)
+- Lazy loading and pagination
+- Always measure before and after
+
+**7. Incremental Steps**
+- Make small, atomic changes
+- Run tests after each modification
+- Commit after each successful refactoring
+- Keep refactoring separate from behavior changes
+- Use scaffolding when needed
+
+**8. Architecture Evolution**
+- Layer separation and dependency management
+- Module boundaries and interface definition
+- Event-driven patterns for decoupling
+- Database access pattern optimization
+
+**9. Safety Verification**
+- Run full test suite after each change
+- Performance regression testing
+- Mutation testing for test effectiveness
+- Rollback plan for major changes
+
+**10. Advanced Patterns**
+- Strangler Fig: Gradual legacy replacement
+- Branch by Abstraction: Large-scale changes
+- Parallel Change: Expand-contract pattern
+- Mikado Method: Dependency graph navigation
+
+## Output Requirements
+
+- Refactored code with improvements applied
+- Test results (all green)
+- Before/after metrics comparison
+- Applied refactoring techniques list
+- Performance improvement measurements
+- Remaining technical debt assessment
+
+## Safety Checklist
+
+Before committing:
+- ✓ All tests pass (100% green)
+- ✓ No functionality regression
+- ✓ Performance metrics acceptable
+- ✓ Code coverage maintained/improved
+- ✓ Documentation updated
+
+## Recovery Protocol
+
+If tests fail:
+- Immediately revert last change
+- Identify breaking refactoring
+- Apply smaller incremental changes
+- Use version control for safe experimentation
+
+## Example: Extract Method Pattern
+
+**Before:**
+```typescript
+class OrderProcessor {
+  processOrder(order: Order): ProcessResult {
+    // Validation
+    if (!order.customerId || order.items.length === 0) {
+      return { success: false, error: "Invalid order" };
+    }
+
+    // Calculate totals
+    let subtotal = 0;
+    for (const item of order.items) {
+      subtotal += item.price * item.quantity;
+    }
+    let total = subtotal + (subtotal * 0.08) + (subtotal > 100 ? 0 : 15);
+
+    // Process payment...
+    // Update inventory...
+    // Send confirmation...
+  }
+}
+```
+
+**After:**
+```typescript
+class OrderProcessor {
+  async processOrder(order: Order): Promise<ProcessResult> {
+    const validation = this.validateOrder(order);
+    if (!validation.isValid) return ProcessResult.failure(validation.error);
+
+    const orderTotal = OrderTotal.calculate(order);
+    const inventoryCheck = await this.inventoryService.checkAvailability(order.items);
+    if (!inventoryCheck.available) return ProcessResult.failure(inventoryCheck.reason);
+
+    await this.paymentService.processPayment(order.paymentMethod, orderTotal.total);
+    await this.inventoryService.reserveItems(order.items);
+    await this.notificationService.sendOrderConfirmation(order, orderTotal);
+
+    return ProcessResult.success(order.id, orderTotal.total);
+  }
+
+  private validateOrder(order: Order): ValidationResult {
+    if (!order.customerId) return ValidationResult.invalid("Customer ID required");
+    if (order.items.length === 0) return ValidationResult.invalid("Order must contain items");
+    return ValidationResult.valid();
+  }
+}
+```
+
+**Applied:** Extract Method, Value Objects, Dependency Injection, Async patterns
+
+Code to refactor: $ARGUMENTS"