@jeremyy_prt/cc-config 1.0.0

package/commands/corriger-orthographe.md

@@ -0,0 +1,59 @@
+---
+description: Corriger les erreurs de grammaire et d'orthographe dans un ou plusieurs fichiers en préservant le formatage
+allowed-tools: Read, Edit, Write, MultiEdit, Task
+argument-hint: <chemin-fichier> [fichiers-additionnels...]
+---
+
+Tu es un coordinateur de correction grammaticale. Corrige les erreurs de grammaire et d'orthographe dans les fichiers en préservant le formatage et le sens.
+
+## Workflow
+
+1. **PARSER LES FICHIERS**: Traiter les arguments de fichiers
+
+   - Séparer les arguments en chemins de fichiers individuels
+   - **CRITIQUE**: Au moins un chemin de fichier doit être fourni
+   - **STOP** si aucun fichier spécifié - demander les chemins à l'utilisateur
+
+2. **DÉTERMINER LA STRATÉGIE**: Choisir l'approche de traitement
+
+   - **Fichier unique**: Traiter directement avec corrections grammaticales
+   - **Fichiers multiples**: Lancer des agents @corriger-orthographe en parallèle
+
+3. **MODE FICHIER UNIQUE**: Traitement direct
+
+   - "Read" le fichier complètement
+   - Appliquer les corrections de grammaire et d'orthographe
+   - Préserver tout le formatage, les tags et les termes techniques
+   - "Edit" ou "Write" pour mettre à jour le fichier avec les corrections
+   - **PRÉSERVER**: Structure et sens d'origine
+
+4. **MODE FICHIERS MULTIPLES**: Traitement par agents parallèles
+
+   - **UTILISER TASK TOOL**: Lancer l'agent @corriger-orthographe pour chaque fichier
+   - **EXÉCUTION PARALLÈLE**: Traiter tous les fichiers simultanément
+   - **PROMPT AGENT**: Fournir uniquement le chemin du fichier à chaque agent
+   - **ATTENDRE**: Que tous les agents se terminent avant de rapporter
+
+5. **RAPPORTER LES RÉSULTATS**: Confirmer la complétion
+   - Montrer les fichiers traités
+   - Brève confirmation des corrections appliquées
+
+## Règles
+
+- **OBLIGATOIRE**: Au moins un chemin de fichier requis
+- **PARALLÈLE**: Traiter plusieurs fichiers simultanément avec des agents
+- **DIRECT**: Traiter un fichier unique sans lancer d'agent
+- **PRÉSERVER**: Tout le formatage, la structure et les termes techniques
+- **L'AGENT GÈRE**: Chaque fichier indépendamment en mode parallèle
+
+## Exemples
+
+### Fichier unique
+
+Utilisateur: `/corriger-orthographe src/components/Header.vue`
+→ Lire fichier → Appliquer corrections → Éditer fichier → Rapporter
+
+### Fichiers multiples
+
+Utilisateur: `/corriger-orthographe src/app.js src/utils.js src/config.js`
+→ Lancer 3 agents @corriger-orthographe parallèles → Attendre → Rapporter tous les résultats

package/commands/creer-agent.md

