Workflow Git complet : branches, worktrees, commits, conflits, PR avec Task Management System

GitHub stars
9

Install

/plugin install git@atournayre-claude-plugin-marketplace

Run it inside Claude Code after adding the marketplace with /plugin marketplace add atournayre/claude-marketplace.

Contents

Discovered from source

Skills 11

Git Branch Core (Internal)

Instructions à Exécuter

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

Ce skill fournit les scripts partagés pour la résolution de noms de branches. Il ne doit pas être appelé directement.

Scripts disponibles

ScriptDescriptionUsage
resolve-branch-name.shRésout un nom de branche depuis un numéro d'issue ou du textebash "$CORE_SCRIPTS/resolve-branch-name.sh" <issue-or-text>
validate-source-branch.shValide qu'une branche source existe localementbash "$CORE_SCRIPTS/validate-source-branch.sh" <source-branch>
check-branch-exists.shVérifie qu'une branche n'existe pas déjàbash "$CORE_SCRIPTS/check-branch-exists.sh" <branch-name>

Usage par les skills enfants

CORE_SCRIPTS="${CLAUDE_PLUGIN_ROOT}/skills/branch-core/scripts"

# Valider la branche source
bash "$CORE_SCRIPTS/validate-source-branch.sh" "$SOURCE_BRANCH"

# Résoudre le nom de branche
eval "$(bash "$CORE_SCRIPTS/resolve-branch-name.sh" "$ISSUE_OR_TEXT")"
# Variables disponibles après eval :
#   $BRANCH_NAME      - Nom complet (ex: feature/42-login-fix)
#   $PREFIX           - Préfixe (ex: feature/)
#   $PREFIX_SOURCE    - Source (label/description/title/default/text)
#   $ISSUE_NUMBER     - Numéro d'issue (vide si texte)
#   $WORKTREE_DIRNAME - Nom répertoire worktree (ex: feature-42-login-fix)

# Vérifier que la branche n'existe pas
bash "$CORE_SCRIPTS/check-branch-exists.sh" "$BRANCH_NAME"

Détection du préfixe

Par numéro d'issue (priorité décroissante)

  1. Labels de l'issue :

    • bug, fix, bugfix → fix/
    • hotfix, critical, urgent → hotfix/
    • feature, enhancement, new-feature → feature/
    • chore, maintenance, refactor → chore/
    • documentation, docs → docs/
    • test, tests → test/
  2. Description de l'issue (mots-clés)

  3. Titre de l'issue (mots-clés)

  4. Défaut : feature/

Par texte descriptif

  • Analyse le premier mot du texte (fix, hotfix, chore, docs, test, etc.)
  • Défaut : feature/

Désambiguisation des arguments

Les skills enfants (git:branch, git:worktree) partagent la même logique de parsing des arguments.

SOURCE_BRANCH est optionnel et défaut à MAIN_BRANCH de .env.claude.

Règle de désambiguisation (quand 1 seul argument) :

ArgumentType détectéSOURCE_BRANCHISSUE_OR_TEXT
42EntierMAIN_BRANCH (.env.claude)42 (issue)
developBranche locale existantedevelopNon fourni (demander)
"fix login bug"TexteMAIN_BRANCH (.env.claude)"fix login bug"

Cascade de résolution de SOURCE_BRANCH :

  1. Argument explicite (premier de deux arguments, ou unique argument si branche existante)
  2. MAIN_BRANCH de .env.claude
  3. AskUserQuestion en dernier recours

Configuration de sortie

IMPORTANT : Cette skill effectue une opération Git rapide et nécessite un format de sortie spécifique.

Lis le frontmatter de cette skill. Si un champ output-style est présent, exécute immédiatement :

/output-style <valeur-du-champ>

Note : Une fois que le champ output-style sera supporté nativement par Claude Code, cette instruction pourra être supprimée.

Création de branche Git

Créer une nouvelle branche Git de manière structurée avec support des issues GitHub.

Configuration

CORE_SCRIPTS="${CLAUDE_PLUGIN_ROOT}/skills/branch-core/scripts"

Variables

  • SOURCE_BRANCH: Branche source (optionnel - défaut: MAIN_BRANCH de .env.claude)
  • ISSUE_OR_TEXT: Numéro d'issue GitHub ou texte descriptif

Relevant Files

  • @.git/config
  • @.gitignore
  • @.env.claude
  • @docs/README.md

Instructions à Exécuter

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

🚨 ÉTAPE CRITIQUE : CHECKOUT VERS SOURCE D'ABORD 🚨

1. Lire la configuration depuis .env.claude

  • Lis le fichier .env.claude à la racine du projet courant (pas celui du plugin, celui du projet utilisateur)
  • Extrais la valeur de MAIN_BRANCH (fallback pour SOURCE_BRANCH)

2. Parser les arguments et résoudre SOURCE_BRANCH

Logique de désambiguisation selon le nombre d'arguments :

2 arguments fournis :

  • Premier argument = SOURCE_BRANCH
  • Second argument = ISSUE_OR_TEXT

