🛠️ WD Framework - Guide Utilisateur

Pour qui? Développeurs qui veulent maîtriser les 22 commandes, les workflows avancés et les options de personnalisation.

📖 Table des Matières

Les 22 Commandes Expliquées
Les 11 Personas en Détail
Les 5 Agents Spécialisés
Guide Complet des Flags
Workflows Courants
Stratégies d'Orchestration
Serveurs MCP
Exemples Avancés

Les 22 Commandes Expliquées

🏗️ Commandes d'Implémentation

`/wd:implement` - Implémenter du Code

Usage: Créer ou modifier des fonctionnalités, composants ou systèmes

Syntaxe:

/wd:implement <description> [--flags]

Quand l'utiliser:

✅ Créer un nouveau composant/feature
✅ Ajouter une fonctionnalité existante
✅ Modifier du code existant
✅ Intégrer des APIs externes

Comportement automatique:

Active automatiquement le persona approprié (frontend/backend/etc.)
Détecte le framework (React/Vue/Angular/etc.)
Génère tests + documentation
Applique les 8 quality gates

Exemples:

# Simple
/wd:implement Créer un composant de pagination

# Avec persona spécifique
/wd:implement API REST pour gestion utilisateurs --persona-backend

# Feature complexe avec orchestration
/wd:implement Système de notifications temps réel --wave-mode force --ultrathink

# Avec agent dédié
/wd:implement Dashboard analytics --agent wd-frontend-agent

# Avec MCP servers
/wd:implement Composant React de calendrier --c7 --magic

Options recommandées:

--ultrathink pour features complexes
--wave-mode auto pour multi-étapes
--agents pour coordination multi-domaines
--all-mcp pour utiliser tous les outils disponibles

`/wd:build` - Construire le Projet

Usage: Builder, compiler et préparer le projet pour le déploiement

Syntaxe:

/wd:build [target] [--flags]

Quand l'utiliser:

✅ Builder pour production
✅ Tester le build process
✅ Optimiser les bundles
✅ Résoudre des erreurs de build

Comportement automatique:

Détecte le build system (Webpack/Vite/Rollup/etc.)
Active persona DevOps
Optimise les assets automatiquement
Génère les sourcemaps
Valide le bundle size

Exemples:

# Build standard
/wd:build

# Build avec optimisation maximale
/wd:build production --persona-performance

# Build avec analyse
/wd:build --analyze-bundle

# Build multi-environnements
/wd:build staging --env staging

`/wd:design` - Designer l'Architecture

Usage: Concevoir l'architecture système, APIs ou composants

Syntaxe:

/wd:design <description> [--flags]

Quand l'utiliser:

✅ Avant de commencer un projet
✅ Refonte d'architecture existante
✅ Design d'APIs
✅ Planning de microservices

Comportement automatique:

Active persona Architect
Utilise Sequential MCP pour analyse profonde
Génère diagrammes (architecture, séquence, classes)
Propose patterns adaptés (SOLID, DDD, etc.)
Considère scalabilité et maintenabilité

Exemples:

# Architecture application
/wd:design Architecture pour application e-commerce scalable

# Design API
/wd:design API REST pour gestion de contenu --persona-backend

# Microservices
/wd:design Architecture microservices pour plateforme SaaS --seq --ultrathink

# Design pattern
/wd:design Stratégie de state management pour app React complexe

📊 Commandes d'Analyse

`/wd:analyze` - Analyser le Code

Usage: Analyse multi-dimensionnelle du code (performance, sécurité, qualité)

Syntaxe:

/wd:analyze [type] [--flags]

Types d'analyse:

security - Audit de sécurité (OWASP Top 10)
performance - Analyse des performances
quality - Qualité du code (code smells, complexité)
architecture - Architecture et structure
dependencies - Analyse des dépendances
(vide) - Analyse complète

Exemples:

# Analyse complète
/wd:analyze

# Analyse de sécurité
/wd:analyze security --persona-security --seq

# Analyse de performance
/wd:analyze performance --persona-performance

# Analyse de qualité
/wd:analyze quality --persona-qa

# Multi-agents parallèles
/wd:analyze Audit complet --agents --all-mcp

Résultats typiques:

Score de qualité (0-100)
Vulnérabilités détectées (critical/high/medium/low)
Recommandations priorisées
Métriques (complexité cyclomatique, couverture tests, etc.)
Plan d'action suggéré

`/wd:explain` - Expliquer le Code

Usage: Obtenir des explications pédagogiques sur du code complexe

Syntaxe:

/wd:explain <code ou fichier> [--flags]

Quand l'utiliser:

✅ Comprendre du code legacy
✅ Onboarding de nouveaux développeurs
✅ Documentation de logique complexe
✅ Apprentissage de nouveaux patterns

Comportement automatique:

Active persona Mentor
Adapte le niveau d'explication (débutant/intermédiaire/avancé)
Génère des diagrammes si nécessaire
Propose des analogies
Identifie les patterns utilisés

Exemples:

# Expliquer un fichier
/wd:explain src/utils/authentication.ts

# Expliquer pour débutants
/wd:explain Comment fonctionne le système de routing --persona-mentor

# Explication technique avancée
/wd:explain Architecture du state management --ultrathink

# Avec diagrammes
/wd:explain Flux de données dans l'application

♻️ Commandes d'Amélioration

`/wd:improve` - Améliorer le Code

Usage: Améliorer qualité, performance, maintenabilité du code existant

Syntaxe:

/wd:improve <cible> [--flags]

Ce qui est amélioré:

Performance (optimisations)
Lisibilité (nommage, structure)
Maintenabilité (découpage, patterns)
Sécurité (vulnérabilités)
Tests (couverture)
Documentation

Exemples:

# Amélioration générale
/wd:improve src/components/Dashboard.tsx

# Amélioration avec focus spécifique
/wd:improve Optimiser les performances --persona-performance

# Refactoring complet
/wd:improve Refactorer l'application --wave-mode force --ultrathink

