@atlashub/smartstack-cli 1.1.0

package/templates/commands/gitflow/11-finish.md

@@ -0,0 +1,323 @@
+---
+description: Phase 11 - Finish and finalize a GitFlow branch (tag + merge back)
+agent: gitflow-finish
+model: sonnet
+---
+
+# Phase 11: FINISH - Finaliser une branche GitFlow
+
+Tu es expert GitFlow. Finalise une branche apres merge de la PR.
+
+**Argument:** `$ARGUMENTS` = branche a finaliser (optionnel, detecte automatiquement)
+
+---
+
+## Quand utiliser
+
+| Situation | Action |
+|-----------|--------|
+| PR feature mergee | Cleanup uniquement |
+| PR release mergee | Tag + merge back to develop |
+| PR hotfix mergee | Tag + merge back to develop |
+
+---
+
+## Workflow
+
+### 1. Detecter le contexte
+
+```bash
+# Branche courante ou argument
+BRANCH=${ARGUMENTS:-$(git rev-parse --abbrev-ref HEAD)}
+
+# Determiner le type
+if [[ $BRANCH == feature/* ]]; then TYPE="feature"
+elif [[ $BRANCH == release/* ]]; then TYPE="release"
+elif [[ $BRANCH == hotfix/* ]]; then TYPE="hotfix"
+else echo "Branche non GitFlow"; exit 1
+fi
+```
+
+### 2. Verifier que PR est mergee
+
+```bash
+# Chercher PR associee
+gh pr list --head $BRANCH --state merged --json number,mergedAt
+
+# Si pas mergee
+if [ -z "$PR" ]; then
+  echo "⚠️ PR non trouvee ou non mergee"
+  echo "Executez d'abord: /gitflow:7-pull-request puis /gitflow:9-merge"
+  exit 1
+fi
+```
+
+---
+
+## Actions selon type
+
+### Feature (simple cleanup)
+
+```bash
+# Detecter si on est dans un worktree et trouver le repo principal
+CURRENT_DIR=$(pwd)
+MAIN_WORKTREE=$(git worktree list --porcelain | grep -m1 "^worktree " | sed 's/worktree //')
+
+# Revenir au repo principal AVANT de supprimer le worktree
+cd "$MAIN_WORKTREE"
+
+# Supprimer worktree si existe
+WORKTREE_PATH="../worktrees/features/{name}"
+if [ -d "$WORKTREE_PATH" ]; then
+  git worktree remove "$WORKTREE_PATH" --force 2>/dev/null || true
+fi
+
+# Supprimer branche locale
+git checkout develop
+git pull origin develop
+git branch -d feature/{name}
+
+# Supprimer branche remote (si pas fait par merge)
+git push origin --delete feature/{name} 2>/dev/null || true
+```
+
+**Resume:**
+```
+FEATURE FINALISEE
+────────────────────────────────
+Branche:  feature/{name}
+Mergee:   develop
+PR:       #{number}
+Cleanup:  ✓ Branche supprimee
+────────────────────────────────
+```
+
+---
+
+### Release (tag + merge back)
+
+```bash
+# 0. Detecter si on est dans un worktree et trouver le repo principal
+CURRENT_DIR=$(pwd)
+MAIN_WORKTREE=$(git worktree list --porcelain | grep -m1 "^worktree " | sed 's/worktree //')
+
+# Revenir au repo principal AVANT toute operation
+cd "$MAIN_WORKTREE"
+
+# 1. Checkout main et pull
+git checkout main
+git pull origin main
+
+# 2. Creer tag
+VERSION=$(echo $BRANCH | sed 's/release\/v//')
+git tag -a "v$VERSION" -m "Release v$VERSION"
+git push origin "v$VERSION"
+
+# 3. Merge back to develop
+git checkout develop
+git pull origin develop
+git merge main --no-ff -m "chore: merge release v$VERSION back to develop"
+git push origin develop
+
+# 4. Cleanup worktree + branche
+WORKTREE_PATH="../worktrees/releases/v$VERSION"
+if [ -d "$WORKTREE_PATH" ]; then
+  git worktree remove "$WORKTREE_PATH" --force 2>/dev/null || true
+fi
+git branch -d release/v$VERSION
+git push origin --delete release/v$VERSION 2>/dev/null || true
+```
+
+**Resume:**
+```
+RELEASE FINALISEE
+════════════════════════════════════════
+Version:  v{version}
+Tag:      v{version} ✓
+Main:     ✓ Mergee
+Develop:  ✓ Merge back complete
+
+Actions effectuees:
+  ✓ Tag v{version} cree et pousse
+  ✓ Main mis a jour
+  ✓ Develop synchronise avec main
+  ✓ Branche release supprimee
+════════════════════════════════════════
+```
+
+---
+
+### Hotfix (auto-increment PATCH + tag + merge back)
+
+```bash
+# 0. Detecter si on est dans un worktree et trouver le repo principal
+CURRENT_DIR=$(pwd)
+MAIN_WORKTREE=$(git worktree list --porcelain | grep -m1 "^worktree " | sed 's/worktree //')
+
+# Revenir au repo principal AVANT toute operation
+cd "$MAIN_WORKTREE"
+
+# 1. Checkout main et pull
+git checkout main
+git pull origin main
+
+# 2. AUTO-INCREMENT PATCH VERSION
+# Lire la version actuelle
+CURRENT_VERSION=$(cat package.json | jq -r '.version')
+
+# Calculer la nouvelle version (PATCH increment)
+# Ex: 1.7.1 → 1.7.2
+NEW_VERSION=$(node -e "
+  const [major, minor, patch] = '$CURRENT_VERSION'.split('.').map(Number);
+  console.log([major, minor, patch + 1].join('.'));
+")
+
+# Mettre a jour package.json avec la nouvelle version
+npm version $NEW_VERSION --no-git-tag-version
+
+# Committer le bump de version
+git add package.json package-lock.json
+git commit -m "chore: bump version to $NEW_VERSION"
+
+# 3. Creer tag avec la nouvelle version
+git tag -a "v$NEW_VERSION" -m "Hotfix v$NEW_VERSION"
+git push origin main
+git push origin "v$NEW_VERSION"
+
+# 4. Merge back to develop
+git checkout develop
+git pull origin develop
+git merge main --no-ff -m "chore: merge hotfix v$NEW_VERSION back to develop"
+git push origin develop
+
+# 5. Cleanup worktree + branche
+WORKTREE_PATH="../worktrees/hotfixes/{name}"
+if [ -d "$WORKTREE_PATH" ]; then
+  git worktree remove "$WORKTREE_PATH" --force 2>/dev/null || true
+fi
+git branch -d hotfix/{name}
+git push origin --delete hotfix/{name} 2>/dev/null || true
+```
+
+**⚠️ IMPORTANT:** Le bump de version PATCH est automatique. Pas besoin de le faire manuellement avant le finish.
+
+**Resume:**
+```
+HOTFIX FINALISE
+════════════════════════════════════════
+Hotfix:   {name}
+Version:  v{CURRENT_VERSION} → v{NEW_VERSION}
+Tag:      v{NEW_VERSION} ✓
+
+Actions effectuees:
+  ✓ Version incrementee (PATCH): {CURRENT_VERSION} → {NEW_VERSION}
+  ✓ package.json mis a jour
+  ✓ Tag v{NEW_VERSION} cree et pousse
+  ✓ Main mis a jour
+  ✓ Develop synchronise (merge back)
+  ✓ Branche hotfix supprimee
+════════════════════════════════════════
+```
+
+---
+
+## Gestion des conflits (merge back)
+
+Si conflit lors du merge back to develop :
+
+```
+⚠️ CONFLIT DETECTE - MERGE BACK
+────────────────────────────────
+Le merge de main vers develop a des conflits.
+
+Fichiers en conflit:
+{liste fichiers}
+
+Options:
+1. Resoudre manuellement puis: git merge --continue
+2. Annuler: git merge --abort
+
+Commande recommandee:
+  Resoudre conflits dans IDE
+  git add .
+  git merge --continue
+  git push origin develop
+────────────────────────────────
+```
+
+---
+
+## Cleanup automatique des worktrees
+
+Apres chaque finish, un cleanup cible est effectue pour le worktree de la branche finalisee:
+
+```bash
+# Fonction de cleanup cible (appelee automatiquement)
+cleanup_worktree_for_branch() {
+  BRANCH=$1
+  WORKTREE_BASE="../worktrees"
+
+  # Determiner le chemin selon le type
+  if [[ $BRANCH == feature/* ]]; then
+    NAME=${BRANCH#feature/}
+    WORKTREE_PATH="$WORKTREE_BASE/features/$NAME"
+  elif [[ $BRANCH == release/* ]]; then
+    VERSION=${BRANCH#release/}
+    WORKTREE_PATH="$WORKTREE_BASE/releases/$VERSION"
+  elif [[ $BRANCH == hotfix/* ]]; then
+    NAME=${BRANCH#hotfix/}
+    WORKTREE_PATH="$WORKTREE_BASE/hotfixes/$NAME"
+  fi
+
+  # Supprimer si existe
+  if [ -d "$WORKTREE_PATH" ]; then
+    git worktree remove "$WORKTREE_PATH" --force 2>/dev/null || true
+    rm -rf "$WORKTREE_PATH" 2>/dev/null || true
+    git worktree prune
+    echo "✓ Worktree nettoye: $WORKTREE_PATH"
+  fi
+}
+
+# Appel automatique
+cleanup_worktree_for_branch "$BRANCH"
+```
+
+**Note:** Pour un audit complet de tous les worktrees, utilisez:
+
+```
+/gitflow:12-cleanup
+```
+
+---
+
+## Resume final
+
+```
+GITFLOW FINISH COMPLETE
+════════════════════════════════════════
+Type:     {feature|release|hotfix}
+Branche:  {branch_name}
+Status:   FINALISEE
+
+Resultats:
+  PR:       #{number} (mergee)
+  Tag:      {tag|N/A}
+  Main:     {updated|N/A}
+  Develop:  {updated|unchanged}
+  Cleanup:  ✓ Branche supprimee
+  Worktree: ✓ Nettoye
+
+════════════════════════════════════════
+Workflow GitFlow complete!
+```
+
+---
+
+## Modes
+
+| Commande | Action |
+|----------|--------|
+| `/gitflow:11-finish` | Finaliser branche courante |
+| `/gitflow:11-finish feature/xxx` | Finaliser branche specifiee |
+| `/gitflow:11-finish --dry-run` | Simulation |
+| `/gitflow:11-finish --skip-tag` | Sans creation de tag |

