@atlashub/smartstack-cli 1.13.2 → 1.14.1

package/templates/commands/gitflow/10-start.md

@@ -1,190 +0,0 @@
----
-description: Phase 10 - Start a new feature, release or hotfix branch with worktree
-agent: gitflow-start
-model: haiku
----
-
-# Phase 10: START - Démarrer une branche GitFlow
-
-**Argument:** `$ARGUMENTS` = `{type} {name} [--no-worktree]`
-
-> **Ref:** Fonctions `normalize_branch_name()`, `detect_worktree_mode()`, `read_gitflow_config()` dans [_shared.md](_shared.md)
-
----
-
-## Flux d'Exécution
-
-```
-AVEC args:  Analyser → Vérifications → Créer branche → Config DB → Résumé
-SANS args:  Analyser → Question Type → Question Nom → Vérifications → Créer → Config DB → Résumé
-```
-
----
-
-## Étape 1: Analyser le contexte
-
-```bash
-CURRENT_BRANCH=$(git branch --show-current)
-VERSION=$(grep -oP '"version":\s*"\K[^"]+' package.json 2>/dev/null || echo "0.1.0")
-STATUS=$(git status --porcelain)
-DEVELOP_AHEAD=$(git rev-list --count origin/main..origin/develop 2>/dev/null || echo "0")
-LAST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "none")
-```
-
-**Afficher:**
-- Branche: `{CURRENT_BRANCH}` | Version: `{VERSION}` | Tag: `{LAST_TAG}`
-- develop → main: `{DEVELOP_AHEAD}` commits (si >0: "Release recommandée")
-
----
-
-## Étape 2: Questions (si pas d'arguments)
-
-### Type de branche
-
-Options dynamiques selon contexte:
-- `feature`: Depuis develop (toujours dispo)
-- `release v{X.Y+1.0}`: Si DEVELOP_AHEAD > 0 (recommandé)
-- `hotfix`: Depuis main
-
-### Nom de branche
-
-Selon langue configurée (`config.language.code`):
-
-| Langue | Options suggérées |
-|--------|-------------------|
-| `en` | add-, update-, fix-, refactor-, improve- |
-| `fr` | ajouter-, modifier-, corriger-, refactorer-, ameliorer- |
-
-**Normalisation automatique:** Utiliser `normalize_branch_name()` de [_shared.md](_shared.md)
-
----
-
-## Étape 3: Vérifications (OBLIGATOIRE même avec args)
-
-```bash
-BRANCH_FULL_NAME="${TYPE}/${NAME}"
-git fetch origin --quiet
-
-# Vérifier existence
-LOCAL_EXISTS=$(git branch --list "$BRANCH_FULL_NAME")
-REMOTE_EXISTS=$(git branch -r --list "origin/$BRANCH_FULL_NAME")
-
-[ -n "$LOCAL_EXISTS" ] || [ -n "$REMOTE_EXISTS" ] && {
-  echo "ERROR: Branche '$BRANCH_FULL_NAME' existe déjà"
-  # Options: Autre nom | Checkout existante | Supprimer
-}
-```
-
-**Si working directory dirty:**
-Options: `Stash` | `Commit (/gitflow:3-commit)` | `Continuer`
-
----
-
-## Étape 4: Créer la branche
-
-### Détection mode worktree
-
-Utiliser `detect_worktree_mode()` de [_shared.md](_shared.md)
-
-### Mode Organized
-
-```bash
-PROJECT_ROOT=".."
-git fetch origin
-
-case "$TYPE" in
-  feature) WORKTREE_PATH="$PROJECT_ROOT/features/$NAME"; BASE="origin/develop" ;;
-  release) WORKTREE_PATH="$PROJECT_ROOT/releases/v$VERSION"; BASE="origin/develop" ;;
-  hotfix)  WORKTREE_PATH="$PROJECT_ROOT/hotfixes/$NAME"; BASE="origin/main" ;;
-esac
-
-mkdir -p "$(dirname $WORKTREE_PATH)"
-git worktree add -b "$TYPE/$NAME" "$WORKTREE_PATH" "$BASE"
-```
-
-### Mode --no-worktree
-
-```bash
-git checkout ${BASE_BRANCH} && git pull origin ${BASE_BRANCH}
-git checkout -b ${TYPE}/${NAME}
-```
-
----
-
-## Étape 5: Config DB automatique (.NET)
-
-Si `appsettings.json` détecté, créer `appsettings.Local.json`:
-
-```bash
-DB_NAME="${PROJECT_NAME}_${TYPE}_${NAME}" | cut -c1-128
-CONNECTION="Server=localhost;Database=$DB_NAME;Trusted_Connection=true;TrustServerCertificate=true"
-```
-
-Convention: `{prefix}_feat_{name}` | `{prefix}_fix_{name}` | `{prefix}_rel_{version}`
-
----
-
-## Étape 6: Résumé
-
-```
-{TYPE} CRÉÉ
-- Branche: {type}/{name}
-- Base: {develop|main} → Cible: {develop|main+develop}
-- Worktree: {path}
-```
-
-**PROCHAINES ÉTAPES**
-
-1. Aller dans le worktree
-2. Faire vos modifications et commiter
-3. Créer la Pull Request
-4. Après merge de la PR, finaliser
-
-**COMMANDES**
-
-Aller dans le worktree:
-
-```bash
-cd {worktree_path}
-```
-
-Commiter:
-
-```
-/gitflow:3-commit
-```
-
-Créer la PR:
-
-```
-/gitflow:7-pull-request
-```
-
-Finaliser:
-
-```
-/gitflow:11-finish {type}/{name}
-```
-
----
-
-## Cas Spéciaux
-
-| Situation | Action |
-|-----------|--------|
-| develop > 10 commits ahead | Proposer release d'abord |
-| Release déjà en cours | Proposer continuer ou nouvelle |
-| Hotfix depuis branche != main | Stash auto → checkout main |
-| main divergent de develop | Option "Reset main" dans release |
-
----
-
-## Modes CLI
-
-| Commande | Résultat |
-|----------|----------|
-| `/gitflow:10-start` | Mode interactif |
-| `/gitflow:10-start feature user-auth` | Direct: feature/user-auth |
-| `/gitflow:10-start release` | Propose versions |
-| `/gitflow:10-start hotfix login-fix` | Direct: hotfix/login-fix |
-| `/gitflow:10-start feature test --no-worktree` | Sans worktree |

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