# Amélioration sécurité
/wd:improve Sécuriser l'authentification --persona-security

Modes d'amélioration:

Quick: Optimisations rapides (5-10 min)
Moderate: Refactoring standard (15-30 min)
Deep: Refactoring profond avec waves (30-60 min)

`/wd:cleanup` - Nettoyer le Code

Usage: Supprimer code mort, dépendances inutilisées, fichiers temporaires

Syntaxe:

/wd:cleanup [scope] [--flags]

Ce qui est nettoyé:

Code mort (unused functions, variables)
Imports inutilisés
Dépendances obsolètes
Fichiers temporaires
Commentaires obsolètes
Console.log de debug

Exemples:

# Nettoyage complet
/wd:cleanup

# Nettoyer un dossier spécifique
/wd:cleanup src/components

# Nettoyer les dépendances
/wd:cleanup dependencies

# Avec confirmation
/wd:cleanup --dry-run  # Voir ce qui sera supprimé sans le faire

⚠️ Précautions:

Toujours commiter avant un cleanup
Utiliser --dry-run pour prévisualiser
Le framework crée un backup automatique
Les tests sont relancés après cleanup

🧪 Commandes de Test

`/wd:test` - Tester le Code

Usage: Exécuter, générer et maintenir les tests

Syntaxe:

/wd:test [type] [--flags]

Types de tests:

unit - Tests unitaires
integration - Tests d'intégration
e2e - Tests End-to-End (avec Playwright)
coverage - Rapport de couverture
generate - Générer des tests manquants

Exemples:

# Exécuter tous les tests
/wd:test

# Tests unitaires seulement
/wd:test unit

# Générer tests manquants
/wd:test generate --agent wd-test-agent

# Tests E2E avec Playwright
/wd:test e2e --play

# Coverage report
/wd:test coverage

# Tests avec benchmark
/wd:test --benchmark

Objectifs de couverture:

Unit tests: ≥80%
Integration tests: ≥70%
E2E tests: Parcours critiques

`/wd:benchmark` - Benchmark Performance

Usage: Mesurer et comparer les performances

Syntaxe:

/wd:benchmark <cible> [--flags]

Métriques mesurées:

Temps d'exécution
Utilisation mémoire
Débit (requests/sec)
Latence (p50, p95, p99)
Bundle size
Time to Interactive (TTI)
First Contentful Paint (FCP)

Exemples:

# Benchmark d'une fonction
/wd:benchmark src/utils/processData.ts

# Benchmark avant/après optimisation
/wd:benchmark Compare performance --baseline main

# Benchmark complet
/wd:benchmark Application complète --persona-performance

# Benchmark avec load testing
/wd:benchmark API endpoints --load 1000req/s

📚 Commandes de Documentation

`/wd:document` - Documenter

Usage: Générer documentation complète et professionnelle

Syntaxe:

/wd:document <cible> [--type inline|external|api|guide] [--flags]

Types de documentation:

inline - Commentaires dans le code
external - Fichiers markdown séparés
api - Documentation API (OpenAPI/Swagger)
guide - Guides utilisateur/développeur

Exemples:

# Documentation complète
/wd:document

# Documenter un fichier
/wd:document src/api/users.ts --type api

# Guide utilisateur
/wd:document Guide d'utilisation --type guide --persona-scribe

# Documentation multilingue
/wd:document --lang fr,en

# Documentation avec diagrammes
/wd:document Architecture système

Génération automatique:

JSDoc/TSDoc pour les fonctions
README.md pour les modules
API documentation (Swagger)
Guides de démarrage
Architecture diagrams

🔧 Commandes Utilitaires

`/wd:git` - Opérations Git

Usage: Gestion intelligente des opérations Git

Syntaxe:

/wd:git <operation> [--flags]

Opérations supportées:

commit - Commit intelligent avec message auto-généré
pr - Créer une Pull Request
review - Review des changements
branch - Gestion des branches
merge - Merge intelligent

Exemples:

# Commit intelligent
/wd:git commit

# Créer PR avec description
/wd:git pr --title "Add authentication system"

# Review avant commit
/wd:git review

# Merge avec résolution conflits
/wd:git merge develop

Messages de commit auto-générés:

Analyse des changements (git diff)
Suit les conventions (Conventional Commits)
Groupé par type (feat, fix, refactor, docs, etc.)
Inclut scope et breaking changes

`/wd:spawn` - Orchestrer des Tâches

Usage: Diviser et orchestrer des tâches complexes en parallèle

Syntaxe:

/wd:spawn <description> [--flags]

Quand l'utiliser:

✅ Tâches indépendantes multiples
✅ Analyse multi-dimensionnelle
✅ Coordination multi-agents
✅ Optimisation du temps d'exécution

Exemples:

# Analyse parallèle
/wd:spawn Analyser frontend, backend et sécurité en parallèle

# Implémentation coordonnée
/wd:spawn Implémenter système de paiement (frontend + backend + tests)

# Migration
/wd:spawn Migrer de Vue 2 à Vue 3 --agents

Pattern d'orchestration:

Tâche complexe détectée
    ↓
Analyse des dépendances
    ↓
Création de sous-tâches
    ↓
├─ Agent 1 (parallèle)
├─ Agent 2 (parallèle)
└─ Agent 3 (parallèle)
    ↓
Agrégation des résultats
    ↓
Validation globale

`/wd:task` - Gestion de Tâches

Usage: Gérer des tâches longues avec persistance inter-sessions

Syntaxe:

/wd:task <action> [--flags]

Actions:

create - Créer une tâche
list - Lister les tâches
status - Statut d'une tâche
resume - Reprendre une tâche
complete - Marquer comme complétée

Exemples:

# Créer une tâche longue
/wd:task create "Migration vers TypeScript"

# Lister les tâches en cours
/wd:task list

# Reprendre une tâche
/wd:task resume task-123

# Marquer comme complétée
/wd:task complete task-123

