Comment automatiser le refactoring avec Claude Code

Pourquoi refactorer avec Claude Code ?

Tout le monde sait que le refactoring est important, mais c’est fastidieux à faire manuellement et souvent relégué au second plan. Claude Code comprend l’intégralité de votre projet et peut exécuter du refactoring de manière autonome sur plusieurs fichiers.

Pattern 1 : Améliorer la sécurité des types

Éliminer les types any

> Recherche dans le projet tous les types any et remplace-les par des types appropriés.
> Après les modifications, vérifie que npx tsc --noEmit passe correctement.

Voici comment Claude Code procède :

1. Recherche les fichiers contenant des types any
2. Déduit les types appropriés à partir du code environnant
3. Crée des fichiers de définition de types si nécessaire
4. Lance le vérificateur de types pour confirmer que tout compile

Avant et après

// Avant
function processData(data: any): any {
  return data.items.map((item: any) => item.name);
}

// Après
interface DataPayload {
  items: Array<{ name: string; id: number }>;
}

function processData(data: DataPayload): string[] {
  return data.items.map((item) => item.name);
}

Pattern 2 : Découper les fonctions et clarifier les responsabilités

Le découpage de fonctions trop volumineuses est quelque chose que Claude Code gère exceptionnellement bien.

> La fonction createOrder dans src/services/orderService.ts fait plus de 200 lignes.
> Découpe-la en fonctions plus petites en suivant le principe de responsabilité unique.
> Assure-toi que les tests existants passent toujours.

Prompt pour le découpage

> Découpe la fonction selon ces directives :
> - Chaque fonction doit faire 30 lignes maximum
> - Sépare la validation, la logique métier et la persistance
> - Ajoute des commentaires JSDoc à chaque fonction
> - Découpe les tests pour correspondre aux nouvelles limites de fonctions

Pattern 3 : Standardiser la gestion des erreurs

Unifiez les patterns de gestion des erreurs dans l’ensemble de votre projet.

> Standardise la gestion des erreurs dans tout le projet :
> - Utilise une classe d'erreur personnalisée (AppError)
> - Définis les codes d'erreur comme des constantes
> - Inclus systématiquement du logging dans les blocs try-catch

Voici un exemple de ce que génère Claude Code :

// src/errors/app-error.ts
export class AppError extends Error {
  constructor(
    public readonly code: string,
    message: string,
    public readonly statusCode: number = 500,
    public readonly cause?: Error
  ) {
    super(message);
    this.name = 'AppError';
  }
}

// Constantes des codes d'erreur
export const ErrorCodes = {
  USER_NOT_FOUND: 'USER_NOT_FOUND',
  INVALID_INPUT: 'INVALID_INPUT',
  DB_CONNECTION_ERROR: 'DB_CONNECTION_ERROR',
} as const;

Pattern 4 : Ajouter et améliorer les tests

Ajoutez des tests là où la couverture est insuffisante.

# Utilisez les rapports de couverture pour guider l'ajout de tests
npx vitest run --coverage | claude -p "Identifie les fichiers avec une faible couverture et ajoute les cas de test manquants"

> Porte la couverture de tests de tout ce qui se trouve dans src/services/ à au moins 80 %.
> Couvre non seulement les cas nominaux, mais aussi les cas limites et les scénarios d'erreur.

Pattern 5 : Standardiser les formats de réponse d’API

> Standardise toutes les réponses des endpoints d'API selon ce format :
>
> Succès : { success: true, data: T }
> Échec : { success: false, error: { code: string, message: string } }
>
> Mets à jour le code frontend pour correspondre au nouveau format.

Conseils pour un refactoring sûr

1. Vérifiez les tests d’abord

> Lance npm test d'abord et assure-toi que tous les tests existants passent.
> Si des tests échouent, signale-les avant de faire des modifications.

2. Travaillez de manière incrémentale

Refactorez module par module plutôt que tout d’un coup.

> Commence par refactorer uniquement src/services/userService.ts.
> Vérifie que les tests passent après les modifications avant de continuer.

3. Examinez le diff

> Montre-moi le git diff. Si c'est trop volumineux, résume les changements par fichier.

4. Utilisez une branche séparée

git checkout -b refactor/error-handling
claude
> Commence le refactoring de la gestion des erreurs...

Exemple concret : Moderniser du code legacy

Voici comment moderniser progressivement une base de code ancienne :

> Modernise ce projet avec les modifications suivantes :
> 1. Remplace var par const/let
> 2. Convertis les fonctions avec callbacks en async/await
> 3. Convertis require en import
> 4. Vérifie que les tests passent après chaque modification
> 5. Procède une étape à la fois et rapporte les résultats à chaque étape

Conclusion

Avec Claude Code, le refactoring qui prenait des jours peut être réalisé en quelques heures. Les clés sont : fournir des règles précises, travailler de manière incrémentale et toujours valider avec des tests. Commencez par un petit module et constatez les résultats par vous-même.