package/templates/commands/gitflow/12-cleanup.md

@@ -0,0 +1,276 @@
+---
+description: Phase 12 - Cleanup worktrees and orphan branches (audit and remove)
+agent: gitflow-cleanup
+model: sonnet
+---
+
+# Phase 12: CLEANUP - Audit et nettoyage des worktrees
+
+Tu es expert GitFlow. Audite et nettoie les worktrees orphelins ou obsoletes.
+
+**Argument:** `$ARGUMENTS` = options (--dry-run, --force, --stale-days=N)
+
+---
+
+## Prerequis
+
+**IMPORTANT:** Cette commande doit etre executee depuis `main` ou `develop` uniquement.
+
+```bash
+CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
+if [[ "$CURRENT_BRANCH" != "main" && "$CURRENT_BRANCH" != "develop" ]]; then
+  echo "⚠️ ERREUR: Cette commande doit etre executee depuis main ou develop"
+  echo "Branche courante: $CURRENT_BRANCH"
+  echo ""
+  echo "Executez: git checkout develop && /gitflow:12-cleanup"
+  exit 1
+fi
+```
+
+---
+
+## Workflow
+
+### 1. Collecter les informations
+
+```bash
+# Lister tous les worktrees
+git worktree list --porcelain
+
+# Lister toutes les branches locales
+git branch -a
+
+# Lister les branches remote
+git fetch --prune
+git branch -r
+```
+
+### 2. Analyser chaque worktree
+
+Pour chaque worktree detecte:
+
+| Verification | Condition | Status |
+|--------------|-----------|--------|
+| Branche existe localement | `git branch --list $BRANCH` | ✓ Active / ✗ Orphelin |
+| Branche existe sur remote | `git branch -r --list origin/$BRANCH` | ✓ Trackee / ✗ Locale only |
+| Derniere activite | `git log -1 --format=%ci $BRANCH` | Date dernier commit |
+| Modifications non commitees | `git -C $WORKTREE status --porcelain` | ✓ Clean / ⚠️ Dirty |
+
+### 3. Categoriser les worktrees
+
+```
+AUDIT WORKTREES
+═══════════════════════════════════════════════════════════════
+
+📁 Worktrees permanents (proteges):
+   ✓ ../worktrees/main          → main
+   ✓ ../worktrees/develop       → develop
+
+📁 Worktrees actifs:
+   ✓ ../worktrees/features/xxx  → feature/xxx (3 jours)
+   ✓ ../worktrees/releases/v2   → release/v2.0.0 (1 jour)
+
+⚠️ Worktrees orphelins (branche supprimee):
+   ✗ ../worktrees/features/old  → feature/old (BRANCHE INEXISTANTE)
+   ✗ ../worktrees/hotfixes/fix  → hotfix/fix (BRANCHE INEXISTANTE)
+
+⏰ Worktrees stale (inactifs > {N} jours):
+   ⚠ ../worktrees/features/abc  → feature/abc (45 jours sans commit)
+
+💾 Worktrees dirty (modifications non commitees):
+   ⚠ ../worktrees/features/wip  → feature/wip (fichiers modifies)
+
+═══════════════════════════════════════════════════════════════
+```
+
+---
+
+## Actions proposees
+
+### Mode par defaut (interactif)
+
+```
+ACTIONS PROPOSEES
+═══════════════════════════════════════════════════════════════
+
+Orphelins a supprimer:
+  [1] ../worktrees/features/old  (branche inexistante)
+  [2] ../worktrees/hotfixes/fix  (branche inexistante)
+
+Stale a examiner (> 30 jours):
+  [3] ../worktrees/features/abc  (45 jours)
+
+Options:
+  [A] Supprimer tous les orphelins
+  [S] Supprimer tous les stale
+  [1-N] Supprimer individuellement
+  [D] Details sur un worktree
+  [Q] Quitter sans action
+
+Choix: _
+═══════════════════════════════════════════════════════════════
+```
+
+### Mode --dry-run
+
+Affiche uniquement l'audit sans proposer d'actions.
+
+### Mode --force
+
+Supprime automatiquement tous les orphelins sans confirmation.
+
+---
+
+## Suppression d'un worktree
+
+```bash
+# Verifier si dirty
+if [ -n "$(git -C $WORKTREE_PATH status --porcelain)" ]; then
+  echo "⚠️ Worktree dirty - modifications non commitees"
+  echo "Utilisez --force pour supprimer quand meme"
+  exit 1
+fi
+
+# Supprimer le worktree
+git worktree remove "$WORKTREE_PATH" --force
+
+# Nettoyer le dossier si reste
+rm -rf "$WORKTREE_PATH" 2>/dev/null || true
+
+# Pruner les worktrees
+git worktree prune
+```
+
+---
+
+## Detection des dossiers orphelins
+
+En plus des worktrees git, detecter les dossiers qui ne sont plus lies:
+
+```bash
+# Lister les worktrees connus
+KNOWN_WORKTREES=$(git worktree list --porcelain | grep "^worktree " | sed 's/worktree //')
+
+# Scanner les dossiers de worktrees
+WORKTREE_BASE="../worktrees"
+for TYPE in features releases hotfixes; do
+  for DIR in "$WORKTREE_BASE/$TYPE"/*; do
+    if [ -d "$DIR" ]; then
+      # Verifier si c'est un worktree connu
+      if ! echo "$KNOWN_WORKTREES" | grep -q "$DIR"; then
+        echo "⚠️ Dossier orphelin: $DIR"
+      fi
+    fi
+  done
+done
+```
+
+---
+
+## Resume final
+
+```
+CLEANUP COMPLETE
+═══════════════════════════════════════════════════════════════
+
+Worktrees analyses:     {total}
+Permanents (proteges):  {n_permanent}
+Actifs:                 {n_active}
+Supprimes:              {n_deleted}
+  - Orphelins:          {n_orphan}
+  - Stale:              {n_stale}
+Ignores (dirty):        {n_dirty}
+
+Espace libere:          ~{size} MB
+
+Dossiers orphelins:     {n_orphan_dirs}
+  - Supprimes:          {n_orphan_dirs_deleted}
+
+═══════════════════════════════════════════════════════════════
+Environnement propre!
+```
+
+---
+
+## Modes
+
+| Commande | Action |
+|----------|--------|
+| `/gitflow:12-cleanup` | Audit interactif avec propositions |
+| `/gitflow:12-cleanup --dry-run` | Audit seul, aucune action |
+| `/gitflow:12-cleanup --force` | Supprime tous les orphelins automatiquement |
+| `/gitflow:12-cleanup --stale-days=30` | Seuil pour worktrees stale (defaut: 30) |
+| `/gitflow:12-cleanup --include-stale` | Inclut les stale dans la suppression auto |
+| `/gitflow:12-cleanup --verbose` | Affiche les details de chaque worktree |
+
+---
+
+## Integration automatique
+
+Cette commande est appelee automatiquement par:
+- `/gitflow:11-finish` → Apres finalisation d'une branche
+- `/gitflow:6-abort --branch` → Apres abandon d'une branche
+
+Dans ces cas, seul le worktree de la branche concernee est nettoye (cleanup cible).
+
+---
+
+## Cleanup cible (usage interne)
+
+Quand appelee depuis finish/abort avec une branche specifique:
+
+```bash
+# Usage interne
+cleanup_worktree_for_branch() {
+  BRANCH=$1
+  WORKTREE_BASE="../worktrees"
+
+  # Determiner le chemin selon le type
+  if [[ $BRANCH == feature/* ]]; then
+    NAME=${BRANCH#feature/}
+    WORKTREE_PATH="$WORKTREE_BASE/features/$NAME"
+  elif [[ $BRANCH == release/* ]]; then
+    VERSION=${BRANCH#release/}
+    WORKTREE_PATH="$WORKTREE_BASE/releases/$VERSION"
+  elif [[ $BRANCH == hotfix/* ]]; then
+    NAME=${BRANCH#hotfix/}
+    WORKTREE_PATH="$WORKTREE_BASE/hotfixes/$NAME"
+  fi
+
+  # Supprimer si existe
+  if [ -d "$WORKTREE_PATH" ]; then
+    git worktree remove "$WORKTREE_PATH" --force 2>/dev/null || true
+    rm -rf "$WORKTREE_PATH" 2>/dev/null || true
+    git worktree prune
+    echo "✓ Worktree nettoye: $WORKTREE_PATH"
+  fi
+}
+```
+
+---
+
+## Logs
+
+Chaque cleanup est logue dans `.claude/gitflow/logs/cleanup_{timestamp}.json`:
+
+```json
+{
+  "timestamp": "{ISO_DATE}",
+  "type": "cleanup",
+  "mode": "interactive|dry-run|force|targeted",
+  "branch": "{main|develop}",
+  "worktrees": {
+    "analyzed": {n},
+    "deleted": [
+      { "path": "...", "branch": "...", "reason": "orphan|stale" }
+    ],
+    "skipped": [
+      { "path": "...", "branch": "...", "reason": "dirty|active|permanent" }
+    ]
+  },
+  "orphan_dirs": {
+    "found": {n},
+    "deleted": {n}
+  }
+}
+```