🚀 Commandes Avancées

`/wd:workflow` - Générer un Workflow

Usage: Créer un workflow structuré depuis un PRD ou spécification

Syntaxe:

/wd:workflow <source> [--flags]

Ce qui est généré:

Plan d'implémentation détaillé
Séquence de tâches ordonnées
Estimations de temps
Dépendances identifiées
Checkpoints de validation

Exemples:

# Depuis un PRD
/wd:workflow docs/prd.md

# Depuis une description
/wd:workflow "Créer un marketplace avec paiements et chat"

# Workflow avec estimation
/wd:workflow feature-spec.md --estimate

`/wd:estimate` - Estimer l'Effort

Usage: Estimer le temps et la complexité d'un développement

Syntaxe:

/wd:estimate <description> [--flags]

Métriques fournies:

Temps estimé (optimiste/réaliste/pessimiste)
Complexité (0-1)
Risques identifiés
Dépendances externes
Recommandations

Exemples:

# Estimer une feature
/wd:estimate Système de notifications temps réel

# Estimer un projet
/wd:estimate docs/project-spec.md --ultrathink

# Estimation comparative
/wd:estimate "Option A vs Option B" --compare

`/wd:troubleshoot` - Dépanner

Usage: Diagnostiquer et résoudre des problèmes

Syntaxe:

/wd:troubleshoot <problème> [--flags]

Types de problèmes:

Bugs de code
Erreurs de build
Problèmes de performance
Issues de déploiement
Conflits de dépendances

Exemples:

# Diagnostiquer une erreur
/wd:troubleshoot "TypeError: Cannot read property 'x' of undefined"

# Problème de performance
/wd:troubleshoot Page lente au chargement --persona-performance

# Erreur de build
/wd:troubleshoot Build failed with webpack error

# Avec analyse approfondie
/wd:troubleshoot Application crash en production --seq --ultrathink

`/wd:migrate` - Migrer

Usage: Migrer frameworks, librairies ou architectures

Syntaxe:

/wd:migrate <from> <to> [--flags]

Migrations supportées:

Frameworks (Vue 2→3, React 17→18, Angular)
Build tools (Webpack→Vite)
State management (Redux→Zustand)
Styles (CSS→Tailwind)
Backend (Express→Fastify)

Exemples:

# Migration de framework
/wd:migrate "Vue 2" "Vue 3" --wave-mode force

# Migration de styling
/wd:migrate CSS Tailwind --agent wd-frontend-agent

# Migration complète
/wd:migrate "Monolith" "Microservices" --ultrathink --seq

Process de migration:

🌊 Vague 1: ANALYSE
   - État actuel
   - Dépendances
   - Breaking changes

🌊 Vague 2: PLANNING
   - Stratégie de migration
   - Ordre des opérations
   - Points de validation

🌊 Vague 3: MIGRATION
   - Transformation du code
   - Mise à jour dépendances
   - Adaptation des tests

🌊 Vague 4: VALIDATION
   - Tests de non-régression
   - Validation fonctionnelle
   - Performance check

🌊 Vague 5: FINALISATION
   - Documentation
   - Cleanup
   - Guide de déploiement

`/wd:finalize` - Finaliser

Usage: Préparer un projet pour la production

Syntaxe:

/wd:finalize [--flags]

Checklist de finalisation:

✅ Tous les tests passent (100%)
✅ Couverture tests ≥80%
✅ Audit de sécurité (0 critical, 0 high)
✅ Performance optimisée
✅ Documentation complète
✅ Build production réussi
✅ Configuration deployment
✅ Environnement variables

Exemples:

# Finalisation standard
/wd:finalize

# Finalisation avec audit complet
/wd:finalize --comprehensive --all-mcp

# Génération release notes
/wd:finalize --release-notes

Les 11 Personas en Détail

🏛️ Architect - L'Architecte Système

Priorités:

Scalabilité
Maintenabilité
Séparation des préoccupations
Patterns robustes

Quand il s'active:

Mots-clés: "architecture", "design", "structure", "scalable"
Projets complexes (≥0.7 complexité)
Refonte d'architecture

Outils préférés:

Sequential MCP (analyse profonde)
Context7 (patterns et best practices)

Principes appliqués:

SOLID
DDD (Domain-Driven Design)
Clean Architecture
Microservices patterns

Exemple de décision:

Demande: "Organiser le code de l'application"

Architect Persona analyse:
├─ Taille du projet: Grande (>50 fichiers)
├─ Complexité: Élevée (multiple domaines)
└─ Recommandation:
   ├─ Architecture en couches
   ├─ Domain/Application/Infrastructure
   ├─ Dependency Injection
   └─ Event-driven communication

Activation manuelle:

/wd:design --persona-architect
/wd:implement --persona-architect

🎨 Frontend - Le Spécialiste UI/UX

Priorités:

Expérience utilisateur
Accessibilité (WCAG 2.1)
Performance de rendu
Responsive design

Quand il s'active:

Mots-clés: "composant", "interface", "UI", "React", "Vue"
Fichiers: *.tsx, *.jsx, *.vue, *.svelte
Domaine: Interface utilisateur

Outils préférés:

Magic MCP (génération de composants)
Context7 (patterns UI/UX)
Playwright (tests visuels)

Validations spécifiques:

Accessibilité (ARIA labels, keyboard navigation)
Responsive (mobile/tablet/desktop)
Performance (Lighthouse score ≥90)
Design system consistency

Exemple de décision:

Demande: "Créer un formulaire de connexion"

Frontend Persona génère:
├─ Composant React/Vue accessible
├─ Validation côté client (UX rapide)
├─ États: default, loading, error, success
├─ Responsive design
├─ Dark mode support
├─ Keyboard navigation
└─ Tests d'accessibilité

Activation manuelle:

/wd:implement --persona-frontend

🔧 Backend - L'Ingénieur de Fiabilité

Priorités:

