Générateur d'Instructions de Migration et d'Évolution de Code

Variables de Configuration

${MIGRATION_TYPE="Version du Framework|Refonte Architecturale|Migration Technologique|Mise à jour des Dépendances|Changements de Patterns"}
<!-- Type de migration ou d'évolution -->

${SOURCE_REFERENCE="branch|commit|tag"}
<!-- Point de référence source (état avant) -->

${TARGET_REFERENCE="branch|commit|tag"}  
<!-- Point de référence cible (état après) -->

${ANALYSIS_SCOPE="Projet entier|Dossier spécifique|Fichiers modifiés uniquement"}
<!-- Portée de l'analyse -->

${CHANGE_FOCUS="Changements Cassants|Nouvelles Conventions|Patterns Obsolètes|Changements API|Configuration"}
<!-- Aspect principal des changements -->

${AUTOMATION_LEVEL="Conservatrice|Équilibrée|Agressive"}
<!-- Niveau d'automatisation pour les suggestions Copilot -->

${GENERATE_EXAMPLES="true|false"}
<!-- Inclure les exemples de transformation -->

${VALIDATION_REQUIRED="true|false"}
<!-- Exiger une validation avant application -->

Prompt Généré

"Analysez l'évolution du code entre deux états du projet pour générer des instructions de migration précises pour GitHub Copilot. Ces instructions guideront Copilot pour appliquer automatiquement les mêmes patterns de transformation lors de futures modifications. Suivez cette méthodologie :

### Phase 1 : Analyse Comparative des États

#### Détection des Changements Structurels
- Comparer la structure des dossiers entre ${SOURCE_REFERENCE} et ${TARGET_REFERENCE}
- Identifier les fichiers déplacés, renommés ou supprimés
- Analyser les changements dans les fichiers de configuration
- Documenter les nouvelles dépendances et celles supprimées