@@ -1,382 +0,0 @@
----
-description: Phase 11 - Finish and finalize a GitFlow branch (tag + merge back)
-agent: gitflow-finish
-model: sonnet
----
-
-# Phase 11: FINISH - Finaliser une branche GitFlow
-
-**Argument:** `$ARGUMENTS` = branche (optionnel, SCAN si absent)
-
-> **IMPORTANT:** Cette commande EXECUTE les opérations automatiquement. Ne PAS afficher les commandes bash à l'utilisateur - les EXECUTER directement via l'outil Bash.
-
-> **Ref:** Fonctions dans [_shared.md](_shared.md)
-> **Ref:** Fonction `determine_base_branch()` dans [efcore/_shared.md](../efcore/_shared.md)
-
----
-
-## MODE D'EXÉCUTION
-
-**CRITIQUE:** Tu dois EXECUTER chaque commande avec l'outil Bash, pas les afficher.
-
-Workflow:
-1. Détecter le contexte (worktree, branche, PR)
-2. Exécuter les opérations silencieusement
-3. Afficher uniquement le RÉSUMÉ final
-
----
-
-## Étape 0: Détection du contexte
-
-**EXECUTER:**
-
-```bash
-# Aller au repo principal si dans un worktree
-MAIN_WORKTREE=$(git worktree list --porcelain | grep -m1 "^worktree " | sed 's/worktree //')
-cd "$MAIN_WORKTREE"
-
-# Synchroniser
-git fetch --all --quiet
-```
-
----
-
-## Étape 1: Scan Proactif (si pas d'argument)
-
-Si `$ARGUMENTS` est vide, scanner les branches avec PR mergées:
-
-**EXECUTER:**
-
-```bash
-# Lister branches avec PR mergée (prêtes à finaliser)
-for BRANCH in $(git branch -r | grep -E 'origin/(feature|release|hotfix)/' | sed 's/origin\///'); do
-  PR_MERGED=$(gh pr list --head "$BRANCH" --state merged --json number --jq '.[0].number' 2>/dev/null)
-  [ -n "$PR_MERGED" ] && echo "✅ $BRANCH (PR #$PR_MERGED mergée)"
-done
-```
-
-Puis demander à l'utilisateur quelle branche finaliser.
-
----
-
-## Étape 2: Vérifier état de la PR
-
-**EXECUTER:**
-
-```bash
-BRANCH="$1"  # Argument fourni ou sélectionné
-
-# Vérifier si PR mergée
-PR_INFO=$(gh pr list --head "$BRANCH" --state merged --json number,mergedAt --jq '.[0]')
-
-if [ -z "$PR_INFO" ]; then
-  # PR pas trouvée comme mergée - vérifier si main a les commits
-  git checkout main --quiet && git pull origin main --quiet
-
-  # Vérifier si la branche existe encore
-  if ! git show-ref --verify --quiet "refs/remotes/origin/$BRANCH"; then
-    echo "✓ Branche déjà supprimée sur remote - PR probablement mergée via GitHub"
-  else
-    echo "⚠️ PR non trouvée comme mergée"
-    exit 1
-  fi
-fi
-```
-
----
-
-## Étape 2.5: Vérification EF Core Post-Merge Manuel (CRITIQUE)
-
-**Contexte:** Si la PR a été mergée manuellement (via GitHub/Azure DevOps UI), les checks EF Core de `/gitflow:9-merge` n'ont pas été exécutés. Cette étape rattrape cette vérification.
-
-**EXECUTER:**
-
-```bash
-# Déterminer la branche cible selon le type
-case "$BRANCH" in
-  feature/*|bugfix/*) TARGET_BRANCH="develop" ;;
-  release/*|hotfix/*) TARGET_BRANCH="main" ;;
-esac
-
-# Vérifier si le projet a des migrations EF Core
-MIGRATIONS_DIR=$(find . -type d -name "Migrations" 2>/dev/null | head -1)
-
-if [ -n "$MIGRATIONS_DIR" ] && [ -d "$MIGRATIONS_DIR" ]; then
-  echo "Vérification EF Core post-merge..."
-
-  git checkout "$TARGET_BRANCH" --quiet && git pull origin "$TARGET_BRANCH" --quiet
-
-  EF_CHECK_FAILED=""
-
-  # 1. Vérifier que le build passe
-  if ! dotnet build --no-restore --verbosity quiet 2>/dev/null; then
-    echo "❌ ERREUR: Build échoue sur $TARGET_BRANCH après merge"
-    echo "→ Possible conflit de migrations non résolu"
-    EF_CHECK_FAILED=true
-  fi
-
-  # 2. Vérifier que les migrations sont listables
-  if ! dotnet ef migrations list --no-build 2>/dev/null | tail -1 | grep -q "Done\|applied"; then
-    echo "⚠️ WARNING: Problème avec les migrations EF Core"
-    EF_CHECK_FAILED=true
-  fi
-
-  # 3. Vérifier pas de markers de conflit Git dans les fichiers
-  if grep -rq "<<<<<<\|>>>>>>\|======" "$MIGRATIONS_DIR" 2>/dev/null; then
-    echo "❌ ERREUR: Conflits Git non résolus dans $MIGRATIONS_DIR"
-    EF_CHECK_FAILED=true
-  fi
-
-  # 4. Pour release/hotfix: info sur divergence develop
-  if [[ "$BRANCH" =~ ^(release|hotfix)/ ]]; then
-    MAIN_COUNT=$(git ls-tree -r --name-only origin/main -- "$MIGRATIONS_DIR" 2>/dev/null | grep -c "\.cs$" || echo "0")
-    DEV_COUNT=$(git ls-tree -r --name-only origin/develop -- "$MIGRATIONS_DIR" 2>/dev/null | grep -c "\.cs$" || echo "0")
-
-    [ "$DEV_COUNT" -gt "$MAIN_COUNT" ] && \
-      echo "ℹ️ develop a $((DEV_COUNT - MAIN_COUNT)) migration(s) de plus que main (normal si features en cours)"
-  fi
-
-  if [ -n "$EF_CHECK_FAILED" ]; then
-    echo ""
-    echo "┌─────────────────────────────────────────────────────────────┐"
-    echo "│  PROBLÈME EF CORE DÉTECTÉ APRÈS MERGE MANUEL                │"
-    echo "│                                                             │"
-    echo "│  Commandes de diagnostic:                                   │"
-    echo "│    /efcore:db-status       - État des migrations            │"
-    echo "│    /efcore:conflicts       - Analyser les conflits          │"
-    echo "│    /efcore:rebase-snapshot - Resync si snapshot diverge     │"
-    echo "└─────────────────────────────────────────────────────────────┘"
-    # Ne pas bloquer, continuer avec le finish mais alerter
-  else
-    echo "✓ EF Core: Migrations OK sur $TARGET_BRANCH"
-  fi
-fi
-```
-
----
-
-## Actions par type
-
-### Feature
-
-**EXECUTER ces commandes dans l'ordre:**
-
-1. Checkout develop et pull:
-```bash
-git checkout develop && git pull origin develop
-```
-
-2. Supprimer branche locale:
-```bash
-git branch -d "$BRANCH" 2>/dev/null || git branch -D "$BRANCH" 2>/dev/null
-```
-
-3. Supprimer branche remote (si existe):
-```bash
-git push origin --delete "$BRANCH" 2>/dev/null || true
-```
-
-4. Cleanup worktree:
-```bash
-# Détecter et nettoyer le worktree
-WORKTREE_PATH=""
-case "$BRANCH" in
-  feature/*)
-    [ -d "../features/${BRANCH#feature/}" ] && WORKTREE_PATH="../features/${BRANCH#feature/}"
-    [ -d "../worktrees/features/${BRANCH#feature/}" ] && WORKTREE_PATH="../worktrees/features/${BRANCH#feature/}"
-    ;;
-esac
-[ -n "$WORKTREE_PATH" ] && [ -d "$WORKTREE_PATH" ] && {
-  git worktree remove "$WORKTREE_PATH" --force 2>/dev/null || rm -rf "$WORKTREE_PATH"
-  git worktree prune
-}
-```
-
----
-
-### Release
-
-**EXECUTER ces commandes dans l'ordre:**
-
-1. Checkout main et pull (récupérer le merge de la PR):
-```bash
-git checkout main && git pull origin main
-```
-
-2. Extraire la version:
-```bash
-VERSION=$(echo "$BRANCH" | sed 's/release\/v\?//')
-```
-
-3. Créer le tag (si pas déjà existant):
-```bash
-if ! git tag -l "v$VERSION" | grep -q "v$VERSION"; then
-  git tag -a "v$VERSION" -m "Release v$VERSION"
-  git push origin "v$VERSION"
-fi
-```
-
-4. Merge back vers develop:
-```bash
-git checkout develop && git pull origin develop
-git merge main --no-ff -m "chore: merge release v$VERSION back to develop"
-```
-
-4.5. **Vérifier propagation migrations (CRITIQUE):**
-```bash
-# Comparer migrations main vs develop après merge
-MAIN_MIGRATIONS=$(git ls-tree -r --name-only origin/main -- Migrations/ | grep "\.cs$" | grep -v "Designer\|Snapshot" | wc -l)
-DEV_MIGRATIONS=$(find Migrations -name "*.cs" | grep -v "Designer\|Snapshot" | wc -l)
-
-if [ "$DEV_MIGRATIONS" -lt "$MAIN_MIGRATIONS" ]; then
-  echo "⚠️ ATTENTION: develop a moins de migrations que main"
-  echo "→ Vérifier le merge des migrations"
-fi
-
-# Vérifier que le snapshot develop inclut tout de main
-git diff origin/main -- Migrations/*ModelSnapshot.cs
-# Si diff significatif → conflit de migrations à résoudre
-```
-
-5. Auto-incrémenter MINOR pour develop:
-```bash
-# Trouver package.json (web ou racine)
-PKG_PATH=$(find . -name "package.json" -not -path "*/node_modules/*" | head -1)
-if [ -n "$PKG_PATH" ]; then
-  CURRENT=$(cat "$PKG_PATH" | grep -oP '"version":\s*"\K[^"]+')
-  NEXT=$(echo "$CURRENT" | awk -F. '{print $1"."$2+1".0"}')
-  cd "$(dirname "$PKG_PATH")"
-  npm version "$NEXT" --no-git-tag-version
-  cd -
-  git add "$PKG_PATH"
-  [ -f "${PKG_PATH%.json}-lock.json" ] && git add "${PKG_PATH%.json}-lock.json"
-  git commit -m "chore: bump develop to v$NEXT for next release"
-fi
-git push origin develop
-```
-
-6. Cleanup:
-```bash
-git branch -d "$BRANCH" 2>/dev/null || git branch -D "$BRANCH" 2>/dev/null
-git push origin --delete "$BRANCH" 2>/dev/null || true
-
-WORKTREE_PATH=""
-[ -d "../releases/${BRANCH#release/}" ] && WORKTREE_PATH="../releases/${BRANCH#release/}"
-[ -d "../releases/v${VERSION}" ] && WORKTREE_PATH="../releases/v${VERSION}"
-[ -d "../worktrees/releases/${VERSION}" ] && WORKTREE_PATH="../worktrees/releases/${VERSION}"
-[ -n "$WORKTREE_PATH" ] && [ -d "$WORKTREE_PATH" ] && {
-  git worktree remove "$WORKTREE_PATH" --force 2>/dev/null || rm -rf "$WORKTREE_PATH"
-  git worktree prune
-}
-```
-
----
-
-### Hotfix
-
-**EXECUTER ces commandes dans l'ordre:**
-
-1. Checkout main et pull:
-```bash
-git checkout main && git pull origin main
-```
-
-2. Auto-incrémenter PATCH:
-```bash
-PKG_PATH=$(find . -name "package.json" -not -path "*/node_modules/*" | head -1)
-CURRENT=$(cat "$PKG_PATH" | grep -oP '"version":\s*"\K[^"]+')
-NEW_VERSION=$(echo "$CURRENT" | awk -F. '{print $1"."$2"."$3+1}')
-cd "$(dirname "$PKG_PATH")"
-npm version "$NEW_VERSION" --no-git-tag-version
-cd -
-git add "$PKG_PATH"
-[ -f "${PKG_PATH%.json}-lock.json" ] && git add "${PKG_PATH%.json}-lock.json"
-git commit -m "chore: bump version to $NEW_VERSION"
-```
-
-3. Créer tag et push:
-```bash
-git tag -a "v$NEW_VERSION" -m "Hotfix v$NEW_VERSION"
-git push origin main "v$NEW_VERSION"
-```
-
-4. Merge back vers develop:
-```bash
-git checkout develop && git pull origin develop
-git merge main --no-ff -m "chore: merge hotfix v$NEW_VERSION back to develop"
-```
-
-4.5. **Vérifier propagation migrations (CRITIQUE):**
-```bash
-# Vérifier que le snapshot develop inclut les changements du hotfix
-git diff origin/main -- Migrations/*ModelSnapshot.cs
-# Si diff significatif → conflit de migrations à résoudre manuellement
-
-# En cas de conflit:
-# 1. Récupérer snapshot main (état production)
-# 2. Régénérer migration develop si nécessaire
-```
-
-```bash
-git push origin develop
-```
-
-5. Cleanup:
-```bash
-git branch -d "$BRANCH" 2>/dev/null || git branch -D "$BRANCH" 2>/dev/null
-git push origin --delete "$BRANCH" 2>/dev/null || true
-
-WORKTREE_PATH=""
-[ -d "../hotfixes/${BRANCH#hotfix/}" ] && WORKTREE_PATH="../hotfixes/${BRANCH#hotfix/}"
-[ -d "../worktrees/hotfixes/${BRANCH#hotfix/}" ] && WORKTREE_PATH="../worktrees/hotfixes/${BRANCH#hotfix/}"
-[ -n "$WORKTREE_PATH" ] && [ -d "$WORKTREE_PATH" ] && {
-  git worktree remove "$WORKTREE_PATH" --force 2>/dev/null || rm -rf "$WORKTREE_PATH"
-  git worktree prune
-}
-```
-
----
-
-## Résumé (AFFICHER à la fin)
-
-```
-{TYPE} FINALISÉ ✓
-- Branche: {branch}
-- PR: #{number} (mergée)
-- Tag: {v1.2.3|N/A}
-- Merge back develop: {done|N/A}
-- Version develop: {NEXT_VERSION|unchanged}
-- Worktree: nettoyé
-```
-
-**PROCHAINE ÉTAPE**
-
-Démarrer une nouvelle feature:
-
-```
-/gitflow:10-start feature {name}
-```
-
----
-
-## Gestion des erreurs
-
-| Erreur | Action |
-|--------|--------|
-| PR non mergée | `⚠️ Merger la PR d'abord: /gitflow:9-merge` |
-| Conflit merge back | Résoudre puis: `git add . && git merge --continue && git push` |
-| Tag existe déjà | Skip création tag, continuer |
-| Branche déjà supprimée | Continuer avec cleanup worktree |
-| Build échoue post-merge | `/efcore:db-status` puis `/efcore:conflicts` |
-| Conflits Git dans migrations | Résoudre manuellement puis `/efcore:rebase-snapshot` |
-| Snapshot désynchronisé | `/efcore:rebase-snapshot` sur la branche cible |
-
----
-
-## Modes
-
-| Commande | Action |
-|----------|--------|
-| `/gitflow:11-finish` | Scan et proposer branches prêtes |
-| `/gitflow:11-finish feature/xxx` | Finaliser branche spécifique |
-| `/gitflow:11-finish --skip-tag` | Sans créer de tag |

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