Fiabilité (uptime 99.9%+)
Gestion d'erreurs robuste
Performance des APIs
Sécurité des données

Quand il s'active:

Mots-clés: "API", "database", "endpoint", "serveur"
Fichiers: .controller., .service., .repository.
Domaine: Backend/Serveur

Outils préférés:

Sequential MCP (logique complexe)
Context7 (patterns backend)

Validations spécifiques:

Gestion d'erreurs (try/catch, error middleware)
Logging structuré
Rate limiting
Input validation
Transaction management

Exemple de décision:

Demande: "Créer un endpoint pour créer un utilisateur"

Backend Persona génère:
├─ Route POST /api/users
├─ Validation des inputs (Joi/Zod)
├─ Hash du mot de passe (bcrypt)
├─ Transaction database
├─ Gestion d'erreurs complète
├─ Logging (création utilisateur)
├─ Rate limiting (anti-spam)
└─ Tests unitaires + intégration

Activation manuelle:

/wd:implement --persona-backend

🔒 Security - L'Expert Sécurité

Priorités:

Prévention des vulnérabilités
Authentification robuste
Chiffrement des données
Conformité (RGPD, SOC2)

Quand il s'active:

Mots-clés: "sécurité", "auth", "vulnérabilité", "OWASP"
Analyse de code sensible (auth, payment)
Audit de sécurité

Outils préférés:

Sequential MCP (analyse de menaces)
Context7 (sécurité best practices)

Validations spécifiques:

OWASP Top 10
Input sanitization
SQL Injection prevention
XSS prevention
CSRF protection
Secrets management

Exemple de décision:

Demande: "Implémenter l'authentification"

Security Persona valide:
├─ Mots de passe: bcrypt (cost ≥12)
├─ Tokens: JWT avec expiration
├─ Session: httpOnly cookies
├─ Rate limiting sur /login
├─ 2FA optionnel
├─ Logs d'authentification
├─ Password requirements (min 12 chars)
└─ Protection brute-force

Activation manuelle:

/wd:analyze security --persona-security

⚡ Performance - L'Optimiseur

Priorités:

Temps de réponse <100ms
Optimisation mémoire
Réduction du bundle size
Caching stratégique

Quand il s'active:

Mots-clés: "lent", "optimiser", "performance", "rapide"
Analyse de performance
Problèmes de latence

Outils préférés:

Sequential MCP (analyse approfondie)
Playwright (benchmarks E2E)

Métriques surveillées:

Time to First Byte (TTFB)
First Contentful Paint (FCP)
Largest Contentful Paint (LCP)
Time to Interactive (TTI)
Total Blocking Time (TBT)

Exemple de décision:

Demande: "Page lente à charger"

Performance Persona analyse:
├─ Profiling du code
├─ Identification des bottlenecks:
│  ├─ Bundle size trop gros (3MB → 500KB)
│  ├─ Requêtes non optimisées (N+1)
│  ├─ Images non optimisées
│  └─ Absence de caching
├─ Optimisations:
│  ├─ Code splitting
│  ├─ Lazy loading
│  ├─ Image optimization
│  ├─ Caching Redis
│  └─ Memoization React
└─ Résultat: -70% temps de chargement

Activation manuelle:

/wd:improve --persona-performance
/wd:analyze performance --persona-performance

🔍 Analyzer - L'Investigateur

Priorités:

Root cause analysis
Compréhension profonde
Identification des patterns
Debugging systématique

Quand il s'active:

Mots-clés: "debug", "pourquoi", "comprendre", "analyser"
Investigation de bugs
Code review

Outils préférés:

Sequential MCP (raisonnement complexe)
Context7 (patterns connus)

Méthode d'analyse:

1. OBSERVATION
   - Quel est le symptôme exact?
   - Quand se produit le problème?

2. HYPOTHÈSES
   - Quelles sont les causes possibles?
   - Priorisation par probabilité

3. INVESTIGATION
   - Tests des hypothèses
   - Analyse du code concerné
   - Vérification des logs

4. DIAGNOSTIC
   - Root cause identifiée
   - Impact assessment

5. SOLUTION
   - Proposition de fix
   - Prévention future

Activation manuelle:

/wd:troubleshoot --persona-analyzer
/wd:explain --persona-analyzer

✅ QA - L'Avocat de la Qualité

Priorités:

Couverture de tests ≥80%
Zéro bugs critiques
Validation complète
Documentation des tests

Quand il s'active:

Mots-clés: "test", "qualité", "valider", "QA"
Génération de tests
Review de qualité

Outils préférés:

Playwright (tests E2E)
Context7 (testing best practices)

Types de tests générés:

Unit tests (Jest/Vitest)
Integration tests
E2E tests (Playwright)
Visual regression tests
Performance tests

Exemple de décision:

Demande: "Tester le système de paiement"

QA Persona génère:
├─ Unit tests
│  ├─ Validation des montants
│  ├─ Calcul des taxes
│  └─ Gestion des devises
├─ Integration tests
│  ├─ API Stripe
│  ├─ Webhooks
│  └─ Database transactions
├─ E2E tests (Playwright)
│  ├─ Parcours complet paiement
│  ├─ Gestion des erreurs
│  └─ Confirmation de commande
└─ Edge cases
   ├─ Montants négatifs
   ├─ Timeout réseau
   └─ Paiement refusé

Activation manuelle:

/wd:test --persona-qa

♻️ Refactorer - Le Nettoyeur de Code

Priorités:

Code lisible
Réduction de la complexité
Élimination des duplications
Respect des patterns

Quand il s'active:

Mots-clés: "refactor", "améliorer", "nettoyer", "simplifier"
Code smell détecté
Complexité élevée

Code smells détectés:

Fonctions trop longues (>50 lignes)
Complexité cyclomatique élevée
Duplication de code
Naming peu clair
Couplage fort

Exemple de décision:

Code avant (refactorer):
function processUser(user) {
  if (user && user.id) {
    if (user.active === true) {
      if (user.email && user.email.includes('@')) {
        // ... 100 lignes imbriquées
      }
    }
  }
}

