mdan-cli 2.2.0

package/README.md

@@ -0,0 +1,223 @@
+# MDAN — Multi-Agent Development Agentic Network
+
+> Une méthode agentique moderne pour construire n'importe quel logiciel avec l'IA.
+
+---
+
+## 🌟 Pourquoi MDAN v2 ?
+
+MDAN v2 a été repensé pour être un véritable collaborateur expert plutôt qu'un simple outil de génération de code.
+
+- **🤖 Aide Intelligente IA** — Tapez `/mdan-help` à tout moment pour savoir quoi faire ensuite
+- **⚖️ Auto-adaptatif (Scale-Domain)** — Ajuste automatiquement la profondeur de la planification selon la taille de votre projet (du script solo à l'application d'entreprise)
+- **🎉 Party Mode** — Invoquez plusieurs agents avec `/party` pour débattre et collaborer sur des choix d'architecture ou de design
+- **🧠 Workflow Structuré** — 5 phases claires et éprouvées (Discover, Design, Build, Verify, Ship)
+- **🔌 Mémoire Persistante** — Avec le fichier `MDAN-STATE.json` qui vous permet de reprendre votre travail d'une session à l'autre
+
+---
+
+## ⚡ Installation
+
+### Option 1 : npm (Recommandé)
+
+```bash
+npm install -g mdan
+```
+
+### Option 2 : npx (Sans installation)
+
+```bash
+npx mdan init mon-projet
+```
+
+### Option 3 : Script d'installation
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/khalilbenaz/MDAN/main/install.sh | bash
+```
+
+### Option 4 : Manuel
+
+```bash
+git clone https://github.com/khalilbenaz/MDAN.git
+cd MDAN && bash install.sh
+```
+
+---
+
+## 🚀 Utilisation
+
+### Nouveau projet
+
+```bash
+mdan init mon-projet
+cursor mon-projet
+```
+
+### Projet existant
+
+```bash
+cd votre-projet
+mdan attach
+cursor .
+```
+
+### Rebuild from scratch
+
+```bash
+cd votre-projet
+mdan attach --rebuild
+cursor .
+```
+
+---
+
+## 📖 Commandes
+
+MDAN v2 propose un installeur **interactif** : tapez simplement `mdan` pour être guidé ! 
+
+Vous pouvez aussi utiliser les commandes directes :
+
+```bash
+mdan init                 # Lancer l'assistant de création (Wizard)
+mdan init [nom]           # Créer un nouveau projet directement
+mdan attach               # Ajouter MDAN au projet courant
+mdan attach --rebuild     # Préparer pour un rebuild complet
+mdan status               # Voir le statut du projet
+mdan phase [1-5|nom]      # Voir le guide d'une phase (ex: mdan phase discover)
+mdan workflow [nom]       # Voir une micro-procédure (ex: bug-fix, refactoring)
+mdan module add [nom]     # Ajouter une extension métier (ex: agile-scrum)
+mdan oc                   # Copier le prompt de l'Orchestrateur dans le presse-papier
+mdan agent [nom]          # Voir le prompt d'un agent
+mdan skills               # Lister les skills
+mdan version              # Version
+```
+
+*Astuce : Vous pouvez ajouter `copy` ou `-c` à la fin des commandes `phase` ou `workflow` pour copier le contenu directement dans votre presse-papier (ex: `mdan phase 1 copy`).*
+
+---
+
+## 🎯 Workflow
+
+| Phase | Agent | Résultat |
+|-------|-------|----------|
+| **1. DISCOVER** | Product Agent | PRD validé |
+| **2. DESIGN** | Architect + UX | Architecture + Specs |
+| **3. BUILD** | Dev + Security | Code implémenté |
+| **4. VERIFY** | Test + Security | Tests passants |
+| **5. SHIP** | DevOps + Doc | Déployé + Documenté |
+
+---
+
+## 🤖 Agents
+
+| Agent | Phase | Rôle |
+|-------|-------|------|
+| Learn Agent | Toutes | Skills, rules, MCP |
+| Product Agent | DISCOVER | PRD, user stories |
+| Architect Agent | DESIGN | Architecture, stack |
+| UX Agent | DESIGN | Flows, design system |
+| Dev Agent | BUILD | Code, tests unitaires |
+| Security Agent | BUILD+VERIFY | Vulnérabilités |
+| Test Agent | VERIFY | Tests E2E, perf |
+| DevOps Agent | SHIP | CI/CD, infra |
+| Doc Agent | SHIP | Documentation |
+
+---
+
+## 💡 Exemples de prompts
+
+### Nouveau projet
+```
+MDAN: Je veux créer une app de gestion de tâches avec auth, 
+dashboard et notifications. Commence par DISCOVER.
+```
+
+### Projet existant
+```
+MDAN: Analyse ce projet et propose des améliorations.
+Identifie la dette technique et suggère des optimizations.
+```
+
+### Rebuild complet
+```
+MDAN REBUILD: Analyse tout le code existant, documente 
+chaque feature, et propose une architecture moderne 
+pour tout réécrire from scratch.
+```
+
+---
+
+## 🔌 IDE Supportés
+
+- **Cursor** — `.cursorrules` auto-généré
+- **Windsurf** — `.windsurfrules` auto-généré
+- **Claude Code** — `.claude/skills/` auto-généré
+- **GitHub Copilot** — `.github/copilot-instructions.md` auto-généré
+- **Claude Web** — Copier `.mdan/orchestrator.md`
+
+---
+
+## 📁 Structure créée
+
+```
+projet/
+├── .mdan/
+│   ├── orchestrator.md      # System prompt
+│   ├── agents/              # Prompts des agents
+│   ├── skills/              # Skills installés
+│   └── STATUS.md            # Progression
+├── mdan_output/             # Dossier où les agents génèrent leurs livrables (PRD, Archi...)
+├── .cursorrules             # Pour Cursor
+├── .windsurfrules           # Pour Windsurf
+├── .claude/skills/          # Pour Claude Code
+└── .github/copilot-instructions.md
+```
+
+---
+
+## 📄 Licence
+
+MIT — Libre d'utilisation.
+
+---
+
+## 🏗️ Architecture
+
+MDAN se compose de plusieurs composants interconnectés:
+
+| Composant | Rôle |
+|-----------|------|
+| **MDAN Core** | Orchestrateur central qui coordonne les agents |
+| **Agents** | 9 agents spécialisés (Product, Architect, UX, Dev, etc.) |
+| **CLI** | Interface en ligne de commande (`mdan init`, `mdan attach`) |
+| **Memory** | Système de persistance entre sessions (`MDAN-STATE.json`) |
+| **Skills** | Compétences optionnelles extensibles |
+
+```
+Utilisateur → CLI → MDAN Core → Agents → Artifacts
+                           ↓
+                       Memory System
+```
+
+Voir [ARCHITECTURE.md](ARCHITECTURE.md) pour la documentation technique complète.
+
+---
+
+## 📚 Documentation
+
+| Document | Description |
+|----------|-------------|
+| [ARCHITECTURE.md](ARCHITECTURE.md) | Architecture technique du projet |
+| [MDAN.md](MDAN.md) | Spécification complète de la méthode |
+| [CLI-REFERENCE.md](docs/fr/CLI-REFERENCE.md) | Référence des commandes CLI |
+| [CONTRIBUTING-DEV.md](docs/fr/CONTRIBUTING-DEV.md) | Guide du contributeur développeur |
+| [Exemple complet](examples/taskflow-api/EXAMPLE.md) | Projet exemple TaskFlow API |
+
+---
+
+## 🔗 Liens
+
+- [Documentation EN](docs/en/README.md)
+- [Documentation FR](docs/fr/README.md)
+- [GitHub](https://github.com/khalilbenaz/MDAN)

package/agents/AGENTS-REGISTRY.md

@@ -0,0 +1,215 @@
+# MDAN — Agent Versioning System
+
+> Comment les agents sont versionnés, mis à jour et rétrocompatibles.
+
+---
+
+## Pourquoi versionner les agents ?
+
+Un projet peut durer des semaines. Entre deux sessions, tu peux mettre à jour un agent  
+(meilleur prompt, nouveaux patterns de sécurité, format de sortie amélioré).  
+Sans versioning, les projets en cours ne savent pas quelle version ils utilisent —  
+et les résultats deviennent incohérents.
+
+---
+
+## Schéma de version
+
+```
+MAJOR.MINOR.PATCH
+
+2.1.3
+│ │ └── PATCH : correction de bug dans le prompt (même comportement, résultat plus propre)
+│ └──── MINOR : nouvelle capacité ajoutée (rétrocompatible)
+└────── MAJOR : changement de comportement ou format de sortie (breaking change)
+```
+
+---
+
+## Registre des versions — AGENTS-REGISTRY.json
+
+```json
+{
+  "registry_version": "1.0",
+  "last_updated": "2025-01-20",
+  "agents": {
+    "product": {
+      "current": "2.0.0",
+      "changelog": [
+        {
+          "version": "2.0.0",
+          "date": "2025-01-20",
+          "type": "MAJOR",
+          "changes": ["Added MoSCoW section", "Added risk matrix", "Added open questions table"]
+        },
+        {
+          "version": "1.0.0",
+          "date": "2025-01-01",
+          "type": "MAJOR",
+          "changes": ["Initial release"]
+        }
+      ]
+    },
+    "architect": {
+      "current": "2.0.0",
+      "changelog": [
+        {
+          "version": "2.0.0",
+          "date": "2025-01-20",
+          "type": "MAJOR",
+          "changes": ["Added Mermaid diagram requirement", "Added ADR format", "Added non-functional requirements table"]
+        }
+      ]
+    },
+    "ux": {
+      "current": "2.0.0",
+      "changelog": [
+        {
+          "version": "2.0.0",
+          "date": "2025-01-20",
+          "type": "MAJOR",
+          "changes": ["Added design system template", "Added all-states requirement", "Added accessibility section"]
+        }
+      ]
+    },
+    "dev": {
+      "current": "2.0.0",
+      "changelog": [
+        {
+          "version": "2.0.0",
+          "date": "2025-01-20",
+          "type": "MAJOR",
+          "changes": ["Added implementation plan format", "Added setup instructions section", "Added coding standards reference"]
+        }
+      ]
+    },
+    "test": {
+      "current": "2.0.0",
+      "changelog": [
+        {
+          "version": "2.0.0",
+          "date": "2025-01-20",
+          "type": "MAJOR",
+          "changes": ["Added performance test section", "Added security edge cases", "Added flakiness prevention rules"]
+        }
+      ]
+    },
+    "security": {
+      "current": "2.0.0",
+      "changelog": [
+        {
+          "version": "2.0.0",
+          "date": "2025-01-20",
+          "type": "MAJOR",
+          "changes": ["Added STRIDE template", "Added VULN severity format", "Added compliance notes section"]
+        }
+      ]
+    },
+    "devops": {
+      "current": "2.0.0",
+      "changelog": [
+        {
+          "version": "2.0.0",
+          "date": "2025-01-20",
+          "type": "MAJOR",
+          "changes": ["Added multi-environment table", "Added runbook template", "Added rollback procedure"]
+        }
+      ]
+    },
+    "doc": {
+      "current": "2.0.0",
+      "changelog": [
+        {
+          "version": "2.0.0",
+          "date": "2025-01-20",
+          "type": "MAJOR",
+          "changes": ["Added API documentation template", "Added README template"]
+        }
+      ]
+    },
+    "learn": {
+      "current": "2.0.0",
+      "changelog": [
+        {
+          "version": "2.0.0",
+          "date": "2025-01-20",
+          "type": "MAJOR",
+          "changes": ["Initial release", "Knowledge acquisition and distribution specialist", "MCP server integration", "Rules ingestion capabilities"]
+        }
+      ]
+    }
+  }
+}
+```
+
+---
+
+## Compatibilité projet/agent
+
+Quand MDAN Core reprend une session depuis MDAN-STATE.json, il compare :
+
+```
+Project uses: dev agent v1.0.0
+Current MDAN:  dev agent v2.0.0
+```
+
+Et affiche :
+
+```
+⚠️  Agent Update Available
+
+Dev Agent: v1.0.0 → v2.0.0 (MAJOR)
+
+Breaking changes in v2.0.0:
+- Output format changed: now includes "Implementation Plan" section
+- Notes section renamed to "Notes for MDAN Core"
+
+Options:
+  [1] Continue with v1.0.0 (no change, consistent with past output)
+  [2] Upgrade to v2.0.0 (recommended, but review past artifacts)
+  [3] Show full changelog
+
+What do you prefer?
+```
+
+---
+
+## Règles de versioning pour les contributeurs
+
+### Quand incrémenter PATCH (2.0.X)
+- Correction de faute de frappe dans le prompt
+- Reformulation qui améliore la clarté sans changer le comportement
+- Ajout d'un exemple dans la checklist
+
+### Quand incrémenter MINOR (2.X.0)
+- Nouvelle capacité ajoutée (ex: l'agent peut maintenant produire des diagrammes Mermaid)
+- Nouvelle section dans le format de sortie (rétrocompatible)
+- Nouvelles questions dans la checklist qualité
+
+### Quand incrémenter MAJOR (X.0.0)
+- Changement de format de sortie (les projets existants ne sont plus compatibles)
+- Changement de responsabilités de l'agent
+- Renommage de sections
+- Suppression de sections existantes
+
+---
+
+## Header de version dans chaque agent
+
+Chaque fichier agent commence par :
+
+```markdown
+# MDAN — [Agent Name]
+<!-- version: 2.0.0 -->
+<!-- last-updated: 2025-01-20 -->
+<!-- breaking-changes-from: 1.x -->
+```
+
+Et dans l'Universal Envelope :
+
+```
+[MDAN-AGENT]
+NAME: Dev Agent
+VERSION: 2.0.0
+...
+```

package/agents/architect.md

@@ -0,0 +1,160 @@
+# MDAN — Architect Agent
+
+```
+[MDAN-AGENT]
+NAME: Architect Agent (Reda)
+VERSION: 2.0.0
+ROLE: Principal Software Architect responsible for system design, tech stack selection, and technical specifications
+PHASE: DESIGN
+REPORTS_TO: MDAN Core
+
+[IDENTITY]
+You are Reda, a principal software architect with 20+ years of experience designing systems at scale.
+You have built monoliths, microservices, event-driven systems, serverless architectures, and everything 
+in between. You know when to use each pattern and — more importantly — when NOT to over-engineer.
+
+You design for:
+- Correctness first
+- Maintainability second
+- Scalability third (only when needed)
+
+You never choose a technology because it's trendy. You choose it because it's right for the job.
+
+[CAPABILITIES]
+- Design system architectures (monolith, microservices, serverless, hybrid)
+- Select and justify technology stacks
+- Design database schemas and data models
+- Design REST, GraphQL, and event-driven APIs
+- Define component diagrams and sequence diagrams (in text/Mermaid format)
+- Identify technical risks and propose mitigations
+- Define coding standards and project conventions
+- Create the Architecture Decision Record (ADR)
+- Estimate technical complexity
+
+[CONSTRAINTS]
+- Do NOT ignore non-functional requirements (performance, security, scalability)
+- Do NOT choose complex architectures when simpler ones suffice
+- Do NOT skip documentation of architecture decisions
+- Do NOT define tech stack without considering team skill level
+- Do NOT design APIs without considering backward compatibility
+
+[INPUT_FORMAT]
+MDAN Core will provide:
+- Validated PRD from Product Agent
+- Technical constraints (budget, team size, timeline)
+- Existing tech stack (if any)
+- Deployment environment preferences
+
+[OUTPUT_FORMAT]
+Produce a complete Architecture Document:
+
+---
+Artifact: Architecture Document
+Phase: DESIGN
+Agent: Architect Agent
+Version: 1.0
+Status: Draft
+---
+
+# Architecture: [Project Name]
+
+## 1. Architecture Overview
+[High-level description and chosen architecture pattern with justification]
+
+## 2. System Diagram
+```mermaid
+graph TD
+    A[Client] --> B[API Gateway]
+    B --> C[Service 1]
+    B --> D[Service 2]
+    C --> E[(Database)]
+```
+
+## 3. Technology Stack
+| Layer | Technology | Version | Justification |
+|-------|-----------|---------|---------------|
+| Frontend | [Tech] | [Ver] | [Why] |
+| Backend | [Tech] | [Ver] | [Why] |
+| Database | [Tech] | [Ver] | [Why] |
+| Cache | [Tech] | [Ver] | [Why] |
+| Auth | [Tech] | [Ver] | [Why] |
+| Hosting | [Tech] | [Ver] | [Why] |
+
+## 4. Data Models
+```
+Entity: [Name]
+Fields:
+  - id: UUID (PK)
+  - created_at: Timestamp
+  - [field]: [type] ([constraints])
+```
+
+## 5. API Design
+### Endpoints
+| Method | Path | Description | Auth |
+|--------|------|-------------|------|
+| GET | /api/v1/[resource] | [Description] | [Yes/No] |
+
+### Request/Response Examples
+```json
+// POST /api/v1/[resource]
+Request: { "field": "value" }
+Response: { "id": "uuid", "field": "value", "created_at": "..." }
+```
+
+## 6. Security Architecture
+- Authentication: [Method]
+- Authorization: [Method]
+- Data encryption: [At rest / In transit]
+- Secret management: [Tool/Approach]
+
+## 7. Non-Functional Requirements
+| Requirement | Target | Strategy |
+|-------------|--------|----------|
+| Performance | [e.g., <200ms p95] | [Strategy] |
+| Availability | [e.g., 99.9%] | [Strategy] |
+| Scalability | [e.g., 10k RPS] | [Strategy] |
+
+## 8. Project Structure
+```
+project/
+├── src/
+│   ├── [module]/
+│   └── [module]/
+├── tests/
+├── mdan_output/
+└── [config files]
+```
+
+## 9. Coding Conventions
+- Language: [Language + version]
+- Style guide: [e.g., Airbnb, PEP8]
+- Naming conventions: [camelCase, snake_case, etc.]
+- Git branching: [Gitflow, trunk-based, etc.]
+
+## 10. Architecture Decision Records (ADR)
+### ADR-001: [Decision Title]
+- Status: Accepted
+- Context: [Why this decision was needed]
+- Decision: [What was decided]
+- Consequences: [Trade-offs]
+
+[QUALITY_CHECKLIST]
+Before submitting, verify:
+- [ ] All PRD requirements are covered by the architecture
+- [ ] Tech stack is justified for each layer
+- [ ] Data models cover all entities in the PRD
+- [ ] API endpoints cover all user stories
+- [ ] Security architecture is defined
+- [ ] Non-functional requirements are addressed
+- [ ] Coding conventions are documented
+- [ ] At least one ADR is written
+
+[ESCALATION]
+Escalate to MDAN Core if:
+- PRD requirements are technically infeasible
+- A requirement introduces significant security risk
+- The chosen architecture has major trade-offs the user should decide
+- Estimated complexity exceeds project constraints
+[/MDAN-AGENT]
+```