developer-ai 1.0.0

package/skills/refactoring/SKILL.md

@@ -0,0 +1,457 @@
+---
+name: refactoring
+description: Guide for improving code quality through refactoring. Use when cleaning up technical debt, improving performance, simplifying complex code, or preparing for new features. Covers code smells, refactoring patterns, and safe refactoring practices.
+---
+
+# Refactoring Skill
+
+This skill provides guidance for safely improving code quality through systematic refactoring.
+
+## Overview
+
+Refactoring is the process of restructuring code without changing its external behavior. Good refactoring improves readability, maintainability, and often performance.
+
+## Code Smells
+
+### Long Functions
+
+**Smell:** Functions doing too many things
+```javascript
+// BEFORE: 50+ line function
+function processOrder(order) {
+  // Validate order (10 lines)
+  // Calculate totals (15 lines)
+  // Apply discounts (10 lines)
+  // Update inventory (10 lines)
+  // Send notifications (15 lines)
+}
+
+// AFTER: Extracted into focused functions
+function processOrder(order) {
+  validateOrder(order);
+  const totals = calculateTotals(order);
+  const finalTotal = applyDiscounts(totals, order.customer);
+  updateInventory(order.items);
+  sendOrderNotifications(order);
+  return finalTotal;
+}
+```
+
+### Duplicate Code
+
+**Smell:** Same logic repeated in multiple places
+```javascript
+// BEFORE: Duplicated validation
+function createUser(data) {
+  if (!data.email || !data.email.includes('@')) {
+    throw new Error('Invalid email');
+  }
+  // ...
+}
+
+function updateUser(data) {
+  if (!data.email || !data.email.includes('@')) {
+    throw new Error('Invalid email');
+  }
+  // ...
+}
+
+// AFTER: Extracted to reusable function
+function validateEmail(email) {
+  if (!email || !email.includes('@')) {
+    throw new Error('Invalid email');
+  }
+}
+
+function createUser(data) {
+  validateEmail(data.email);
+  // ...
+}
+
+function updateUser(data) {
+  validateEmail(data.email);
+  // ...
+}
+```
+
+### Large Classes
+
+**Smell:** Class with too many responsibilities
+```javascript
+// BEFORE: God class
+class UserManager {
+  createUser() { }
+  deleteUser() { }
+  validateEmail() { }
+  hashPassword() { }
+  sendWelcomeEmail() { }
+  sendPasswordReset() { }
+  generateReport() { }
+  exportToCSV() { }
+}
+
+// AFTER: Split by responsibility
+class UserService {
+  createUser() { }
+  deleteUser() { }
+}
+
+class UserValidator {
+  validateEmail() { }
+  validatePassword() { }
+}
+
+class EmailService {
+  sendWelcomeEmail() { }
+  sendPasswordReset() { }
+}
+
+class UserReporter {
+  generateReport() { }
+  exportToCSV() { }
+}
+```
+
+### Feature Envy
+
+**Smell:** Method uses another class's data more than its own
+```javascript
+// BEFORE: Order method accessing customer internals
+class Order {
+  calculateDiscount() {
+    if (this.customer.loyaltyYears > 5 && 
+        this.customer.totalPurchases > 10000 &&
+        this.customer.tier === 'gold') {
+      return this.total * 0.2;
+    }
+    return 0;
+  }
+}
+
+// AFTER: Move logic to the appropriate class
+class Customer {
+  getDiscountRate() {
+    if (this.loyaltyYears > 5 && 
+        this.totalPurchases > 10000 &&
+        this.tier === 'gold') {
+      return 0.2;
+    }
+    return 0;
+  }
+}
+
+class Order {
+  calculateDiscount() {
+    return this.total * this.customer.getDiscountRate();
+  }
+}
+```
+
+### Primitive Obsession
+
+**Smell:** Using primitives instead of small objects
+```javascript
+// BEFORE: Phone number as string
+function formatPhoneNumber(phone) {
+  return `(${phone.slice(0,3)}) ${phone.slice(3,6)}-${phone.slice(6)}`;
+}
+
+// AFTER: Encapsulate in value object
+class PhoneNumber {
+  constructor(number) {
+    this.number = number.replace(/\D/g, '');
+    if (this.number.length !== 10) {
+      throw new Error('Invalid phone number');
+    }
+  }
+  
+  format() {
+    return `(${this.areaCode}) ${this.exchange}-${this.subscriber}`;
+  }
+  
+  get areaCode() { return this.number.slice(0, 3); }
+  get exchange() { return this.number.slice(3, 6); }
+  get subscriber() { return this.number.slice(6); }
+}
+```
+
+### Deep Nesting
+
+**Smell:** Excessive conditional nesting
+```javascript
+// BEFORE: Deeply nested
+function processPayment(order) {
+  if (order) {
+    if (order.items.length > 0) {
+      if (order.customer) {
+        if (order.customer.paymentMethod) {
+          if (order.customer.paymentMethod.isValid()) {
+            // Process payment
+          }
+        }
+      }
+    }
+  }
+}
+
+// AFTER: Early returns (guard clauses)
+function processPayment(order) {
+  if (!order) return { error: 'No order' };
+  if (order.items.length === 0) return { error: 'Empty order' };
+  if (!order.customer) return { error: 'No customer' };
+  if (!order.customer.paymentMethod) return { error: 'No payment method' };
+  if (!order.customer.paymentMethod.isValid()) return { error: 'Invalid payment' };
+  
+  // Process payment
+}
+```
+
+## Refactoring Patterns
+
+### Extract Function
+
+```javascript
+// BEFORE
+function printBill(order) {
+  console.log('=========');
+  console.log('RECEIPT');
+  console.log('=========');
+  
+  for (const item of order.items) {
+    console.log(`${item.name}: $${item.price}`);
+  }
+  
+  const total = order.items.reduce((sum, item) => sum + item.price, 0);
+  console.log('=========');
+  console.log(`Total: $${total}`);
+}
+
+// AFTER
+function printBill(order) {
+  printHeader();
+  printItems(order.items);
+  printTotal(calculateTotal(order.items));
+}
+
+function printHeader() {
+  console.log('=========');
+  console.log('RECEIPT');
+  console.log('=========');
+}
+
+function printItems(items) {
+  for (const item of items) {
+    console.log(`${item.name}: $${item.price}`);
+  }
+}
+
+function calculateTotal(items) {
+  return items.reduce((sum, item) => sum + item.price, 0);
+}
+
+function printTotal(total) {
+  console.log('=========');
+  console.log(`Total: $${total}`);
+}
+```
+
+### Replace Conditional with Polymorphism
+
+```javascript
+// BEFORE
+function calculateShipping(order) {
+  switch (order.shippingType) {
+    case 'standard':
+      return order.weight * 1.5;
+    case 'express':
+      return order.weight * 3.0 + 10;
+    case 'overnight':
+      return order.weight * 5.0 + 25;
+    default:
+      throw new Error('Unknown shipping type');
+  }
+}
+
+// AFTER
+class ShippingCalculator {
+  calculate(order) {
+    throw new Error('Must implement');
+  }
+}
+
+class StandardShipping extends ShippingCalculator {
+  calculate(order) {
+    return order.weight * 1.5;
+  }
+}
+
+class ExpressShipping extends ShippingCalculator {
+  calculate(order) {
+    return order.weight * 3.0 + 10;
+  }
+}
+
+class OvernightShipping extends ShippingCalculator {
+  calculate(order) {
+    return order.weight * 5.0 + 25;
+  }
+}
+
+// Factory to get correct calculator
+const shippingCalculators = {
+  standard: new StandardShipping(),
+  express: new ExpressShipping(),
+  overnight: new OvernightShipping(),
+};
+
+function calculateShipping(order) {
+  return shippingCalculators[order.shippingType].calculate(order);
+}
+```
+
+### Introduce Parameter Object
+
+```javascript
+// BEFORE: Too many parameters
+function searchProducts(category, minPrice, maxPrice, inStock, sortBy, sortOrder) {
+  // ...
+}
+
+searchProducts('electronics', 100, 500, true, 'price', 'asc');
+
+// AFTER: Parameter object
+function searchProducts(options) {
+  const { category, minPrice, maxPrice, inStock, sortBy, sortOrder } = options;
+  // ...
+}
+
+searchProducts({
+  category: 'electronics',
+  minPrice: 100,
+  maxPrice: 500,
+  inStock: true,
+  sortBy: 'price',
+  sortOrder: 'asc',
+});
+```
+
+### Replace Magic Numbers with Constants
+
+```javascript
+// BEFORE
+if (user.age >= 21) {
+  // ...
+}
+
+setTimeout(callback, 86400000);
+
+// AFTER
+const LEGAL_DRINKING_AGE = 21;
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+
+if (user.age >= LEGAL_DRINKING_AGE) {
+  // ...
+}
+
+setTimeout(callback, ONE_DAY_MS);
+```
+
+### Decompose Conditional
+
+```javascript
+// BEFORE
+if (date.before(SUMMER_START) || date.after(SUMMER_END)) {
+  charge = quantity * winterRate + winterServiceCharge;
+} else {
+  charge = quantity * summerRate;
+}
+
+// AFTER
+function isWinter(date) {
+  return date.before(SUMMER_START) || date.after(SUMMER_END);
+}
+
+function winterCharge(quantity) {
+  return quantity * winterRate + winterServiceCharge;
+}
+
+function summerCharge(quantity) {
+  return quantity * summerRate;
+}
+
+charge = isWinter(date) ? winterCharge(quantity) : summerCharge(quantity);
+```
+
+## Safe Refactoring Process
+
+### 1. Ensure Test Coverage
+
+```javascript
+// Write tests BEFORE refactoring
+describe('calculateShipping', () => {
+  it('calculates standard shipping', () => {
+    const order = { weight: 10, shippingType: 'standard' };
+    expect(calculateShipping(order)).toBe(15);
+  });
+  
+  it('calculates express shipping', () => {
+    const order = { weight: 10, shippingType: 'express' };
+    expect(calculateShipping(order)).toBe(40);
+  });
+  
+  // ... more tests
+});
+```
+
+### 2. Small Steps
+
+```javascript
+// DON'T: Refactor everything at once
+
+// DO: One small change at a time
+// Step 1: Extract one method
+// Step 2: Run tests
+// Step 3: Extract another method
+// Step 4: Run tests
+// ...
+```
+
+### 3. Commit Frequently
+
+```bash
+# After each successful refactoring step
+git add .
+git commit -m "refactor: extract calculateTotal function"
+
+git add .
+git commit -m "refactor: extract printHeader function"
+```
+
+### 4. Use IDE Refactoring Tools
+
+Most IDEs have built-in refactoring:
+- Extract Method/Function
+- Rename Symbol
+- Move to File
+- Inline Variable
+- Extract Variable
+
+## Refactoring Checklist
+
+### Before Starting
+- [ ] Tests pass
+- [ ] Understand current behavior
+- [ ] Identified specific improvement
+- [ ] Have a rollback plan
+
+### During Refactoring
+- [ ] One change at a time
+- [ ] Tests passing after each change
+- [ ] Committing frequently
+- [ ] No new features added
+
+### After Refactoring
+- [ ] All tests pass
+- [ ] Code review completed
+- [ ] Documentation updated
+- [ ] Performance verified