Skip to content

Latest commit

 

History

History
209 lines (154 loc) · 4.71 KB

refactor.md

File metadata and controls

209 lines (154 loc) · 4.71 KB

SOLID Refactoring Assistant

Analyze code for SOLID violations and suggest targeted improvements.

Purpose

Identify refactoring opportunities based on:

  • SOLID principle violations
  • Code smells and anti-patterns
  • Complexity metrics
  • Duplication detection

Instructions

Step 1: Scope Analysis

Determine the refactoring scope from user input:

  • Single file: Deep analysis
  • Directory: Pattern detection across files
  • Function/class: Focused extraction suggestions
# Get file/directory stats
if [ -f "$TARGET" ]; then
  wc -l "$TARGET"
  echo "Single file analysis"
elif [ -d "$TARGET" ]; then
  find "$TARGET" -type f \( -name "*.ts" -o -name "*.js" -o -name "*.py" \) | wc -l
  echo "Directory analysis"
fi

Step 2: SOLID Violations Detection

S - Single Responsibility

Look for:

  • Files > 300 lines
  • Functions > 50 lines
  • Classes with > 10 methods
  • Mixed concerns (data + UI + business logic)
# Find large files
find . -name "*.{ts,js,py}" -exec wc -l {} + 2>/dev/null | sort -rn | head -10

# Functions with high line count (approximate)
grep -rn "function\|def \|fn " --include="*.{ts,js,py,rs}" . | head -20

O - Open/Closed Principle

Look for:

  • Switch/case statements on types
  • Repeated if/else type checking
  • Direct modifications vs extensions

L - Liskov Substitution

Look for:

  • Overridden methods that throw "not implemented"
  • Type checks before method calls
  • Empty method overrides

I - Interface Segregation

Look for:

  • Large interfaces (> 10 methods)
  • Classes implementing unused interface methods
  • Fat service classes

D - Dependency Inversion

Look for:

  • Direct instantiation of dependencies (new Service())
  • Hardcoded class references
  • Missing dependency injection

Step 3: Code Smells

# Duplication patterns
grep -rn --include="*.{ts,js,py}" . 2>/dev/null | \
  awk -F: '{print $3}' | sort | uniq -c | sort -rn | head -10

# Long parameter lists (> 4 params)
grep -rn "function.*,.*,.*,.*," --include="*.{ts,js}" . 2>/dev/null | head -10

# Deep nesting (4+ levels)
grep -rn "^\s\{16,\}" --include="*.{ts,js,py}" . 2>/dev/null | head -10

Step 4: Complexity Assessment

For each issue found, assess:

  • Impact: How much code is affected?
  • Risk: What could break?
  • Effort: Lines to change, tests needed?

Output Format

🔧 Refactoring Analysis

Target: [file/directory] Lines Analyzed: [count]

📊 SOLID Scorecard

Principle Status Issues Found
Single Responsibility 🟡 3 large classes
Open/Closed 🟢 OK
Liskov Substitution 🟢 OK
Interface Segregation 🔴 2 fat interfaces
Dependency Inversion 🟡 5 direct instantiations

🎯 Priority Refactorings

1. [Highest Impact] - Extract class from UserService

Violation: Single Responsibility Current: 450 lines handling auth + profile + notifications Suggested:

UserService.ts (450 lines)
    ↓ Extract
AuthService.ts (~150 lines)
ProfileService.ts (~150 lines)
NotificationService.ts (~100 lines)

Risk: Medium (update imports) Tests Needed: Update dependency injection in tests

2. [Second Priority] - Replace switch with polymorphism

Location: src/handlers/payment.ts:45 Current:

switch (paymentType) {
  case 'card': // 50 lines
  case 'bank': // 50 lines
  case 'crypto': // 50 lines
}

Suggested: Strategy pattern with PaymentProcessor interface Risk: Low (isolated change)

📝 Code Smells

Smell Location Severity
Long Method api.ts:calculateTotal (120 lines) 🟠 High
Duplicate Code utils/*.ts (3 similar blocks) 🟡 Medium
Deep Nesting parser.ts:parse (6 levels) 🟡 Medium

🚀 Quick Wins (Low Risk, High Value)

  1. Extract validateEmail() to shared utils (used in 4 places)
  2. Replace magic numbers with named constants
  3. Add early returns to reduce nesting in processOrder()

⚠️ Technical Debt Notes

  • [Item to track for future sprints]

Refactoring Safety Checklist

Before applying suggestions:

  • Tests exist for affected code
  • Create feature branch
  • Commit current state
  • Apply one refactoring at a time
  • Run tests after each change
  • Review diff before committing

Usage

Analyze specific file:

/refactor src/services/user.ts

Analyze directory:

/refactor src/api/

Focus on specific principle:

/refactor --focus=srp src/services/

With complexity threshold:

/refactor --threshold=high

References

  • Martin Fowler's Refactoring Catalog
  • Clean Code by Robert C. Martin
  • SOLID principles by Robert C. Martin

$ARGUMENTS