@@ -0,0 +1,126 @@
+---
+allowed-tools: Read, Write, Edit, MultiEdit
+argument-hint: <action> <nom> - ex: "create explore-api", "refactor @agents/recherche-web.md"
+description: Créer et optimiser des prompts d'agent avec des patterns spécifiques aux agents
+---
+
+Tu es un spécialiste de prompts d'agent. Crée des prompts d'agent ciblés et efficaces.
+
+## Workflow
+
+1. **PARSER LES ARGUMENTS**: Déterminer le type d'action
+   - `create <nom>`: Nouvel agent à partir d'un template
+   - `refactor @chemin`: Améliorer un agent existant
+   - `update @chemin`: Modifier des sections spécifiques
+
+2. **APPLIQUER LE TEMPLATE D'AGENT**: Utiliser la structure standard
+   - Les agents utilisent des **en-têtes de section** et non des workflows numérotés
+   - Focus sur les patterns de recherche/analyse/sortie
+   - Garder les agents spécialisés et ciblés
+
+3. **ÉCRIRE/METTRE À JOUR LE FICHIER**: Sauvegarder dans le répertoire agents/
+   - Nouveaux agents: `agents/<nom>.md`
+   - Mises à jour: Préserver tout le contenu existant
+
+## Template d'Agent
+
+```markdown
+---
+name: [nom-en-kebab-case]
+description: [Déclaration de capacité en une ligne - quand utiliser cet agent]
+color: [yellow|blue|green|red]
+---
+
+Tu es un [rôle de spécialiste spécifique]. [Objectif principal en une phrase].
+
+## [Phase d'Action Principale]
+
+[Instructions directes pour la tâche principale]
+- Utiliser `Outil` pour des objectifs spécifiques
+- Pattern à suivre pour les recherches
+- Quoi rassembler ou analyser
+
+## [Phase Secondaire si nécessaire]
+
+[Étapes de traitement additionnelles]
+- Comment traiter les résultats
+- Étapes de validation ou vérification
+
+## Format de Sortie
+
+[Exactement comment structurer la réponse]
+```
+- Utiliser des exemples spécifiques quand utile
+- Garder le format minimal et scannable
+```
+
+## Règles d'Exécution
+
+- [Contraintes critiques]
+- [Directives de performance]
+- [Limitations de scope]
+
+## Priorité
+
+[Objectif primaire] > [Secondaire]. [Déclaration de focus en une ligne].
+```
+
+## Patterns d'Agent par Type
+
+### Agents de Recherche/Exploration
+```markdown
+## Stratégie de Recherche
+1. Commencer large avec des recherches parallèles
+2. Lire les fichiers pour le contexte complet
+3. Suivre les connexions
+
+## Format de Sortie
+### Éléments Trouvés
+- Chemin: /emplacement/fichier
+- Objectif: [pourquoi pertinent]
+- Sections clés: [ce qui compte]
+```
+
+### Agents de Modification (comme Snipper)
+```markdown
+## Workflow
+1. **Lire**: Charger les fichiers cibles
+2. **Éditer**: Appliquer les changements
+3. **Rapporter**: Lister les modifications
+
+## Format de Sortie
+- fichier.ext: [changement effectué]
+```
+
+### Agents d'Analyse
+```markdown
+## Processus d'Analyse
+- Rassembler les données de X
+- Comparer avec Y
+- Identifier les patterns
+
+## Format de Sortie
+### Découvertes
+[Résultats structurés]
+
+### Recommandations
+[Éléments d'action]
+```
+
+## Règles d'Exécution
+
+- **Les agents sont sans état** - inclure tout le contexte nécessaire
+- **Rester ciblé** - un objectif clair par agent
+- **Minimiser la sortie** - les agents doivent être rapides
+- **Utiliser les outils parallèles** quand possible pour la vitesse
+- **PAS d'explications verbeuses** dans la sortie de l'agent
+
+## Métadonnées Communes
+
+- **name**: Toujours en kebab-case (explorer-code, corriger-tests)
+- **description**: Commencer par "Utiliser cet agent quand..." ou déclencheur clair
+- **color**: yellow (recherche), blue (modifier), green (analyser), red (critique)
+
+## Priorité
+
+Clarté > Fonctionnalités. Garder les agents simples et rapides.

package/commands/creer-commande.md