Refactorer Persona améliore:
├─ Early returns (réduire imbrication)
├─ Extraction de fonctions
├─ Nommage explicite
├─ Validation séparée
└─ Code résultant: clair, testable, maintenable

Activation manuelle:

/wd:improve --persona-refactorer
/wd:cleanup --persona-refactorer

🚀 DevOps - L'Expert Infrastructure

Priorités:

Automatisation CI/CD
Infrastructure as Code
Monitoring et alerting
Zero-downtime deployment

Quand il s'active:

Mots-clés: "deploy", "CI/CD", "docker", "kubernetes"
Configuration d'infrastructure
Problèmes de déploiement

Outils configurés:

Docker & Docker Compose
Kubernetes
GitHub Actions / GitLab CI
Terraform
Monitoring (Prometheus, Grafana)

Exemple de décision:

Demande: "Configurer le déploiement"

DevOps Persona configure:
├─ Dockerfile optimisé (multi-stage)
├─ Docker Compose (dev environment)
├─ CI/CD Pipeline:
│  ├─ Lint
│  ├─ Tests
│  ├─ Build
│  ├─ Security scan
│  └─ Deploy (staging → production)
├─ Kubernetes manifests
│  ├─ Deployment
│  ├─ Service
│  ├─ Ingress
│  └─ ConfigMap/Secrets
└─ Monitoring
   ├─ Health checks
   ├─ Metrics
   └─ Alerting

Activation manuelle:

/wd:build --persona-devops

👨‍🏫 Mentor - Le Pédagogue

Priorités:

Clarté des explications
Progression pédagogique
Exemples concrets
Transfert de connaissances

Quand il s'active:

Mots-clés: "expliquer", "comprendre", "comment", "pourquoi"
Demandes d'explication
Onboarding

Style d'explication:

Analogies du monde réel
Progression simple → complexe
Exemples multiples
Diagrammes visuels

Exemple de décision:

Demande: "Expliquer les closures en JavaScript"

Mentor Persona explique:
├─ 1. Analogie simple (boîte dans une boîte)
├─ 2. Exemple de base
├─ 3. Cas d'usage pratiques
├─ 4. Pièges courants
├─ 5. Exercices
└─ 6. Ressources pour aller plus loin

Activation manuelle:

/wd:explain --persona-mentor

📚 Scribe - Le Documentaliste

Priorités:

Documentation complète
Clarté et accessibilité
Exemples pratiques
Multilinguisme

Quand il s'active:

Mots-clés: "documenter", "guide", "README", "docs"
Génération de documentation
Création de guides

Types de documentation:

READMEs
API documentation (OpenAPI)
Guides utilisateur
Architecture documentation
Changelog

Support multilingue:

Français
Anglais
Espagnol
Allemand
(autres sur demande)

Exemple de décision:

Demande: "Documenter l'API"

Scribe Persona génère:
├─ OpenAPI 3.0 spec
├─ README.md
│  ├─ Installation
│  ├─ Configuration
│  ├─ Endpoints
│  └─ Exemples
├─ Guides
│  ├─ Getting Started
│  ├─ Authentication
│  └─ Best Practices
└─ Multilingue (FR + EN)

Activation manuelle:

/wd:document --persona-scribe

Les 5 Agents Spécialisés

🎨 Frontend Agent

Responsabilités:

Composants UI
State management
Routing
Styling
Accessibilité

Frameworks supportés:

React (+ Next.js)
Vue (+ Nuxt)
Angular
Svelte (+ SvelteKit)
Solid.js

Activation:

/wd:implement --agent wd-frontend-agent

Cas d'usage:

Création de composants
Design system
Refonte UI
Migration de framework frontend

🔧 Backend Agent

Responsabilités:

APIs REST/GraphQL
Base de données
Authentication/Authorization
Business logic
Microservices

Frameworks supportés:

Node.js (Express, Fastify, NestJS)
Python (FastAPI, Django, Flask)
Go (Gin, Echo)
Rust (Actix, Rocket)

Activation:

/wd:implement --agent wd-backend-agent

Cas d'usage:

Création d'APIs
Intégration database
Système d'authentification
Microservices architecture

🔒 Security Agent

Responsabilités:

Audits de sécurité
Scan de vulnérabilités
Threat modeling
Conformité (OWASP, RGPD)
Secrets management

Checklist de sécurité:

✅ OWASP Top 10
✅ Input validation
✅ Authentication robuste
✅ Authorization (RBAC)
✅ Data encryption
✅ Secrets management
✅ HTTPS/TLS
✅ CORS configuration

Activation:

/wd:analyze security --agent wd-security-agent

Cas d'usage:

Audit de sécurité
Pen-testing
Compliance check
Security review

🧪 Test Agent

Responsabilités:

Génération de tests
Exécution de tests
Coverage reports
E2E testing
Visual regression

Frameworks de test:

Unit: Jest, Vitest, Mocha
Integration: Testing Library
E2E: Playwright, Cypress
Visual: Percy, Chromatic

Activation:

/wd:test --agent wd-test-agent

Cas d'usage:

Génération de tests manquants
Augmentation de la couverture
Tests E2E automatisés
CI/CD integration

📚 Docs Agent

Responsabilités:

Documentation technique
Guides utilisateur
API documentation
Architecture docs
Changelog

Formats générés:

Markdown
OpenAPI/Swagger
JSDoc/TSDoc
Diagrammes (Mermaid)

Activation:

/wd:document --agent wd-docs-agent

Cas d'usage:

Documentation complète
Onboarding documentation
API reference
Knowledge base

Guide Complet des Flags

🧠 Flags de Réflexion

--think             # 4K tokens de réflexion (standard)
--think-hard        # 10K tokens (complexe)
--ultrathink        # 32K tokens (très complexe)

Quand utiliser:

