---
name: wasabeef/refactorización-segura-e-incremental
source: https://app.decimal.ai/s/wasabeef-refactorizacio-n-segura-e-incremental@1/SKILL.md
source_sha256: 38945fa9b17f
---

# Refactorización segura e incremental

Implementa refactorización de código segura y gradual, evalúa cuantitativamente la adherencia a los principios SOLID. Visualiza la deuda técnica y clarifica las prioridades de mejora.

## Uso

```bash
# Identificación de código complejo y plan de refactorización
find . -name "*.js" -exec wc -l {} + | sort -rn | head -10
"Refactoriza estos archivos grandes para reducir la complejidad"

# Detección e integración de código duplicado
grep -r "function processUser" . --include="*.js"
"Unifica estas funciones duplicadas con Extract Method"

# Detección de violaciones de principios SOLID
grep -r "class.*Service" . --include="*.js" | head -10
"Evalúa si estas clases siguen el principio de responsabilidad única"
```

## Ejemplos básicos

```bash
# Detección de métodos largos
grep -A 50 "function" src/*.js | grep -B 50 -A 50 "return" | wc -l
"Divide métodos de más de 50 líneas con Extract Method"

# Complejidad de ramificaciones condicionales
grep -r "if.*if.*if" . --include="*.js"
"Mejora estas declaraciones condicionales anidadas con patrón Strategy"

# Detección de code smells
grep -r "TODO\|FIXME\|HACK" . --exclude-dir=node_modules
"Resuelve los comentarios que se han convertido en deuda técnica"
```

## Técnicas de refactorización

### Extract Method (Extracción de método)

```javascript
// Antes: Método extenso
function processOrder(order) {
  // 50 líneas de procesamiento complejo
}

// Después: Separación de responsabilidades
function processOrder(order) {
  validateOrder(order);
  calculateTotal(order);
  saveOrder(order);
}
```

### Replace Conditional with Polymorphism

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

// Después: patrón Strategy
class PremiumPricing {
  calculate(basePrice) {
    return basePrice * 0.8;
  }
}
```

## Puntuación de principios SOLID (0-100 puntos)

### Criterios de evaluación y puntuación

```text
S - Single Responsibility (20 puntos)
├─ Número de responsabilidades de clase: 1 (20 pts) | 2 (15 pts) | 3 (10 pts) | 4+ (5 pts)
├─ Número de métodos: <7 (+5 pts) | 7-15 (+3 pts) | >15 (0 pts)
├─ Claridad de razón de cambio: Clara (+5 pts) | Ambigua (0 pts)
└─ Ejemplo de puntuación: UserService(autenticación+procesamiento de datos) = 10 puntos

O - Open/Closed (20 puntos)
├─ Puntos de extensión: Strategy/Template Method (20 pts) | Solo herencia (10 pts) | Ninguno (5 pts)
├─ Cambios en código existente al agregar nuevas funciones: No necesario (+5 pts) | Mínimo (+3 pts) | Necesario (0 pts)
├─ Uso de interfaces: Apropiado (+5 pts) | Parcial (+3 pts) | Ninguno (0 pts)
└─ Ejemplo de puntuación: PaymentProcessor(Strategy) = 20 puntos

L - Liskov Substitution (20 puntos)
├─ Adherencia al contrato de clases derivadas: Completa (20 pts) | Parcial (10 pts) | Violación (0 pts)
├─ Fortalecimiento de precondiciones: Ninguno (+5 pts) | Existe (-5 pts)
├─ Debilitamiento de postcondiciones: Ninguno (+5 pts) | Existe (-5 pts)
└─ Ejemplo de puntuación: Square extends Rectangle = 0 puntos (violación)

I - Interface Segregation (20 puntos)
├─ Tamaño de interfaz: 1-3 métodos (20 pts) | 4-7 (15 pts) | 8+ (5 pts)
├─ Implementación de métodos no utilizados: Ninguno (+5 pts) | 1-2 (+2 pts) | 3+ (0 pts)
├─ Claridad de rol: Rol único (+5 pts) | Múltiples roles (0 pts)
└─ Ejemplo de puntuación: Separación Readable/Writable = 20 puntos

D - Dependency Inversion (20 puntos)
├─ Dirección de dependencia: Solo abstracción (20 pts) | Mixta (10 pts) | Solo concreta (5 pts)
├─ Uso de DI: Constructor Injection (+5 pts) | Setter (+3 pts) | Ninguno (0 pts)
├─ Capacidad de prueba: Mockeable (+5 pts) | Difícil (0 pts)
└─ Ejemplo de puntuación: Repository Pattern = 20 puntos

