refactoring-guide

name	refactoring-guide
description	Guide de refactoring avec les principes SOLID, DRY, KISS et les patterns de transformation. Utilise cette skill quand l'utilisateur veut refactorer du code, améliorer la qualité, réduire la dette technique, ou appliquer un design pattern.

Refactoring Guide — Workflow Collègue

Tu guides le refactoring de code en suivant une approche méthodique. Utilise repo_consistency_check pour diagnostiquer, code_refactoring pour transformer, et test_generation pour sécuriser.

Règle d'or

Ne jamais refactorer sans tests. Si le code n'a pas de tests, en générer d'abord avec test_generation.

Workflow de refactoring

1. Diagnostic

Appelle repo_consistency_check pour identifier les problèmes :

repo_consistency_check({
  files: [...],
  checks: ['unused_imports', 'unused_vars', 'dead_code', 'duplication'],
  mode: 'deep'
})

Indicateurs de besoin de refactoring :

• Score de duplication > 20%
• Fichiers > 300 lignes
• Fonctions > 50 lignes
• Complexité cyclomatique > 10
• Imports inutilisés > 5 par fichier
• Variables non utilisées

2. Sécurisation (tests)

Avant toute modification, s'assurer que les tests existent :

test_generation({
  code: "...",
  language: "typescript",
  coverage_target: 0.8,
  include_mocks: true
})

3. Transformation

Appelle code_refactoring avec le type approprié :

Situation	Type	Description
Nommage confus	rename	Renommer variables, fonctions, classes
Fonction trop longue	extract	Extraire des sous-fonctions
Logique complexe	simplify	Simplifier les conditions et boucles
Performance faible	optimize	Optimiser les algorithmes et requêtes
Code mort / imports inutiles	clean	Nettoyer le code superflu
Patterns obsolètes	modernize	Adopter les patterns modernes

4. Vérification

Relancer repo_consistency_check pour confirmer l'amélioration.

Quand refactorer

Refactorer maintenant

• Avant d'ajouter une nouvelle feature au même fichier
• Quand un bug révèle du code fragile
• Quand les tests sont difficiles à écrire (signe de mauvais design)
• Quand le même code est copié-collé une 3ème fois (Rule of Three)

Ne PAS refactorer maintenant

• Juste avant un deadline / release
• Du code qui fonctionne et qu'on ne touche pas
• Sans tests existants ou sans temps d'en écrire
• Pour des raisons purement esthétiques

Techniques de refactoring par smell

Bloaters (code trop gros)

Long Method (>50 lignes)

Technique: Extract Method
1. Identifier les blocs logiques dans la fonction
2. Extraire chaque bloc en une fonction nommée
3. Remplacer le bloc par l'appel de fonction
→ code_refactoring type: "extract"

Large Class (>300 lignes, >10 méthodes)

Technique: Extract Class
1. Identifier les groupes de méthodes/attributs liés
2. Créer une nouvelle classe pour chaque groupe
3. Déléguer via composition
→ code_refactoring type: "extract"

Long Parameter List (>4 paramètres)

Technique: Introduce Parameter Object
1. Grouper les paramètres liés en un objet/interface
2. Passer l'objet au lieu des paramètres individuels
→ code_refactoring type: "simplify"

Couplers (couplage excessif)

Feature Envy (utilise plus les données d'un autre objet)

Technique: Move Method
1. Déplacer la méthode vers la classe dont elle utilise les données
→ code_refactoring type: "extract"

Inappropriate Intimacy (classes trop liées)

Technique: Extract Interface + Dependency Injection
1. Définir une interface pour le contrat
2. Injecter la dépendance au lieu de la créer
→ code_refactoring type: "simplify"

Dispensables (code inutile)

Dead Code

Technique: Remove Dead Code
1. repo_consistency_check → détecte le code mort
2. Supprimer les fonctions/variables non utilisées
→ code_refactoring type: "clean"

Duplicated Code

Technique: Extract Method / Pull Up Method
1. repo_consistency_check → détecte les duplications
2. Extraire le code commun en fonction partagée
→ code_refactoring type: "extract"

Change Preventers (résistance au changement)

Shotgun Surgery (un changement = modifier 10 fichiers)

Technique: Move Method + Inline Class
1. impact_analysis → voir les fichiers impactés
2. Consolider la logique dispersée en un module
→ code_refactoring type: "simplify"

Modernisation par langage

Python : patterns modernes

Ancien	Moderne
os.path.join()	pathlib.Path()
dict.keys() iteration	for k, v in dict.items()
try/except pass	Gestion d'erreur explicite
class Config: pass	@dataclass ou BaseModel
format() strings	f-strings
type() checks	isinstance() + type hints
threading pour I/O	asyncio
manual __init__	@dataclass(frozen=True)

TypeScript / JavaScript : patterns modernes

Ancien	Moderne
var	const / let
.then().catch()	async/await
for (let i = 0; ...)	.map() / .filter() / .reduce()
Object.assign()	Spread {...obj}
require()	import ESM
class + inheritance	Composition + hooks
any type	Types stricts + generics
Callback hell	Promises + async/await

Pour des exemples détaillés, consulte examples.md.