--think: Tâches standard
--think-hard: Architecture, design complexe
--ultrathink: Migration, refactoring complet

🌊 Flags d'Orchestration

--wave-mode auto    # Auto-détection (défaut)
--wave-mode force   # Force les vagues
--wave-mode off     # Désactive les vagues

--wave-strategy progressive   # Amélioration incrémentale
--wave-strategy systematic    # Approche méthodique
--wave-strategy adaptive      # S'adapte en cours
--wave-strategy enterprise    # Maximum qualité

Quand utiliser:

force: Projets complexes (refactoring, migration)
progressive: Amélioration continue
systematic: Respect strict des standards
enterprise: Production critique

🤖 Flags d'Agents

--agent <nom>              # Agent spécifique
--agents                   # Multi-agents coordonnés
--delegate files           # Délégation par fichiers
--delegate folders         # Délégation par dossiers
--multi-agent             # Orchestration hiérarchique

Exemples:

# Un seul agent
/wd:implement --agent wd-frontend-agent

# Multi-agents en parallèle
/wd:analyze --agents

# Délégation pour gros projet
/wd:improve --delegate folders

🎭 Flags de Personas

--persona-architect
--persona-frontend
--persona-backend
--persona-security
--persona-performance
--persona-analyzer
--persona-qa
--persona-refactorer
--persona-devops
--persona-mentor
--persona-scribe

Utilisation:

# Forcer un persona
/wd:implement --persona-security

# Combiner plusieurs personas (non recommandé)
/wd:improve --persona-performance --persona-security

🔧 Flags MCP Servers

--c7         # Context7 (documentation)
--seq        # Sequential (analyse complexe)
--magic      # Magic (génération UI)
--play       # Playwright (tests E2E)
--all-mcp    # Tous les serveurs
--no-mcp     # Aucun serveur

⚡ Flags d'Optimisation

--uc         # Ultra-Compressed (30-50% tokens)
--loop       # Mode itératif avec validation
--dry-run    # Simulation (pas d'exécution)
--fast       # Mode rapide (moins de validation)

Workflows Courants

Workflow 1: Nouvelle Feature Complète

# 1. Design
/wd:design Feature de chat en temps réel --persona-architect --seq

# 2. Estimation
/wd:estimate Chat temps réel avec WebSockets

# 3. Implémentation (multi-agents)
/wd:implement Chat temps réel --agents --all-mcp

# 4. Tests
/wd:test generate --agent wd-test-agent

# 5. Documentation
/wd:document Chat feature --type guide

# 6. Review finale
/wd:analyze Audit complet --agents

Workflow 2: Optimisation de Performance

# 1. Baseline
/wd:benchmark Application complète

# 2. Analyse
/wd:analyze performance --persona-performance --seq

# 3. Améliorations
/wd:improve Optimiser les performances --wave-mode force

# 4. Validation
/wd:benchmark Compare avec baseline

# 5. Documentation
/wd:document Performance optimizations

Workflow 3: Refactoring Complet

# 1. Analyse actuelle
/wd:analyze quality --persona-analyzer

# 2. Plan de refactoring
/wd:workflow docs/refactoring-plan.md

# 3. Refactoring par vagues
/wd:improve Refactoriser l'application --wave-mode force --ultrathink

# 4. Validation
/wd:test coverage

# 5. Documentation
/wd:document Architecture refactorée

Workflow 4: Audit de Sécurité

# 1. Scan initial
/wd:analyze security --persona-security --seq

# 2. Corrections
/wd:improve Corriger les vulnérabilités --persona-security

# 3. Validation
/wd:analyze security --agent wd-security-agent

# 4. Documentation
/wd:document Security audit report

Workflow 5: Migration de Framework

# 1. Analyse de faisabilité
/wd:estimate Migration Vue 2 vers Vue 3

# 2. Plan détaillé
/wd:workflow Migration vers Vue 3

# 3. Migration par vagues
/wd:migrate "Vue 2" "Vue 3" --wave-mode force --ultrathink

# 4. Tests de régression
/wd:test e2e --play

# 5. Documentation
/wd:document Migration guide

Stratégies d'Orchestration

Progressive Strategy

Quand l'utiliser: Amélioration continue, refactoring progressif

Vague 1: Identifier les quick wins
Vague 2: Appliquer les améliorations faciles
Vague 3: Valider les résultats
Vague 4: Continuer avec complexités moyennes
Vague 5: Finaliser avec les parties complexes

Exemple:

/wd:improve Améliorer la qualité du code --wave-strategy progressive

Systematic Strategy

Quand l'utiliser: Projets avec standards stricts, compliance

Vague 1: Analyse exhaustive selon checklist
Vague 2: Planification rigoureuse
Vague 3: Implémentation par catégories
Vague 4: Validation contre standards
Vague 5: Documentation complète

Exemple:

/wd:implement Feature bancaire --wave-strategy systematic --persona-security

Adaptive Strategy

Quand l'utiliser: Projets avec incertitudes, exploration

Vague 1: Exploration et découverte
Vague 2: Ajustement de la stratégie
Vague 3: Implémentation adaptée
Vague 4: Évaluation des résultats
Vague 5: Optimisation finale basée sur learnings

Exemple:

/wd:migrate Legacy vers Architecture moderne --wave-strategy adaptive

Enterprise Strategy

Quand l'utiliser: Production critique, qualité maximale

Vague 1: Analyse complète multi-dimensionnelle
Vague 2: Design avec review et validation
Vague 3: Implémentation avec validation continue
Vague 4: Testing exhaustif (unit + integration + E2E)
Vague 5: Audit final + documentation + deployment prep

Exemple:

/wd:implement Système de paiement --wave-strategy enterprise --all-mcp

Serveurs MCP

📚 Context7

Spécialité: Documentation officielle des bibliothèques

Quand l'utiliser:

Intégration de nouvelles librairies
Best practices
Exemples officiels

Activation:

/wd:implement --c7

🧠 Sequential

Spécialité: Analyse complexe multi-étapes