Puntuación total = S + O + L + I + D
├─ 90-100 puntos: Excelente (Cumplimiento completo SOLID)
├─ 70-89 puntos: Bueno (Margen de mejora leve)
├─ 50-69 puntos: Aceptable (Refactorización recomendada)
├─ 30-49 puntos: Pobre (Mejora a gran escala necesaria)
└─ 0-29 puntos: Crítico (Revisión de diseño obligatoria)
```

## Cuantificación de deuda técnica

### Fórmula de cálculo de deuda

```text
Deuda técnica (tiempo) = Puntuación de complejidad × Alcance de impacto × Dificultad de corrección

Puntuación de complejidad:
├─ Complejidad ciclomática: 1-5(baja) | 6-10(media) | 11-20(alta) | 21+(peligrosa)
├─ Complejidad cognitiva: Profundidad de anidación × Número de ramificaciones condicionales
├─ Líneas de código: <50(1 pt) | 50-200(2 pts) | 200-500(3 pts) | 500+(5 pts)
└─ Tasa de duplicación: 0-10%(1 pt) | 10-30%(2 pts) | 30-50%(3 pts) | 50%+(5 pts)

Alcance de impacto:
├─ Número de módulos dependientes: Dependencia directa + Dependencia indirecta × 0.5
├─ Frecuencia de uso: Número de llamadas API/día
├─ Importancia comercial: Crítica(×3) | Alta(×2) | Media(×1) | Baja(×0.5)
└─ Conocimiento del equipo: 1 persona que entiende(×3) | 2-3(×2) | 4+(×1)

Dificultad de corrección:
├─ Cobertura de pruebas: 0%(×3) | <50%(×2) | 50-80%(×1.5) | >80%(×1)
├─ Documentación: Ninguna(×2) | Insuficiente(×1.5) | Suficiente(×1)
├─ Relaciones de dependencia: Acoplamiento fuerte(×3) | Moderado(×2) | Acoplamiento débil(×1)
└─ Riesgo de cambio: Breaking Change(×3) | Consideración de compatibilidad(×2) | Seguro(×1)

Conversión de costos:
├─ Costo de tiempo: Tiempo de deuda × Salario por hora del desarrollador
├─ Costo de oportunidad: Días de retraso en desarrollo de nuevas funciones × Impacto diario en ventas
├─ Costo de calidad: Probabilidad de aparición de bugs × Costo de corrección × Frecuencia de aparición
└─ Costo total: Tiempo + Costo de oportunidad + Costo de calidad
```

### Matriz de prioridades

| Prioridad                             | Grado de impacto | Costo de corrección | Plazo de respuesta    | Ejemplo concreto                                                      | Acción recomendada                              |
| ------------------------------------- | ---------------- | ------------------- | --------------------- | --------------------------------------------------------------------- | ----------------------------------------------- |
| **Critical (Respuesta inmediata)**    | Alto             | Bajo                | Dentro de 1 semana    | God Object, dependencia circular                                      | Iniciar refactorización inmediatamente          |
| **Important (Respuesta planificada)** | Alto             | Alto                | Dentro de 1 mes       | Separación de responsabilidades a gran escala, cambio de arquitectura | Incorporar en planificación de sprint           |
| **Watch (Objeto de monitoreo)**       | Bajo             | Alto                | Dentro de 3 meses     | Procesamiento interno de alta complejidad                             | Monitoreo de métricas, respuesta cuando empeore |
| **Acceptable (Rango aceptable)**      | Bajo             | Bajo                | No requiere respuesta | Code smells leves                                                     | Respuesta con refactorización normal            |

## Procedimiento de refactorización

1. **Análisis y medición del estado actual**
   - Medición de complejidad (ciclomática ・cognitiva)
   - Cálculo de puntuación SOLID (0-100 puntos)
   - Cuantificación de deuda técnica (tiempo/costo)
   - Creación de matriz de prioridades

2. **Ejecución gradual**
   - Pasos pequeños (unidades de 15-30 minutos)
   - Ejecución de pruebas después de cada cambio
   - Commits frecuentes
   - Medición continua de puntuación SOLID

3. **Confirmación de calidad**
   - Mantenimiento de cobertura de pruebas
   - Medición de rendimiento
   - Confirmación de reducción de deuda técnica
   - Revisión de código

## Code smells comunes y puntuación de deuda

| Code Smell              | Criterio de detección                   | Puntuación de deuda | Método de mejora              |
| ----------------------- | --------------------------------------- | ------------------- | ----------------------------- |
| **God Object**          | Responsabilidades >3, métodos >20       | Alta (15-20h)       | Extract Class, aplicación SRP |
| **Long Method**         | Líneas >50, complejidad >10             | Media (5-10h)       | Extract Method                |
| **Duplicate Code**      | Tasa de duplicación >30%                | Alta (10-15h)       | Extract Method/Class          |
| **Large Class**         | Líneas >300, métodos >15                | Alta (10-20h)       | Extract Class                 |
| **Long Parameter List** | Parámetros >4                           | Baja (2-5h)         | Parameter Object              |
| **Feature Envy**        | Referencias a otras clases >5           | Media (5-10h)       | Move Method                   |
| **Data Clumps**         | Repetición de mismo grupo de argumentos | Baja (3-5h)         | Extract Class                 |
| **Primitive Obsession** | Uso excesivo de tipos primitivos        | Media (5-8h)        | Replace with Object           |
| **Switch Statements**   | case >5                                 | Media (5-10h)       | Strategy Pattern              |
| **Shotgun Surgery**     | Áreas afectadas al cambiar >3           | Alta (10-15h)       | Move Method/Field             |

## Ejemplo práctico: Evaluación de puntuación SOLID

```javascript
// Objeto de evaluación: clase UserService
class UserService {
  constructor(db, cache, logger, emailService) { // 4 dependencias
    this.db = db;
    this.cache = cache;
    this.logger = logger;
    this.emailService = emailService;
  }