@@ -1,103 +0,0 @@
----
-description: Phase 12 - Cleanup worktrees and orphan branches (audit and remove)
-agent: gitflow-cleanup
-model: sonnet
----
-
-# Phase 12: CLEANUP - Audit et nettoyage worktrees
-
-**Argument:** `$ARGUMENTS` = options (--dry-run, --force, --stale-days=N)
-
-> **Ref:** Fonction `cleanup_worktree_for_branch()` dans [_shared.md](_shared.md)
-
----
-
-## Prérequis
-
-```bash
-CURRENT=$(git rev-parse --abbrev-ref HEAD)
-[[ "$CURRENT" != "main" && "$CURRENT" != "develop" ]] && {
-  echo "⚠️ Exécuter depuis main ou develop"
-  exit 1
-}
-```
-
----
-
-## Workflow
-
-### 1. Collecter
-
-```bash
-git worktree list --porcelain
-git branch -a
-git fetch --prune
-```
-
-### 2. Analyser chaque worktree
-
-| Vérification | Status |
-|--------------|--------|
-| Branche existe localement | ✓ Active / ✗ Orphelin |
-| Branche existe sur remote | ✓ Trackée / ✗ Locale only |
-| Dernière activité | Date dernier commit |
-| Modifications | ✓ Clean / ⚠️ Dirty |
-
-### 3. Catégoriser
-
-```
-AUDIT WORKTREES
-───────────────────────────────────
-📁 Permanents: main, develop (protégés)
-📁 Actifs: feature/xxx (3 jours)
-⚠️ Orphelins: feature/old (BRANCHE INEXISTANTE)
-⏰ Stale: feature/abc (45 jours)
-💾 Dirty: feature/wip (non committés)
-```
-
----
-
-## Actions
-
-### Suppression worktree
-
-```bash
-[ -z "$(git -C $WORKTREE_PATH status --porcelain)" ] || {
-  echo "⚠️ Dirty - utiliser --force"
-  exit 1
-}
-git worktree remove "$WORKTREE_PATH" --force
-rm -rf "$WORKTREE_PATH" 2>/dev/null
-git worktree prune
-```
-
-### Détection dossiers orphelins
-
-```bash
-KNOWN=$(git worktree list --porcelain | grep "^worktree " | sed 's/worktree //')
-for DIR in ../worktrees/{features,releases,hotfixes}/*; do
-  echo "$KNOWN" | grep -q "$DIR" || echo "⚠️ Orphelin: $DIR"
-done
-```
-
----
-
-## Résumé
-
-```
-CLEANUP COMPLETE
-- Analysés: {total} | Supprimés: {n}
-- Orphelins: {n} | Stale: {n}
-- Espace libéré: ~{size} MB
-```
-
----
-
-## Modes
-
-| Commande | Action |
-|----------|--------|
-| `/gitflow:12-cleanup` | Audit interactif |
-| `/gitflow:12-cleanup --dry-run` | Audit seul |
-| `/gitflow:12-cleanup --force` | Supprime orphelins auto |
-| `/gitflow:12-cleanup --stale-days=30` | Seuil stale |