git:conflict

Instructions à Exécuter

IMPORTANT : Exécute ce workflow étape par étape :

Résoudre les conflits git de manière interactive : $ARGUMENTS

Purpose

Analyser les conflits git et guider l'utilisateur dans une résolution pas à pas, fichier par fichier, avec validation à chaque étape.

Variables

• DESTINATION_BRANCH: $1 (branche de destination pour le merge/rebase)
• CURRENT_BRANCH: !git branch --show-current
• CONFLICTED_FILES: Liste des fichiers en conflit
• RESOLUTION_MODE: merge ou rebase (détecté automatiquement)

État Actuel du Repository

• Branche actuelle : !git branch --show-current
• Status Git : !git status --porcelain
• Conflits détectés : !git diff --name-only --diff-filter=U
• Commits divergents : !git log --oneline HEAD...$DESTINATION_BRANCH --max-count=5

Ce Que Fait Cette Commande

1. Détecte s'il y a un merge/rebase en cours ou si on doit l'initier
2. Identifie tous les fichiers en conflit
3. Pour chaque fichier en conflit :
   • Affiche le contexte du conflit
   • Montre les différences entre les versions
   • Propose 3 stratégies de résolution
   • Demande validation avant d'appliquer
4. Vérifie que tous les conflits sont résolus
5. Finalise le merge/rebase

Workflow

1. Validation initiale

Vérifier DESTINATION_BRANCH obligatoire :

• Si DESTINATION_BRANCH n'est pas fourni → ARRÊTER et demander à l'utilisateur

Vérifier que DESTINATION_BRANCH existe :

• git branch --list "$DESTINATION_BRANCH" (locale)
• git branch -r --list "origin/$DESTINATION_BRANCH" (remote)
• Si n'existe pas → ARRÊTER avec erreur

Vérifier l'état du repository :

• git status pour détecter :
  • Merge en cours (fichiers "both modified")
  • Rebase en cours (.git/rebase-merge/ ou .git/rebase-apply/)
  • Conflits existants

2. Initier l'opération si nécessaire

Si aucun merge/rebase en cours :

• Demander à l'utilisateur : "Voulez-vous merger ou rebaser $CURRENT_BRANCH sur $DESTINATION_BRANCH ?"
• Options :
  1. Merge : git merge $DESTINATION_BRANCH
  2. Rebase : git rebase $DESTINATION_BRANCH
  3. Annuler
• Exécuter l'opération choisie

Si l'opération échoue avec conflits :

• Continuer avec l'analyse des conflits

3. Analyse des conflits

Lister tous les fichiers en conflit :

git diff --name-only --diff-filter=U

Pour chaque fichier, collecter :

• Chemin complet du fichier
• Nombre de sections en conflit
• Lignes concernées
• Contexte (fonction/classe/module)

4. Résolution interactive par fichier

Pour chaque fichier en conflit :

Étape A : Afficher le contexte

• Nom du fichier et chemin
• Nombre de conflits dans ce fichier
• git diff $FICHIER pour voir les marqueurs de conflit

Étape B : Analyser les versions

• Lire le fichier avec Read pour voir les marqueurs :
  • <<<<<<< HEAD : version actuelle
  • ======= : séparateur
  • >>>>>>> $DESTINATION_BRANCH : version à merger
• Afficher les différences de manière claire

Étape C : Proposer 3 stratégies

1. Garder la version actuelle (ours)

   • git checkout --ours $FICHIER
   • Quand : notre version est correcte, l'autre est obsolète

2. Garder la version entrante (theirs)

   • git checkout --theirs $FICHIER
   • Quand : leur version est correcte, la nôtre est obsolète

3. Résolution manuelle

   • Utiliser Edit pour fusionner manuellement
   • Supprimer les marqueurs <<<<<<<, =======, >>>>>>>
   • Combiner les changements pertinents des deux versions

Étape D : Demander confirmation

• Afficher un résumé de la stratégie choisie
• Demander : "Voulez-vous appliquer cette résolution ? (oui/non/voir le diff)"
• Si "voir le diff" : montrer le résultat avec git diff --cached $FICHIER

Étape E : Appliquer la résolution

• Exécuter la stratégie choisie
• Marquer le fichier comme résolu : git add $FICHIER
• Confirmer : "✅ Conflit résolu dans $FICHIER"

5. Vérification finale

Après avoir résolu tous les fichiers :

git status

• Vérifier qu'il n'y a plus de fichiers "both modified"
• Vérifier que tous les fichiers conflictuels sont stagés

Demander confirmation finale :

• "Tous les conflits sont résolus. Voulez-vous finaliser ?"
• Options :
  1. Oui, finaliser
  2. Non, réviser les changements
  3. Annuler tout (abort)

6. Finalisation

Si merge :

git commit --no-edit
# ou si l'utilisateur veut personnaliser :
git commit -m "Merge branch '$DESTINATION_BRANCH' into $CURRENT_BRANCH"