Quand l'utiliser:

Logique complexe
Architecture design
Debugging profond

Activation:

/wd:analyze --seq

✨ Magic

Spécialité: Génération de composants UI

Quand l'utiliser:

Composants visuels
Prototypage rapide
Design system

Activation:

/wd:implement Galerie d'images --magic

🎭 Playwright

Spécialité: Tests E2E automatisés

Quand l'utiliser:

Tests de navigation
Tests d'interaction utilisateur
Visual regression

Activation:

/wd:test e2e --play

Exemples Avancés

Exemple 1: Feature Complète avec Orchestration

/wd:implement Système de notifications push (web + mobile) \
  --wave-mode force \
  --agents \
  --all-mcp \
  --ultrathink

Ce qui se passe:

1. Orchestrateur analyse (ultrathink):
   - Complexité élevée (multi-plateforme)
   - Nécessite backend + frontend + infrastructure
   - Temps réel (WebSockets/Firebase)

2. Active automatiquement:
   - Wave mode (5 vagues)
   - Multi-agents (backend, frontend, devops)
   - MCP servers (Context7, Sequential, Magic)

3. Vague 1: DESIGN (5 min)
   - Architecture pub/sub
   - Design d'API
   - Choix de technologies

4. Vague 2: BACKEND (10 min)
   - Backend Agent: API de notifications
   - WebSocket server
   - Database schema
   - Firebase Cloud Messaging

5. Vague 3: FRONTEND (10 min)
   - Frontend Agent: Composants UI
   - Service Worker (web push)
   - React Native (mobile)
   - State management

6. Vague 4: INFRASTRUCTURE (5 min)
   - DevOps: Docker configuration
   - CI/CD pipeline
   - Monitoring

7. Vague 5: VALIDATION (5 min)
   - Test Agent: Tests E2E
   - Docs Agent: Documentation
   - Security Agent: Audit

Total: ~35 minutes
Résultat: Feature production-ready complète

Exemple 2: Refactoring Legacy avec Risques Minimaux

/wd:improve Refactorer application legacy de 10 ans \
  --wave-mode force \
  --wave-strategy systematic \
  --delegate folders \
  --ultrathink

Approche systématique:

Vague 1: AUDIT COMPLET (15 min)
├─ Analyze architecture actuelle
├─ Identifier dépendances
├─ Détecter code smells
├─ Évaluer risques
└─ Prioriser par impact/effort

Vague 2: PLAN SÉCURISÉ (10 min)
├─ Stratégie de migration
├─ Ordre des opérations
├─ Points de rollback
└─ Tests de validation

Vague 3: REFACTORING PHASE 1 (20 min)
├─ Délégation par folders (parallèle)
├─ Modules indépendants first
├─ Tests de non-régression après chaque module
└─ Validation continue

Vague 4: REFACTORING PHASE 2 (20 min)
├─ Modules interdépendants
├─ Integration testing
└─ Performance validation

Vague 5: FINALISATION (10 min)
├─ Documentation de migration
├─ Cleanup code mort
├─ Optimisations finales
└─ Deployment guide

Total: ~75 minutes
Risque: Minimisé par approche progressive

Exemple 3: Migration Complète de Stack

/wd:migrate "Vue 2 + Vuex + Webpack" "Vue 3 + Pinia + Vite" \
  --wave-mode force \
  --wave-strategy enterprise \
  --agents \
  --all-mcp \
  --ultrathink

Migration enterprise-grade:

Vague 1: ANALYSE EXHAUSTIVE (20 min)
├─ Scan de toute la codebase
├─ Identification breaking changes
├─ Dépendances à migrer
├─ Risques et mitigation
└─ Timeline estimée

Vague 2: STRATÉGIE & DESIGN (15 min)
├─ Architecture cible
├─ Plan de migration par phases
├─ Dual-running strategy (Vue 2 + 3)
└─ Rollback procedures

Vague 3: MIGRATION INFRASTRUCTURE (20 min)
├─ Webpack → Vite
├─ Configuration
├─ Build scripts
└─ Dev environment

Vague 4: MIGRATION CODE (40 min)
├─ Vue 2 → Vue 3 (Composition API)
├─ Vuex → Pinia
├─ Mise à jour des composants
├─ Migration des directives
└─ Adaptation des tests

Vague 5: VALIDATION & FINALIZATION (20 min)
├─ Tests E2E complets
├─ Performance benchmarks
├─ Documentation migration
├─ Training guide pour l'équipe
└─ Deployment strategy

Total: ~115 minutes
Résultat: Migration complète, sécurisée, documentée

Exemple 4: Audit Multi-Dimensionnel

/wd:spawn Analyse complète (sécurité + performance + qualité + architecture) \
  --agents \
  --all-mcp

Orchestration parallèle:

┌────────────────────────────────────────┐
│  COORDINATION PARALLÈLE (15 min)      │
├────────────────────────────────────────┤
│                                        │
│  🔒 Security Agent                     │
│     - OWASP Top 10 scan                │
│     - Dependency vulnerabilities       │
│     - Secrets leakage                  │
│     - Report: 12 issues (2 critical)   │
│                                        │
│  ⚡ Performance Analysis                │
│     - Profiling code                   │
│     - Bundle size analysis             │
│     - Network waterfall                │
│     - Report: 8 optimizations          │
│                                        │
│  📊 Quality Analysis                   │
│     - Code smells                      │
│     - Complexité cyclomatique          │
│     - Test coverage                    │
│     - Report: Score 72/100             │
│                                        │
│  🏛️ Architecture Review                │
│     - Patterns utilisés                │
│     - Debt technique                   │
│     - Scalability issues               │
│     - Report: 5 recommandations        │
│                                        │
└────────────────────────────────────────┘
         ↓
   AGRÉGATION DES RÉSULTATS
         ↓
   RAPPORT CONSOLIDÉ
   - Priorisation par impact
   - Plan d'action suggéré
   - Estimations de correction