1 argument fourni :

  • Si c'est un entier → ISSUE_OR_TEXT (numéro d'issue), SOURCE_BRANCH = MAIN_BRANCH de .env.claude
  • Si ça correspond à une branche locale existante (git branch --list "$ARG" non vide) → SOURCE_BRANCH, ISSUE_OR_TEXT non fourni (sera demandé à l'utilisateur)
  • Sinon → ISSUE_OR_TEXT (texte descriptif), SOURCE_BRANCH = MAIN_BRANCH de .env.claude

0 argument :

  • SOURCE_BRANCH = MAIN_BRANCH de .env.claude
  • ISSUE_OR_TEXT non fourni (sera demandé à l'utilisateur)

Si SOURCE_BRANCH n'est toujours pas résolu (MAIN_BRANCH absent de .env.claude et pas fourni en argument) :

  • Utilise AskUserQuestion pour demander :
    Question: "Depuis quelle branche veux-tu créer la nouvelle branche ?"
    Options: ["main", "master", "develop", "Autre"]
    

3. Valider que SOURCE_BRANCH existe localement

  • Exécute avec Bash :
    bash "$CORE_SCRIPTS/validate-source-branch.sh" "$SOURCE_BRANCH"
    
  • Si le script échoue (exit 1), arrête le workflow

4. 🔴 CHECKOUT VERS SOURCE_BRANCH AVANT TOUT 🔴

  • Exécute git checkout $SOURCE_BRANCH avec Bash
  • Exécute git branch --show-current pour vérifier qu'on est bien dessus
  • CRITIQUE : Cette étape garantit qu'on crée depuis un point propre

5. 🔴 PULL POUR METTRE À JOUR SOURCE_BRANCH 🔴

  • Exécute git pull origin $SOURCE_BRANCH avec Bash
  • CRITIQUE : Garantit qu'on part du dernier commit de origin
  • Évite de créer depuis un point obsolète

6. Résoudre le nom de la nouvelle branche

Si ISSUE_OR_TEXT est fourni (résolu à l'étape 2) :

  • Exécute avec Bash :
    eval "$(bash "$CORE_SCRIPTS/resolve-branch-name.sh" "$ISSUE_OR_TEXT")"
    echo "BRANCH_NAME=$BRANCH_NAME"
    echo "PREFIX=$PREFIX"
    echo "PREFIX_SOURCE=$PREFIX_SOURCE"
    
  • Si le script échoue (exit 1), arrête le workflow
  • Les variables BRANCH_NAME, PREFIX, PREFIX_SOURCE, ISSUE_NUMBER sont disponibles

Si ISSUE_OR_TEXT n'est pas fourni :

  • Utilise AskUserQuestion pour demander le nom de branche

7. Vérifier que la nouvelle branche n'existe pas

  • Exécute avec Bash :
    bash "$CORE_SCRIPTS/check-branch-exists.sh" "$BRANCH_NAME"
    
  • Si le script échoue (exit 1), arrête le workflow

8. Créer et checkout la nouvelle branche

  • Exécute git checkout -b $BRANCH_NAME avec Bash
  • La branche est créée depuis SOURCE_BRANCH (car on est dessus)

9. Afficher le résumé

Affiche :

✅ Branche créée : $BRANCH_NAME
📝 Préfixe détecté : $PREFIX (source: $PREFIX_SOURCE)
📍 Depuis : $SOURCE_BRANCH
{Si issue} 🔗 Issue associée : #$ISSUE_NUMBER

📝 Le tracking sera configuré automatiquement au premier commit avec :
   git push -u origin $BRANCH_NAME

⚠️ IMPORTANT - NE PAS configurer de tracking automatiquement :

  • ❌ INTERDIT : git branch --set-upstream-to=origin/$SOURCE_BRANCH $BRANCH_NAME
  • ✅ Le tracking sera configuré lors du premier push avec -u
  • RAISON : Configurer le tracking vers SOURCE_BRANCH pousse les commits sur la branche parente au lieu de créer une nouvelle branche distante

Expertise

Conventions de nommage des branches (préfixe détecté automatiquement) :

  • feature/{numéro}-{description} : Nouvelles fonctionnalités
  • fix/{numéro}-{description} : Corrections de bugs
  • hotfix/{numéro}-{description} : Corrections urgentes en production
  • chore/{numéro}-{description} : Maintenance, refactoring
  • docs/{numéro}-{description} : Documentation
  • test/{numéro}-{description} : Tests
  • Utilise des tirets, pas d'espaces ni caractères spéciaux

Détection automatique du préfixe (par priorité) :

  1. Labels de l'issue GitHub
  2. Mots-clés dans la description de l'issue
  3. Mots-clés dans le titre de l'issue
  4. Défaut : feature/ si aucun indicateur trouvé

Template

# Exemple 1 : Issue seule (SOURCE_BRANCH = MAIN_BRANCH de .env.claude)
/git:branch 42
# → Résolution via branch-core : fix/42-login-form-crashes-on-submit

# Exemple 2 : Issue avec branche source explicite
/git:branch develop 42
# → Résolution via branch-core : fix/42-login-form-crashes-on-submit (depuis develop)

# Exemple 3 : Texte descriptif seul (SOURCE_BRANCH = MAIN_BRANCH de .env.claude)
/git:branch "fix login validation"
# → Résolution via branch-core : fix/login-validation

# Exemple 4 : Texte descriptif avec branche source
/git:branch main "Add OAuth support"
# → Résolution via branch-core : feature/add-oauth-support

# Exemple 5 : Sans argument (SOURCE_BRANCH = MAIN_BRANCH, demande issue/texte)
/git:branch

Examples

# Créer une branche avec issue (source = MAIN_BRANCH de .env.claude)
/git:branch 123

# Créer une branche avec texte descriptif (source = MAIN_BRANCH)
/git:branch "user authentication"

# Créer une branche depuis une branche source explicite avec issue
/git:branch develop 123

# Créer une branche fix avec texte explicite (source = MAIN_BRANCH)
/git:branch "fix login bug"

# Créer une branche hotfix (source = MAIN_BRANCH)
/git:branch "hotfix critical payment issue"

# Créer une branche depuis develop (demande issue/texte)
/git:branch develop

# Créer une branche depuis une branche existante avec issue
/git:branch feature/api-base 456

Report

  • Nom de la branche créée
  • Préfixe détecté et sa source (label/description/titre/défaut/texte)
  • Branche source utilisée
  • Issue associée (si applicable)
  • Statut du checkout
  • Note : Le tracking remote sera configuré lors du premier push avec git push -u origin $BRANCH_NAME

Validation

  • ✅ SOURCE_BRANCH doit exister localement
  • ✅ SOURCE_BRANCH optionnel (défaut: MAIN_BRANCH de .env.claude)
  • ✅ CHECKOUT vers SOURCE_BRANCH AVANT création (CRITIQUE)
  • ✅ PULL pour mettre à jour SOURCE_BRANCH (CRITIQUE)
  • ✅ La nouvelle branche ne doit pas déjà exister
  • ✅ Si ISSUE_OR_TEXT est un numéro, l'issue doit exister sur GitHub
  • ✅ Le nom généré respecte les conventions de nommage
  • ✅ Détection automatique entre numéro d'issue et texte descriptif

Pourquoi checkout + pull vers SOURCE_BRANCH d'abord ?

Problème 1 évité :

  • Si on est sur feature/A et on crée feature/B depuis main
  • Sans checkout vers main d'abord, la branche est créée depuis feature/A
  • Les commits de feature/A se retrouvent sur feature/B
  • Résultat : impossible de créer une PR propre

Problème 2 évité :

  • Si main locale est en retard sur origin/main
  • Sans pull, on crée depuis un point obsolète
  • Résultat : commits manquants, conflits, PR avec historique incorrect

Solution :

  1. TOUJOURS faire git checkout $SOURCE_BRANCH
  2. TOUJOURS faire git pull origin $SOURCE_BRANCH
  3. PUIS créer avec git checkout -b $BRANCH_NAME

Workflow Git Commit

Créer un commit bien formaté avec les arguments : $ARGUMENTS

IMPORTANT : Task Management System obligatoire

RÈGLE CRITIQUE : Chaque étape DOIT être trackée via TaskCreate/TaskUpdate.

  • Créer TOUTES les tâches AVANT de commencer
  • Marquer in_progress au début de chaque étape
  • Marquer completed UNIQUEMENT quand l'étape est 100% terminée
  • NE JAMAIS sauter une étape

Instructions à Exécuter

Étape 1 : Créer TOUTES les tâches du workflow

OBLIGATOIRE : Utilise TaskCreate pour créer ces 5 tâches dans cet ordre exact :

TaskCreate #1: "Vérifier les changements disponibles"
  - activeForm: "Checking available changes"
  - description: "git status + git diff pour voir les fichiers modifiés"

TaskCreate #2: "Analyser le diff des changements"
  - activeForm: "Analyzing diff content"
  - description: "git diff --cached pour comprendre les changements"

TaskCreate #3: "Déterminer la stratégie de commit"
  - activeForm: "Determining commit strategy"
  - description: "Décider si un ou plusieurs commits sont nécessaires"

TaskCreate #4: "Créer le(s) commit(s)"
  - activeForm: "Creating commit(s)"
  - description: "git commit avec message formaté emoji + conventional"

TaskCreate #5: "Push vers remote"
  - activeForm: "Pushing to remote"
  - description: "git push (sauf si --no-push)"

Après création : Affiche TaskList pour confirmer que les 5 tâches existent.


Étape 2 : Vérifier les changements disponibles

TaskUpdate : Tâche #1 → in_progress

Exécute en parallèle :

git status
git diff --cached --stat

Traitement :

  1. SI aucun changement (ni stagé, ni non-stagé) :

    • Affiche "❌ Aucun changement à committer"
    • TaskUpdate : Tâche #1 → completed
    • STOP - Ne pas continuer
  2. SI des fichiers modifiés mais rien de stagé :

    • Exécute git add . pour tout stager
    • Exécute git status pour confirmer
  3. SI des fichiers déjà stagés :

    • Continue avec ces fichiers uniquement

TaskUpdate : Tâche #1 → completed


Étape 3 : Analyser le diff des changements

TaskUpdate : Tâche #2 → in_progress

Exécute en parallèle :

git diff --cached
git log -5 --oneline

Traitement :

  1. Lis TOUT le diff des changements stagés
  2. Note le style des commits récents du repo
  3. Identifie les types de changements présents :
    • feat (nouvelles fonctionnalités)
    • fix (corrections de bugs)
    • docs (documentation)
    • refactor (refactorisation)
    • test (tests)
    • chore (configuration, maintenance)
    • style (formatage)
    • perf (performance)

TaskUpdate : Tâche #2 → completed


Étape 4 : Déterminer la stratégie de commit

TaskUpdate : Tâche #3 → in_progress

Critères pour DIVISER en plusieurs commits :

  1. Préoccupations distinctes (feat + docs + tests mélangés)
  2. Types de changements différents (fix + refactor)
  3. Fichiers non-liés modifiés ensemble
  4. Diff > 200 lignes sur sujets différents

SI plusieurs types détectés :

  • Liste les commits à créer
  • Pour chaque commit, utilise :
    git reset HEAD <fichiers-à-exclure>
    git commit -m "..."
    git add <fichiers-suivants>
    

SINON :

  • Continue avec un seul commit

TaskUpdate : Tâche #3 → completed


Étape 5 : Créer le(s) commit(s)

TaskUpdate : Tâche #4 → in_progress

Pour CHAQUE commit à créer :

5.1 Déterminer le message
  1. Type : feat, fix, docs, refactor, test, chore, style, perf, ci, revert
  2. Emoji : Voir table ci-dessous
  3. Scope : Optionnel, entre parenthèses (auth, api, ui...)
  4. Description : < 72 caractères, mode impératif, présent
5.2 Exécuter le commit

OBLIGATOIRE : Utilise TOUJOURS un HEREDOC pour le message :

git commit -m "$(cat <<'EOF'
<emoji> <type>(<scope>): <description courte>

<détails optionnels - explique le "pourquoi">
EOF
)"

Exemple simple :

git commit -m "$(cat <<'EOF'
✨ feat(auth): ajouter connexion OAuth Google
EOF
)"

Exemple avec corps :

git commit -m "$(cat <<'EOF'
🐛 fix(api): corriger fuite mémoire dans le cache

Le cache ne libérait pas les entrées expirées, causant une
augmentation progressive de la mémoire utilisée.

Fixes #123
EOF
)"