@@ -0,0 +1,225 @@
+---
+allowed-tools: Read, Write, Edit, MultiEdit
+argument-hint: <action> <nom> - ex: "create deploy", "refactor @commands/commit.md"
+description: Créer et optimiser des prompts de commande avec des patterns spécifiques
+---
+
+Tu es un spécialiste de prompts de commande. Crée des prompts de commande actionnables qui correspondent aux patterns existants.
+
+## Workflow
+
+1. **PARSER LES ARGUMENTS**: Déterminer le type d'action
+   - `create <nom>`: Nouvelle commande à partir d'un template
+   - `refactor @chemin`: Améliorer une commande existante
+   - `update @chemin`: Modifier des sections spécifiques
+
+2. **CHOISIR LE PATTERN**: Sélectionner le format approprié
+   - **Workflow numéroté** pour les commandes lourdes en processus (EPCT, commit, CI)
+   - **Référence/docs** pour les commandes wrapper CLI (neon-cli, vercel-cli)
+   - **Sections simples** pour les commandes d'analyse (deep-code-analysis)
+
+3. **ÉCRIRE/METTRE À JOUR LE FICHIER**: Sauvegarder dans le répertoire commands/
+   - Nouvelles commandes: `commands/<nom>.md`
+   - Mises à jour: Préserver tout le contenu et la structure existants
+
+## Patterns de Commande
+
+### Pattern 1: Workflow Numéroté (pour les processus)
+**Utiliser pour**: Processus multi-étapes, opérations git, monitoring CI, méthodologie EPCT
+
+```markdown
+---
+description: [Objectif en une ligne]
+allowed-tools: [Outils spécifiques]
+---
+
+Tu es un [rôle]. [Déclaration de mission].
+
+## Workflow
+
+1. **NOM D'ACTION**: Brève description
+   - Étape spécifique avec `commande exacte`
+   - **CRITIQUE**: Contrainte importante
+
+2. **PHASE SUIVANTE**: Ce qui se passe ensuite
+   - Continuer avec les actions
+   - **RESTER DANS LE SCOPE**: Limites
+
+## Règles d'Exécution
+- **NON-NÉGOCIABLE**: Règles critiques
+- Autres directives
+
+## Priorité
+[Déclaration de focus].
+```
+
+### Pattern 2: Format Référence/Docs (pour les outils CLI)
+**Utiliser pour**: Wrappers CLI, référence de commandes, commandes de documentation
+
+```markdown
+---
+allowed-tools: Bash(<cli> *)
+description: Commandes [Outil CLI] pour [objectif]
+---
+
+# Commandes CLI [Nom de l'Outil]
+
+## [Catégorie 1]
+\```bash
+# Commentaire expliquant la commande
+tool command --flag
+
+# Autre exemple
+tool other-command <arg>
+\```
+
+## [Catégorie 2]
+\```bash
+# Plus de commandes groupées par fonction
+\```
+
+## Workflows Communs
+
+### [Nom du Workflow]
+\```bash
+# Exemple étape par étape
+# 1. Première commande
+tool setup
+
+# 2. Action principale
+tool action --flag
+\```
+```
+
+### Pattern 3: Analyse Basée sur Sections (pour recherche/analyse)
+**Utiliser pour**: Commandes d'analyse, tâches de recherche, workflows d'investigation
+
+```markdown
+---
+description: [Objectif d'analyse]
+allowed-tools: [Outils de recherche]
+---
+
+Tu es un [rôle d'analyste]. [Déclaration d'objectif].
+
+## [Nom de Phase]
+
+**Objectif**: [Ce que cela accomplit]
+
+- Éléments d'action
+- **CRITIQUE**: Contraintes
+- Utiliser `outils spécifiques`
+
+## [Autre Phase]
+
+[Structure similaire]
+
+## Règles d'Exécution
+- Directives et contraintes
+```
+
+## Patterns de Commande par Type
+
+### Opérations Git (commit, PR)
+```markdown
+## Workflow
+1. **STAGE**: Préparer les changements
+   - `git add -A` ou staging sélectif
+   - `git status` pour vérifier
+
+2. **COMMIT**: Créer le commit
+   - Générer le message suivant la convention
+   - `git commit -m "type: description"`
+
+3. **PUSH**: Soumettre les changements
+   - `git push` vers le remote
+   - Vérifier avec `gh pr view`
+```
+
+### Commandes CI/Build
+```markdown
+## Workflow
+1. **ATTENDRE**: Délai initial si nécessaire
+   - `sleep 30` pour que la CI démarre
+
+2. **MONITORER**: Surveiller le statut
+   - `gh run list` pour trouver les runs
+   - `gh run watch <id>` pour monitorer
+
+3. **EN CAS D'ÉCHEC**: Corriger et réessayer
+   - Obtenir les logs avec `gh run view --log-failed`
+   - Corriger les problèmes et push
+   - Boucler (max tentatives)
+```
+
+### Exécution de Tâches (pattern EPCT)
+```markdown
+## Workflow
+1. **EXPLORER**: Rassembler les informations
+   - Rechercher avec des agents parallèles
+   - Trouver les fichiers pertinents
+
+2. **PLANIFIER**: Créer la stratégie
+   - Documenter l'approche
+   - Poster le plan en commentaire si GitHub issue
+
+3. **CODER**: Implémenter les changements
+   - Suivre les patterns existants
+   - Rester dans le scope
+
+4. **TESTER**: Vérifier les changements
+   - Lancer uniquement les tests pertinents
+   - Vérifier lint et types
+```
+
+### Commandes Wrapper CLI
+```markdown
+## Workflow
+1. **PARSER**: Obtenir les arguments de $ARGUMENTS
+   - Valider le format d'entrée
+   - Extraire les paramètres
+
+2. **EXÉCUTER**: Lancer la commande CLI
+   - `cli-tool command --flags`
+   - Gérer la sortie
+
+3. **RAPPORTER**: Montrer les résultats
+   - Parser et formater la sortie
+   - Mettre en évidence les infos importantes
+```
+
+## Directives Métadonnées
+
+### allowed-tools
+- **Commandes Git**: `Bash(git :*)`
+- **GitHub CLI**: `Bash(gh :*)`
+- **CLI spécifique**: `Bash(npm :*)`, `Bash(vercel :*)`
+- **Opérations fichiers**: `Read, Edit, MultiEdit, Write`
+- **Autres**: `Task`, `WebFetch`, etc.
+
+### argument-hint
+Inclure uniquement si la commande prend des arguments:
+- `<chemin-fichier>` - entrée d'un seul fichier
+- `<numéro-issue|url-issue>` - types d'entrée multiples
+- `<action> <cible>` - arguments multi-parties
+- Sauter pour les commandes simples comme `commit`
+
+## Patterns d'Emphase
+
+- **CRITIQUE/DOIT/JAMAIS**: Règles non-négociables
+- **RESTER DANS LE SCOPE**: Prévenir le feature creep
+- **AVANT [action]**: Prérequis
+- **NON-NÉGOCIABLE**: Exigences absolues
+- **STOP**: Conditions d'arrêt
+
+## Règles d'Exécution
+
+- **Les commandes sont avec état** - peuvent référencer les étapes précédentes
+- **Utiliser des workflows numérotés** pour une séquence claire
+- **Inclure les commandes exactes** pas d'abstractions
+- **Ajouter des étapes de vérification** après les actions
+- **Définir le comportement en cas d'échec** (réessayer, arrêter, demander)
+
+## Priorité
+
+Actionnabilité > Complétude. Rendre chaque étape exécutable.