Si rebase :

git rebase --continue

Si annulation demandée :

git merge --abort   # ou
git rebase --abort

Stratégies de Résolution Détaillées

Stratégie 1 : Garder la version actuelle (ours)

• Utilisation : Quand notre implémentation est plus récente/correcte
• Commande : git checkout --ours $FICHIER && git add $FICHIER
• Attention : Perte des changements de l'autre branche

Stratégie 2 : Garder la version entrante (theirs)

• Utilisation : Quand la version à merger est plus récente/correcte
• Commande : git checkout --theirs $FICHIER && git add $FICHIER
• Attention : Perte de nos changements

Stratégie 3 : Résolution manuelle intelligente

• Utilisation : Quand les deux versions contiennent des changements valides
• Processus :
  1. Lire le fichier avec Read
  2. Identifier les sections en conflit
  3. Analyser la logique de chaque version
  4. Utiliser Edit pour fusionner :
     • Garder les imports/dépendances des deux côtés
     • Fusionner la logique métier intelligemment
     • Supprimer tous les marqueurs de conflit
  5. Vérifier la syntaxe du résultat
  6. git add $FICHIER

Examples

Exemple 1 : Merge avec conflits

# Situation : on est sur feature/auth, on veut merger main
/git:conflit main

# Claude détecte : pas de merge en cours
# Claude demande : "Voulez-vous merger main dans feature/auth ?"
# Utilisateur : "oui, merge"
# Claude exécute : git merge main
# Conflits détectés dans : src/auth.php, config/app.php
# Claude guide la résolution fichier par fichier

Exemple 2 : Rebase en cours avec conflits

# Situation : rebase en cours, 3 fichiers en conflit
/git:conflit develop

# Claude détecte : rebase en cours sur develop
# Claude liste : file1.php, file2.js, file3.md
# Claude résout interactivement chaque fichier
# Claude finalise : git rebase --continue

Exemple 3 : Résolution manuelle complexe

/git:conflit main

# Conflit dans src/payment.php :
# HEAD : ajout méthode processRefund()
# main : ajout méthode processChargeback()
# Stratégie : Résolution manuelle
# Claude fusionne les deux méthodes
# Validation : utilisateur confirme

Report Format

# Rapport de Résolution de Conflits

## Configuration
- Branche actuelle : $CURRENT_BRANCH
- Branche destination : $DESTINATION_BRANCH
- Type d'opération : merge/rebase

## Conflits Détectés
- Nombre total de fichiers : X
- Fichiers résolus : Y
- Fichiers restants : Z

## Résolutions Appliquées

### Fichier : src/auth.php
- Stratégie : Résolution manuelle
- Raison : Fusion de deux implémentations valides
- Lignes modifiées : 42-58

### Fichier : config/app.php
- Stratégie : Garder version actuelle (ours)
- Raison : Configuration locale spécifique

## Statut Final
✅ Tous les conflits résolus
✅ Merge/rebase finalisé avec succès

Best Practices

Avant de commencer

• ✅ S'assurer que le working directory est propre
• ✅ Avoir une sauvegarde (commit ou stash)
• ✅ Comprendre les changements des deux branches

Pendant la résolution

• ✅ Résoudre un fichier à la fois
• ✅ Tester la syntaxe après chaque résolution manuelle
• ✅ Ne jamais garder les marqueurs de conflit (<<<<, ====, >>>>)
• ✅ Valider que la logique est cohérente
• ✅ En cas de doute, demander à l'utilisateur

Après la résolution

• ✅ Vérifier que le code compile/s'exécute
• ✅ Lancer les tests si disponibles
• ✅ Réviser le diff final avant commit

Messages d'Erreur et Solutions

"error: you need to resolve your current index first"

• Cause : Conflits non résolus
• Solution : Continuer la résolution ou faire git merge --abort

"no changes added to commit"

• Cause : Fichiers résolus mais non stagés
• Solution : git add $FICHIER après chaque résolution

"conflict (content): Merge conflict in X"

• Cause : Changements incompatibles dans le même fichier
• Solution : Résoudre avec une des 3 stratégies

Validation

• ✅ DESTINATION_BRANCH doit exister (locale ou remote)
• ✅ Tous les fichiers en conflit doivent être traités
• ✅ Aucun marqueur de conflit ne doit rester dans les fichiers
• ✅ Tous les fichiers résolus doivent être stagés
• ✅ L'utilisateur doit valider avant chaque résolution
• ✅ L'utilisateur doit confirmer avant la finalisation

Notes Importantes

• La commande est 100% interactive : chaque action nécessite validation
• L'utilisateur garde le contrôle total du processus
• Possibilité d'annuler à tout moment avec merge/rebase --abort
• Les résolutions manuelles utilisent Edit pour garantir la qualité
• Un rapport détaillé est généré à la fin