  // Responsabilidad 1: autenticación
  authenticate(username, password) { /* ... */ }
  refreshToken(token) { /* ... */ }

  // Responsabilidad 2: gestión de usuarios
  createUser(data) { /* ... */ }
  updateUser(id, data) { /* ... */ }
  deleteUser(id) { /* ... */ }

  // Responsabilidad 3: notificación
  sendWelcomeEmail(user) { /* ... */ }
  sendPasswordReset(email) { /* ... */ }
}

// Resultado de evaluación de puntuación SOLID
S: 10 puntos (3 responsabilidades: autenticación, CRUD, notificación)
O: 5 puntos (sin puntos de extensión, implementación directa)
L: 15 puntos (sin herencia, no aplicable)
I: 10 puntos (interfaz no segregada)
D: 10 puntos (dependencia de clases concretas)
Total: 50 puntos (Aceptable - Refactorización recomendada)

// Deuda técnica
Complejidad: 15 (7 métodos, 3 responsabilidades)
Alcance de impacto: 8 (autenticación usada en todas las funciones)
Dificultad de corrección: 2 (con pruebas, documentación insuficiente)
Tiempo de deuda: 15 × 8 × 2 = 240 horas
Prioridad: Critical (sistema de autenticación requiere respuesta inmediata)
```

## Ejemplo de implementación después de mejora

```javascript
// Después de aplicar principios SOLID (Puntuación: 90 puntos)

// S: Responsabilidad única (20 puntos)
class AuthenticationService {
  authenticate(credentials) { /* ... */ }
  refreshToken(token) { /* ... */ }
}

// O: Abierto/cerrado (20 puntos)
class UserRepository {
  constructor(storage) { // Strategy Pattern
    this.storage = storage;
  }
  save(user) { return this.storage.save(user); }
}

// I: Segregación de interfaz (20 puntos)
interface Readable {
  find(id);
  findAll();
}
interface Writable {
  save(entity);
  delete(id);
}

// D: Inversión de dependencia (20 puntos)
class UserService {
  constructor(
    private auth: IAuthService,
    private repo: IUserRepository,
    private notifier: INotificationService
  ) {}
}

// Reducción de deuda: 240 horas → 20 horas (92% de reducción)
```

## Soporte de automatización

```bash
# Medición de puntuación SOLID
npx solid-analyzer src/ --output report.json

# Análisis de complejidad
npx complexity-report src/ --format json
sonar-scanner -Dsonar.javascript.lcov.reportPaths=coverage/lcov.info

# Visualización de deuda técnica
npx code-debt-analyzer --config .debt.yml

# Formato de código
npm run lint:fix
prettier --write src/

# Ejecución de pruebas y cobertura
npm test -- --coverage
npm run test:mutation  # pruebas de mutación
```

## Precauciones

- **Prohibición de cambios funcionales**: No cambiar el comportamiento externo
- **Test first**: Agregar pruebas antes de la refactorización
- **Enfoque gradual**: No hacer cambios grandes de una vez
- **Verificación continua**: Ejecución de pruebas en cada paso