package/commands/liste-commande.md

@@ -0,0 +1,103 @@
+---
+description: Afficher la liste de toutes les commandes et agents avec exemples d'utilisation
+allowed-tools: Read, Glob
+argument-hint: [--exemples | -e]
+---
+
+Tu es un assistant qui liste les commandes et agents disponibles avec leurs exemples d'utilisation.
+
+## Workflow
+
+1. **PARSER L'ARGUMENT** :
+   - Vérifier si `--exemples` ou `-e` est passé en argument
+   - Mode normal: liste simple
+   - Mode exemples: liste + exemples d'utilisation
+
+2. **LISTER LES COMMANDES** :
+   - Utiliser `Glob` avec le pattern `*.md` dans `/Users/jeremy/.claude/commands/`
+   - Pour chaque fichier, utiliser `Read` pour lire le frontmatter YAML et le contenu
+   - Extraire la description entre les `---`
+   - Si mode exemples: extraire aussi les exemples du contenu
+
+3. **LISTER LES AGENTS** :
+   - Utiliser `Glob` avec le pattern `*.md` dans `/Users/jeremy/.claude/agents/`
+   - Pour chaque fichier, utiliser `Read` pour lire le frontmatter YAML et le contenu
+   - Extraire le `name` et `description` entre les `---`
+   - Si mode exemples: créer des exemples basés sur la description
+
+4. **AFFICHER** :
+   - Afficher les commandes dans une section
+   - Afficher les agents dans une autre section
+   - Si mode exemples: ajouter un exemple d'utilisation pour chaque
+
+## Format de Sortie (Mode Normal)
+
+```
+🔧 COMMANDES DISPONIBLES
+
+/nom-commande    Description de la commande
+/autre-commande  Description de l'autre commande
+
+🤖 AGENTS DISPONIBLES
+
+@nom-agent       Description de l'agent
+@autre-agent     Description de l'autre agent
+
+💡 Pour voir des exemples: /liste-commande --exemples
+```
+
+## Format de Sortie (Mode Exemples)
+
+```
+🔧 COMMANDES DISPONIBLES
+
+/commit
+└─ Commit et push rapides avec messages minimaux
+   Exemple: /commit
+
+/corriger-orthographe
+└─ Corriger les erreurs de grammaire et d'orthographe
+   Exemple: /corriger-orthographe src/components/Header.vue
+   Exemple: /corriger-orthographe src/*.vue
+
+/surveiller-ci
+└─ Surveiller et corriger automatiquement les erreurs de CI
+   Exemple: /surveiller-ci
+
+🤖 AGENTS DISPONIBLES
+
+@explorer-docs
+└─ Explorer la documentation de bibliothèques avec exemples de code
+   Exemple: @explorer-docs cherche la doc de Nuxt 4
+   Exemple: Comment utiliser les server routes dans Vue 3 ?
+
+@recherche-web
+└─ Recherche web rapide avec sources fiables
+   Exemple: @recherche-web quoi de neuf dans TypeScript 5.7
+   Exemple: Trouve-moi des infos sur l'API Context7
+```
+
+## Exemples par Défaut
+
+Si le fichier ne contient pas d'exemples, génère des exemples intelligents basés sur:
+- Le nom de la commande/agent
+- La description
+- L'argument-hint si présent
+
+**Exemples types** :
+- Commandes sans arguments: Juste `/nom-commande`
+- Commandes avec fichiers: `/nom-commande chemin/vers/fichier.ext`
+- Agents: `@nom-agent [question ou contexte]` ou en conversationnel
+
+## Règles
+
+- Ne pas inclure le fichier `liste-commande.md` lui-même dans la liste
+- Trier par ordre alphabétique
+- Format compact et lisible
+- En mode normal: juste lister
+- En mode exemples: exemples clairs et concrets
+- Les exemples doivent être copy-paste ready
+
+## Priorité
+
+Clarté > Détails. Exemples pratiques et immédiatement utilisables.

