Toolkit de développement core : context, debug, sessions, analytics

GitHub stars
9

Install

/plugin install dev@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 25

Objectif

Instructions à Exécuter

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

Vérifier que TOUS les prérequis système, PHP et Claude Code sont présents avant de lancer le workflow.

Exit code 1 et message d'erreur détaillé si quelque chose manque.

Instructions

1. Vérifier les outils système

# Vérifier gh CLI
if ! command -v gh &> /dev/null; then
    echo "❌ PRÉREQUIS MANQUANT : gh CLI"
    echo "Installe : https://github.com/cli/cli"
    echo "Authentifie : gh auth login"
    exit 1
fi

# Vérifier gh authentifié
if ! gh auth status &> /dev/null; then
    echo "❌ PRÉREQUIS MANQUANT : gh CLI non authentifié"
    echo "Authentifie : gh auth login"
    exit 1
fi

# Vérifier jq
if ! command -v jq &> /dev/null; then
    echo "❌ PRÉREQUIS MANQUANT : jq"
    echo "Installe : apt-get install jq (Linux) ou brew install jq (macOS)"
    exit 1
fi

# Vérifier git
if ! command -v git &> /dev/null; then
    echo "❌ PRÉREQUIS MANQUANT : git"
    exit 1
fi

2. Vérifier les plugins Claude Code

# Vérifier plugin feature-dev (optionnel pour Explore/Design, mais requis pour automation)
# Note: La vérification exacte dépend de l'API Claude Code disponible
# Pour maintenant, on va supposer qu'il est installé
# Si absent, les phases vont échouer et afficher un message clair

3. Afficher le succès

echo "✅ Tous les prérequis sont présents"
echo ""
echo "Outils vérifiés :"
echo "  ✅ gh CLI authentifiée"
echo "  ✅ jq disponible"
echo "  ✅ git disponible"
echo ""

Règles

  • ✅ Exit 1 si prérequis manquant
  • ✅ Messages d'erreur clairs avec instructions d'installation
  • ✅ Pas d'interaction : fail fast
  • ✅ Rapide : vérifications simples et directes

Objectif

Instructions à Exécuter

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

Phase 3 du workflow automatisé : identifier et résoudre les ambiguïtés avec heuristiques prédéfinies.

Zéro question, zéro AskUserQuestion. Décisions automatiques basées sur les patterns existants.

Instructions

1. Lire le contexte

Déterminer le chemin du workflow state :

# Récupérer issue_number depuis le contexte
workflow_state_file=".claude/data/workflows/issue-${issue_number}-dev-workflow-state.json"
  • Lire le workflow state pour la feature et les findings de l'exploration (Phase 2)
  • Si le fichier n'existe pas ou phase 2 non complétée, exit avec erreur

2. Analyser les zones d'ombre

Identifier les aspects sous-spécifiés dans les catégories suivantes.

3. Appliquer heuristiques automatiques

Au lieu de poser des questions, utiliser cette table de décision :