#### Analyse des Transformations de Code
${MIGRATION_TYPE == "Version du Framework" ? 
  "- Identifier les changements d'API entre les versions du framework
   - Analyser les nouvelles fonctionnalités utilisées
   - Documenter les méthodes/propriétés obsolètes
   - Noter les changements de syntaxe ou de convention" : ""}

${MIGRATION_TYPE == "Refonte Architecturale" ? 
  "- Analyser les changements de patterns architecturaux
   - Identifier les nouvelles abstractions introduites
   - Documenter la réorganisation des responsabilités
   - Noter les changements dans les flux de données" : ""}

${MIGRATION_TYPE == "Migration Technologique" ? 
  "- Analyser le remplacement d'une technologie par une autre
   - Identifier les équivalences fonctionnelles
   - Documenter les changements d'API et de syntaxe
   - Noter les nouvelles dépendances et configurations" : ""}

#### Extraction des Patterns de Transformation
- Identifier les transformations répétitives appliquées
- Analyser les règles de conversion du format ancien au format nouveau
- Documenter les exceptions et cas particuliers
- Créer une matrice de correspondance avant/après

### Phase 2 : Génération des Instructions de Migration

Créer un fichier `.github/copilot-migration-instructions.md` avec cette structure :

\`\`\`markdown
# Instructions de Migration GitHub Copilot

## Contexte de Migration
- **Type** : ${MIGRATION_TYPE}
- **De** : ${SOURCE_REFERENCE} 
- **Vers** : ${TARGET_REFERENCE}
- **Date** : [GENERATION_DATE]
- **Portée** : ${ANALYSIS_SCOPE}

## Règles de Transformation Automatique

### 1. Transformations Obligatoires
${AUTOMATION_LEVEL != "Conservatrice" ? 
  "[AUTOMATIC_TRANSFORMATION_RULES]
   - **Ancien Pattern** : [OLD_CODE]
   - **Nouveau Pattern** : [NEW_CODE]
   - **Déclencheur** : Quand détecter ce pattern
   - **Action** : Transformation à appliquer automatiquement" : ""}

### 2. Transformations avec Validation
${VALIDATION_REQUIRED == "true" ? 
  "[TRANSFORMATIONS_WITH_VALIDATION]
   - **Pattern Détecté** : [DESCRIPTION]
   - **Transformation Suggérée** : [NEW_APPROACH]
   - **Validation Requise** : [VALIDATION_CRITERIA]
   - **Alternatives** : [ALTERNATIVE_OPTIONS]" : ""}

### 3. Correspondances API
${CHANGE_FOCUS == "Changements API" || MIGRATION_TYPE == "Version du Framework" ? 
  "[API_CORRESPONDENCE_TABLE]
   | Ancienne API | Nouvelle API | Remarques | Exemple        |
   | ------------ | ------------ | --------- | -------------- |
   | [OLD_API]    | [NEW_API]    | [CHANGES] | [CODE_EXAMPLE] | " : ""} |

### 4. Nouveaux Patterns à Adopter
[DETECTED_EMERGING_PATTERNS]
- **Pattern** : [PATTERN_NAME]
- **Utilisation** : [WHEN_TO_USE] 
- **Implémentation** : [HOW_TO_IMPLEMENT]
- **Avantages** : [ADVANTAGES]

### 5. Patterns Obsolètes à Éviter
[DETECTED_OBSOLETE_PATTERNS]
- **Pattern Obsolète** : [OLD_PATTERN]
- **Pourquoi Éviter** : [REASONS]
- **Alternative** : [NEW_PATTERN]
- **Migration** : [CONVERSION_STEPS]

## Instructions Spécifiques aux Types de Fichiers

${GENERATE_EXAMPLES == "true" ? 
  "### Fichiers de Configuration
   [CONFIG_TRANSFORMATION_EXAMPLES]

   ### Fichiers Sources Principaux
   [SOURCE_TRANSFORMATION_EXAMPLES]

   ### Fichiers de Test
   [TEST_TRANSFORMATION_EXAMPLES]" : ""}

## Validation et Sécurité

### Points de Contrôle Automatiques
- Vérifications à effectuer après chaque transformation
- Tests à exécuter pour valider les changements
- Métriques de performance à surveiller
- Vérifications de compatibilité à effectuer

### Escalade Manuelle
Situations nécessitant une intervention humaine :
- [COMPLEX_CASES_LIST]
- [ARCHITECTURAL_DECISIONS]
- [BUSINESS_IMPACTS]

## Suivi de la Migration

### Métriques de Suivi
- Pourcentage de code migré automatiquement
- Nombre de validations manuelles requises
- Taux d'erreur des transformations automatiques
- Temps moyen de migration par fichier

### Signalement des Erreurs
Comment signaler à Copilot les transformations incorrectes :
- Patterns de feedback pour améliorer les règles
- Exceptions à documenter
- Ajustements à apporter aux instructions

\`\`\`

### Phase 3 : Génération d'Exemples Contextuels

${GENERATE_EXAMPLES == "true" ? 
  "#### Exemples de Transformation
   Pour chaque pattern identifié, générer :

   \`\`\`
   // AVANT (${SOURCE_REFERENCE})
   [OLD_CODE_EXAMPLE]

   // APRÈS (${TARGET_REFERENCE}) 
   [NEW_CODE_EXAMPLE]

   // INSTRUCTIONS COPILOT
   Quand vous voyez ce pattern [TRIGGER], transformez-le en [NEW_PATTERN] en suivant ces étapes : [STEPS]
   \`\`\`" : ""}

### Phase 4 : Validation et Optimisation

#### Test des Instructions
- Appliquer les instructions sur du code de test
- Vérifier la cohérence des transformations
- Ajuster les règles selon les résultats
- Documenter les exceptions et cas limites

#### Optimisation Itérative  
${AUTOMATION_LEVEL == "Agressive" ? 
  "- Affiner les règles pour maximiser l'automatisation
   - Réduire les faux positifs dans la détection
   - Améliorer la précision des transformations
   - Documenter les apprentissages" : ""}

### Résultat Final

Instructions de migration qui permettent à GitHub Copilot de :
1. **Appliquer automatiquement** les mêmes transformations lors de futures modifications
2. **Maintenir la cohérence** avec les nouvelles conventions adoptées  
3. **Éviter les patterns obsolètes** en proposant automatiquement des alternatives
4. **Accélérer les futures migrations** en capitalisant sur l'expérience acquise
5. **Réduire les erreurs** en automatisant les transformations répétitives

Ces instructions transforment Copilot en assistant de migration intelligent, capable de reproduire vos décisions d'évolution technologique de manière cohérente et fiable.
"

Cas d'Usage Typiques

Migration de Version du Framework

Parfait pour documenter la transition d'Angular 14 à Angular 17, des Class Components aux Hooks React, ou de .NET Framework à .NET Core. Identifie automatiquement les changements cassants et génère les règles de transformation correspondantes.

Évolution de la Pile Technologique

Essentiel lors du remplacement complet d'une technologie : jQuery vers React, REST vers GraphQL, SQL vers NoSQL. Crée un guide de migration complet avec les mappages de patterns.

Refonte Architecturale

Idéal pour les grandes refentes comme Monolith vers Microservices, MVC vers Clean Architecture, ou Component vers architecture Composable. Préserve les connaissances architecturales pour les futures transformations similaires.

Modernisation des Design Patterns

Utile pour adopter de nouveaux patterns : Repository Pattern, Dependency Injection, Observer vers Programmation Réactive. Documente la logique et les différences d'implémentation.

Bénéfices Uniques

🧠 Amélioration de l'Intelligence Artificielle

Contrairement à la documentation de migration traditionnelle, ces instructions « entraînent » GitHub Copilot à reproduire automatiquement vos décisions d'évolution technologique lors de futures modifications de code.

🔄 Capitalisation des Connaissances

Transforme l'expérience spécifique du projet en règles réutilisables, évitant la perte d'expertise en migration et accélérant les futures transformations similaires.

🎯 Précision Consciente du Contexte

Au lieu de conseils génériques, génère des instructions adaptées à votre codebase spécifique, avec de véritables exemples avant/après tirés de votre évolution de projet.

⚡ Cohérence Automatisée

Assure que les nouveaux ajouts de code suivent automatiquement les nouvelles conventions, prévenant la régression architecturale et maintenant la cohérence de l'évolution du code.

generate-custom-instructions-from-codebase