## Refactor

Performs safe, step-by-step code refactoring with quantitative SOLID principles evaluation. Visualizes technical debt and clarifies improvement priorities.

### Usage

```bash
# Identify complex code and create refactoring plan
find . -name "*.js" -exec wc -l {} + | sort -rn | head -10
"Refactor large files to reduce complexity"

# Detect and consolidate duplicate code
grep -r "function processUser" . --include="*.js"
"Consolidate duplicate functions using Extract Method"

# Evaluate SOLID principles violations
grep -r "class.*Service" . --include="*.js" | head -10
"Assess whether these classes follow Single Responsibility Principle"
```

### Basic Examples

```bash
# Find long methods
grep -A 50 "function" src/*.js | grep -B 50 -A 50 "return" | wc -l
"Split methods over 50 lines using Extract Method"

# Find complex conditions
grep -r "if.*if.*if" . --include="*.js"
"Improve nested conditions using Strategy pattern"

# Find code smells
grep -r "TODO\|FIXME\|HACK" . --exclude-dir=node_modules
"Resolve technical debt in comments"
```

### Refactoring Techniques

#### Extract Method (Split Big Functions)

```javascript
// Before: Long method
function processOrder(order) {
  // 50 lines of complex processing
}

// After: Separation of responsibilities
function processOrder(order) {
  validateOrder(order);
  calculateTotal(order);
  saveOrder(order);
}
```

#### Replace Conditional with Polymorphism (Remove Switch/If Chains)

```javascript
// Before: switch statement
function getPrice(user) {
  switch (user.type) {
    case "premium":
      return basePrice * 0.8;
    case "regular":
      return basePrice;
  }
}

// After: Strategy pattern
class PremiumPricing {
  calculate(basePrice) {
    return basePrice * 0.8;
  }
}
```

### SOLID Principles Scoring (0-100 points)

#### Evaluation Criteria and Scoring

```text
S - Single Responsibility (20 points)
├─ Number of responsibilities: 1 (20pts) | 2 (15pts) | 3 (10pts) | 4+ (5pts)
├─ Method count: <7 (+5pts) | 7-15 (+3pts) | >15 (0pts)
├─ Clear reasons for change: Clear (+5pts) | Unclear (0pts)
└─ Example score: UserService (auth + data processing) = 10 points

O - Open/Closed (20 points)
├─ Extension points: Strategy/Template Method (20pts) | Inheritance only (10pts) | None (5pts)
├─ Existing code changes for new features: Not needed (+5pts) | Minimal (+3pts) | Required (0pts)
├─ Interface usage: Appropriate (+5pts) | Partial (+3pts) | None (0pts)
└─ Example score: PaymentProcessor (Strategy) = 20 points

L - Liskov Substitution (20 points)
├─ Derived class contract compliance: Complete (20pts) | Partial (10pts) | Violated (0pts)
├─ Precondition strengthening: None (+5pts) | Present (-5pts)
├─ Postcondition weakening: None (+5pts) | Present (-5pts)
└─ Example score: Square extends Rectangle = 0 points (violated)

I - Interface Segregation (20 points)
├─ Interface size: 1-3 methods (20pts) | 4-7 (15pts) | 8+ (5pts)
├─ Unused method implementations: None (+5pts) | 1-2 (+2pts) | 3+ (0pts)
├─ Role clarity: Single role (+5pts) | Multiple roles (0pts)
└─ Example score: Readable/Writable separation = 20 points

D - Dependency Inversion (20 points)
├─ Dependency direction: Abstractions only (20pts) | Mixed (10pts) | Concretions only (5pts)
├─ DI usage: Constructor Injection (+5pts) | Setter (+3pts) | None (0pts)
├─ Testability: Mockable (+5pts) | Difficult (0pts)
└─ Example score: Repository Pattern = 20 points

Total Score = S + O + L + I + D
├─ 90-100 points: Excellent (SOLID compliant)
├─ 70-89 points: Good (Minor improvements needed)
├─ 50-69 points: Fair (Refactoring recommended)
├─ 30-49 points: Poor (Major improvements required)
└─ 0-29 points: Critical (Design overhaul required)
```

### Technical Debt Quantification

#### Debt Calculation Formula

```text
Technical Debt (time) = Complexity Score × Impact Range × Fix Difficulty

Complexity Score:
├─ Cyclomatic complexity: 1-5 (low) | 6-10 (med) | 11-20 (high) | 21+ (critical)
├─ Cognitive complexity: Nesting depth × conditional branches
├─ Lines of code: <50 (1pt) | 50-200 (2pts) | 200-500 (3pts) | 500+ (5pts)
└─ Duplication rate: 0-10% (1pt) | 10-30% (2pts) | 30-50% (3pts) | 50%+ (5pts)

Impact Range:
├─ Dependent modules: Direct dependencies + Indirect × 0.5
├─ Usage frequency: API calls/day
├─ Business importance: Critical (×3) | High (×2) | Medium (×1) | Low (×0.5)
└─ Team knowledge: 1 person knows (×3) | 2-3 (×2) | 4+ (×1)

Fix Difficulty:
├─ Test coverage: 0% (×3) | <50% (×2) | 50-80% (×1.5) | >80% (×1)
├─ Documentation: None (×2) | Insufficient (×1.5) | Adequate (×1)
├─ Dependencies: Tightly coupled (×3) | Moderate (×2) | Loosely coupled (×1)
└─ Change risk: Breaking change (×3) | Backward compatibility (×2) | Safe (×1)

Cost Conversion:
├─ Time cost: Debt time × Developer hourly rate
├─ Opportunity cost: New feature delay days × Daily revenue impact
├─ Quality cost: Bug probability × Fix cost × Frequency
└─ Total cost: Time + Opportunity + Quality costs
```