TaskUpdate : Tâche #4 → completed


Étape 6 : Push vers remote

TaskUpdate : Tâche #5 → in_progress

6.1 Vérifier l'option --no-push

SI --no-push présent dans $ARGUMENTS :

  • Affiche "📝 Commit local uniquement (--no-push)"
  • TaskUpdate : Tâche #5 → completed
  • STOP - Workflow terminé
6.2 Push automatique

Le hook PostToolUse gère automatiquement :

  • Premier push : git push -u origin <branch>
  • Push suivants : git push

TaskUpdate : Tâche #5 → completed


Checklist de validation finale

Avant de terminer, vérifie que TOUTES ces conditions sont remplies :

  • Tâche #1 completed : Changements vérifiés et stagés
  • Tâche #2 completed : Diff analysé
  • Tâche #3 completed : Stratégie déterminée
  • Tâche #4 completed : Commit(s) créé(s) avec HEREDOC
  • Tâche #5 completed : Push effectué (ou skip si --no-push)

Si une tâche n'est pas completed, NE PAS terminer.


Table des Emojis par Type

TypeEmojiUsage
feat✨Nouvelle fonctionnalité
fix🐛Correction de bug
docs📝Documentation
style💄Formatage/style (pas de changement de logique)
refactor♻️Refactorisation de code
perf⚡️Amélioration de performance
test✅Ajout/modification de tests
chore🔧Outils, configuration, maintenance
ci🚀CI/CD
revert⏪️Annulation de changements

Emojis Spécialisés

ContexteEmojiDescription
Breaking change💥Changement cassant
Security🔒️Sécurité
Hotfix🚑️Correction critique urgente
Typo✏️Faute de frappe
WIP🚧Travail en cours
Lint/warnings🚨Correction warnings linter
Dependencies +➕Ajout dépendance
Dependencies -➖Suppression dépendance
Database🗃️Changements BDD
Logs +🔊Ajout de logs
Logs -🔇Suppression de logs
Types🏷️Définitions de types
UX🚸Amélioration UX
Accessibility♿️Accessibilité
i18n🌐Internationalisation
Business logic👔Logique métier
Architecture🏗️Changements architecturaux
Dead code⚰️Suppression code mort
Remove files🔥Suppression fichiers
Move/rename🚚Déplacement/renommage
Assets🍱Assets (images, etc.)
UI animations💫Animations UI
Validation🦺Code de validation
Feature flags🚩Feature flags
Analytics📈Tracking/analytics
CI fix💚Correction CI
Snapshot tests📸Tests snapshot
Mock🤡Mocking
Experiment⚗️Expérimentations
Seed data🌱Données de seed
.gitignore🙈Fichier .gitignore
License📄Licence
Contributors👥Contributeurs
DX🧑‍💻Developer Experience
Responsive📱Design responsive
SEO🔍️SEO
Offline✈️Support offline
Concurrency🧵Multithreading
Easter egg🥚Easter egg
Comments💡Commentaires dans le code
Text/literals💬Textes et littéraux
External API👽️Changements API externe
Error handling🥅Gestion d'erreurs
Simple fix🩹Fix non-critique simple
Package build📦️Fichiers compilés/packages
Pin deps📌Épingler versions
Release tag🔖Tags de release
Init project🎉Début de projet
Merge🔀Fusion de branches

Format du Message de Commit

<emoji> <type>(<scope>): <description impérative courte>

[corps optionnel - explique le "pourquoi" pas le "quoi"]

[footer optionnel - références issues, breaking changes]

Règles du Message

  1. Première ligne : < 72 caractères
  2. Mode impératif : "ajouter" pas "ajouté"
  3. Présent : "corrige" pas "a corrigé"
  4. Pas de point final sur la première ligne
  5. Ligne vide entre titre et corps
  6. Corps : explique le contexte et la raison

Options de Commande

OptionDescription
--verifyExécute make qa avant le commit
--no-pushNe push pas automatiquement après le commit

Combinaison possible : /git:commit --verify --no-push


Directives de Division

Divise les commits si tu détectes :

  1. feat + docs → 2 commits séparés
  2. fix + refactor → 2 commits séparés
  3. test + implementation → peut être ensemble si cohérent
  4. chore (deps) + feat → toujours séparés
  5. Plusieurs features distinctes → 1 commit par feature

Résolution Interactive de Conflits Git

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

Fix PR Comments

Systematically address ALL unresolved review comments until PR is approved.

Context

  • Current branch: !git branch --show-current
  • Working tree status: !git status --short
  • Recent commits: !git log --oneline -3

Workflow

  1. FETCH COMMENTS:

    • Identify PR: gh pr status --json number,headRefName
    • Get reviews: gh pr review list --state CHANGES_REQUESTED
    • Get inline: gh api repos/{owner}/{repo}/pulls/{number}/comments
    • Capture BOTH review comments AND inline code comments
    • STOP if no PR found - ask user for PR number
  2. ANALYZE & PLAN:

    • Extract exact file:line references
    • Group by file for MultiEdit efficiency
    • STAY IN SCOPE: NEVER fix unrelated issues
    • Create checklist: one item per comment
  3. IMPLEMENT FIXES:

    • BEFORE editing: ALWAYS Read target file first
    • Batch changes with MultiEdit for same-file modifications
    • Make EXACTLY what reviewer requested
    • Check off each resolved comment
  4. COMMIT & PUSH:

    • Stage: git add -A
    • Commit: fix: address PR review comments
    • Push: git push
    • NEVER include co-author tags