package/commands/memoire-claude.md

@@ -0,0 +1,190 @@
+---
+description: Créer et mettre à jour les fichiers CLAUDE.md en suivant les meilleures pratiques
+allowed-tools: Read, Write, Edit, MultiEdit, Glob, Grep, Bash(find *)
+argument-hint: <action> <chemin> - ex: "create global", "update apps/web/CLAUDE.md"
+---
+
+Tu es un spécialiste CLAUDE.md. Crée et maintiens des fichiers de mémoire de projet qui guident Claude Code efficacement en utilisant les meilleures pratiques officielles.
+
+Tu dois ULTRA PENSER à la spécificité, la clarté et les conseils actionnables.
+
+## Workflow
+
+1. **PARSER LES ARGUMENTS**: Déterminer l'action et la portée
+   - `create global`: Nouveau CLAUDE.md global à la racine du dépôt
+   - `create <chemin-dossier>`: Nouveau CLAUDE.md spécifique à un dossier
+   - `update <chemin>`: Mettre à jour un CLAUDE.md existant avec du nouveau contenu
+   - **CRITIQUE**: Valider le chemin et déterminer si global ou spécifique au dossier
+
+2. **ANALYSER LE CONTEXTE**: Rechercher les patterns existants en suivant les meilleures pratiques officielles
+   - Utiliser `Glob` pour trouver les fichiers CLAUDE.md existants comme référence
+   - `Read` package.json, README.md et fichiers clés pour comprendre la structure du projet
+   - `Grep` pour les patterns d'import, frameworks et commandes
+   - **CRITIQUE**: Focus sur la spécificité - "Utiliser indentation de 2 espaces" pas "Formater le code correctement"
+   - **ULTRA PENSER**: Quel contexte actionnable et spécifique Claude a-t-il besoin le plus?
+
+3. **RASSEMBLER LES EXIGENCES**: Collecter les informations spécifiques au projet
+   - **Pour Global**: Architecture, stack technique, déploiement, commandes clés
+   - **Pour Dossier**: Patterns spécifiques, conventions, fichiers importants dans ce dossier
+   - Utiliser `find` et l'exploration de fichiers pour comprendre la structure
+   - **CRITIQUE**: Focus sur les conseils actionnables, pas seulement la documentation
+
+4. **CRÉER/METTRE À JOUR LE CONTENU**: Construire des conseils complets en suivant les meilleures pratiques officielles
+   - **Utiliser des points de liste markdown** pour une organisation claire
+   - **Grouper les mémoires liées** sous des titres markdown descriptifs
+   - **Être extrêmement spécifique**: Inclure les commandes exactes, chemins de fichiers, patterns
+   - **Inclure la syntaxe @** pour les imports (ex: @apps/web/src/lib/safe-route.ts)
+   - **Maximum 5 sauts d'import** pour les inclusions récursives
+   - **ULTRA PENSER**: Quels patterns spécifiques et actionnables Claude va-t-il rencontrer de manière répétée?
+
+5. **VALIDER ET SAUVEGARDER**: Assurer la qualité et sauvegarder
+   - Vérifier que toutes les commandes sont exactes avec la structure du projet
+   - Vérifier que les chemins de fichiers existent et sont corrects
+   - `Write` à l'emplacement cible
+   - **CRITIQUE**: Tester les commandes mentionnées si possible
+
+## Template CLAUDE.md Global (Suivant les Meilleures Pratiques Officielles)
+
+```markdown
+# CLAUDE.md
+
+Ce fichier fournit des conseils à Claude Code lors du travail avec le code dans ce dépôt.
+
+## Commandes de Développement
+
+### Commandes Principales
+- `pnpm dev` - Démarrer le serveur de développement
+- `pnpm build` - Build tous les packages
+- `pnpm lint` - Lancer ESLint avec config spécifique
+- `pnpm test` - Lancer les tests (spécifier la commande de test exacte)
+
+### [Commandes d'Application Spécifiques]
+- `pnpm dev:web` - Démarrer Next.js avec Turbo
+- **TOUJOURS lancer `pnpm ts` après modification de fichiers TypeScript**
+
+## Vue d'Ensemble de l'Architecture
+
+**Stack Technique**: [Versions et configurations spécifiques]
+- Next.js 15 avec App Router
+- TypeScript avec mode strict activé
+- Prisma avec PostgreSQL
+
+### Applications/Packages Clés
+- **apps/web** - Application Next.js (produit principal)
+- **packages/database** - Client Prisma et schémas
+
+### [Patterns Spécifiques au Framework]
+- **Routes API**: Toujours utiliser le pattern @src/lib/safe-route.ts
+- **Server Actions**: Utiliser @src/lib/safe-action.ts avec le nommage ACTION_NAME.action.ts
+
+## Style de Code & Conventions
+
+- **Indentation**: Utiliser 2 espaces (pas de tabs)
+- **Imports**: Utiliser @/ pour les imports du dossier src
+- **Composants**: Utiliser uniquement les composants shadcn/ui
+- **Styling**: Utiliser l'utilitaire `cn()` pour les classes conditionnelles
+
+## Workflow
+
+- **Après modification de fichiers**: Toujours lancer `pnpm lint` et `pnpm ts` dans apps/web
+- **Avant commits**: Vérifier que TypeScript compile avec succès
+```
+
+## Template CLAUDE.md de Dossier
+
+```markdown
+### Structure du Répertoire ([nom-du-dossier])
+
+- [Répertoires clés et leur objectif]
+
+## Directives [Framework/Technologie]
+
+[Patterns spécifiques pour le stack technique de ce dossier]
+
+## Workflow de Développement
+
+[Commandes spécifiques au dossier et étapes de vérification]
+
+## Commandes
+
+[Commandes build/test/lint spécifiques au dossier]
+
+## Important
+
+[Patterns critiques avec exemples de fichiers spécifiques utilisant la syntaxe @]
+```
+
+## Patterns d'Emphase et de Priorité (Critique pour l'Efficacité de CLAUDE.md)
+
+### Techniques d'Emphase à Fort Impact
+- **CRITIQUE**: Utiliser pour les exigences non-négociables qui cassent les fonctionnalités si ignorées
+- **TOUJOURS**: Pour les actions obligatoires qui doivent se produire à chaque fois
+- **JAMAIS**: Pour les actions qui causeront des problèmes ou casseront les patterns
+- **AVANT [action]**: Pour les prérequis nécessaires
+- **APRÈS [action]**: Pour les étapes de suivi nécessaires
+
+### Formatage pour un Impact Maximum
+- **Texte en gras**: Pour les commandes, chemins de fichiers et concepts clés
+- `Blocs de code`: Pour les commandes exactes et chemins de fichiers
+- **Mots-clés EN MAJUSCULES**: CRITIQUE, TOUJOURS, JAMAIS, DOIT, REQUIS
+- Points de liste avec emphase: **TOUJOURS lancer `pnpm ts` après changements TypeScript**
+
+### Structure de Priorité (Du Plus au Moins Important)
+1. **Commandes qui cassent les builds/déploiements** - Marquer comme CRITIQUE
+2. **Étapes de workflow requises** - Marquer comme TOUJOURS/DOIT
+3. **Patterns de fichiers et conventions** - Utiliser gras et exemples
+4. **Directives utiles** - Points de liste standards
+
+### Exemples d'Emphase Efficace
+```markdown
+- **CRITIQUE**: Toujours utiliser @src/lib/safe-route.ts pour les routes API
+- **JAMAIS** importer directement depuis les dossiers internes de packages
+- **AVANT de commiter**: Lancer `pnpm lint` et `pnpm ts` dans apps/web
+- **REQUIS**: Utiliser uniquement les composants shadcn/ui (pas de frameworks CSS custom)
+```
+
+## Stratégie de Collecte de Contenu
+
+### Pour CLAUDE.md Global:
+- **Commandes**: Extraire depuis scripts package.json, Makefile, fichiers CI
+- **Architecture**: Analyser structure de dossiers, dépendances principales
+- **Stack Technique**: Lire package.json, patterns d'import, fichiers de config
+- **Déploiement**: Trouver configs de déploiement (Vercel, Docker, etc.)
+- **Environnement**: Scanner fichiers .env, patterns de config
+
+### Pour CLAUDE.md de Dossier:
+- **Patterns**: Analyser les fichiers existants dans le dossier pour les conventions
+- **Imports**: Patterns d'import communs et usage de bibliothèques
+- **Types de Fichiers**: Routes API, composants, patterns utilitaires
+- **Conventions**: Nommage, structure, patterns spécifiques au framework
+
+## Stratégie de Mise à Jour
+
+Lors de la mise à jour d'un CLAUDE.md existant:
+1. **PRÉSERVER**: Garder la structure existante et le contenu fonctionnel
+2. **AMÉLIORER**: Ajouter les nouveaux patterns trouvés dans la demande de mise à jour
+3. **ORGANISER**: Placer le nouveau contenu dans les sections appropriées
+4. **VALIDER**: Assurer que les nouvelles additions n'entrent pas en conflit avec les conseils existants
+
+## Règles d'Exécution
+
+- **NE JAMAIS ASSUMER**: Toujours vérifier que les commandes et chemins de fichiers existent
+- **ÊTRE EXTRÊMEMENT SPÉCIFIQUE**: "Utiliser indentation de 2 espaces" pas "Formater le code correctement"
+- **METTRE L'EMPHASE SUR LES ÉLÉMENTS CRITIQUES**: Utiliser CRITIQUE, TOUJOURS, JAMAIS pour les règles importantes
+- **TESTER LES COMMANDES**: Valider toutes les commandes mentionnées dans CLAUDE.md
+- **SUIVRE LA HIÉRARCHIE**: Règles critiques → Workflow requis → Patterns → Directives
+- **ULTRA PENSER**: Qu'est-ce qui va casser si Claude ne suit pas cela exactement?
+
+## Checklist d'Efficacité de CLAUDE.md
+
+Avant de sauvegarder n'importe quel CLAUDE.md:
+- ☐ **Les commandes sont testées et fonctionnent**
+- ☐ **Les éléments critiques utilisent l'emphase appropriée** (CRITIQUE, TOUJOURS, JAMAIS)
+- ☐ **Les chemins de fichiers utilisent la syntaxe @** et existent
+- ☐ **Spécifique plutôt que générique** ("Utiliser l'utilitaire `cn()`" pas "Utiliser de bons noms de classes")
+- ☐ **Structure hiérarchique** avec titres markdown clairs
+- ☐ **Conseils actionnables** - chaque ligne dit à Claude quoi faire
+
+## Priorité
+
+Spécificité > Complétude. Chaque instruction devrait être immédiatement exécutable avec l'emphase appropriée.