Exemple 5: Système Complet en Mode Express

/wd:implement CRUD complet pour e-commerce (produits, paniers, commandes) \
  --agents \
  --magic \
  --c7 \
  --fast

Mode rapide (compromis vitesse/qualité):

Backend Agent (10 min):
├─ API REST complète
├─ Models (Product, Cart, Order)
├─ Controllers + Routes
├─ Validation basique
└─ Tests unitaires essentiels

Frontend Agent (10 min):
├─ Pages (Products, Cart, Checkout)
├─ Composants réutilisables
├─ State management (Zustand/Pinia)
├─ Intégration API
└─ UI avec Magic MCP

Docs Agent (3 min):
├─ API documentation
└─ README quickstart

Total: ~23 minutes
Qualité: Prototype fonctionnel (non production)

🎯 Récapitulatif

Commandes les Plus Utilisées

/wd:implement - Créer du code (80% des usages)
/wd:improve - Améliorer du code existant
/wd:analyze - Analyser et diagnostiquer
/wd:test - Tester
/wd:document - Documenter

Flags les Plus Utiles

--ultrathink - Pour tâches complexes
--wave-mode force - Pour qualité maximale
--agents - Pour coordination multi-domaines
--all-mcp - Pour utiliser tous les outils
--uc - Pour économiser les tokens

Personas les Plus Utilisés

Frontend - Composants UI
Backend - APIs
Security - Audits
Performance - Optimisations
Architect - Design de systèmes

📚 Prochaines Étapes

Maintenant que vous maîtrisez les commandes et workflows:

Guide Avancé (WD_FRAMEWORK_GUIDE_AVANCE.md)
- Architecture interne du framework
- Optimisations avancées
- Personnalisation
Exemples Pratiques (EXEMPLES_PRATIQUES.md)
- 20+ cas d'usage avec code complet
- Solutions aux problèmes courants
FAQ (FAQ_ET_TROUBLESHOOTING.md)
- Problèmes fréquents et solutions
- Astuces et best practices

📅 Dernière mise à jour: WD Framework v2.0 📝 Documentation générée avec WD Framework 📄 Licence: MIT

WD FRAMEWORK GUIDE UTILISATEUR

🛠️ WD Framework - Guide Utilisateur

📖 Table des Matières

Les 22 Commandes Expliquées

🏗️ Commandes d'Implémentation

/wd:implement - Implémenter du Code

/wd:build - Construire le Projet

/wd:design - Designer l'Architecture

📊 Commandes d'Analyse

/wd:analyze - Analyser le Code

/wd:explain - Expliquer le Code

♻️ Commandes d'Amélioration

/wd:improve - Améliorer le Code

/wd:cleanup - Nettoyer le Code

🧪 Commandes de Test

/wd:test - Tester le Code

/wd:benchmark - Benchmark Performance

📚 Commandes de Documentation

/wd:document - Documenter

🔧 Commandes Utilitaires

/wd:git - Opérations Git

/wd:spawn - Orchestrer des Tâches

/wd:task - Gestion de Tâches

🚀 Commandes Avancées

/wd:workflow - Générer un Workflow

/wd:estimate - Estimer l'Effort

/wd:troubleshoot - Dépanner

/wd:migrate - Migrer

/wd:finalize - Finaliser

Les 11 Personas en Détail

🏛️ Architect - L'Architecte Système

🎨 Frontend - Le Spécialiste UI/UX

🔧 Backend - L'Ingénieur de Fiabilité

🔒 Security - L'Expert Sécurité

⚡ Performance - L'Optimiseur

🔍 Analyzer - L'Investigateur

✅ QA - L'Avocat de la Qualité

♻️ Refactorer - Le Nettoyeur de Code

🚀 DevOps - L'Expert Infrastructure

👨‍🏫 Mentor - Le Pédagogue

📚 Scribe - Le Documentaliste

Les 5 Agents Spécialisés

🎨 Frontend Agent

🔧 Backend Agent

🔒 Security Agent

🧪 Test Agent

📚 Docs Agent

Guide Complet des Flags

🧠 Flags de Réflexion

🌊 Flags d'Orchestration

🤖 Flags d'Agents

🎭 Flags de Personas

🔧 Flags MCP Servers

⚡ Flags d'Optimisation

Workflows Courants

Workflow 1: Nouvelle Feature Complète

Workflow 2: Optimisation de Performance

Workflow 3: Refactoring Complet

Workflow 4: Audit de Sécurité

Workflow 5: Migration de Framework

Stratégies d'Orchestration

Progressive Strategy

Systematic Strategy

Adaptive Strategy

Enterprise Strategy

Serveurs MCP

📚 Context7

🧠 Sequential

✨ Magic

🎭 Playwright

Exemples Avancés

Exemple 1: Feature Complète avec Orchestration

Exemple 2: Refactoring Legacy avec Risques Minimaux

Exemple 3: Migration Complète de Stack

Exemple 4: Audit Multi-Dimensionnel

Exemple 5: Système Complet en Mode Express

🎯 Récapitulatif

Commandes les Plus Utilisées

Flags les Plus Utiles

Personas les Plus Utilisés

`/wd:implement` - Implémenter du Code

`/wd:build` - Construire le Projet

`/wd:design` - Designer l'Architecture

`/wd:analyze` - Analyser le Code

`/wd:explain` - Expliquer le Code

`/wd:improve` - Améliorer le Code

`/wd:cleanup` - Nettoyer le Code

`/wd:test` - Tester le Code

`/wd:benchmark` - Benchmark Performance

`/wd:document` - Documenter

`/wd:git` - Opérations Git

`/wd:spawn` - Orchestrer des Tâches

`/wd:task` - Gestion de Tâches

`/wd:workflow` - Générer un Workflow

`/wd:estimate` - Estimer l'Effort

`/wd:troubleshoot` - Dépanner

`/wd:migrate` - Migrer

`/wd:finalize` - Finaliser