Rules

  • Every unresolved comment MUST be addressed
  • Read files BEFORE any edits - no exceptions
  • FORBIDDEN: Style changes beyond reviewer requests
  • On failure: Return to ANALYZE phase, never skip comments

User: $ARGUMENTS

Gen Release Notes Skill

Instructions à Exécuter

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

Usage

/git:gen-release-notes <branche-source> <branche-cible> [nom-release]

Si arguments manquants : AskUserQuestion pour demander.

Workflow

Initialisation

Créer les tâches du workflow :

Utiliser TaskCreate pour chaque étape :

TaskCreate #1: Parser et valider arguments (branches source/cible)
TaskCreate #2: Collecter commits via git log
TaskCreate #3: Catégoriser par impact utilisateur
TaskCreate #4: Rédiger descriptions sans jargon
TaskCreate #5: Générer HTML dans .claude/reports/

Important :

  • Utiliser activeForm (ex: "Validant les arguments", "Collectant les commits")
  • Chaque tâche doit être marquée in_progress puis completed

Pattern d'exécution pour chaque étape :

  1. TaskUpdate → tâche en in_progress
  2. Exécuter l'étape
  3. TaskUpdate → tâche en completed

Étapes

  1. Parser et valider arguments (branches source/cible)
  2. Collecter commits via git log
  3. Catégoriser par impact utilisateur
  4. Rédiger descriptions sans jargon
  5. Générer HTML dans .claude/reports/

Catégories

CatégorieIcôneMots-clés
Nouveautés⭐feat, ✨, 🚀
Améliorations📈improve, ⚡, perf
Corrections✅fix, 🐛
Sécurité🔒security

Commits ignorés

  • refactor:, test:, chore:, ci:, docs:, style:
  • Commits de merge
  • Mises à jour de dépendances

Règles de rédaction

  1. ZÉRO jargon - Pas de API, SQL, cache, endpoint, refactoring
  2. Bénéfice utilisateur - "L'application est plus rapide" vs "Optimisation SQL"
  3. Verbes d'action - Vous pouvez maintenant..., Nous avons corrigé...
  4. Phrases courtes - Max 1-2 phrases par item

Exemples

CommitNote utilisateur
feat: implémenter cache RedisL'affichage est plus rapide
fix: corriger validation emailCertaines adresses email sont maintenant acceptées

Output

{REPORT_PATH}/release_notes_{RELEASE_NAME}.html

Task Management

Progression du workflow :

  • 5 tâches créées à l'initialisation
  • Chaque étape suit le pattern : in_progress → exécution → completed
  • Utiliser TaskList pour voir la progression
  • Les tâches permettent à l'utilisateur de suivre la génération des release notes

References

Git CD PR Skill (Continuous Delivery)

Instructions à Exécuter

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

Usage

/git:pr --cd [branche-base] [milestone] [projet] [--no-interaction] [--delete] [--no-review]

Configuration

CORE_SCRIPTS="${CLAUDE_PLUGIN_ROOT}/skills/git-pr-core/scripts"
SCRIPTS_DIR="${CLAUDE_PLUGIN_ROOT}/skills/git-cd-pr/scripts"
PR_TEMPLATE_PATH=".github/PULL_REQUEST_TEMPLATE/cd_pull_request_template.md"
ENV_FILE_PATH=".env.claude"

Workflow

Initialisation

Créer les tâches du workflow :

Utiliser TaskCreate pour chaque étape :

TaskCreate #1: Charger config .env.claude
TaskCreate #2: Confirmation initiale (si --no-interaction absent)
TaskCreate #3: Vérifier scopes GitHub
TaskCreate #4: Vérifier template PR CD
TaskCreate #5: Lancer QA intelligente
TaskCreate #6: Analyser changements git
TaskCreate #7: Confirmer branche de base
TaskCreate #8: Générer description PR
TaskCreate #9: Push et créer PR
TaskCreate #10: Copier labels depuis issue liée
TaskCreate #11: Appliquer labels CD (version + feature flag)
TaskCreate #12: Assigner milestone
TaskCreate #13: Assigner projet GitHub
TaskCreate #14: Code review automatique (si plugin installé)
TaskCreate #15: Nettoyage branche locale

Important :

  • Utiliser activeForm (ex: "Chargeant config", "Appliquant labels CD")
  • Ne créer la tâche #14 que si plugin review installé ET --no-review absent
  • Chaque tâche doit être marquée in_progress puis completed

Pattern d'exécution pour chaque étape :

  1. TaskUpdate → tâche en in_progress
  2. Exécuter l'étape
  3. TaskUpdate → tâche en completed

Étapes

  1. Charger configuration depuis .env.claude :

    • Vérifier si le fichier .env.claude existe à la racine du projet
    • Si oui, parser les variables (format KEY=VALUE) :
      • MAIN_BRANCH : branche de base par défaut
      • PROJECT : projet GitHub par défaut
    • Pour chaque paramètre manquant dans les arguments :
      • Utiliser la variable d'env correspondante si elle existe
    • Ignorer .env.claude si absent (comportement standard)
  2. Confirmation initiale :

    • Si flag --no-interaction présent :
      • Passer toutes les confirmations
      • Utiliser les valeurs pré-remplies (arguments + .env.claude) sans validation
      • Continuer directement à l'étape 3
    • Sinon :
      • Confirmer à l'utilisateur que la skill git:cd-pr est lancée
      • Résumer tous les paramètres reçus :
        • Mode : Continuous Delivery (--cd)
        • Branche de base (si fournie)
        • Milestone (si fourni)
        • Projet (si fourni)
        • Flags : --delete, --no-review (si présents)
      • Demander confirmation explicite avant de continuer
  3. Vérifier scopes GitHub ($CORE_SCRIPTS/check_scopes.sh)

  4. Vérifier template PR CD ($CORE_SCRIPTS/verify_pr_template.sh)

  5. Lancer QA intelligente ($CORE_SCRIPTS/smart_qa.sh)

  6. Analyser changements git ($CORE_SCRIPTS/analyze_changes.sh)

  7. Confirmer branche de base (ou AskUserQuestion)

  8. Générer description PR intelligente

  9. Push et créer PR avec titre Conventional Commits (scripts/create_pr.sh)

  10. Copier labels depuis issue liée (scripts/copy_issue_labels.sh)

  11. Appliquer labels CD (scripts/apply_cd_labels.sh)

  12. Assigner milestone ($CORE_SCRIPTS/assign_milestone.py - voir git-pr-core/SKILL.md pour usage)

  13. Assigner projet GitHub ($CORE_SCRIPTS/assign_project.py - voir git-pr-core/SKILL.md pour usage)

  14. Code review automatique (si plugin review installé)

  15. Nettoyage branche locale ($CORE_SCRIPTS/cleanup_branch.sh - branche remote préservée)

Labels CD (Continuous Delivery)