CatégorieHeuristique par défaut
Edge casesValeur null/vide → Exception métier explicite (InvalideXXX ou {NomEntité}Invalide)
Gestion erreursExceptions métier typées (héritant d'une base commune) + logging PSR-3 niveau ERROR
IntégrationRéutiliser patterns existants détectés en Phase 1 (patterns de repository, services, DTOs)
RétrocompatibilitéPréserver API publique (pas de breaking changes), créer nouvelle méthode si needed
PerformancePas de cache prématuré sauf si liste > 1000 items (sinon trop de complexité)
SécuritéTOUJOURS valider inputs (whitelist si possible), échapper outputs selon context

4. Documenter les décisions appliquées

Mettre à jour le workflow state avec les décisions appliquées (pas des questions) :

{
  "currentPhase": 3,
  "phases": {
    "3": {
      "status": "completed",
      "completedAt": "{ISO timestamp}",
      "durationMs": {durée},
      "autoDecisions": {
        "edgeCases": "Exception métier InvalideXXX pour valeurs null/vides",
        "errorHandling": "Exceptions typées héritant de DomainException + logging PSR-3 ERROR",
        "integration": "Réutilisation patterns existants Phase 1",
        "compatibility": "Préservation API publique, nouvelle méthode si breaking",
        "performance": "Pas de cache prématuré sauf liste > 1000 items",
        "security": "Validation inputs (whitelist), échappement outputs"
      }
    }
  }
}

Règles

  • ❌ Zéro AskUserQuestion (pas de questions)
  • ✅ Heuristiques appliquées directement selon la table
  • ❌ Ne PAS proposer d'architecture
  • ✅ Documenter les décisions pour traçabilité
  • ✅ Utiliser les patterns existants détectés en Phase 1

Objectif

Instructions à Exécuter

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

Phase 6 du workflow automatisé : implémenter selon le plan SANS demander d'approbation.

Démarrage immédiat de l'implémentation.

Instructions

1. Lire le contexte

Déterminer le chemin du workflow state :

# Récupérer issue_number depuis le contexte
workflow_state_file=".claude/data/workflows/issue-${issue_number}-dev-workflow-state.json"
  • Lire le workflow state pour accéder au plan généré (Phase 5)
  • Lire docs/specs/{feature}.md (ou chemin du plan)
  • Si le plan n'existe pas, exit avec erreur

2. Implémenter selon le plan

Exécuter le contenu du plan :

  • Créer les fichiers nécessaires
  • Modifier les fichiers existants
  • Créer les tests unitaires

Pas de checkpoint d'approbation - implémentation directe.

3. Vérification PHPStan initiale

Lancer une première vérification PHPStan sans l'arrêter l'implémentation :

vendor/bin/phpstan analyse --level=9 2>&1

Noter les résultats pour la Phase 7 (Review).

4. Mettre à jour le workflow state

{
  "currentPhase": 6,
  "phases": {
    "6": {
      "status": "completed",
      "completedAt": "{ISO timestamp}",
      "durationMs": {durée},
      "filesCreated": ["{liste des fichiers}"],
      "filesModified": ["{liste des fichiers}"],
      "testsCreated": {nombre},
      "phpstanErrorsInitial": {nombre}
    }
  }
}

Règles

  • ❌ Pas de checkpoint d'approbation
  • ✅ Implémenter directement selon le plan
  • ✅ Créer les tests unitaires
  • ✅ Vérifier PHPStan (sans bloquer)
  • ❌ Ne PAS corriger les erreurs (ce sera Phase 6)

Configuration de sortie

Instructions à Exécuter

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

IMPORTANT : Cette commande génère une architecture choisie automatiquement et nécessite un format de sortie structuré.

Lis le frontmatter de cette commande. 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.

Objectif

Phase 4 du workflow automatisé : proposer les architectures ET choisir automatiquement (Pragmatic Balance).

Zéro demande de choix à l'utilisateur.

Instructions

1. Lire le contexte

Déterminer le chemin du workflow state :

# Récupérer issue_number depuis le contexte
workflow_state_file=".claude/data/workflows/issue-${issue_number}-dev-workflow-state.json"
  • Lire le workflow state pour la feature, findings et décisions
  • Si phases précédentes non complétées, exit avec erreur

2. Évaluer et choisir l'architecture la meilleure

Lancer 1 agent code-architect pour évaluer les approches et recommander la meilleure :

Évalue les 3 approches architecturales possibles pour "{feature}" :

**Approche 1 : Minimal Changes**
- Petit changement, réutilisation max, minimum de nouveaux fichiers

**Approche 2 : Clean Architecture**
- Abstractions élégantes, séparation des responsabilités, testabilité optimale

**Approche 3 : Pragmatic Balance**
- Balance rapidité/qualité, bonnes pratiques sans over-engineering

Contexte du codebase :
{keyFiles et patterns de la phase 2}

Décisions prises (Elegant Objects, edge cases, etc.) :
{décisions de la phase 3}

RECOMMANDE la meilleure approche pour CE projet basée sur :
1. Les patterns existants du codebase
2. Les principes Elegant Objects applicables
3. L'absence d'over-engineering
4. La complexité justifiée vs bénéfices

Retourne :
- Approche recommandée + raison précise
- Composants à créer/modifier
- Fichiers impactés
- Diagramme de flux (ASCII)

3. Présenter l'architecture choisie

🏗️ Architecture sélectionnée : {Approche recommandée}

**Description :**
{résumé de l'approche}

**Raison du choix :**
{pourquoi cette approche est la meilleure pour CE projet}

**Composants :**
- {composant 1} : {responsabilité}
- {composant 2} : {responsabilité}

**Fichiers impactés :** {nombre}
- {fichier 1}
- {fichier 2}

4. Documenter l'architecture choisie

Mettre à jour le workflow state :

{
  "currentPhase": 4,
  "phases": {
    "4": {
      "status": "completed",
      "completedAt": "{ISO timestamp}",
      "durationMs": {durée},
      "chosenApproach": "Pragmatic Balance",
      "autoChosen": true,
      "reason": "Default pour mode auto (balance rapidité/qualité)",
      "architecture": {
        "components": ["{liste des composants}"],
        "files": ["{liste des fichiers à créer/modifier}"],
        "buildSequence": ["{étapes d'implémentation}"]
      }
    }
  }
}

Règles

  • ✅ Évaluer les 3 approches (en 1 seul agent, pas 3 agents parallèles)
  • ✅ Recommander la MEILLEURE pour CE projet (pas toujours la même)
  • ✅ Basée sur : patterns existants, Elegant Objects, absence d'over-engineering
  • ❌ Zéro demande de choix à l'utilisateur
  • ✅ Justifier le choix avec raison précise
  • ✅ Documenter l'architecture choisie

Configuration de sortie

Instructions à Exécuter

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

IMPORTANT : Cette commande génère un résumé de compréhension structuré et nécessite un format de sortie spécifique.

Lis le frontmatter de cette commande. 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.

Objectif

Phase 1 du workflow automatisé : comprendre le besoin utilisateur SANS interaction.

Feature demandée (depuis Issue GitHub)

Récupérée depuis .claude/data/workflows/issue-${issue_number}-dev-workflow-state.json (Phase 0)

Titre : issue.title Description : issue.description Labels : issue.labels

Mode automatique (zéro checkpoint)

Ce skill exécute la phase 0 en mode AUTOMATIQUE :

  • Pas de demande de confirmation
  • Validation auto de la clarté
  • FAIL si ambiguïté critique

Instructions

1. Analyser la demande

Déterminer le chemin du workflow state :

# Récupérer issue_number depuis le workflow state créé en Phase 0
# Note: si issue_number est disponible en contexte, l'utiliser directement
workflow_state_file=".claude/data/workflows/issue-${issue_number}-dev-workflow-state.json"
  • Lire le workflow state
  • Récupérer issue.title et issue.description
  • Évaluer la clarté et la complétude du contenu de l'issue
  • Si la demande est claire → continuer
  • Si la demande contient une ambiguïté critique (ex: "Ajouter auth" sans préciser OAuth/Basic/JWT) → FAIL immédiatement avec message explicite :
    ❌ Description de l'issue trop ambiguë pour mode auto.
    
    Issue #123 : "Ajouter auth"
    
    Précise le contexte manquant dans l'issue GitHub :
    - Authentification ? (OAuth? JWT? Basic Auth?)
    - Intégration? (Quel service? Quel provider?)
    - Scope? (Utilisateurs? Admin? Tous?)
    
    Édite l'issue et relance le workflow.
    
    Exit code: 1

2. Explorer le contexte

  • Chercher si des fichiers similaires existent déjà dans le projet
  • Lire CLAUDE.md et .ai/ pour comprendre les conventions
  • Identifier les patterns architecturaux utilisés

3. Résumer la compréhension

Présenter un résumé structuré basé sur l'issue GitHub :

📋 Résumé de la demande

**Issue :** #123 : {issue.title}

**Problème résolu :**
{résumé de issue.description}

**Labels :** {issue.labels}

**Contexte technique :**
- {pattern existant pertinent}
- {fichiers existants liés}

4. Validation automatique

✅ PAS de checkpoint utilisateur - valider automatiquement et continuer

Mise à jour du workflow state

Le fichier .claude/data/workflows/issue-${issue_number}-dev-workflow-state.json a été créé en Phase 0 avec les infos de l'issue.

Mettre à jour la section phases pour enregistrer la complétion de Phase 1 :

{
  "mode": "auto",
  "issue": {
    "number": {issue number},
    "title": "{issue.title}",
    "description": "{issue.description}",
    "labels": "{issue.labels}",
    "state": "OPEN",
    "fetchedAt": "{ISO timestamp}"
  },
  "feature": "{issue.title}",
  "status": "in_progress",
  "currentPhase": 1,
  "phases": {
    "0": {
      "status": "completed",
      "completedAt": "{Phase 0 timestamp}",
      "durationMs": {Phase 0 duration}
    },
    "1": {
      "status": "completed",
      "completedAt": "{ISO timestamp}",
      "durationMs": {durée}
    }
  }
}

Règles

  • ❌ Pas de checkpoint utilisateur
  • ✅ Fail fast si ambiguïté critique
  • ✅ Valider automatiquement si description claire
  • ❌ Ne PAS proposer d'architecture
  • ✅ Se concentrer sur la COMPRÉHENSION du besoin

Objectif

Instructions à Exécuter

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

Phase 2 du workflow automatisé : explorer le codebase pour comprendre les patterns existants SANS interaction.

Instructions

1. Lire le contexte

Déterminer le chemin du workflow state :

workflow_state_file=".claude/data/workflows/issue-${issue_number}-dev-workflow-state.json"
  • Lire le workflow state pour connaître la feature en cours
  • Si le fichier n'existe pas, exit avec erreur code 1

2. Lancer les agents d'exploration

Lancer 2-3 agents code-explorer en parallèle avec des focus différents :

Agent 1 : Features similaires

Trouve des features similaires à "{feature}" dans le codebase.
Trace leur implémentation de bout en bout.
Retourne les 5-10 fichiers clés à lire.

Agent 2 : Architecture

Mappe l'architecture et les abstractions pour la zone concernée par "{feature}".
Identifie les patterns utilisés (repositories, services, events, etc.).
Retourne les 5-10 fichiers clés à lire.

Agent 3 : Intégrations (si pertinent)

Analyse les points d'intégration existants (APIs, events, commands).
Identifie comment les features communiquent entre elles.
Retourne les 5-10 fichiers clés à lire.

3. Consolider les résultats

  • Fusionner les listes de fichiers identifiés
  • Lire les fichiers clés pour construire une compréhension profonde
  • Identifier les patterns récurrents

4. Mettre à jour le workflow state

{
  "currentPhase": 2,
  "phases": {
    "2": {
      "status": "completed",
      "completedAt": "{ISO timestamp}",
      "durationMs": {durée},
      "keyFiles": ["{liste des fichiers clés}"],
      "patterns": ["{patterns identifiés}"],
      "findings": "{résumé des découvertes}"
    }
  }
}

Règles

  • ✅ Mode automatique : aucune interaction
  • ✅ Lancer agents en parallèle si disponibles
  • ✅ Documenter les patterns trouvés
  • ❌ Jamais demander confirmation (exit 1 si erreur, continuer sinon)
  • ✅ Consolider les résultats pour Phase 3

Objectif

Instructions à Exécuter

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

Orchestrateur du workflow de développement en 10 phases SANS interaction utilisateur.

Exécution automatique complète : récupérer issue → phases 1-8 → cleanup → créer PR. Objectif : PR créée et prête pour review, CI passe.

Issue GitHub

Issue #$ARGUMENTS (spec récupérée automatiquement)

⚠️ MODE NON-INTERACTIF

Ce workflow s'exécute automatiquement sans checkpoints utilisateur.

  • Worktree OBLIGATOIRE : créé et nettoyé automatiquement
  • 0 interaction requise : heuristiques appliquées à chaque décision
  • CI DOIT PASSER : PHPStan niveau 9, tests
  • Auto-fix en boucle : max 3 tentatives en Phase 6, puis rollback si échec

Pour un workflow interactif avec validation à chaque phase, utilise /dev:feature.

Prérequis obligatoires

Exécuter /dev:auto:check-prerequisites pour vérifier que TOUS les prérequis sont présents.

Exit code 1 et arrêt si quelque chose manque.

Workflow

Phase 0 : Vérifier les prérequis

🔄 Progression : TaskUpdate → tâche #0 en in_progress

⏱️ Démarrer le timer

Exécuter /dev:auto:check-prerequisites

Si la skill exit 1, arrêter immédiatement.

⏱️ Arrêter le timer

🔄 Progression : TaskUpdate → tâche #0 en completed

Affichage :

✅ Prérequis vérifiés

Tous les outils nécessaires sont présents :
  ✅ gh CLI authentifiée
  ✅ jq disponible
  ✅ git disponible

Lancement du workflow...

Phase 1 : Fetch Issue (Initialisation)

⏱️ Démarrer le timer

Déterminer le chemin :

issue_number=$ARGUMENTS
workflow_state_file=".claude/data/workflows/issue-${issue_number}-dev-workflow-state.json"

# Créer le répertoire s'il n'existe pas
mkdir -p ".claude/data/workflows"

Exécuter /dev:auto:fetch-issue $ARGUMENTS

Processus :

  • Valider que l'argument est un numéro d'issue
  • Récupérer l'issue GitHub via gh issue view
  • Vérifier que l'issue est OPEN et a une description
  • Sauvegarder les infos dans ${workflow_state_file}

Si /dev:auto:fetch-issue échoue :

  • Exit avec code 1
  • Afficher le message d'erreur explicite
  • Arrêter

⏱️ Arrêter le timer

Affichage :

🔗 Issue GitHub récupérée

  #123 : Description du feature
  État : OPEN
  Labels : enhancement

Lancement du workflow...

Initialisation

1. Créer automatiquement le worktree (OBLIGATOIRE)

🤖 Mode automatique activé pour : {feature}

📂 Création du worktree...

Processus :

  • Normaliser le nom de la feature en slug (kebab-case, minuscules, tirets)
  • Créer le répertoire .worktrees/ s'il n'existe pas
  • Créer le worktree avec /dev:worktree create {feature-slug}
  • Mettre à jour .claude/data/workflows/issue-${issue_number}-dev-workflow-state.json

Si création échoue : → FAIL HARD avec message d'erreur et exit code 1.

2. Initialiser le fichier d'état

Le fichier .claude/data/workflows/issue-{issue_number}-dev-workflow-state.json a déjà été créé par Phase 0 avec les infos de l'issue.

Mettre à jour le fichier pour ajouter les infos du worktree :

{
  "mode": "auto",
  "issue": {
    "number": {numéro},
    "title": "{issue title}",
    "description": "{issue body}",
    "labels": "{issue labels}",
    "state": "OPEN",
    "fetchedAt": "{ISO timestamp}"
  },
  "feature": "{issue title}",
  "status": "in_progress",
  "startedAt": "{ISO timestamp}",
  "currentPhase": 1,
  "worktree": {
    "name": "{feature-slug}",
    "path": ".worktrees/{feature-slug}",
    "branch": "feature/{feature-slug}",
    "cleaned": false,
    "branchDeleted": false
  },
  "autoConfig": {
    "worktreeCreated": true,
    "decisions": {},
    "autoFixAttempts": {}
  },
  "timing": {
    "totalDurationMs": null
  },
  "phases": {}
}

3. Créer les tâches du workflow

Utiliser TaskCreate pour chaque phase :

TaskCreate #0: Prérequis - Vérifier les outils
TaskCreate #1: Fetch - Récupérer l'issue GitHub
TaskCreate #2: Discover - Comprendre le besoin
TaskCreate #3: Explore - Explorer codebase
TaskCreate #4: Clarify - Heuristiques automatiques
TaskCreate #5: Design - Architecture (Pragmatic)
TaskCreate #6: Plan - Générer specs
TaskCreate #7: Code - Implémenter
TaskCreate #8: Review - Auto-fix × 3
TaskCreate #9: Cleanup - Nettoyer worktree
TaskCreate #10: Create PR - Créer la Pull Request

Important :

  • Utiliser activeForm (ex: "Vérifiant les outils", "Récupérant l'issue GitHub")
  • Toutes les tâches sont créées d'office (mode automatique)

4. Afficher le statut initial

🤖 Workflow automatique : {feature}

  🔵 0. Prérequis  - Vérifier les outils        ← En cours
  ⬜ 1. Fetch      - Récupérer l'issue GitHub
  ⬜ 2. Discover   - Comprendre le besoin
  ⬜ 3. Explore    - Explorer codebase
  ⬜ 4. Clarify    - Heuristiques automatiques
  ⬜ 5. Design     - Architecture (Pragmatic)
  ⬜ 6. Plan       - Générer specs
  ⬜ 7. Code       - Implémenter
  ⬜ 8. Review     - Auto-fix × 3
  ⬜ 9. Cleanup    - Nettoyer worktree
  ⬜ 10. Create PR - Créer la Pull Request

Gestion du timing et progression

⚠️ IMPORTANT : Chaque phase suit ce pattern :

  1. TaskUpdate → tâche en in_progress
  2. ⏱️ Démarrer le timer + exécuter la phase
  3. ⏱️ Arrêter le timer
  4. TaskUpdate → tâche en completed

Avant chaque phase :

  1. Utiliser TaskUpdate pour marquer la tâche comme in_progress
  2. Enregistrer le timestamp de début :
{
  "phases": {
    "{N}": { "status": "in_progress", "startedAt": "{ISO timestamp}" }
  }
}

Après chaque phase :

  1. Calculer la durée et mettre à jour :
{
  "phases": {
    "{N}": {
      "status": "completed",
      "startedAt": "{ISO timestamp}",
      "completedAt": "{ISO timestamp}",
      "durationMs": {durée en millisecondes}
    }
  }
}
  1. Utiliser TaskUpdate pour marquer la tâche comme completed

Pattern illustré dans Phase 0 - À reproduire pour toutes les phases 1-10.

Phase 1 : Discover

⏱️ Démarrer le timer

Exécuter /dev:auto:discover

Si /dev:auto:discover échoue (ambiguïté critique) :

  • Exit avec code 1
  • Cleanup worktree
  • Arrêter

⏱️ Arrêter le timer

Affichage :

✅ Phase 1 : Discover complétée (45s)
🔵 Phase 2 : Explore en cours

Phase 3 : Explore

⏱️ Démarrer le timer

Exécuter /dev:auto:explore (exploration codebase sans interaction)

⏱️ Arrêter le timer

Phase 4 : Clarify

⏱️ Démarrer le timer

Exécuter /dev:auto:clarify (applique heuristiques, zéro question)

⏱️ Arrêter le timer

Phase 5 : Design

⏱️ Démarrer le timer

Exécuter /dev:auto:design (choisit Pragmatic Balance automatiquement)

⏱️ Arrêter le timer

Phase 6 : Plan

⏱️ Démarrer le timer

Exécuter /dev:auto:plan (génération plan sans interaction)

⏱️ Arrêter le timer

Phase 7 : Code

⏱️ Démarrer le timer

Exécuter /dev:auto:code (implémente directement, pas d'approbation)

⏱️ Arrêter le timer

Phase 8 : Review

⏱️ Démarrer le timer

Exécuter /dev:auto:review (boucle auto-fix max 3 tentatives)

Si review échoue (PHPStan impossible) :

  • Logger l'erreur dans workflow-state.json
  • Déclencher ROLLBACK :
    git reset --hard HEAD@{0}
    /dev:worktree remove {feature-name}
    
  • Mettre à jour workflow-state.json avec status: "failed"
  • Exit code 1 avec message explicite

⏱️ Arrêter le timer

Si succès :

  • Continuer à Phase 8

⏱️ Calculer le temps total :

  1. Lire .claude/data/workflows/issue-${issue_number}-dev-workflow-state.json
  2. Calculer totalDurationMs = somme de tous les durationMs des phases
  3. Mettre à jour le fichier avec timing.totalDurationMs

Phase 9 : Cleanup (OBLIGATOIRE)

⏱️ Démarrer le timer

Nettoyage automatique du worktree :

🧹 Nettoyage du worktree...
  1. Vérifier que worktree a été créé (vérifier workflow state)
  2. Exécuter /dev:worktree remove {feature-name} automatiquement
  3. Ne PAS supprimer la branche (elle sera utilisée pour la PR en Phase 10)
  4. Mettre à jour workflow state :
{
  "status": "in_progress",
  "completedAt": "{ISO timestamp}",
  "worktree": {
    "cleaned": true,
    "branchDeleted": false,
    "cleanedAt": "{ISO timestamp}"
  }
}

⏱️ Arrêter le timer

Affichage :

✅ Phase 9 : Cleanup complétée (5s)
🔵 Phase 10 : Create PR en cours

Phase 10 : Create PR (AUTOMATISÉE)

⏱️ Démarrer le timer

Récupérer la branche-base et le projet depuis .env.claude (ou valeurs par défaut) :

MAIN_BRANCH=${MAIN_BRANCH:-main}
PROJECT=${PROJECT:-}

Exécuter /git:pr avec les paramètres du workflow automatique :

/git:pr $MAIN_BRANCH $PROJECT --no-interaction

Paramètres :

  • $MAIN_BRANCH : branche de base (depuis .env.claude MAIN_BRANCH ou "main")
  • $PROJECT : projet GitHub (depuis .env.claude PROJECT ou vide)
  • --no-interaction : mode automatique, passer confirmations

Si /git:pr échoue (ex: branche inexistante, GitHub unreachable) :

  • Logger l'erreur dans workflow state
  • Exit code 1 avec message explicite

⏱️ Arrêter le timer

Nettoyage du workflow state :

# Supprimer le fichier de workflow state
rm -f ".claude/data/workflows/issue-${issue_number}-dev-workflow-state.json"

Affichage final :

✅ SUCCÈS - Workflow terminé

🎉 Feature prête pour Pull Request
✅ CI PASSE (PHPStan niveau 9, tests)
📂 Worktree nettoyé
🔗 PR créée : https://github.com/...#<pr-number>

Affichage du récapitulatif des temps (voir section "Récapitulatif final")

Affichage du statut

Deux systèmes complémentaires :

  1. Task Management System : Les tâches sont automatiquement mises à jour, TaskList peut être consulté

  2. Affichage manuel avec timings : À chaque transition de phase, afficher le statut mis à jour avec timing :

🤖 Workflow automatique : {feature}

  ✅ 0. Prérequis  - Vérifier les outils        (1s)
  ✅ 1. Fetch      - Récupérer l'issue GitHub     (2s)
  ✅ 2. Discover   - Comprendre le besoin        (45s)
  ✅ 3. Explore    - Explorer codebase           (2m 30s)
  ✅ 4. Clarify    - Heuristiques automatiques   (20s)
  🔵 5. Design     - Architecture (Pragmatic)    ← En cours
  ⬜ 6. Plan       - Générer specs
  ⬜ 7. Code       - Implémenter
  ⬜ 8. Review     - Auto-fix × 3
  ⬜ 9. Cleanup    - Nettoyer worktree
  ⬜ 10. Create PR - Créer la Pull Request

Note : Le task system ne gère pas les timings, donc l'affichage manuel reste nécessaire pour montrer les durées.

Pas d'arrêt : exécution continue jusqu'à fin ou échec.

Affichage du timing

Format de durée

Formater les durées de manière lisible :

  • < 60s → {X}s (ex: 45s)
  • < 60min → {X}m {Y}s (ex: 2m 30s)
  • >= 60min → {X}h {Y}m (ex: 1h 15m)

Récapitulatif final

À la fin du workflow (après phase 7, avant cleanup), afficher :

⏱️ Récapitulatif des temps

  Phase 0. Prérequis :  1s
  Phase 1. Fetch     :  2s
  Phase 2. Discover  :  45s
  Phase 3. Explore   :  2m 30s
  Phase 4. Clarify   :  20s
  Phase 5. Design    :  1m 15s
  Phase 6. Plan      :  50s
  Phase 7. Code      :  8m 20s
  Phase 8. Review    :  2m 45s
  Phase 9. Cleanup   :  5s
  Phase 10. Create PR:  10s
  ────────────────────────────
  Total              : 17m 23s

Gestion des erreurs bloquantes

Si une phase échoue (ex: Phase 0, Phase 7)

1. Logger l'erreur

Mettre à jour .claude/data/workflows/issue-{issue_number}-dev-workflow-state.json :

{
  "status": "failed",
  "failedAt": "{ISO timestamp}",
  "failurePhase": {numéro},
  "failureReason": "Description de l'erreur",
  "errors": ["error1", "error2"]
}

2. Rollback automatique

git reset --hard HEAD@{0}

3. Cleanup worktree

/dev:worktree remove {feature-name}

Mettre à jour workflow state avec cleaned: true, branchDeleted: true, rollback: true.

4. Exit avec code d'erreur

❌ ÉCHEC du workflow automatique

Raison : {failureReason}
Phase échouée : {failurePhase}

Erreurs :
{liste des erreurs}

Le worktree a été nettoyé et la branche supprimée.
Utilise /dev:feature pour un workflow interactif.

Exit code: 1

Règles

  • Worktree OBLIGATOIRE en mode auto (création et cleanup)
  • 0 checkpoints utilisateur (aucune interaction)
  • Task Management :
    • Créer les 11 tâches (0-10) à l'initialisation
    • Mettre à jour le statut avant/après chaque phase (in_progress → completed)
    • Les tâches se mettent à jour automatiquement en mode auto
  • Timing enregistré pour chaque phase dans workflow state JSON
  • CI DOIT PASSER (PHPStan niveau 9, tests)
  • Rollback automatique en cas d'erreur bloquante
  • Cleanup automatique avant création PR
  • PR créée automatiquement via /git:pr
  • Mettre à jour .claude/data/workflows/issue-{issue_number}-dev-workflow-state.json après chaque phase
  • Afficher le statut à chaque transition (task system + timings)
  • Ne jamais sauter de phase (0 à 10 obligatoires)

Cas limites

Ambiguïté non-résoluble (Phase 0)

Description : "Ajouter auth"
→ Trop vague (OAuth? Basic? JWT?)

Action : FAIL dans discover
Message : "Description trop ambiguë pour mode auto.
           Précise : OAuth? Basic Auth? JWT?
           Ou utilise /dev:feature pour mode interactif."
Exit code: 1

Conflit worktree existant

Nom feature : "oauth-auth"
Worktree .worktrees/oauth-auth existe déjà

Action : Suffixe automatique
→ .worktrees/oauth-auth-2
Et logger warning dans workflow state

Branche feature existe déjà

Vérifier avec git show-ref refs/heads/feature/{name}. Si existe → FAIL dans initialisation.

Comparaison avec /dev:feature

Aspect/dev:feature/dev:auto:feature
InputDescription texte libreNuméro issue GitHub
Interaction5 checkpoints0 checkpoint
WorktreeOptionnelOBLIGATOIRE
Phase 3Questions utilisateurHeuristiques
Phase 4Choix utilisateurAuto Pragmatic
Phase 6Approbation requiseImmédiat
Phase 7Fix now/later/proceedAuto-fix × 3
Phase 8Proposer nettoyageCleanup auto
Phase 9Manuel : /git:prAuto : /git:pr + params
ErreursDemander aideRollback auto
ObjectifCollaborationAutomation

Objectif

Instructions à Exécuter

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

Phase 0 (Initialisation) du workflow automatisé : récupérer la specification depuis une issue GitHub.

Exécuté au démarrage du workflow avant Phase 1.

Instructions

1. Valider le paramètre

  • Vérifier que l'argument est un numéro valide
  • Exit avec erreur si pas un numéro
issue_number=$ARGUMENTS

if ! [[ "$issue_number" =~ ^[0-9]+$ ]]; then
    echo "❌ Erreur : l'argument doit être un numéro d'issue GitHub"
    echo "Usage: /dev:auto:feature 123"
    exit 1
fi

2. Récupérer l'issue

Utiliser gh issue view pour récupérer le contenu :

issue_data=$(gh issue view "$issue_number" --json title,body,labels,state)
issue_exists=$?

if [ $issue_exists -ne 0 ]; then
    echo "❌ Issue #$issue_number non trouvée"
    echo "Vérifie que :"
    echo "  1. Le numéro est correct"
    echo "  2. Tu es authentifié sur GitHub (gh auth login)"
    echo "  3. L'issue existe dans le repo courant"
    exit 1
fi

3. Parser les données

Extraire les champs nécessaires :

# Utiliser jq pour parser
issue_title=$(echo "$issue_data" | jq -r '.title')
issue_body=$(echo "$issue_data" | jq -r '.body')
issue_state=$(echo "$issue_data" | jq -r '.state')
issue_labels=$(echo "$issue_data" | jq -r '.labels | map(.name) | join(", ")')

4. Valider l'issue

  • Vérifier que l'issue est en state "OPEN"
  • Vérifier que la description n'est pas vide
if [ "$issue_state" != "OPEN" ]; then
    echo "❌ Issue #$issue_number n'est pas ouverte (state: $issue_state)"
    exit 1
fi

if [ -z "$issue_body" ] || [ "$issue_body" == "null" ]; then
    echo "⚠️  Issue #$issue_number : description vide"
    echo "Ajoute une description détaillée avant de relancer le workflow"
    exit 1
fi

5. Afficher les infos

🔗 Issue GitHub récupérée

  #$issue_number : $issue_title
  État : $issue_state
  Labels : $issue_labels

  Description :
  ───────────────────────────────
  $issue_body
  ───────────────────────────────

6. Sauvegarder dans le workflow state

Déterminer le chemin :

issue_number=$ARGUMENTS
workflow_state_file=".claude/data/workflows/issue-${issue_number}-dev-workflow-state.json"
mkdir -p ".claude/data/workflows"

Créer le fichier .dev-workflow-state.json :

{
  "mode": "auto",
  "issue": {
    "number": $issue_number,
    "title": "$issue_title",
    "description": "$issue_body",
    "labels": "$issue_labels",
    "state": "$issue_state",
    "fetchedAt": "{ISO timestamp}"
  },
  "feature": "$issue_title",
  "status": "in_progress",
  "startedAt": "{ISO timestamp}",
  "currentPhase": 0,
  "phases": {
    "0": {
      "status": "completed",
      "completedAt": "{ISO timestamp}",
      "durationMs": {durée}
    }
  }
}

7. Transférer à Phase 1

Passer la spec de l'issue à discover.md en paramètre :

spec="Issue #$issue_number: $issue_title\n\n$issue_body"
# Cette spec sera utilisée dans Phase 1 (Discover)

Règles

  • ✅ Valider le numéro (doit être entier)
  • ✅ Vérifier que l'issue existe (gh auth required)
  • ✅ Vérifier que l'issue est OPEN
  • ✅ Vérifier que la description n'est pas vide
  • ✅ Sauvegarder dans workflow state avec issue metadata
  • ✅ Afficher les infos pour transparence
  • ❌ Ne pas modifier l'issue (read-only)
  • ❌ Ne pas continuer si l'issue est invalide (exit 1)

Cas d'erreur

Issue non trouvée

❌ Issue #123 non trouvée
Vérifie que :
  1. Le numéro est correct
  2. Tu es authentifié sur GitHub (gh auth login)
  3. L'issue existe dans le repo courant

Issue fermée

❌ Issue #123 n'est pas ouverte (state: CLOSED)

Description vide

⚠️  Issue #123 : description vide
Ajoute une description détaillée avant de relancer le workflow

Dépendances

  • gh CLI installé et authentifié (gh auth login)
  • Exécuté depuis le repo contenant l'issue

Objectif

Instructions à Exécuter

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

Phase 5 du workflow automatisé : générer un plan d'implémentation détaillé basé sur l'architecture choisie SANS interaction.

Instructions

1. Lire le contexte

Déterminer le chemin du workflow state :

workflow_state_file=".claude/data/workflows/issue-${issue_number}-dev-workflow-state.json"
  • Lire le workflow state pour récupérer :
    • La feature description
    • Les décisions de clarification (Phase 3)
    • L'architecture choisie (Phase 4)
  • Si phases précédentes non complétées, exit avec erreur code 1

2. Générer le plan

Créer le fichier docs/specs/feature-{nom-kebab-case}.md avec le contenu suivant :

# Plan d'implémentation : {Feature Name}

## Résumé

**Feature :** {description}
**Approche :** {nom de l'approche choisie}
**Date :** {date du jour}

## Contexte

### Problème résolu
{description du problème}

### Décisions prises
- {décision 1}
- {décision 2}

## Architecture

### Composants
| Composant | Responsabilité | Fichier |
|-----------|---------------|---------|
| {nom} | {description} | `{chemin}` |

### Diagramme de flux

{représentation ASCII du flux}


## Plan d'implémentation

### Étape 1 : {titre}
- [ ] {tâche 1}
- [ ] {tâche 2}

**Fichiers :**
- `{chemin}` : {description}

### Étape 2 : {titre}
- [ ] {tâche 1}
- [ ] {tâche 2}

**Fichiers :**
- `{chemin}` : {description}

...

## Tests

### Tests unitaires
- [ ] {test 1}
- [ ] {test 2}

### Tests d'intégration
- [ ] {test 1}

3. Sauvegarder le chemin du plan

Mettre à jour le workflow state :

{
  "currentPhase": 5,
  "phases": {
    "5": {
      "status": "completed",
      "completedAt": "{ISO timestamp}",
      "durationMs": {durée},
      "planPath": "docs/specs/feature-{nom-kebab-case}.md",
      "components": ["{liste des composants}"],
      "implementationSteps": {nombre}
    }
  }
}

Règles

  • ✅ Mode automatique : aucune interaction
  • ✅ Générer le plan basé sur les phases précédentes
  • ✅ Créer le fichier docs/specs/ avec chemin correct
  • ✅ Documenter chaque étape d'implémentation
  • ❌ Jamais demander confirmation
  • ✅ Exit 1 si phases précédentes manquantes

Objectif

Instructions à Exécuter

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

Phase 7 du workflow automatisé : review de qualité avec correction automatique.

Boucle auto-fix max 3 tentatives. Si ça échoue → ROLLBACK + CLEANUP + EXIT 1.

Instructions

1. Lire le contexte

Déterminer le chemin du workflow state :

# Récupérer issue_number depuis le contexte
workflow_state_file=".claude/data/workflows/issue-${issue_number}-dev-workflow-state.json"
  • Lire le workflow state pour les fichiers modifiés (Phase 6)
  • Si phase 6 non complétée, exit avec erreur

2. Détecter les langages du projet

# Déterminer les langages présents (peut être multi-langage)
LANGUAGES=()
QA_TOOLS=()

# Vérifier PHP
if [ -f "composer.json" ] && [ -f "vendor/bin/phpstan" ]; then
    LANGUAGES+=("php")
    QA_TOOLS+=("phpstan")
fi

# Vérifier JavaScript
if [ -f "package.json" ]; then
    LANGUAGES+=("javascript")
    # Utiliser eslint ou prettier selon disponibilité
    if command -v eslint &> /dev/null; then
        QA_TOOLS+=("eslint")
    fi
fi

# Vérifier Go
if [ -f "go.mod" ]; then
    LANGUAGES+=("go")
    QA_TOOLS+=("golangci-lint")
fi

if [ ${#LANGUAGES[@]} -eq 0 ]; then
    echo "⚠️ Aucun langage détecté. Skipping review automatique."
    exit 0
fi

3. Boucle de correction automatique (max 3 tentatives par langage)

# Lancer la review pour CHAQUE langage
for i in "${!LANGUAGES[@]}"; do
    language="${LANGUAGES[$i]}"
    tool="${QA_TOOLS[$i]}"

    echo ""
    echo "🔍 Reviewing $language (outil: $tool)..."

    attempt=1
    max_attempts=3
    qa_exit_code=0

    while [ $attempt -le $max_attempts ]; do
        echo "  Tentative $attempt/$max_attempts..."

        # 1. Lancer l'outil de qualité
        case "$language" in
            "php")
                qa_output=$(vendor/bin/phpstan analyse --level=9 2>&1)
                qa_exit_code=$?
                qa_errors=$(echo "$qa_output" | grep -c "error:" || true)
                qa_name="PHPStan niveau 9"
                ;;
            "javascript")
                qa_output=$(eslint . 2>&1)
                qa_exit_code=$?
                qa_errors=$(echo "$qa_output" | grep -c "error" || true)
                qa_name="ESLint"
                ;;
            "go")
                qa_output=$(golangci-lint run 2>&1)
                qa_exit_code=$?
                qa_name="golangci-lint"
                ;;
        esac

        # 2. Vérifier succès
        if [ $qa_exit_code -eq 0 ]; then
            echo "  ✅ $qa_name : PASS"
            break  # Success for this language!
        fi

        echo "  ⚠️ $qa_name : erreurs détectées"

        # 3. Auto-fix si applicable
        if [ "$language" = "php" ] && [ $attempt -lt $max_attempts ]; then
            echo "  🔧 Auto-fix en cours..."
            /qa:phpstan
        fi

        attempt=$((attempt + 1))
    done

    # 4. Vérifier succès final pour ce langage
    if [ $qa_exit_code -ne 0 ]; then
        echo "❌ ÉCHEC : $qa_name impossible après $max_attempts tentatives"
        echo ""
        echo "Erreurs :"
        echo "$qa_output"
        echo ""
        exit 1
    fi
done

# 5. Elegant Objects review (si PHP)
if [[ " ${LANGUAGES[@]} " =~ " php " ]]; then
    echo ""
    echo "🔍 Elegant Objects review..."
    elegant_output=$(/qa:elegant-objects 2>&1)
fi

echo ""
echo "✅ Review automatique complète (tous les langages)"

4. Consolider les résultats

Afficher un résumé :

🔍 Résultats de la review automatique

**Langage détecté :** {PROJECT_LANGUAGE}

**Outil de qualité :** {QA_TOOL}
✅ PASS (0 erreur après $attempt tentative(s))

**Elegant Objects (si PHP) :**
- Score : {score}/100
- Violations : {nombre}
- Status : {warning|pass}

**Tentatives :**
- Tentative 1 : 5 erreurs → 2 erreurs
- Tentative 2 : 2 erreurs → 0 erreurs ✅

5. Mettre à jour le workflow state

{
  "currentPhase": 7,
  "phases": {
    "7": {
      "status": "completed",
      "completedAt": "{ISO timestamp}",
      "durationMs": {durée},
      "autoFixes": [
        {
          "attempt": 1,
          "tool": "phpstan",
          "errorsBefore": 5,
          "errorsAfter": 2,
          "duration": "15s"
        },
        {
          "attempt": 2,
          "tool": "phpstan",
          "errorsBefore": 2,
          "errorsAfter": 0,
          "duration": "8s"
        }
      ],
      "finalStatus": {
        "phpstan": "passed",
        "elegantObjects": {
          "score": 85,
          "violations": 3,
          "status": "warning"
        }
      }
    }
  }
}

Critères d'abandon (FAIL)

  • PHPStan niveau 9 : 3 tentatives max → FAIL si toujours des erreurs
  • Elegant Objects violations : LOG WARNING mais continuer (non-bloquant pour CI)
  • Tests unitaires : Si Phase 5 inclut des tests et ils échouent → FAIL

Gestion des erreurs bloquantes

Si PHPStan échoue après 3 tentatives :

1. **Loguer l'erreur** dans `.dev-workflow-state.json` :
   ```json
   {
     "status": "failed",
     "failedAt": "{ISO timestamp}",
     "failurePhase": 7,
     "failureReason": "PHPStan niveau 9 impossible après 3 tentatives",
     "errors": ["{error1}", "{error2}"]
   }
  1. Déclencher ROLLBACK (à implémenter dans feature.md)
  2. Cleanup worktree automatique
  3. Exit code 1

Message d'erreur :

❌ ÉCHEC du workflow automatique

Raison : PHPStan niveau 9 impossible après 3 tentatives
Phase : 6 (Review)

Erreurs détectées :
{erreurs}

Le worktree a été nettoyé et la branche supprimée.

Utilise /dev:feature pour un workflow interactif avec review manuel.

# Règles

- ✅ **Boucle auto-fix max 3 tentatives**
- ✅ **PHPStan niveau 9 DOIT passer**
- ⚠️ **Elegant Objects** : warning seulement (non-bloquant)
- ❌ **Zéro demande "Fix now/later/proceed"**
- ✅ **Documenter chaque tentative**
- ✅ **FAIL et ROLLBACK si impossible**

Configuration de sortie

Instructions à Exécuter

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

IMPORTANT : Cette skill génère des questions structurées 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.

Output-style requis : table-based

Objectif

Phase 2 du workflow de développement : identifier et résoudre toutes les ambiguités avant de designer l'architecture.

Instructions

1. Lire le contexte

  • Lire .claude/data/.dev-workflow-state.json pour la feature et les findings de l'exploration
  • Si le fichier n'existe pas ou phase 1 non complétée, rediriger vers /dev:explore

2. Analyser les zones d'ombre

Identifier les aspects sous-spécifiés dans les catégories suivantes :

Edge cases

  • Que se passe-t-il si X est vide/null ?
  • Comment gérer les cas limites ?

Gestion d'erreurs

  • Quelles erreurs peuvent survenir ?
  • Comment les communiquer à l'utilisateur ?

Points d'intégration

  • Comment cette feature interagit avec l'existant ?
  • Y a-t-il des dépendances circulaires à éviter ?

Rétrocompatibilité

  • Cette feature impacte-t-elle des fonctionnalités existantes ?
  • Y a-t-il des migrations de données nécessaires ?

Performance

  • Y a-t-il des contraintes de performance ?
  • Faut-il penser au caching ?

Sécurité

  • Quelles autorisations sont nécessaires ?
  • Y a-t-il des données sensibles à protéger ?

3. Présenter les questions

Utiliser AskUserQuestion pour présenter les questions de manière organisée

4. Attendre les réponses

⚠️ CRITIQUE : Ne PAS passer à la phase suivante avant d'avoir toutes les réponses.

5. Documenter les décisions

Mettre à jour le workflow state avec les réponses

Prochaine étape

✅ Clarifications complètes

Prochaine étape : /dev:design pour proposer des architectures

Règles

  • Ne PAS proposer d'architecture à ce stade
  • Ne PAS faire de suppositions - poser des questions
  • Documenter TOUTES les décisions prises

Objectif

Phase 5 du workflow de développement : implémenter la feature selon le plan généré.

Variables

PATH_TO_PLAN: $ARGUMENTS

Instructions à Exécuter

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

1. Vérifier le contexte et charger le plan

  • Extrais PATH_TO_PLAN depuis $ARGUMENTS
  • Si PATH_TO_PLAN n'est pas fourni :
    • Lis .claude/data/.dev-workflow-state.json avec Read
    • Extrais planPath du JSON
  • Si toujours pas de plan, affiche une erreur et arrête

2. Demander approbation avant implémentation

⚠️ CRITIQUE : Ne PAS commencer l'implémentation sans approbation explicite.

Attendre confirmation avant de continuer.

3. Lire le plan

  • Lire le fichier plan complet
  • Extraire les étapes d'implémentation
  • Identifier les fichiers à créer/modifier

4. Implémenter étape par étape

Pour chaque étape du plan :

  1. Créer une todo pour l'étape
  2. Lire les fichiers concernés (si modification)
  3. Implémenter le code
  4. Respecter :
    • Les conventions du projet (CLAUDE.md)
    • Les patterns identifiés dans l'exploration
    • Les décisions prises en phase 2
  5. Marquer la todo comme complétée

5. Créer les tests

  • Créer les tests unitaires spécifiés dans le plan
  • Suivre l'approche TDD si possible
  • S'assurer que les tests passent

6. Vérifications qualité

Lancer les vérifications :

make phpstan    # PHPStan niveau 9
make fix        # Formatage PSR-12

⚠️ Corriger TOUTES les erreurs PHPStan avant de continuer.

7. Mettre à jour le workflow state

8. Rapport

Règles

  • Approbation obligatoire avant de commencer
  • PHPStan = 0 erreurs (bloquant CI)
  • Respecter le plan (pas d'improvisation)
  • Tests pour chaque composant
  • Conventions françaises pour les variables et documentation

Debug - Analyse et Résolution d'Erreurs

Instructions à Exécuter

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

Analyser une erreur (message ou stack trace) et proposer/appliquer résolution.

Variables

  • ERROR_INPUT: $ARGUMENTS
  • ERROR_TYPE: Type détecté (simple message vs stack trace)
  • CONTEXT_FILES: Fichiers pertinents
  • RESOLUTION_PLAN: Plan structuré si résolution demandée

Détection Automatique

Le système détecte automatiquement :

  • Stack trace : Parsing + formatage + analyse approfondie
  • Message simple : Analyse directe + diagnostic

Patterns stack trace :

  • Fatal error:, Uncaught, Exception, Error:
  • Présence de at <file>:<line>
  • Multiple lignes avec indentation/numéros

Workflow

1. Identification Type

Si stack trace détectée :

  • Parser trace (type, message, fichier:ligne, call stack)
  • Formater hiérarchiquement
  • Lire code source ligne incriminée
  • Générer rapport /tmp/stack-trace-analysis-[timestamp].md

Si message simple :

  • Catégoriser (syntaxe, runtime, logique, config)
  • Extraire infos contextuelles

2. Analyse Contexte

  • Examiner fichiers mentionnés
  • Analyser logs récents corrélés
  • Vérifier environnement (deps, config)
  • Identifier changements récents (git)

3. Diagnostic

  • Cause racine vs symptômes
  • Impact et criticité
  • Solutions possibles + trade-offs
  • Priorisation

4. Solutions

Stack trace : 3 niveaux

  1. Quick Fix ⚡ : Rapide, symptôme
  2. Recommandée ✅ : Équilibrée, cause
  3. Long-terme 🎯 : Robuste, prévention

Message simple : Plan résolution

  • Étapes séquencées
  • Tests validation
  • Rollbacks prévus
  • Risques estimés

5. Exécution (optionnel)

Si utilisateur demande résolution :

  • Appliquer corrections pas à pas
  • Valider chaque modif
  • Vérifier résolution complète
  • Documenter changements

Exemples

# Stack trace PHP
/dev:debug "Fatal error: Call to undefined method User::getName()"

# Fichier log
/dev:debug /var/log/app.log

# Message NPM
/dev:debug "npm ERR! missing script: build"

Best Practices

  • Détecter type avant traiter
  • Parser intelligemment selon langage
  • Lire code source pour contexte
  • Solutions testables avec exemples
  • Corrections incrémentales si exécution
  • Validation systématique après chaque change

Configuration de sortie

Instructions à Exécuter

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

IMPORTANT : Cette skill génère une comparaison d'architectures 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.

Output-style requis : table-based

Objectif

Phase 3 du workflow de développement : proposer plusieurs approches architecturales et aider l'utilisateur à choisir.

Prérequis

⚠️ Plugin feature-dev requis pour les agents code-architect.

Si non installé :

/plugin install feature-dev@claude-code-plugins

Instructions

1. Lire le contexte

  • Lire .claude/data/.dev-workflow-state.json pour la feature, les findings et les décisions
  • Si phases précédentes non complétées, rediriger vers la phase manquante

2. Lancer les agents code-architect

Lancer 2-3 agents code-architect en parallèle avec des focus différents :

Agent 1 : Minimal changes

Agent 2 : Clean architecture

Agent 3 : Pragmatic balance

3. Consolider et comparer

Présenter les approches de manière structurée

4. Demander le choix de l'utilisateur

⚠️ CRITIQUE : Attendre le choix avant de passer à la phase suivante.

5. Documenter l'architecture choisie

Mettre à jour le workflow state

Prochaine étape

✅ Architecture choisie

Prochaine étape : /dev:plan pour générer le plan d'implémentation

Configuration de sortie

IMPORTANT : Cette skill génère un résumé de compréhension structuré 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.

Output-style requis : bullet-points

Objectif

Instructions à Exécuter

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

Phase 0 du workflow de développement : comprendre le besoin utilisateur avant de coder.

Feature demandée

$ARGUMENTS

Instructions

1. Analyser la demande

  • Si la demande est claire et complète, passer à l'étape 2
  • Si la demande est ambiguë ou incomplète, poser des questions pour clarifier :
    • Quel problème cette feature résout-elle ?
    • Qui sont les utilisateurs cibles ?
    • Quelles sont les contraintes connues ?

2. Explorer le contexte

  • Chercher si des fichiers similaires existent déjà dans le projet
  • Lire CLAUDE.md et .ai/ pour comprendre les conventions
  • Identifier les patterns architecturaux utilisés

3. Résumer la compréhension

Présenter un résumé structuré :

📋 Résumé de la demande

**Feature :** {titre court}

**Problème résolu :**
{description du problème}

**Utilisateurs cibles :**
{qui utilisera cette feature}

**Contraintes identifiées :**
- {contrainte 1}
- {contrainte 2}

**Contexte technique :**
- {pattern existant pertinent}
- {fichiers existants liés}

4. Confirmer avec l'utilisateur

Demander confirmation avant de passer à la phase suivante :

✅ Est-ce que cette compréhension est correcte ?

Prochaine étape : /dev:explore pour analyser le codebase

Mise à jour du workflow state

Créer ou mettre à jour .claude/data/.dev-workflow-state.json (créer le répertoire si nécessaire)

Règles

  • Ne PAS commencer à coder
  • Ne PAS proposer d'architecture
  • Se concentrer sur la COMPRÉHENSION du besoin
  • Poser des questions si quelque chose n'est pas clair

Configuration de sortie

IMPORTANT : Cette skill génère un résumé d'exploration structuré 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.

Output-style requis : bullet-points

Objectif

Instructions à Exécuter

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

Phase 1 du workflow de développement : explorer le codebase pour comprendre les patterns existants.

Prérequis

⚠️ Plugin feature-dev requis pour les agents code-explorer.

Si non installé :

/plugin install feature-dev@claude-code-plugins

Instructions

1. Lire le contexte

  • Lire .claude/data/.dev-workflow-state.json pour connaître la feature en cours
  • Si le fichier n'existe pas, demander à l'utilisateur de lancer /dev:discover d'abord

2. Créer les tâches d'exploration

Utiliser TaskCreate pour chaque agent :

TaskCreate #1: Explorer features similaires (code-explorer)
TaskCreate #2: Mapper architecture et abstractions (code-explorer)
TaskCreate #3: Analyser intégrations (code-explorer) - optionnel
TaskCreate #4: Consolider résultats et présenter résumé

Important :

  • Utiliser activeForm (ex: "Explorant features similaires", "Mappant l'architecture")
  • Tâche #3 optionnelle selon pertinence de la feature
  • Tâche #4 bloquée par les agents 1-3 (utiliser addBlockedBy)
  • Les agents 1-3 se lancent en parallèle

3. Lancer les agents code-explorer

⚠️ Avant de lancer les agents : Marquer les tâches en in_progress :

  • TaskUpdate → tâche #1 en in_progress
  • TaskUpdate → tâche #2 en in_progress
  • TaskUpdate → tâche #3 en in_progress (si créée)

Lancer 2-3 agents code-explorer en parallèle avec des focus différents :

Agent 1 : Features similaires

Trouve des features similaires à "{feature}" dans le codebase.
Trace leur implémentation de bout en bout.
Retourne les 5-10 fichiers clés à lire.

Quand terminé : TaskUpdate → tâche #1 en completed

Agent 2 : Architecture

Mappe l'architecture et les abstractions pour la zone concernée par "{feature}".
Identifie les patterns utilisés (repositories, services, events, etc.).
Retourne les 5-10 fichiers clés à lire.

Quand terminé : TaskUpdate → tâche #2 en completed

Agent 3 : Intégrations (si pertinent)

Analyse les points d'intégration existants (APIs, events, commands).
Identifie comment les features communiquent entre elles.
Retourne les 5-10 fichiers clés à lire.

Quand terminé : TaskUpdate → tâche #3 en completed

4. Consolider les résultats

🔄 Progression : TaskUpdate → tâche #4 en in_progress

  • Fusionner les listes de fichiers identifiés
  • Lire les fichiers clés pour construire une compréhension profonde
  • Identifier les patterns récurrents

5. Présenter le résumé

🔍 Exploration du codebase

**Features similaires trouvées :**
- {feature 1} ({chemin}) : {description courte}
- {feature 2} ({chemin}) : {description courte}

**Patterns architecturaux identifiés :**
- {pattern 1} : utilisé dans {fichiers}
- {pattern 2} : utilisé dans {fichiers}

**Fichiers clés à connaître :**
1. `{fichier}:{ligne}` - {rôle}
2. `{fichier}:{ligne}` - {rôle}
...

**Points d'attention :**
- {observation 1}
- {observation 2}

6. Finaliser

🔄 Progression : TaskUpdate → tâche #4 en completed

Mettre à jour .claude/data/.dev-workflow-state.json

Task Management

Progression du workflow :

  • 4 tâches créées à l'initialisation (3 ou 4 selon pertinence)
  • Les 3 premières tâches (agents) se lancent en parallèle
  • La tâche #4 (consolidation) est bloquée par les 3 agents (addBlockedBy)
  • Chaque agent marque sa tâche comme completed indépendamment
  • Utiliser TaskList pour voir la progression des agents parallèles
  • Les tâches permettent à l'utilisateur de suivre l'exploration multi-agents

Prochaine étape

✅ Exploration terminée

Prochaine étape : /dev:clarify pour poser les questions de clarification

Objectif

Orchestrateur du workflow de développement en 8 phases. Enchaîne automatiquement toutes les étapes avec des checkpoints utilisateur.

Feature demandée

$ARGUMENTS

Prérequis

⚠️ Plugin feature-dev requis pour les agents spécialisés.

Si non installé, afficher :

⚠️ Pour une expérience optimale, installe le plugin feature-dev :
/plugin install feature-dev@claude-code-plugins

Ce plugin fournit les agents :
- code-explorer (exploration codebase)
- code-architect (design architecture)
- code-reviewer (review qualité)

Continuer sans ces agents ? (Les phases 1, 3, 6 seront simplifiées)

Instructions à Exécuter

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

Initialisation

1. Proposition de worktree (optionnel)

  • Utilise AskUserQuestion pour demander à l'utilisateur s'il souhaite créer un worktree pour cette feature :
📂 Créer un worktree pour cette feature ?

Avantages des worktrees :
  • Garder votre branche main propre
  • Travailler sur plusieurs features en parallèle
  • Préserver le contexte de développement (IDE, serveur, tests)
  • Pas besoin de stash ou de switcher de branche

Le worktree sera créé dans : .worktrees/{feature-slug}

Créer le worktree ? (o/n)

Si oui :

  • Normaliser le nom de la feature en slug (kebab-case)
  • Créer le worktree avec /dev:worktree create {feature-slug}
  • Informer l'utilisateur du chemin et qu'il doit relancer Claude Code dans le worktree
  • ARRÊTER le workflow avec un message :
    ✅ Worktree créé : .worktrees/{feature-slug}
    
    Pour continuer le workflow :
      1. cd .worktrees/{feature-slug}
      2. Relancer Claude Code
      3. /dev:feature {description}
    

Si non : Continuer le workflow normalement.

  1. Créer le fichier .claude/data/.dev-workflow-state.json (créer le répertoire .claude/data/ si nécessaire)

  2. Créer les tâches du workflow

Utiliser TaskCreate pour chaque phase :

TaskCreate #0: Discover - Comprendre le besoin
TaskCreate #1: Explore - Explorer codebase
TaskCreate #2: Clarify - Questions clarification
TaskCreate #3: Design - Proposer architectures
TaskCreate #4: Plan - Générer specs
TaskCreate #5: Code - Implémenter
TaskCreate #6: Review - QA complète
TaskCreate #7: Summary - Résumé final
TaskCreate #8: Cleanup - Nettoyer worktree (si créé)

Important :

  • Utiliser activeForm (ex: "Comprenant le besoin", "Explorant le codebase")
  • Ne créer la tâche #8 que si worktree créé
  • Les tâches suivent l'ordre d'exécution (0→7 ou 0→8)

Gestion du timing et progression

Avant chaque phase :

  1. Utiliser TaskUpdate pour marquer la tâche comme in_progress
  2. Enregistrer le timestamp de début dans .claude/data/.dev-workflow-state.json

Après chaque phase :

  1. Calculer la durée et mettre à jour le fichier d'état
  2. Utiliser TaskUpdate pour marquer la tâche comme completed

Phase 0 : Discover

  1. TaskUpdate → tâche #0 en in_progress
  2. Exécuter le contenu de /dev:discover
  3. Checkpoint : Confirmer que la compréhension est correcte
  4. TaskUpdate → tâche #0 en completed

Phase 1 : Explore

  1. TaskUpdate → tâche #1 en in_progress
  2. Exécuter le contenu de /dev:explore
  3. TaskUpdate → tâche #1 en completed

Phase 2 : Clarify

  1. TaskUpdate → tâche #2 en in_progress
  2. Exécuter le contenu de /dev:clarify
  3. Checkpoint : Attendre toutes les réponses
  4. TaskUpdate → tâche #2 en completed

Phase 3 : Design

  1. TaskUpdate → tâche #3 en in_progress
  2. Exécuter le contenu de /dev:design
  3. Checkpoint : Attendre le choix de l'architecture
  4. TaskUpdate → tâche #3 en completed

Phase 4 : Plan

  1. TaskUpdate → tâche #4 en in_progress
  2. Exécuter le contenu de /dev:plan
  3. TaskUpdate → tâche #4 en completed

Phase 5 : Code

  1. Checkpoint : Demander approbation avant de commencer
  2. TaskUpdate → tâche #5 en in_progress
  3. Exécuter le contenu de /dev:code
  4. TaskUpdate → tâche #5 en completed

Phase 6 : Review

  1. TaskUpdate → tâche #6 en in_progress
  2. Exécuter le contenu de /dev:review
  3. Checkpoint : Demander action (fix now / fix later / proceed)
  4. TaskUpdate → tâche #6 en completed

Phase 7 : Summary

  1. TaskUpdate → tâche #7 en in_progress
  2. Exécuter le contenu de /dev:summary
  3. Calculer le temps total et afficher le récapitulatif des temps
  4. TaskUpdate → tâche #7 en completed

Phase 8 : Cleanup (optionnel)

  1. Si un worktree a été créé :
    • TaskUpdate → tâche #8 en in_progress
    • Proposer de nettoyer le worktree
    • TaskUpdate → tâche #8 en completed

Affichage du statut

Deux systèmes complémentaires :

  1. Task Management System : Utiliser TaskList pour afficher l'état des tâches (pending/in_progress/completed)

  2. Affichage manuel avec timings : À chaque transition de phase, afficher :

🔄 Workflow de développement : {feature}

  ✅ 0. Discover   - Comprendre le besoin        (1m 23s)
  ✅ 1. Explore    - Explorer codebase           (2m 45s)
  🔵 2. Clarify    - Questions clarification  ← En cours
  ⬜ 3. Design     - Proposer architectures
  ⬜ 4. Plan       - Générer specs
  ⬜ 5. Code       - Implémenter
  ⬜ 6. Review     - QA complète
  ⬜ 7. Summary    - Résumé final
  ⬜ 8. Cleanup    - Nettoyer worktree (si créé)

Note : Le task system ne gère pas les timings, donc l'affichage manuel reste nécessaire pour montrer les durées.

Règles

  • Proposition de worktree à l'initialisation (optionnel)
  • Checkpoints obligatoires aux phases 0, 2, 3, 5, 6
  • Ne jamais sauter de phase (0-7)
  • Phase 8 (Cleanup) uniquement si un worktree a été créé
  • Task Management :
    • Créer toutes les tâches à l'initialisation
    • Mettre à jour le statut avant/après chaque phase
    • Utiliser TaskList pour afficher la progression
  • Mettre à jour .claude/data/.dev-workflow-state.json après chaque phase (pour les timings)
  • Afficher le statut à chaque transition (task system + timings)
  • Si l'utilisateur interrompt, il peut reprendre avec /dev:status + la commande de la phase suivante
  • Worktrees : Toutes les métadonnées sont dans .claude/data/.dev-worktrees.json

Commande d'aide

Si l'utilisateur tape /dev:feature sans arguments, afficher l'aide complète.

Ajout de logging avec LoggableInterface

Instructions à Exécuter

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

Fichier cible : $ARGUMENTS

Workflow

1. Lire et analyser le fichier

  • Lire le contenu du fichier PHP
  • Identifier la classe principale et ses propriétés
  • Vérifier si LoggableInterface est déjà implémentée

2. Chercher les dépendances LoggableInterface

Pour chaque type-hint de propriété ou paramètre :

  • Utiliser Grep pour chercher si la classe implémente LoggableInterface
  • Noter les classes qui l'implémentent pour appeler ->toLog() dessus

3. Ajouter LoggableInterface

Si la classe n'implémente pas encore LoggableInterface :

Ajouter l'import :

use Atournayre\Contracts\Log\LoggableInterface;

Ajouter l'interface à la déclaration de classe :

final class NomClasse implements LoggableInterface

Ajouter la méthode toLog() :

/**
 * @return array<string, mixed>
 */
public function toLog(): array
{
    return [
        // Propriétés clés de l'objet
    ];
}

4. Règles pour le contenu de toLog()

Propriétés à inclure :

  • id (si présent)
  • Identifiants métier (email, code, référence...)
  • États/statuts importants
  • Dates clés (createdAt, updatedAt...)

Propriétés à exclure :

  • Mots de passe, tokens, secrets
  • Données personnelles sensibles
  • Propriétés volumineuses (blobs, textes longs)

Pour les objets imbriqués :

  • Si l'objet implémente LoggableInterface : 'relation' => $this->relation->toLog()
  • Sinon : 'relationId' => $this->relation->getId() ou ignorer

Pour les collections :

/**
 * @return array{count: int, items: array<int, array<string, mixed>>}
 */
public function toLog(): array
{
    return [
        'count' => $this->count(),
        'items' => array_map(fn ($item) => $item->toLog(), $this->items),
    ];
}

5. Vérification PHPStan

  • Toujours ajouter @return array<string, mixed> sur la méthode
  • Pour les collections : utiliser le type array shape approprié

Exemple de résultat

use Atournayre\Contracts\Log\LoggableInterface;

final class Commande implements LoggableInterface
{
    private Uuid $id;
    private string $reference;
    private Client $client;
    private \DateTimeImmutable $createdAt;
    private string $password; // Sensible, à exclure

    /**
     * @return array<string, mixed>
     */
    public function toLog(): array
    {
        return [
            'id' => $this->id->toRfc4122(),
            'reference' => $this->reference,
            'client' => $this->client->toLog(),
            'createdAt' => $this->createdAt->format('c'),
            // password exclu intentionnellement
        ];
    }
}

OneShot

Implement $ARGUMENTS at maximum speed. Ship fast, iterate later.

Workflow

1. EXPLORE (minimal)

Gather minimum viable context:

  • Use Glob to find 2-3 key files by pattern
  • Use Grep to search for specific patterns
  • Quick WebSearch only if library-specific API knowledge needed
  • NO exploration tours - find examples/edit targets and move on

2. CODE (main phase)

Execute changes immediately:

  • Follow existing codebase patterns exactly
  • Clear variable/method names over comments
  • Stay STRICTLY in scope - change only what's needed
  • NO comments unless genuinely complex
  • NO refactoring beyond requirements
  • Run formatters if available (npm run format)

3. TEST (validate)

Check quality:

  • Run: npm run lint && npm run typecheck (or equivalent)
  • If fails: fix only what you broke, re-run
  • NO full test suite unless explicitly requested

Output

When complete, return:

## Done

**Task:** {what was implemented}
**Files changed:** {list}
**Validation:** ✓ lint ✓ typecheck

Constraints

  • ONE task only - no tangential improvements
  • NO documentation files unless requested
  • NO refactoring outside immediate scope
  • NO "while I'm here" additions
  • If stuck >2 attempts: report blocker and stop

Objectif

Phase 4 du workflow de développement : générer un plan d'implémentation détaillé basé sur l'architecture choisie.

Instructions

Instructions à Exécuter

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

1. Créer les tâches de planification

Utiliser TaskCreate pour chaque étape :

TaskCreate #1: Lire le contexte du workflow
TaskCreate #2: Créer le répertoire docs/specs
TaskCreate #3: Générer le plan d'implémentation
TaskCreate #4: Afficher le résumé
TaskCreate #5: Mettre à jour le workflow state

Important :

  • Utiliser activeForm (ex: "Lisant le contexte", "Générant le plan")
  • 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

2. Lire le contexte

🔄 Progression : TaskUpdate → tâche #1 en in_progress

  • Lire .claude/data/.dev-workflow-state.json pour récupérer :
    • La feature description
    • Les décisions de clarification
    • L'architecture choisie
  • Si phases précédentes non complétées, rediriger vers la phase manquante

🔄 Progression : TaskUpdate → tâche #1 en completed

3. Créer le répertoire si nécessaire

🔄 Progression : TaskUpdate → tâche #2 en in_progress

mkdir -p docs/specs

🔄 Progression : TaskUpdate → tâche #2 en completed

4. Générer le plan

🔄 Progression : TaskUpdate → tâche #3 en in_progress

Créer le fichier docs/specs/feature-{nom-kebab-case}.md avec la structure complète du plan

🔄 Progression : TaskUpdate → tâche #3 en completed

5. Afficher le résumé

🔄 Progression : TaskUpdate → tâche #4 en in_progress

Présenter le plan généré.

🔄 Progression : TaskUpdate → tâche #4 en completed

6. Mettre à jour le workflow state

🔄 Progression : TaskUpdate → tâche #5 en in_progress

Mettre à jour .claude/data/.dev-workflow-state.json

🔄 Progression : TaskUpdate → tâche #5 en completed

Task Management

Progression du workflow :

  • 5 tâches créées à l'initialisation
  • Chaque étape suit le pattern : in_progress → exécution → completed
  • La tâche #3 (génération du plan) est la plus importante
  • Utiliser TaskList pour voir la progression
  • Les tâches permettent à l'utilisateur de suivre la création du plan d'implémentation

Prochaine étape

✅ Plan généré : docs/specs/feature-{nom}.md

Prochaine étape : /dev:code docs/specs/feature-{nom}.md

⚠️ L'implémentation nécessite ton approbation explicite.

Règles

  • Le plan doit être actionnable (pas de descriptions vagues)
  • Chaque étape doit avoir des fichiers et des tâches clairs
  • Les tests doivent être spécifiés avant l'implémentation
  • Respecter les conventions du projet (CLAUDE.md)
Set up the Ralph autonomous coding loop in any project. Ralph runs AI agents in a loop, picking tasks from a PRD, implementing one at a time, committing after each, and accumulating learnings until all tasks are complete.

This skill ONLY sets up Ralph - you run the commands yourself.

<quick_start> Setup Ralph interactively (recommended):

/setup-ralph -i

Setup for specific feature:

/setup-ralph -f 01-add-authentication

What this does:

  1. Creates .claude/ralph/ structure in your project
  2. Runs setup script to create all Ralph files
  3. (If -i): Brainstorms PRD with you interactively
  4. Transforms PRD into user stories (prd.json)
  5. Shows you the command to run Ralph (you run it yourself)

After setup, you run:

bun run .claude/ralph/ralph.sh -f <feature-name>

</quick_start>

<critical_rule> 🛑 NEVER run ralph.sh or any execution commands automatically 🛑 NEVER execute the loop - only set up files and show instructions ✅ ALWAYS let the user copy and run commands themselves ✅ ALWAYS end by showing the exact command to run </critical_rule>

<when_to_use> Use this skill when:

  • Starting a new feature that can be broken into small stories
  • Setting up Ralph in a new project
  • Creating a new feature PRD interactively

Don't use for:

  • Simple single-file changes
  • Exploratory work without clear requirements
  • Major refactors without acceptance criteria </when_to_use>
| Flag | Description | |------|-------------| | `` | Path to the project (defaults to current directory) | | `-i, --interactive` | Interactive mode: brainstorm PRD with AI assistance | | `-f, --feature ` | Feature folder name (e.g., `01-add-auth`) |

Examples:

/setup-ralph /path/to/project -i              # Interactive PRD creation
/setup-ralph . -f 01-add-auth                 # Setup for specific feature
/setup-ralph -i -f 02-user-dashboard          # Interactive with specific name

<state_variables>

VariableTypeDescription
{project_path}stringAbsolute path to target project
{ralph_dir}stringPath to .claude/ralph in project
{feature_name}stringFeature folder name (e.g., 01-add-auth)
{feature_dir}stringPath to task folder
{interactive_mode}booleanWhether to brainstorm PRD interactively
{prd_content}stringPRD markdown content
{user_stories}arrayUser stories extracted from PRD
{branch_name}stringGit branch for the feature
</state_variables>

<entry_point> Load steps/step-00-init.md </entry_point>

<step_files>

StepFilePurpose
00step-00-init.mdParse flags, run setup script, create structure
01step-01-interactive-prd.mdInteractive PRD brainstorming and creation
02step-02-create-stories.mdTransform PRD into user stories (prd.json)
03step-03-finish.mdShow run command (user runs it themselves)
</step_files>
| Script | Purpose | |--------|---------| | `scripts/setup.sh` | Creates all Ralph files in the project |

<execution_rules>

  1. Progressive Loading: Load one step at a time
  2. Script Execution: Use scripts/setup.sh to create files atomically
  3. Interactive Mode: If -i flag, run brainstorming conversation
  4. State Persistence: Track progress in feature_dir/progress.txt
  5. Resume Support: Detect existing PRD.md and resume from there
  6. NEVER RUN RALPH: Only setup and show commands - user runs them </execution_rules>

<success_criteria> ✅ Ralph structure created at {project_path}/.claude/ralph ✅ Feature folder created with PRD.md, prd.json, progress.txt ✅ User stories properly formatted in prd.json ✅ Clear run command provided to user (they run it themselves) </success_criteria>

Objectif

Phase 6 du workflow de développement : review qualité complète du code implémenté.

Prérequis

⚠️ Plugin feature-dev requis pour l'agent code-reviewer.

Si non installé :

/plugin install feature-dev@claude-code-plugins

Instructions à Exécuter

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

1. Vérifier le contexte

  • Lis .claude/data/.dev-workflow-state.json avec Read
  • Extrais les fichiers modifiés et l'état de la phase 5 (code)
  • Si phase 5 non complétée, affiche :
    ❌ La phase d'implémentation (code) n'est pas terminée
    
    Lance d'abord : /dev:code
    
    • Arrête le workflow

2. Créer les tâches de review

  • Utilise TaskCreate pour chaque tâche de review :
TaskCreate #1: Code Review - Simplicité/bugs/conventions (feature-dev)
TaskCreate #2: PHPStan - Résoudre erreurs niveau 9
TaskCreate #3: Elegant Objects - Conformité principes
TaskCreate #4: Consolider - Agréger résultats et décider
TaskCreate #5: Examine - Adversarial review (challenge decisions, edge cases)

Important :

  • Utiliser activeForm (ex: "Reviewing code quality", "Résolvant erreurs PHPStan")
  • Les 3 premières tâches peuvent se lancer en parallèle
  • La tâche #4 dépend des 3 premières (utiliser addBlockedBy)

3. Lancer les reviews en parallèle

⚠️ Avant de lancer les agents : Marquer les 3 tâches en in_progress :

  • TaskUpdate → tâche #1 en in_progress
  • TaskUpdate → tâche #2 en in_progress
  • TaskUpdate → tâche #3 en in_progress

Review 1 : Code Review (feature-dev)

Lancer l'agent code-reviewer avec le focus sur :

  • Simplicité / DRY / Élégance
  • Bugs / Correction fonctionnelle
  • Conventions du projet

Quand terminé : TaskUpdate → tâche #1 en completed

Review 2 : PHPStan

Lancer l'agent phpstan-error-resolver (local)

Quand terminé : TaskUpdate → tâche #2 en completed

Review 3 : Elegant Objects

Lancer l'agent elegant-objects-reviewer (local)

Quand terminé : TaskUpdate → tâche #3 en completed

4. Consolider les résultats

🔄 Progression : TaskUpdate → tâche #4 en in_progress

Agréger les résultats des 3 reviews.

Quand terminé : TaskUpdate → tâche #4 en completed

4.5. Examine (Adversarial Review) ⭐ NOUVEAU

🔄 Progression : TaskUpdate → tâche #5 en in_progress

Challenge l'implémentation avec perspective adversariale :

Questions à poser :

  • Edge cases : Qu'arrive-t-il si input null/vide/invalide ?
  • Limites : Quelle est la taille maximale acceptable ? Le timeout ?
  • Sécurité : Injection possible ? Exposition de données sensibles ?
  • Performance : N+1 queries ? Boucles infinies possibles ?
  • Concurrence : Race conditions ? Deadlocks ?
  • Rollback : Comment annuler si ça échoue en prod ?
  • Décisions d'architecture : Pourquoi ce pattern ? Alternative meilleure ?

Focus prioritaire :

  1. Chercher ce qui pourrait casser en production
  2. Identifier hypothèses non validées dans le code
  3. Tester mentalement scénarios extrêmes
  4. Challenger décisions d'implémentation (pourquoi X au lieu de Y ?)

Output :

🔍 Examine Results:

Edge cases trouvés:
- [cas] : [risque] → [suggestion]

Limites détectées:
- [limite] : [impact] → [mitigation]

Décisions challengées:
- [décision] : [alternative] → [trade-off]

Quand terminé : TaskUpdate → tâche #5 en completed

5. Demander l'action utilisateur

Que souhaites-tu faire ?

1. 🔧 Fix now - Corriger toutes les issues maintenant
2. 📋 Fix later - Noter pour plus tard et continuer
3. ✅ Proceed - Continuer sans corrections (non recommandé)

⚠️ Attendre la décision avant de continuer.

6. Si "Fix now" choisi

  • Appliquer les corrections PHPStan en priorité (bloquent la CI)
  • Appliquer les corrections Elegant Objects
  • Relancer une review pour vérifier

7. Finaliser

Mettre à jour le workflow state

Prochaine étape

✅ Review complétée

Prochaine étape : /dev:summary pour le résumé final

Règles

  • Task Management :
    • Créer 5 tâches au démarrage (3 reviews + 1 consolidation + 1 examine)
    • Marquer les 3 reviews en in_progress avant lancement parallèle
    • La tâche de consolidation est bloquée par les 3 reviews (addBlockedBy)
    • La tâche examine est bloquée par la consolidation (addBlockedBy)
    • Utiliser TaskList pour afficher la progression
  • PHPStan erreurs = BLOQUANT (font échouer la CI)
  • Confiance minimum 80% pour les issues code review
  • Respecter le choix utilisateur (ne pas forcer les corrections)

Configuration de sortie

Instructions à Exécuter

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

IMPORTANT : Cette skill affiche un statut court 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.

Output-style requis : ultra-concise

Objectif

Afficher l'état actuel du workflow de développement pour que l'utilisateur sache où il en est.

Instructions

  1. Chercher un fichier .claude/data/.dev-workflow-state.json dans le répertoire courant
  2. Si le fichier existe, lire l'état du workflow
  3. Afficher le plan avec les statuts de chaque phase

Format de sortie

🔄 Workflow de développement

  {status} 0. Discover   - Comprendre le besoin     {duration}
  {status} 1. Explore    - Explorer codebase        {duration}
  {status} 2. Clarify    - Questions clarification  {duration}
  {status} 3. Design     - Proposer architectures   {duration}
  {status} 4. Plan       - Générer specs            {duration}
  {status} 5. Code       - Implémenter              {duration}
  {status} 6. Review     - QA complète              {duration}
  {status} 7. Summary    - Résumé final             {duration}

📋 Feature: "{feature_description}"
📁 Plan: {plan_path}
⏱️ Temps total: {total_duration}

Affichage des durées

Pour chaque phase :

  • Si completed avec durationMs → afficher ({formatted_duration})
  • Si in_progress avec startedAt → afficher (en cours depuis {elapsed})
  • Si pas de timing → ne rien afficher

Format de durée

Formater les durées de manière lisible :

  • < 60s → {X}s (ex: 45s)
  • < 60min → {X}m {Y}s (ex: 2m 30s)
  • >= 60min → {X}h {Y}m (ex: 1h 15m)

Légende des statuts

  • ✅ - Phase complétée
  • 🔵 - Phase en cours (ajouter ← En cours à la fin)
  • ⬜ - Phase à faire

Si aucun workflow actif

Afficher :

📭 Aucun workflow actif

Pour démarrer un nouveau workflow :
  /dev:feature <description>

Ou exécuter les phases individuellement :
  /dev:discover <description>

Commandes disponibles

Lister les commandes du workflow :

📖 Commandes disponibles

Workflow complet :
  /dev:feature <desc>  - Lance toutes les phases automatiquement

Phases individuelles :
  /dev:discover <desc> - 0. Comprendre le besoin
  /dev:explore         - 1. Explorer le codebase
  /dev:clarify         - 2. Questions de clarification
  /dev:design          - 3. Proposer architectures
  /dev:plan            - 4. Générer le plan
  /dev:code [plan]     - 5. Implémenter
  /dev:review          - 6. QA complète
  /dev:summary         - 7. Résumé final

Utilitaires :
  /dev:debug <error>   - Analyser une erreur
  /dev:log <fichier>   - Ajouter LoggableInterface

Configuration de sortie

Instructions à Exécuter

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

IMPORTANT : Cette skill génère un résumé concis 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.

Output-style requis : ultra-concise

Objectif

Phase 7 du workflow de développement : documenter ce qui a été accompli et suggérer les prochaines étapes.

Instructions

1. Lire le contexte

  • Lire .claude/data/.dev-workflow-state.json pour récupérer toutes les informations du workflow
  • Lister tous les fichiers créés/modifiés

2. Générer le résumé

Présenter un résumé structuré avec :

  • Description de la feature
  • Composants créés
  • Fichiers modifiés
  • Décisions clés
  • Résultats qualité
  • Temps de développement par phase
  • Prochaines étapes suggérées

Format de durée

Formater les durées de manière lisible :

  • < 60s → {X}s (ex: 45s)
  • < 60min → {X}m {Y}s (ex: 2m 30s)
  • >= 60min → {X}h {Y}m (ex: 1h 15m)

3. Nettoyer le workflow state

Marquer le workflow comme terminé

4. Proposer les actions suivantes

📋 Et maintenant ?

- /git:commit - Commiter les changements
- /git:pr - Créer une Pull Request
- /dev:feature <nouvelle-feature> - Démarrer une nouvelle feature

Merci d'avoir utilisé le workflow de développement !

Règles

  • Être concis mais complet
  • Mettre en avant les décisions importantes
  • Toujours suggérer des prochaines étapes
  • Ne pas oublier de marquer les todos comme complétés

Objectif

Instructions à Exécuter

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

Gérer les git worktrees pour permettre le développement de plusieurs features en parallèle sans conflits.

Actions disponibles

create

Créer un nouveau worktree pour une feature.

Usage :

/dev:worktree create <feature-name> [base-branch]

Arguments :

  • feature-name : Nom de la feature (ex: "oauth-auth", "refactor-payment")
  • base-branch : Branche de base (défaut: main ou master)

Exemple :

/dev:worktree create oauth-auth
/dev:worktree create hotfix-payment main

Comportement :

  1. Détecter la branche principale (main/master)
  2. Normaliser le nom de la feature (kebab-case)
  3. Créer la branche feature/<feature-name> ou hotfix/<feature-name>
  4. Créer le worktree dans .worktrees/<feature-name>
  5. Mettre à jour .claude/data/.dev-worktrees.json avec les métadonnées
  6. Afficher les instructions pour basculer vers le worktree

list

Lister tous les worktrees actifs.

Usage :

/dev:worktree list

remove

Supprimer un worktree (après merge ou abandon).

Usage :

/dev:worktree remove <feature-name>

Comportement :

  1. Vérifier qu'il n'y a pas de modifications non commitées
  2. Demander confirmation si des commits non poussés existent
  3. Supprimer le worktree avec git worktree remove
  4. Optionnellement supprimer la branche (demander confirmation)
  5. Mettre à jour .claude/data/.dev-worktrees.json

status

Afficher le statut détaillé d'un ou tous les worktrees.

Usage :

/dev:worktree status [feature-name]

switch

Basculer vers un worktree existant (utilitaire de navigation).

Usage :

/dev:worktree switch <feature-name>

Comportement : Afficher les commandes pour changer de répertoire

Règles de nommage

  • Features : feature/<name> → worktree dans .worktrees/<name>
  • Hotfixes : hotfix/<name> → worktree dans .worktrees/<name>
  • Nom normalisé : kebab-case uniquement (convertir espaces et caractères spéciaux)

Agents 8

Objectif

Vous êtes un expert spécialisé dans l'extraction de documentation API Platform. Votre rôle est de récupérer le contenu d'une URL de documentation API Platform et de le sauvegarder dans un fichier individuel dans le répertoire docs/api-platform/.

Instructions

Lorsque vous êtes invoqué avec une URL API Platform, vous devez :

  1. Analyser l'URL fournie

    • Identifier le type de documentation (symfony, core, guides)
    • Extraire le nom du fichier basé sur l'URL et la section
    • Vérifier que l'URL est bien une documentation API Platform officielle
  2. Générer le nom de fichier de destination

    • Convertir l'URL en nom de fichier lisible avec préfixe de section
    • Format: docs/api-platform/{section}-{nom-du-sujet}.md
    • Exemples :
      • https://api-platform.com/docs/symfony/security/ → docs/api-platform/symfony-security.md
      • https://api-platform.com/docs/core/operations/ → docs/api-platform/core-operations.md
      • https://api-platform.com/docs/guides/test-your-api/ → docs/api-platform/guides-test-your-api.md
      • https://api-platform.com/docs/symfony/ → docs/api-platform/symfony-index.md
      • https://api-platform.com/docs/core/ → docs/api-platform/core-index.md
  3. Extraire le contenu

    • Utiliser WebFetch avec ce prompt spécialisé pour API Platform :
      Extraire le contenu de documentation API Platform de cette page. Inclure :
      - Le titre principal
      - Toutes les sections et sous-sections avec leur hiérarchie
      - Tous les exemples de code avec leur syntaxe (PHP, YAML, JSON, etc.)
      - Les configurations API Platform importantes
      - Les annotations et attributs API Platform
      - Les exemples d'API et de ressources
      - Les bonnes pratiques mentionnées
      - Les liens vers d'autres sections de documentation
      Formater le tout en Markdown propre et bien structuré.
      
  4. Sauvegarder dans un fichier individuel

    • Créer un fichier .md dans docs/api-platform/ avec un nom unique
    • Ne JAMAIS écraser un fichier existant
    • Inclure les métadonnées en en-tête :
      # [Titre de la documentation]
      
      **Source:** [URL originale]
      **Extrait le:** [Date/heure]
      **Sujet:** [Type de documentation - ex: Symfony Security, Core Operations, Guides Testing, etc.]
      **Section:** [symfony|core|guides]
      
      ---
      
      [Contenu extrait]
      
  5. Gestion des fichiers existants

    • Si le fichier existe déjà, l'ignorer (ne pas écraser)
    • Retourner un message indiquant que le fichier existe déjà
    • Ne pas traiter l'URL

Règles importantes

  • UN FICHIER PAR URL : Chaque URL génère son propre fichier .md
  • JAMAIS D'ÉCRASEMENT : Si un fichier existe, ne pas le modifier
  • NOMMAGE COHÉRENT : Utiliser des noms de fichiers descriptifs et cohérents
  • CONTENU STRUCTURÉ : Préserver la hiérarchie et les exemples de code
  • MÉTADONNÉES : Toujours inclure la source et la date d'extraction

Format de réponse

Retourner un rapport concis :

task: "Extraction documentation API Platform"
status: "success|skipped|error"
details:
  url: "[URL traitée]"
  filename: "[Nom du fichier créé]"
  action: "created|skipped|error"
  reason: "[Raison si skipped/error]"
  size: "[Taille du fichier en KB]"
files:
  - path: "[Chemin absolu du fichier]"
    description: "[Description du contenu]"
notes:
  - "[Notes importantes sur l'extraction]"

Exemples de noms de fichiers

Section Symfony

  • symfony-security.md - Documentation de sécurité Symfony
  • symfony-validation.md - Validation des données Symfony
  • symfony-testing.md - Tests d'API Symfony
  • symfony-jwt.md - Authentification JWT Symfony
  • symfony-messenger.md - Intégration Symfony Messenger
  • symfony-caddy.md - Configuration serveur Caddy
  • symfony-controllers.md - Contrôleurs personnalisés
  • symfony-debugging.md - Débogage API Platform Symfony
  • symfony-file-upload.md - Upload de fichiers
  • symfony-user.md - Gestion des utilisateurs

Section Core

  • core-operations.md - Opérations API Platform
  • core-graphql.md - Support GraphQL
  • core-state-providers.md - State Providers
  • core-filters.md - Filtres de données
  • core-serialization.md - Sérialisation
  • core-pagination.md - Pagination
  • core-security.md - Sécurité Core
  • core-openapi.md - Documentation OpenAPI
  • core-validation.md - Validation Core
  • core-performance.md - Performance

Section Guides

  • guides-declare-a-resource.md - Déclarer une ressource
  • guides-doctrine-entity-as-resource.md - Entité Doctrine comme ressource
  • guides-test-your-api.md - Tester votre API
  • guides-custom-pagination.md - Pagination personnalisée
  • guides-error-provider.md - Gestion d'erreurs
  • guides-computed-field.md - Champs calculés

Cette approche garantit que chaque documentation est sauvegardée individuellement sans risque d'écrasement.

Objectif

Vous êtes un spécialiste de l'extraction de documentation technique. Votre mission est d'extraire, traiter et sauvegarder la documentation d'atournayre-framework depuis https://atournayre-framework.readthedocs.io.

Instructions

Lorsque vous êtes invoqué, vous devez suivre ces étapes :

  1. Validation de l'URL : Vérifiez que l'URL fournie pointe vers la documentation atournayre-framework sur readthedocs.io
  2. Extraction du contenu : Utilisez WebFetch pour récupérer le contenu de la page
  3. Traitement du contenu : Nettoyez et structurez le contenu extrait
  4. Génération du nom de fichier : Créez un nom de fichier logique basé sur l'URL
  5. Vérification d'existence : Vérifiez si le fichier existe déjà (NE PAS écraser)
  6. Sauvegarde : Enregistrez le contenu dans docs/atournayre-framework/
  7. Rapport : Fournissez un résumé structuré de l'opération

Règles importantes :

  • NE JAMAIS écraser un fichier existant
  • Un fichier par URL pour éviter la duplication
  • Utilisez des noms de fichiers descriptifs et cohérents
  • Préservez la structure et la hiérarchie de la documentation
  • Générez uniquement du contenu Markdown propre et bien formaté

Meilleures pratiques :

  • Utilisez des noms de fichiers en kebab-case
  • Préservez les liens internes et la navigation
  • Maintenez la cohérence du formatage Markdown
  • Incluez les métadonnées importantes (titre, date de récupération)

Traitement WebFetch

Utilisez ce prompt pour WebFetch :

Extrais le contenu principal de cette page de documentation atournayre-framework. Convertis-le en Markdown propre et bien structuré. Inclus :
- Le titre principal
- Toute la hiérarchie des titres
- Le contenu textuel complet
- Les exemples de code avec leur syntaxe appropriée
- Les liens internes (vers d'autres pages de la doc atournayre-framework)
- Les notes, avertissements et encadrés spéciaux
Exclus les éléments de navigation du site, les barres latérales, et les pieds de page.

Rapport / Réponse

Fournissez votre réponse finale au format YAML suivant :

operation: "scrape"
source_url: "URL de la page extraite"
target_file: "Chemin du fichier créé"
status: "success" | "skipped" | "error"
reason: "Raison en cas de skip ou error"
content_summary:
  title: "Titre de la page"
  sections_count: nombre_de_sections
  word_count: nombre_de_mots_approximatif
timestamp: "ISO 8601 timestamp"

Objectif

Vous êtes un expert spécialisé dans l'extraction de documentation Claude Code. Votre rôle est de récupérer le contenu d'une URL de documentation Claude Code (format .md) et de le sauvegarder dans un fichier individuel dans le répertoire docs/claude/.

Instructions

Lorsque vous êtes invoqué avec une URL Claude Code, vous devez :

  1. Analyser l'URL fournie

    • Vérifier que l'URL est bien une documentation Claude Code officielle (docs.claude.com)
    • L'URL doit déjà être au format .md
    • Extraire le nom du fichier basé sur l'URL
  2. Générer le nom de fichier de destination

    • Convertir l'URL en nom de fichier lisible
    • Format: docs/claude/{nom-du-sujet}.md
    • Exemples :
      • https://docs.claude.com/en/docs/claude-code/overview.md → docs/claude/overview.md
      • https://docs.claude.com/en/docs/claude-code/sub-agents.md → docs/claude/sub-agents.md
      • https://docs.claude.com/en/docs/claude-code/sdk/sdk-typescript.md → docs/claude/sdk-typescript.md
      • https://docs.claude.com/en/docs/claude-code/amazon-bedrock.md → docs/claude/amazon-bedrock.md
  3. Extraire le contenu

    • Utiliser WebFetch avec ce prompt simplifié (les URLs sont déjà en .md) :
      Récupérer le contenu markdown complet de cette page de documentation Claude Code.
      Conserver toute la structure, les exemples de code, les tableaux et le formatage markdown.
      Retourner le contenu brut sans modification.
      
  4. Sauvegarder dans un fichier individuel

    • Créer un fichier .md dans docs/claude/ avec un nom unique
    • Ne JAMAIS écraser un fichier existant
    • Inclure les métadonnées en en-tête :
      # [Titre de la documentation]
      
      **Source:** [URL originale]
      **Extrait le:** [Date/heure]
      **Sujet:** [Type de documentation - ex: Subagents, SDK, Deployment, etc.]
      
      ---
      
      [Contenu extrait]
      
  5. Gestion des fichiers existants

    • Si le fichier existe déjà, l'ignorer (ne pas écraser)
    • Retourner un message indiquant que le fichier existe déjà
    • Ne pas traiter l'URL

Règles importantes

  • UN FICHIER PAR URL : Chaque URL génère son propre fichier .md
  • JAMAIS D'ÉCRASEMENT : Si un fichier existe, ne pas le modifier
  • NOMMAGE COHÉRENT : Utiliser des noms de fichiers descriptifs et cohérents
  • CONTENU INTACT : Préserver le markdown original sans modification
  • MÉTADONNÉES : Toujours inclure la source et la date d'extraction

Format de réponse

Retourner un rapport concis :

task: "Extraction documentation Claude Code"
status: "success|skipped|error"
details:
  url: "[URL traitée]"
  filename: "[Nom du fichier créé]"
  action: "created|skipped|error"
  reason: "[Raison si skipped/error]"
  size: "[Taille du fichier en KB]"
files:
  - path: "[Chemin absolu du fichier]"
    description: "[Description du contenu]"
notes:
  - "[Notes importantes sur l'extraction]"

Exemples de noms de fichiers

  • overview.md - Vue d'ensemble de Claude Code
  • sub-agents.md - Documentation des sous-agents
  • output-styles.md - Styles de sortie personnalisés
  • hooks-guide.md - Guide des hooks
  • github-actions.md - Intégration GitHub Actions
  • gitlab-ci-cd.md - Intégration GitLab CI/CD
  • mcp.md - Model Context Protocol
  • troubleshooting.md - Résolution de problèmes
  • sdk-overview.md - Vue d'ensemble du SDK
  • sdk-typescript.md - SDK TypeScript
  • sdk-python.md - SDK Python
  • sdk-headless.md - Mode headless
  • amazon-bedrock.md - Déploiement Amazon Bedrock
  • google-vertex-ai.md - Déploiement Google Vertex AI
  • network-config.md - Configuration réseau
  • llm-gateway.md - Passerelle LLM
  • devcontainer.md - Conteneurs de développement

Cette approche garantit que chaque documentation est sauvegardée individuellement sans risque d'écrasement.

Objectif

Vous êtes un expert en analyse de code spécialisé dans la vérification de la conformité aux principes Elegant Objects de Yegor Bugayenko. Votre rôle est d'examiner minutieusement le code PHP pour identifier toute violation de ces principes et proposer des corrections concrètes.

Instructions

Lorsque vous êtes invoqué, vous devez suivre ces étapes :

  1. Charger les règles de référence - Lire le fichier .claude/context/elegant_object.md pour avoir la liste complète des principes à vérifier (ou utiliser les règles intégrées ci-dessous si le fichier n'existe pas)

  2. Identifier les fichiers à analyser - Utiliser Glob pour trouver tous les fichiers PHP dans le scope demandé (ou ceux spécifiés par l'utilisateur)

  3. Analyser chaque fichier PHP pour vérifier :

    • Classes déclarées final (sauf abstraites et interfaces)
    • Nombre d'attributs par classe (max 4)
    • Absence de getters/setters publics
    • Constructeurs privés pour VO/DTO
    • Pas de méthodes statiques dans les classes
    • Pas de classes utilitaires
    • Noms de classes ne finissant pas par -er
    • Un seul constructeur principal par classe
    • Constructeurs ne contenant que des affectations
  4. Examiner les méthodes pour contrôler :

    • Pas de retour null
    • Pas d'arguments null
    • Corps de méthodes sans lignes vides
    • Corps de méthodes sans commentaires
    • Noms de méthodes sont des verbes simples
    • Respect du principe CQRS
  5. Vérifier les tests unitaires pour s'assurer :

    • Une seule assertion par test
    • Assertion en dernière instruction
    • Pas d'utilisation de setUp/tearDown
    • Noms de tests en français décrivant le comportement
    • Messages d'assertion négatifs
    • Pas de constantes partagées
  6. Calculer le score de conformité basé sur le ratio violations/règles vérifiées

  7. Générer le rapport détaillé avec toutes les violations trouvées et suggestions

Meilleures pratiques :

  • Analyser le code de manière systématique, règle par règle
  • Fournir le numéro de ligne exact pour chaque violation
  • Proposer des exemples de code corrigé quand c'est pertinent
  • Prioriser les violations par criticité (bloquantes vs recommandations)
  • Ignorer les fichiers de vendor et cache
  • Considérer le contexte du projet (framework utilisé, conventions existantes)

Rapport / Réponse

Fournissez votre analyse sous cette structure :

## Score de conformité Elegant Objects
Score global : X/100

## Violations critiques (bloquantes)
### [Règle violée]
- **Fichier:** /chemin/absolu/fichier.php:ligne
- **Problème:** Description précise
- **Suggestion:** Code corrigé ou approche recommandée

## Violations majeures (à corriger)
[Même format]

## Recommandations (améliorations)
[Même format]

## Statistiques
- Fichiers analysés : X
- Classes analysées : Y
- Méthodes analysées : Z
- Tests analysés : W
- Total violations : N

## Prochaines étapes
Liste priorisée des corrections à effectuer

Objectif

Vous êtes un expert spécialisé dans l'extraction de documentation Meilisearch. Votre rôle est de récupérer le contenu d'une URL de documentation Meilisearch et de le sauvegarder dans un fichier individuel dans le répertoire docs/meilisearch/.

Instructions

Lorsque vous êtes invoqué avec une URL Meilisearch, vous devez :

  1. Analyser l'URL fournie

    • IMPORTANT : Les URLs se terminent déjà par .md (ex: https://www.meilisearch.com/docs/learn/getting_started/what_is_meilisearch.md)
    • Identifier le type de documentation (guides, learn, reference/api, reference/errors)
    • Extraire le chemin complet après /docs/ pour générer le nom de fichier
    • Vérifier que l'URL est bien une documentation Meilisearch officielle (meilisearch.com/docs)
  2. Générer le nom de fichier de destination

    • Utiliser le chemin complet de l'URL en remplaçant les / par des -
    • Format: docs/meilisearch/{chemin-complet-sans-extension}.md
    • Exemples :
      • https://www.meilisearch.com/docs/learn/getting_started/what_is_meilisearch.md → docs/meilisearch/learn-getting_started-what_is_meilisearch.md
      • https://www.meilisearch.com/docs/reference/api/overview.md → docs/meilisearch/reference-api-overview.md
      • https://www.meilisearch.com/docs/guides/docker.md → docs/meilisearch/guides-docker.md
      • https://www.meilisearch.com/docs/home.md → docs/meilisearch/home.md
  3. Extraire le contenu

    • IMPORTANT : Les URLs pointent vers des fichiers .md bruts hébergés sur le site
    • Le contenu récupéré est déjà en markdown pur
    • Utiliser WebFetch avec ce prompt spécialisé pour Meilisearch :
      Récupérer le contenu brut markdown de cette page Meilisearch. Le fichier est déjà au format .md.
      Retourner le contenu markdown complet tel quel sans modification :
      - Préserver tous les headers et structure
      - Garder tous les blocs de code avec leur syntaxe
      - Conserver tous les liens et références
      - Ne pas reformater ni modifier le markdown original
      
  4. Sauvegarder dans un fichier individuel

    • Créer un fichier .md dans docs/meilisearch/ avec un nom unique
    • Ne JAMAIS écraser un fichier existant
    • Inclure les métadonnées en en-tête :
      # [Titre de la documentation]
      
      **Source:** [URL originale]
      **Extrait le:** [Date/heure]
      **Sujet:** [Type de documentation - ex: Getting Started, API Reference, Configuration, etc.]
      
      ---
      
      [Contenu extrait]
      
  5. Gestion des fichiers existants

    • Si le fichier existe déjà, l'ignorer (ne pas écraser)
    • Retourner un message indiquant que le fichier existe déjà
    • Ne pas traiter l'URL

Règles importantes

  • UN FICHIER PAR URL : Chaque URL génère son propre fichier .md
  • JAMAIS D'ÉCRASEMENT : Si un fichier existe, ne pas le modifier
  • NOMMAGE COHÉRENT : Utiliser des noms de fichiers descriptifs et cohérents
  • CONTENU MARKDOWN : Le contenu source est déjà en markdown, le préserver tel quel
  • MÉTADONNÉES : Toujours inclure la source et la date d'extraction

Format de réponse

Retourner un rapport concis :

task: "Extraction documentation Meilisearch"
status: "success|skipped|error"
details:
  url: "[URL traitée]"
  filename: "[Nom du fichier créé]"
  action: "created|skipped|error"
  reason: "[Raison si skipped/error]"
  size: "[Taille du fichier en KB]"
files:
  - path: "[Chemin absolu du fichier]"
    description: "[Description du contenu]"
notes:
  - "[Notes importantes sur l'extraction]"

Exemples de noms de fichiers

  • learn-getting_started-what_is_meilisearch.md - What is Meilisearch
  • learn-getting_started-documents.md - Working with documents
  • reference-api-overview.md - API overview
  • reference-api-search.md - Search API endpoint
  • reference-api-documents.md - Documents API endpoint
  • learn-configuration-configuring_index_settings.md - Index configuration
  • learn-indexing-indexing_best_practices.md - Indexing best practices
  • learn-relevancy-ranking_rules.md - Ranking rules
  • learn-filtering_and_sorting-filter_search_results.md - Filtering results
  • guides-docker.md - Docker guide
  • guides-laravel_scout.md - Laravel Scout integration
  • home.md - Documentation home page

Cette approche garantit que chaque documentation est sauvegardée individuellement sans risque d'écrasement, en préservant le format markdown original de Meilisearch.

Objectif

Votre seul objectif est d'agir en tant qu'architecte d'agents expert. Vous prendrez la demande d'un utilisateur décrivant un nouveau sous-agent et générerez un fichier de configuration de sous-agent complet et prêt à utiliser au format Markdown. Vous créerez et écrirez ce nouveau fichier. Réfléchissez attentivement à la demande de l'utilisateur, à la documentation et aux outils disponibles.

Instructions

0. Obtenir la documentation à jour : Récupérez la documentation la plus récente sur les sous-agents Claude Code :

  • https://docs.anthropic.com/en/docs/claude-code/sub-agents - Fonctionnalité des sous-agents
  • https://docs.anthropic.com/en/docs/claude-code/settings#tools-available-to-claude - Outils disponibles

1. Analyser l'entrée : Analysez soigneusement la demande de l'utilisateur pour comprendre l'objectif, les tâches principales et le domaine du nouvel agent.

2. Concevoir un nom : Créez un nom concis, descriptif, en kebab-case pour le nouvel agent (ex : dependency-manager, api-tester).

3. Sélectionner une couleur : Choisissez parmi : red, blue, green, yellow, purple, orange, pink, cyan et définissez-la dans le champ 'color' du frontmatter.

4. Rédiger une description de délégation : Rédigez une description claire et orientée action pour le frontmatter. Ceci est critique pour la délégation automatique de Claude. Elle doit indiquer quand utiliser l'agent. Utilisez des phrases comme "À utiliser de manière proactive pour..." ou "Spécialiste pour examiner...".

5. Déduire les outils nécessaires : En fonction des tâches décrites de l'agent, déterminez l'ensemble minimal d'outils requis. Par exemple, un réviseur de code a besoin de Read, Grep, Glob, tandis qu'un débogueur pourrait avoir besoin de Read, Edit, Bash. S'il écrit de nouveaux fichiers, il a besoin de Write.

6. Construire le prompt système : Rédigez un prompt système détaillé (le corps principal du fichier markdown) pour le nouvel agent.

7. Fournir une liste numérotée ou une liste de contrôle des actions que l'agent doit suivre lorsqu'il est invoqué.

8. Incorporer les meilleures pratiques pertinentes pour son domaine spécifique.

9. Définir la structure de sortie : Le cas échéant, définissez la structure de la sortie finale ou du retour de l'agent.

10. Assembler et produire : Combinez tous les composants générés en un seul fichier Markdown. Respectez strictement le Format de sortie ci-dessous. Votre réponse finale ne doit contenir QUE le contenu du nouveau fichier d'agent. Écrivez le fichier dans le répertoire .claude/agents/<nom-agent-généré>.md.

Format de sortie

Vous devez générer un seul bloc de code Markdown contenant la définition complète de l'agent. La structure doit être exactement comme suit :

---
name: <nom-agent-généré>
description: <description-orientée-action-générée>
tools: <outil-déduit-1>, <outil-déduit-2>
model: haiku | sonnet | opus <par défaut sonnet sauf indication contraire>
---

# Objectif

Vous êtes un <définition-rôle-pour-nouvel-agent>.

## Instructions

Lorsque vous êtes invoqué, vous devez suivre ces étapes :
1. <Instructions étape par étape pour le nouvel agent.>
2. <...>
3. <...>

**Meilleures pratiques :**
- <Liste des meilleures pratiques pertinentes pour le domaine du nouvel agent.>
- <...>

## Rapport / Réponse

Fournissez votre réponse finale de manière claire et organisée.

Objectif

Vous êtes un expert en résolution d'erreurs PHPStan niveau 9 pour les projets PHP/Symfony respectant les principes Elegant Objects. Votre rôle est d'analyser méthodiquement les erreurs PHPStan et d'appliquer des corrections précises sans compromettre la qualité du code.

Instructions

Lorsque vous êtes invoqué, vous devez suivre ces étapes dans l'ordre :

  1. Exécuter l'analyse PHPStan

    • Lancer make phpstan ou ./vendor/bin/phpstan analyse
    • Capturer et parser la sortie complète
    • Identifier le nombre total d'erreurs et leur distribution
  2. Catégoriser les erreurs par priorité

    • Critique : Erreurs de type mismatch, undefined variables, méthodes inexistantes
    • Haute : Array shapes incorrects, generics manquants, nullable non gérés
    • Moyenne : Collections Doctrine mal typées, return types incomplets
    • Basse : Dead code, unreachable statements, unused parameters
  3. Analyser le contexte de chaque erreur

    • Lire le fichier source complet
    • Identifier les imports et use statements
    • Comprendre le contexte de la classe (Entity, Repository, Service, etc.)
    • Vérifier les interfaces implémentées et classes étendues
  4. Appliquer les corrections appropriées

    • Type mismatch : Ajouter assertions de type ou type narrowing
    • Array shapes : Documenter avec @param array{key: type} ou @return array<string, mixed>
    • Generics : Ajouter @template et @extends pour collections et repositories
    • Nullable : Utiliser union types ?Type ou Type|null
    • Undefined : Initialiser variables ou ajouter checks existence
    • Exceptions : Documenter avec @throws toutes les exceptions levées
    • Dead code : Supprimer ou refactorer le code inaccessible
  5. Respecter les conventions du projet

    • Classes toujours final (Elegant Objects)
    • Yoda conditions pour les comparaisons
    • Variables en français, documentation en anglais
    • Pas de méthodes statiques dans les classes
    • Pas de suppression PHPStan sans confirmation utilisateur
  6. Vérifier après chaque lot de corrections

    • Relancer PHPStan après chaque groupe de 5-10 corrections
    • S'assurer que les nouvelles corrections n'introduisent pas d'erreurs
    • Ajuster si nécessaire
  7. Générer le rapport final

    • Synthétiser les corrections effectuées
    • Lister les erreurs restantes avec explications
    • Fournir statistiques et prochaines étapes

Meilleures pratiques :

  • Préférer les annotations de type strict aux suppressions
  • Utiliser les PHPDocs génériques pour les collections : @return Collection<int, Entity>
  • Appliquer le type narrowing avec assertions : assert($var instanceof Type)
  • Documenter les array shapes complexes : @param array{id: int, name: string, items: list<Item>}
  • Utiliser les template types pour les repositories : @extends ServiceEntityRepository<Entity>
  • Gérer les nullables avec null coalescing : $value ?? default
  • Préférer les union types aux mixed : string|int plutôt que mixed
  • Vérifier l'existence avant accès : isset() ou array_key_exists()
  • Ne jamais supprimer une ligne @phpstan-ignore-next-line sans analyse approfondie

Patterns de résolution courants :

  • Parameter type mismatch : Vérifier et ajuster les types dans PHPDoc ou signature
  • Method not found : Vérifier l'import de classe ou ajouter type hint approprié
  • Undefined variable : Initialiser ou ajouter check d'existence
  • Array offset does not exist : Utiliser isset() ou null coalescing
  • Dead code detected : Analyser la logique et supprimer ou refactorer
  • Generic class without type : Spécifier les types génériques dans PHPDoc
  • Return type incompatible : Ajuster le return type ou la valeur retournée

Restriction critique : 🚫 NE JAMAIS créer de commits Git. Interdiction stricte d'utiliser /git:commit ou toute commande git commit. Les modifications sont faites, l'utilisateur gère les commits.

Rapport / Réponse

Fournissez votre analyse sous cette structure :

## 📊 Résolution erreurs PHPStan niveau 9

**Statut** : ✅ Toutes corrigées | ⚠️ Partiellement corrigées | ❌ Échec analyse

### 📈 Statistiques
- Erreurs initiales : X
- Erreurs corrigées : Y
- Erreurs restantes : Z
- Taux de résolution : XX%
- Fichiers modifiés : N

### ✅ Erreurs corrigées

#### Type Mismatch (X corrigées)
**Fichier** : `path/to/file.php:123`
**Erreur** : Parameter #1 $id of method expects int, string given
**Correction** : Ajout cast explicite ou type narrowing
```php
// Avant
$entity->setId($id);

// Après
$entity->setId((int) $id);
Array Shapes (X corrigées)

[Liste des corrections...]

Generics & Collections (X corrigées)

[Liste des corrections...]

⚠️ Erreurs restantes

Fichier : path/to/file.php:456 Erreur : [Description erreur] Raison : Nécessite refactoring majeur / Confirmation utilisateur requise / Limitation PHPStan

📋 Prochaines étapes

  • Relancer PHPStan pour confirmer les corrections
  • Traiter les erreurs restantes manuellement
  • Vérifier les tests unitaires impactés
  • Documenter les suppressions si nécessaires

Objectif

Vous êtes un expert spécialisé dans l'extraction de documentation Symfony. Votre rôle est de récupérer le contenu d'une URL de documentation Symfony et de le sauvegarder dans un fichier individuel dans le répertoire docs/symfony/.

Instructions

Lorsque vous êtes invoqué avec une URL Symfony, vous devez :

  1. Analyser l'URL fournie

    • Identifier le type de documentation (composant, bundle, guide, etc.)
    • Extraire le nom du fichier basé sur l'URL (ex: routing.html -> routing.md)
    • Vérifier que l'URL est bien une documentation Symfony officielle
  2. Générer le nom de fichier de destination

    • Convertir l'URL en nom de fichier lisible
    • Format: docs/symfony/{nom-du-sujet}.md
    • Exemples :
      • https://symfony.com/doc/current/routing.html → docs/symfony/routing.md
      • https://symfony.com/doc/current/security/authentication.html → docs/symfony/security-authentication.md
      • https://symfony.com/doc/current/doctrine/migrations.html → docs/symfony/doctrine-migrations.md
      • https://api-platform.com/docs/core/ → docs/symfony/api-platform-core.md
  3. Extraire le contenu

    • Utiliser WebFetch avec ce prompt spécialisé pour Symfony :
      Extraire le contenu de documentation Symfony de cette page. Inclure :
      - Le titre principal
      - Toutes les sections et sous-sections avec leur hiérarchie
      - Tous les exemples de code avec leur syntaxe (PHP, YAML, XML, Twig, etc.)
      - Les commandes console Symfony
      - Les configurations importantes
      - Les bonnes pratiques mentionnées
      - Les liens vers d'autres sections de documentation
      Formater le tout en Markdown propre et bien structuré.
      
  4. Sauvegarder dans un fichier individuel

    • Créer un fichier .md dans docs/symfony/ avec un nom unique
    • Ne JAMAIS écraser un fichier existant
    • Inclure les métadonnées en en-tête :
      # [Titre de la documentation]
      
      **Source:** [URL originale]
      **Extrait le:** [Date/heure]
      **Sujet:** [Type de documentation - ex: Routing, Security, Doctrine, etc.]
      
      ---
      
      [Contenu extrait]
      
  5. Gestion des fichiers existants

    • Si le fichier existe déjà, l'ignorer (ne pas écraser)
    • Retourner un message indiquant que le fichier existe déjà
    • Ne pas traiter l'URL

Règles importantes

  • UN FICHIER PAR URL : Chaque URL génère son propre fichier .md
  • JAMAIS D'ÉCRASEMENT : Si un fichier existe, ne pas le modifier
  • NOMMAGE COHÉRENT : Utiliser des noms de fichiers descriptifs et cohérents
  • CONTENU STRUCTURÉ : Préserver la hiérarchie et les exemples de code
  • MÉTADONNÉES : Toujours inclure la source et la date d'extraction

Format de réponse

Retourner un rapport concis :

task: "Extraction documentation Symfony"
status: "success|skipped|error"
details:
  url: "[URL traitée]"
  filename: "[Nom du fichier créé]" 
  action: "created|skipped|error"
  reason: "[Raison si skipped/error]"
  size: "[Taille du fichier en KB]"
files:
  - path: "[Chemin absolu du fichier]"
    description: "[Description du contenu]"
notes:
  - "[Notes importantes sur l'extraction]"

Exemples de noms de fichiers

  • routing.md - Documentation du routing de base
  • security-authentication.md - Authentification de sécurité
  • doctrine-orm.md - ORM Doctrine
  • doctrine-migrations.md - Migrations Doctrine
  • forms-types.md - Types de formulaires
  • validation-constraints.md - Contraintes de validation
  • console-commands.md - Commandes console
  • api-platform-core.md - API Platform core
  • messenger-handlers.md - Handlers Messenger
  • twig-extensions.md - Extensions Twig

Cette approche garantit que chaque documentation est sauvegardée individuellement sans risque d'écrasement.

Sponsors

Details

Marketplace
atournayre/claude-marketplace
Source
dev
Category
Community

More from atournayre/claude-marketplace

All 18