#### Priority Matrix

| Priority                   | Impact | Fix Cost | Time Savings | Investment ROI        | Response Deadline |
| -------------------------- | ------ | -------- | ------------ | --------------------- | ----------------- |
| **Critical (Immediate)**   | High   | Low      | > 5x         | Invest 1h → Save 5h+  | Immediately       |
| **Important (Planned)**    | High   | High     | 2-5x         | Invest 1h → Save 2-5h | Within 1 month    |
| **Watch (Monitor)**        | Low    | High     | 1-2x         | Invest 1h → Save 1-2h | Within 3 months   |
| **Acceptable (Tolerable)** | Low    | Low      | < 1x         | Investment = Savings  | No action needed  |

### Refactoring Process

1. **Current Analysis and Measurement**
   - Measure complexity (cyclomatic & cognitive)
   - Calculate SOLID score (0-100 points)
   - Quantify technical debt (time/cost)
   - Create priority matrix

2. **Step-by-Step Execution**
   - Small steps (15-30 minute increments)
   - Run tests after each change
   - Frequent commits
   - Continuous SOLID score measurement

3. **Quality Verification**
   - Maintain test coverage
   - Measure performance
   - Verify technical debt reduction
   - Code review

### Common Code Smells and Debt Scores

| Code Smell              | Detection Criteria               | Debt Score     | Improvement Method       |
| ----------------------- | -------------------------------- | -------------- | ------------------------ |
| **God Object**          | Responsibilities >3, Methods >20 | High (15-20h)  | Extract Class, Apply SRP |
| **Long Method**         | Lines >50, Complexity >10        | Medium (5-10h) | Extract Method           |
| **Duplicate Code**      | Duplication rate >30%            | High (10-15h)  | Extract Method/Class     |
| **Large Class**         | Lines >300, Methods >15          | High (10-20h)  | Extract Class            |
| **Long Parameter List** | Parameters >4                    | Low (2-5h)     | Parameter Object         |
| **Feature Envy**        | Other class references >5        | Medium (5-10h) | Move Method              |
| **Data Clumps**         | Repeated argument groups         | Low (3-5h)     | Extract Class            |
| **Primitive Obsession** | Excessive primitive type usage   | Medium (5-8h)  | Replace with Object      |
| **Switch Statements**   | Cases >5                         | Medium (5-10h) | Strategy Pattern         |
| **Shotgun Surgery**     | Change impact areas >3           | High (10-15h)  | Move Method/Field        |

### Practical Example: SOLID Score Evaluation

```javascript
// Evaluation target: UserService class
class UserService {
  constructor(db, cache, logger, emailService) { // 4 dependencies
    this.db = db;
    this.cache = cache;
    this.logger = logger;
    this.emailService = emailService;
  }

  // Responsibility 1: Authentication
  authenticate(username, password) { /* ... */ }
  refreshToken(token) { /* ... */ }

  // Responsibility 2: User management
  createUser(data) { /* ... */ }
  updateUser(id, data) { /* ... */ }
  deleteUser(id) { /* ... */ }

  // Responsibility 3: Notifications
  sendWelcomeEmail(user) { /* ... */ }
  sendPasswordReset(email) { /* ... */ }
}

// SOLID Score Evaluation Result
S: 10 points (3 responsibilities: auth, CRUD, notifications)
O: 5 points (No extension points, direct implementation)
L: 15 points (No inheritance, not applicable)
I: 10 points (Interfaces not segregated)
D: 10 points (Depends on concrete classes)
Total: 50 points (Fair - Refactoring recommended)

// Technical Debt
Complexity: 15 (7 methods, 3 responsibilities)
Impact Range: 8 (Authentication used across all features)
Fix Difficulty: 2 (Tests exist, documentation lacking)
Debt Time: 15 × 8 × 2 = 240 hours
Priority: Critical (Auth system requires immediate attention)
```

### Improved Implementation Example

```javascript
// After applying SOLID principles (Score: 90 points)

// S: Single Responsibility (20 points)
class AuthenticationService {
  authenticate(credentials) { /* ... */ }
  refreshToken(token) { /* ... */ }
}

// O: Open/Closed (20 points)
class UserRepository {
  constructor(storage) { // Strategy Pattern
    this.storage = storage;
  }
  save(user) { return this.storage.save(user); }
}

// I: Interface Segregation (20 points)
interface Readable {
  find(id);
  findAll();
}
interface Writable {
  save(entity);
  delete(id);
}

// D: Dependency Inversion (20 points)
class UserService {
  constructor(
    private auth: IAuthService,
    private repo: IUserRepository,
    private notifier: INotificationService
  ) {}
}

// Debt reduction: 240 hours → 20 hours (92% reduction)
```

### Automation Support

```bash
# SOLID score measurement
npx solid-analyzer src/ --output report.json

# Complexity analysis
npx complexity-report src/ --format json
sonar-scanner -Dsonar.javascript.lcov.reportPaths=coverage/lcov.info

# Technical debt visualization
npx code-debt-analyzer --config .debt.yml

# Code formatting
npm run lint:fix
prettier --write src/

# Test execution and coverage
npm test -- --coverage
npm run test:mutation  # Mutation testing
```

### Important Rules

- **No functional changes**: Don't alter external behavior
- **Test first**: Add tests before refactoring
- **Step-by-step approach**: No large changes at once
- **Continuous verification**: Run tests at each step