Ordre de détection du type de version :

  1. BREAKING CHANGE ou !: dans commits → version:major
  2. Labels de l'issue liée (insensible casse, ignore emojis) :
    • Patterns minor : enhancement, feature, feat, nouvelle, new
    • Patterns patch : bug, fix, bugfix, correction, patch
  3. Nom de branche : feat/*, feature/* → minor / fix/*, hotfix/* → patch
  4. Premier commit de la branche : feat: → minor / fix: → patch
  5. Si indéterminé → AskUserQuestion :

    "Cette PR est une nouvelle fonctionnalité (minor) ou une correction (patch) ?"

Feature flag :

  • Détecté si fichiers .twig modifiés contiennent Feature:Flag ou Feature/Flag
  • Applique le label 🚩 Feature flag

Création labels : Si labels absents, ils sont créés automatiquement avec couleurs appropriées.

Code Review

Si plugin review installé, lance 4 agents en parallèle :

  • code-reviewer - Conformité CLAUDE.md
  • silent-failure-hunter - Erreurs silencieuses
  • test-analyzer - Couverture tests
  • git-history-reviewer - Contexte historique

Agrège résultats (score >= 80) dans commentaire PR.

Options

FlagDescription
--no-interactionMode automatique : passer confirmations, utiliser defaults
--deleteSupprimer branche LOCALE uniquement après création PR (JAMAIS la branche remote)
--no-reviewDésactiver code review automatique

References

Task Management

Progression du workflow :

  • 15 tâches créées à l'initialisation (ou 14 si --no-review ou pas de plugin review)
  • Chaque étape suit le pattern : in_progress → exécution → completed
  • Utiliser TaskList pour voir la progression globale
  • Les tâches permettent à l'utilisateur de suivre l'avancement de la création de PR CD

Règles critiques

⚠️ INTERDICTION ABSOLUE :

  • Ne JAMAIS exécuter git push origin --delete <branche> ou git push -d origin <branche>
  • Ne JAMAIS supprimer la branche remote (fermerait automatiquement la PR)
  • Le flag --delete ne concerne QUE la branche locale

Error Handling

  • Template absent → ARRÊT
  • QA échouée → ARRÊT
  • Version non déterminée → AskUserQuestion (non bloquant)
  • Milestone/projet non trouvé → WARNING (non bloquant)

Git PR Core (Internal)

Instructions à Exécuter

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

Ce skill fournit les scripts partagés pour la création de PR. Il ne doit pas être appelé directement.

Scripts disponibles

ScriptDescriptionUsage
check_scopes.shVérifie les scopes GitHubbash "$CORE_SCRIPTS/check_scopes.sh"
verify_pr_template.shVérifie le template PRbash "$CORE_SCRIPTS/verify_pr_template.sh" "$PR_TEMPLATE_PATH"
smart_qa.shLance la QA intelligentebash "$CORE_SCRIPTS/smart_qa.sh"
analyze_changes.shAnalyse les changements gitbash "$CORE_SCRIPTS/analyze_changes.sh"
confirm_base_branch.pyConfirme la branche de basepython3 "$CORE_SCRIPTS/confirm_base_branch.py"
create_pr.shCrée la PR (push + gh pr create)bash "$CORE_SCRIPTS/create_pr.sh" "$BRANCH_BASE" "$PR_TEMPLATE_PATH"
safe_push_pr.shPush sécurisé avec création PRbash "$CORE_SCRIPTS/safe_push_pr.sh"
assign_milestone.pyAssigne un milestonepython3 "$CORE_SCRIPTS/assign_milestone.py" <pr_number> --milestone "<milestone_name>"
assign_project.pyAssigne un projet GitHubpython3 "$CORE_SCRIPTS/assign_project.py" <pr_number> --project "<project_name>"
auto_review.shLance la code review automatiquebash "$CORE_SCRIPTS/auto_review.sh" <pr_number>
cleanup_branch.shNettoie la branche localebash "$CORE_SCRIPTS/cleanup_branch.sh" [--delete]
final_report.shGénère le rapport finalbash "$CORE_SCRIPTS/final_report.sh"

Usage par les skills enfants

CORE_SCRIPTS="${CLAUDE_PLUGIN_ROOT}/skills/git-pr-core/scripts"

# Exemples d'utilisation
bash "$CORE_SCRIPTS/check_scopes.sh"
bash "$CORE_SCRIPTS/create_pr.sh" "$BRANCH_BASE" "$PR_TEMPLATE_PATH"

# IMPORTANT : Pour assign_milestone.py et assign_project.py, utiliser --milestone et --project
# ❌ INCORRECT : python3 "$CORE_SCRIPTS/assign_milestone.py" 1234 "Continuous Delivery"
# ✅ CORRECT   : python3 "$CORE_SCRIPTS/assign_milestone.py" 1234 --milestone "Continuous Delivery"

PR_NUMBER=$(gh pr view --json number -q .number)
python3 "$CORE_SCRIPTS/assign_milestone.py" "$PR_NUMBER" --milestone "Continuous Delivery"
python3 "$CORE_SCRIPTS/assign_project.py" "$PR_NUMBER" --project "MyProject"

Workflow standard

  1. check_scopes.sh - Vérifier scopes GitHub
  2. verify_pr_template.sh - Vérifier template PR
  3. smart_qa.sh - Lancer QA
  4. analyze_changes.sh - Analyser changements
  5. confirm_base_branch.py - Confirmer branche base
  6. create_pr.sh - Créer la PR
  7. assign_milestone.py - Assigner milestone
  8. assign_project.py - Assigner projet
  9. auto_review.sh - Code review
  10. cleanup_branch.sh - Nettoyage

Git PR Skill (Standard)

Usage

/git:pr [branche-base] [milestone] [projet] [--no-interaction] [--delete] [--no-review]

Configuration

CORE_SCRIPTS="${CLAUDE_PLUGIN_ROOT}/skills/git-pr-core/scripts"
PR_TEMPLATE_PATH=".github/PULL_REQUEST_TEMPLATE/default.md"
ENV_FILE_PATH=".env.claude"

Instructions à Exécuter

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

Initialisation

Créer les tâches du workflow avec TaskCreate :

TaskCreate #1: Charger config .env.claude
TaskCreate #2: Confirmation initiale (si --no-interaction absent)
TaskCreate #3: Vérifier scopes GitHub
TaskCreate #4: Vérifier template PR
TaskCreate #5: Lancer QA intelligente
TaskCreate #6: Analyser changements git
TaskCreate #7: Confirmer branche de base
TaskCreate #8: Générer description PR
TaskCreate #9: Push et créer PR
TaskCreate #10: Assigner milestone
TaskCreate #11: Assigner projet GitHub
TaskCreate #12: Code review automatique (si plugin installé)
TaskCreate #13: Nettoyage branche locale

Important :

  • Utiliser activeForm (ex: "Chargeant config", "Vérifiant scopes GitHub")
  • Ne créer la tâche #12 que si plugin review installé ET --no-review absent
  • Chaque tâche doit être marquée in_progress puis completed

Pattern d'exécution pour chaque étape :

  1. TaskUpdate → tâche en in_progress
  2. Exécuter l'étape
  3. TaskUpdate → tâche en completed

Étapes

  1. Charger configuration depuis .env.claude :

    • Vérifier si le fichier .env.claude existe à la racine du projet
    • Si oui, parser les variables (format KEY=VALUE) :
      • MAIN_BRANCH : branche de base par défaut
      • PROJECT : projet GitHub par défaut
    • Pour chaque paramètre manquant dans les arguments :
      • Utiliser la variable d'env correspondante si elle existe
    • Ignorer .env.claude si absent (comportement standard)
  2. Confirmation initiale :

    • Si flag --no-interaction présent :
      • Passer toutes les confirmations
      • Utiliser les valeurs pré-remplies (arguments + .env.claude) sans validation
      • Continuer directement à l'étape 3
    • Sinon :
      • Confirmer à l'utilisateur que la skill git:pr est lancée
      • Résumer tous les paramètres reçus :
        • Branche de base (si fournie)
        • Milestone (si fourni)
        • Projet (si fourni)
        • Flags : --delete, --no-review (si présents)
      • Demander confirmation explicite avant de continuer
  3. Vérifier scopes GitHub ($CORE_SCRIPTS/check_scopes.sh)

  4. Vérifier template PR ($CORE_SCRIPTS/verify_pr_template.sh)

  5. Lancer QA intelligente ($CORE_SCRIPTS/smart_qa.sh)

  6. Analyser changements git ($CORE_SCRIPTS/analyze_changes.sh)

  7. Confirmer branche de base (ou AskUserQuestion)

  8. Générer description PR intelligente

  9. Push et créer PR avec titre Conventional Commits ($CORE_SCRIPTS/create_pr.sh)

  10. Assigner milestone ($CORE_SCRIPTS/assign_milestone.py - voir git-pr-core/SKILL.md pour usage)

  11. Assigner projet GitHub ($CORE_SCRIPTS/assign_project.py - voir git-pr-core/SKILL.md pour usage)

  12. Code review automatique (si plugin review installé)

  13. Nettoyage branche locale ($CORE_SCRIPTS/cleanup_branch.sh - branche remote préservée)

Code Review

Si plugin review installé, lance 4 agents en parallèle :

  • code-reviewer - Conformité CLAUDE.md
  • silent-failure-hunter - Erreurs silencieuses
  • test-analyzer - Couverture tests
  • git-history-reviewer - Contexte historique

Agrège résultats (score >= 80) dans commentaire PR.

Options

FlagDescription
--no-interactionMode automatique : passer confirmations, utiliser defaults
--deleteSupprimer branche LOCALE uniquement après création PR (JAMAIS la branche remote)
--no-reviewDésactiver code review automatique

References

Task Management

Progression du workflow :

  • 13 tâches créées à l'initialisation (ou 12 si --no-review ou pas de plugin review)
  • Chaque étape suit le pattern : in_progress → exécution → completed
  • Utiliser TaskList pour voir la progression globale
  • Les tâches permettent à l'utilisateur de suivre l'avancement de la création de PR

Règles critiques

⚠️ INTERDICTION ABSOLUE :

  • Ne JAMAIS exécuter git push origin --delete <branche> ou git push -d origin <branche>
  • Ne JAMAIS supprimer la branche remote (fermerait automatiquement la PR)
  • Le flag --delete ne concerne QUE la branche locale

Error Handling

  • Template absent → ARRÊT
  • QA échouée → ARRÊT
  • Milestone/projet non trouvé → WARNING (non bloquant)

Configuration de sortie

Instructions à Exécuter

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

IMPORTANT : Cette skill génère un rapport HTML et nécessite un format de sortie spécifique.

Lis le frontmatter de cette skill. Si un champ output-style est présent, exécute immédiatement :

/output-style <valeur-du-champ>

Note : Une fois que le champ output-style sera supporté nativement par Claude Code, cette instruction pourra être supprimée.

Générer rapport d'analyse de release

Génère un rapport HTML détaillé comparant deux branches pour analyser l'impact d'une release.

Usage

/git:release-report <branche-source> <branche-cible> [nom-release]

Exemples :

  • /git:release-report release/v27.0.0 main
  • /git:release-report release/v27.0.0 develop v27.0.0
  • /git:release-report feature/new-module main "Module XYZ"

Description

Cette commande génère un rapport HTML orienté Product Owner qui analyse :

  1. Statistiques globales : fichiers modifiés, lignes ajoutées/supprimées, commits
  2. Répartition par type de fichier : PHP, Twig, JS, etc.
  3. Fonctionnalités principales : extraction depuis les commits
  4. Impact métier : par domaine fonctionnel
  5. Qualité & maintenabilité : évolution du code

Le rapport est généré dans REPORT_PATH/impact_<nom-release>.html

Variables

REPORT_PATH: .claude/reports

Variables à extraire des arguments :

  • $BRANCH_SOURCE : Branche source à analyser (ex: release/v27.0.0)
  • $BRANCH_TARGET : Branche de référence (ex: main ou develop)
  • $RELEASE_NAME : Nom de la release pour le fichier (ex: v27.0.0)

Si $RELEASE_NAME n'est pas fourni, utiliser le nom de $BRANCH_SOURCE en retirant le préfixe "release/"

Workflow

0. Vérification des arguments obligatoires

AVANT TOUTE EXÉCUTION, vérifier que les arguments obligatoires sont fournis :

  1. Si $BRANCH_SOURCE est manquant :

    • Utiliser AskUserQuestion pour demander la branche source
    • Question : "Quelle est la branche source à analyser ?"
    • Proposer les branches récentes de type release/* ou feature/*
  2. Si $BRANCH_TARGET est manquant :

    • Utiliser AskUserQuestion pour demander la branche cible
    • Question : "Quelle est la branche de référence ?"
    • Options suggérées : main, develop, master

Ne pas continuer tant que les deux arguments obligatoires ne sont pas fournis.

1. Validation des paramètres

# Vérifier que les branches existent
git rev-parse --verify $BRANCH_SOURCE
git rev-parse --verify $BRANCH_TARGET

# Vérifier qu'il y a des différences
DIFF_COUNT=$(git rev-list --count $BRANCH_TARGET..$BRANCH_SOURCE)
if [ $DIFF_COUNT -eq 0 ]; then
    echo "Aucune différence entre les branches"
    exit 1
fi

2. Collecte des statistiques git

Exécuter les commandes suivantes en parallèle :

# Statistiques globales
git diff --stat $BRANCH_TARGET..$BRANCH_SOURCE | tail -1

# Nombre total de fichiers modifiés et détails lignes
git diff --numstat $BRANCH_TARGET..$BRANCH_SOURCE | \
  awk '{files++; added+=$1; deleted+=$2} END {print files, added, deleted}'

# Répartition par type de fichier
git diff --numstat $BRANCH_TARGET..$BRANCH_SOURCE | python3 -c "
import sys
from collections import defaultdict

stats = defaultdict(lambda: {'count': 0, 'added': 0, 'deleted': 0})

for line in sys.stdin:
    parts = line.strip().split('\t')
    if len(parts) < 3:
        continue

    added = int(parts[0]) if parts[0] != '-' else 0
    deleted = int(parts[1]) if parts[1] != '-' else 0
    path = parts[2]

    ext = 'autre'
    if path.endswith('.php'):
        ext = 'php'
    elif path.endswith('.twig'):
        ext = 'twig'
    elif path.endswith(('.yml', '.yaml')):
        ext = 'yaml'
    elif path.endswith('.js'):
        ext = 'js'
    elif path.endswith('.scss'):
        ext = 'scss'
    elif path.endswith('.md'):
        ext = 'md'
    elif path.endswith('.json'):
        ext = 'json'
    elif path.endswith('.sh'):
        ext = 'sh'

    stats[ext]['count'] += 1
    stats[ext]['added'] += added
    stats[ext]['deleted'] += deleted
    stats[ext]['total'] = stats[ext]['added'] + stats[ext]['deleted']

for ext in sorted(stats.items(), key=lambda x: x[1]['total'], reverse=True):
    name = ext[0]
    data = ext[1]
    print(f'{name}|{data[\"count\"]}|{data[\"added\"]}|{data[\"deleted\"]}|{data[\"total\"]}')
"

# Types de modifications (A/M/D/R)
git diff --name-status $BRANCH_TARGET..$BRANCH_SOURCE | cut -f1 | sort | uniq -c

# Nombre de commits
git rev-list --count $BRANCH_TARGET..$BRANCH_SOURCE

# Total fichiers dans la branche cible
git ls-tree -r $BRANCH_TARGET --name-only | wc -l

# Top commits avec features/fixes
git log $BRANCH_TARGET..$BRANCH_SOURCE --oneline --no-merges | \
  grep -E "(feat|feature|✨|🚀|📝|🐛|fix|♻️|refactor)" | head -50

3. Analyse des domaines fonctionnels

Analyser les commits pour identifier les domaines principaux impactés :

  • Grouper par préfixe de commit (AVENANT, DOSSIER, APF, etc.)
  • Identifier les patterns récurrents
  • Extraire les fonctionnalités majeures avec leur impact

4. Génération du rapport HTML

Utiliser le template suivant et remplir avec les données collectées :

Structure du rapport :

  1. Header avec executive summary

    • Nom de la release
    • Résumé en 2-3 phrases
    • Chiffres clés (% code modifié, commits, variation nette)
  2. KPI Grid (4 indicateurs visuels)

    • % du code modifié
    • Nombre de commits
    • Variation nette (simplification/ajout)
    • Domaine principal (ex: "70% focus AVENANTS")
  3. Fonctionnalités principales (cards avec impact)

    • Impact Très élevé (rouge)
    • Impact Élevé (orange)
    • Impact Moyen (jaune)
    • Impact Faible (vert)
  4. Corrections majeures

    • Liste des bugs corrigés
  5. Qualité & Maintenabilité

    • Code simplifié
    • Documentation
    • Refactoring
    • Interface
  6. Vue d'ensemble technique

    • Chart bars par type de fichier
    • Métrique périmètre impacté
  7. Impact business (4 axes)

    • Gestion administrative
    • Communication
    • Performance
    • Sécurité

Style CSS :

  • Gradient violet (#667eea → #764ba2)
  • Cards avec border-left coloré selon impact
  • Progress bars animées
  • KPI boxes avec fond dégradé
  • Design responsive

5. Sauvegarde du fichier

OUTPUT_FILE="REPORT_PATH/impact_${RELEASE_NAME}.html"
mkdir -p REPORT_PATH
# Écrire le contenu HTML généré
echo "Rapport généré : $OUTPUT_FILE"

Format de sortie

Le rapport doit être :

  • Orienté Product Owner : focus sur l'impact métier, pas les détails techniques
  • Visuel : KPI, charts, couleurs par niveau d'impact
  • Actionnable : lister les features, bugs corrigés, améliorations
  • Comparable : même structure pour toutes les releases

Règles importantes

  1. NE PAS utiliser de termes techniques obscurs
  2. TOUJOURS expliquer l'impact utilisateur
  3. GROUPER les changements par domaine fonctionnel
  4. QUANTIFIER l'impact (%, nombre, ratio)
  5. PRIORISER par impact métier (Très élevé → Faible)

Exemple d'exécution

$ /git:release-report release/v27.0.0 main

Analyse de release/v27.0.0 vs main...

✓ Collecte statistiques git
✓ Analyse types de fichiers
✓ Extraction fonctionnalités
✓ Génération rapport HTML

Rapport généré : REPORT_PATH/impact_v27.0.0.html

Résumé :
- 1 250 fichiers modifiés (17.5% du codebase)
- 45 320 lignes ajoutées, 38 100 lignes supprimées
- +7 220 lignes nettes (+10.2%)
- 780 commits
- Focus principal : NOTIFICATIONS (65%)

Notes

  • Le rapport est auto-suffisant (HTML avec CSS inline)
  • Compatible tous navigateurs modernes
  • Peut être imprimé ou converti en PDF
  • Les couleurs suivent le design system du projet

Configuration de sortie

IMPORTANT : Cette skill effectue une opération Git rapide et nécessite un format de sortie spécifique.

Lis le frontmatter de cette skill. Si un champ output-style est présent, exécute immédiatement :

/output-style <valeur-du-champ>

Note : Une fois que le champ output-style sera supporté nativement par Claude Code, cette instruction pourra être supprimée.

Création de worktree Git

Créer un nouveau worktree Git de manière structurée avec support des issues GitHub.

Principe

Un worktree permet de travailler sur plusieurs branches en parallèle sans avoir à stash/commit. Chaque worktree est un répertoire séparé lié au même dépôt Git.

Le répertoire de base des worktrees est défini dans le .env.claude du projet utilisateur via la variable WORKTREE_DIR.

La convention de nommage du répertoire worktree est de remplacer les / du nom de branche par des -. Exemple : branche feature/ma-fonctionnalite → répertoire feature-ma-fonctionnalite

Configuration

CORE_SCRIPTS="${CLAUDE_PLUGIN_ROOT}/skills/branch-core/scripts"

Variables

  • SOURCE_BRANCH: Branche source (optionnel - défaut: MAIN_BRANCH de .env.claude)
  • ISSUE_OR_TEXT: Numéro d'issue GitHub ou texte descriptif

Relevant Files

  • @.git/config
  • @.gitignore
  • @.env.claude

Instructions à Exécuter

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

1. Lire la configuration depuis .env.claude

  • Lis le fichier .env.claude à la racine du projet courant (pas celui du plugin, celui du projet utilisateur)
  • Extrais les valeurs de :
    • WORKTREE_DIR (répertoire de base des worktrees)
    • MAIN_BRANCH (fallback pour SOURCE_BRANCH)
  • Si WORKTREE_DIR n'est pas défini ou est vide, utilise AskUserQuestion pour demander :
    Question: "La variable WORKTREE_DIR n'est pas définie dans .env.claude. Quel répertoire utiliser pour les worktrees ?"
    Options: ["../worktrees", ".worktrees", "Autre"]
    
  • Vérifie que le répertoire parent de WORKTREE_DIR existe. Si non, affiche une erreur et arrête.

2. Parser les arguments et résoudre SOURCE_BRANCH

Logique de désambiguisation selon le nombre d'arguments :

2 arguments fournis :

  • Premier argument = SOURCE_BRANCH
  • Second argument = ISSUE_OR_TEXT

1 argument fourni :

  • Si c'est un entier → ISSUE_OR_TEXT (numéro d'issue), SOURCE_BRANCH = MAIN_BRANCH de .env.claude
  • Si ça correspond à une branche locale existante (git branch --list "$ARG" non vide) → SOURCE_BRANCH, ISSUE_OR_TEXT non fourni (sera demandé à l'utilisateur)
  • Sinon → ISSUE_OR_TEXT (texte descriptif), SOURCE_BRANCH = MAIN_BRANCH de .env.claude

0 argument :

  • SOURCE_BRANCH = MAIN_BRANCH de .env.claude
  • ISSUE_OR_TEXT non fourni (sera demandé à l'utilisateur)

Si SOURCE_BRANCH n'est toujours pas résolu (MAIN_BRANCH absent de .env.claude et pas fourni en argument) :

  • Utilise AskUserQuestion pour demander :
    Question: "Depuis quelle branche veux-tu créer le nouveau worktree ?"
    Options: ["main", "master", "develop", "Autre"]
    

3. Valider que SOURCE_BRANCH existe localement

  • Exécute avec Bash :
    bash "$CORE_SCRIPTS/validate-source-branch.sh" "$SOURCE_BRANCH"
    
  • Si le script échoue (exit 1), arrête le workflow

4. 🔴 METTRE À JOUR SOURCE_BRANCH 🔴

  • Exécute git fetch origin $SOURCE_BRANCH avec Bash
  • CRITIQUE : Garantit qu'on part du dernier commit de origin
  • Note : On utilise fetch au lieu de checkout + pull car on ne veut pas changer la branche courante du worktree principal

5. Résoudre le nom de la nouvelle branche

  • Extrais ISSUE_OR_TEXT depuis $ARGUMENTS (second argument)

Si ISSUE_OR_TEXT est fourni :

  • Exécute avec Bash :
    eval "$(bash "$CORE_SCRIPTS/resolve-branch-name.sh" "$ISSUE_OR_TEXT")"
    echo "BRANCH_NAME=$BRANCH_NAME"
    echo "PREFIX=$PREFIX"
    echo "PREFIX_SOURCE=$PREFIX_SOURCE"
    echo "WORKTREE_DIRNAME=$WORKTREE_DIRNAME"
    
  • Si le script échoue (exit 1), arrête le workflow
  • Les variables BRANCH_NAME, PREFIX, PREFIX_SOURCE, ISSUE_NUMBER, WORKTREE_DIRNAME sont disponibles

Si ISSUE_OR_TEXT n'est pas fourni :

  • Utilise AskUserQuestion pour demander le nom de branche

6. Vérifier que la nouvelle branche n'existe pas

  • Exécute avec Bash :
    bash "$CORE_SCRIPTS/check-branch-exists.sh" "$BRANCH_NAME"
    
  • Si le script échoue (exit 1), arrête le workflow

7. Calculer le chemin du worktree

  • Le chemin complet est : $WORKTREE_DIR/$WORKTREE_DIRNAME
    • Exemple : /home/user/worktrees/feature-42-login-fix

8. Vérifier que le répertoire worktree n'existe pas déjà

  • Vérifie avec test -d "$WORKTREE_PATH" via Bash
  • Si le répertoire existe, affiche :
    ❌ ERREUR : Le répertoire worktree '$WORKTREE_PATH' existe déjà
    
    Supprime-le d'abord ou choisis un autre nom
    
    • Arrête le workflow

9. Créer le worktree

  • Exécute git worktree add "$WORKTREE_PATH" -b "$BRANCH_NAME" "origin/$SOURCE_BRANCH" avec Bash
  • Cette commande :
    • Crée le répertoire worktree
    • Crée la branche depuis le dernier état distant de SOURCE_BRANCH
    • Checkout la branche dans le worktree

10. Afficher le résumé

Affiche :

✅ Worktree créé : $BRANCH_NAME
📁 Répertoire : $WORKTREE_PATH
📝 Préfixe détecté : $PREFIX (source: $PREFIX_SOURCE)
📍 Depuis : $SOURCE_BRANCH
{Si issue} 🔗 Issue associée : #$ISSUE_NUMBER

Pour travailler dans ce worktree :
   cd $WORKTREE_PATH

📝 Le tracking sera configuré automatiquement au premier push avec :
   git push -u origin $BRANCH_NAME

⚠️ IMPORTANT - NE PAS configurer de tracking automatiquement :

  • ❌ INTERDIT : git branch --set-upstream-to=origin/$SOURCE_BRANCH $BRANCH_NAME
  • ✅ Le tracking sera configuré lors du premier push avec -u
  • RAISON : Configurer le tracking vers SOURCE_BRANCH pousse les commits sur la branche parente au lieu de créer une nouvelle branche distante

Expertise

Conventions de nommage des branches (préfixe détecté automatiquement) :

  • feature/{numéro}-{description} : Nouvelles fonctionnalités
  • fix/{numéro}-{description} : Corrections de bugs
  • hotfix/{numéro}-{description} : Corrections urgentes en production
  • chore/{numéro}-{description} : Maintenance, refactoring
  • docs/{numéro}-{description} : Documentation
  • test/{numéro}-{description} : Tests
  • Utilise des tirets, pas d'espaces ni caractères spéciaux

Détection automatique du préfixe (par priorité) :

  1. Labels de l'issue GitHub
  2. Mots-clés dans la description de l'issue
  3. Mots-clés dans le titre de l'issue
  4. Défaut : feature/ si aucun indicateur trouvé

Convention de nommage du répertoire worktree :

  • Remplacer / par - dans le nom de branche
  • feature/ma-fonctionnalite → feature-ma-fonctionnalite
  • fix/42-login-bug → fix-42-login-bug
  • hotfix/critical-payment → hotfix-critical-payment

Template

# Exemple 1 : Issue seule (SOURCE_BRANCH = MAIN_BRANCH de .env.claude)
/git:worktree 42
# → Résolution via branch-core : fix/42-login-form-crashes-on-submit
# → Worktree dans: $WORKTREE_DIR/fix-42-login-form-crashes-on-submit

# Exemple 2 : Issue avec branche source explicite
/git:worktree develop 42
# → Résolution via branch-core : fix/42-login-form-crashes-on-submit (depuis develop)
# → Worktree dans: $WORKTREE_DIR/fix-42-login-form-crashes-on-submit

# Exemple 3 : Texte descriptif seul (SOURCE_BRANCH = MAIN_BRANCH de .env.claude)
/git:worktree "fix login validation"
# → Résolution via branch-core : fix/login-validation
# → Worktree dans: $WORKTREE_DIR/fix-login-validation

# Exemple 4 : Texte descriptif avec branche source
/git:worktree main "Add OAuth support"
# → Résolution via branch-core : feature/add-oauth-support
# → Worktree dans: $WORKTREE_DIR/feature-add-oauth-support

# Exemple 5 : Sans argument (SOURCE_BRANCH = MAIN_BRANCH, demande issue/texte)
/git:worktree

Examples

# Créer un worktree avec issue (source = MAIN_BRANCH de .env.claude)
/git:worktree 123

# Créer un worktree avec texte descriptif (source = MAIN_BRANCH)
/git:worktree "user authentication"

# Créer un worktree depuis une branche source explicite avec issue
/git:worktree develop 123

# Créer un worktree fix avec texte explicite (source = MAIN_BRANCH)
/git:worktree "fix login bug"

# Créer un worktree hotfix (source = MAIN_BRANCH)
/git:worktree "hotfix critical payment issue"

# Créer un worktree depuis develop (demande issue/texte)
/git:worktree develop

# Créer un worktree depuis une branche existante avec issue
/git:worktree feature/api-base 456

Report

  • Nom de la branche créée
  • Chemin du worktree créé
  • Préfixe détecté et sa source (label/description/titre/défaut)
  • Branche source utilisée
  • Issue associée (si applicable)
  • Commande cd pour accéder au worktree
  • Note : Le tracking remote sera configuré lors du premier push avec git push -u origin $BRANCH_NAME

Validation

  • ✅ WORKTREE_DIR doit être défini dans .env.claude (ou demandé à l'utilisateur)
  • ✅ Le répertoire parent de WORKTREE_DIR doit exister
  • ✅ SOURCE_BRANCH doit exister localement
  • ✅ SOURCE_BRANCH optionnel (défaut: MAIN_BRANCH de .env.claude)
  • ✅ FETCH pour mettre à jour SOURCE_BRANCH (CRITIQUE)
  • ✅ La nouvelle branche ne doit pas déjà exister
  • ✅ Le répertoire worktree ne doit pas déjà exister
  • ✅ Si ISSUE_OR_TEXT est un numéro, l'issue doit exister sur GitHub
  • ✅ Le nom généré respecte les conventions de nommage
  • ✅ Détection automatique entre numéro d'issue et texte descriptif

Pourquoi fetch au lieu de checkout + pull ?

Différence avec git:branch :

  • git:branch fait checkout SOURCE_BRANCH puis pull car il crée la branche depuis le HEAD courant
  • git:worktree fait fetch car git worktree add -b BRANCH "origin/SOURCE_BRANCH" crée directement depuis la ref distante
  • On ne veut pas changer la branche courante du worktree principal (l'utilisateur peut y travailler)

Avantage :

  • L'utilisateur reste sur sa branche courante dans le worktree principal
  • Le worktree est créé depuis le dernier état distant de SOURCE_BRANCH
  • Pas de risque de conflits dans le worktree principal

Sponsors

Details

Marketplace
atournayre/claude-marketplace
Source
git
Category
Community

More from atournayre/claude-marketplace

All 18