mdan-cli 2.5.0 → 2.5.2

package/memory/MEMORY-SYSTEM.md

@@ -1,197 +0,0 @@
-# MDAN Memory System
-
-> La mémoire persistante de MDAN entre les sessions.  
-> Chaque projet génère et maintient un fichier `MDAN-STATE.json` à la racine.
-
----
-
-## Concept
-
-Le problème fondamental des agents IA : chaque nouvelle conversation repart de zéro.  
-MDAN résout ça avec un fichier d'état JSON versionné, lisible par n'importe quel LLM.
-
-Au début de chaque session, l'utilisateur colle le contenu de `MDAN-STATE.json` dans la conversation.  
-MDAN Core le lit, reconstruit le contexte complet, et reprend exactement où on s'était arrêté.
-
----
-
-## Structure du fichier MDAN-STATE.json
-
-```json
-{
-  "mdan_version": "2.0.0",
-  "user": {
-    "name": "Alex"
-  },
-  "project": {
-    "name": "mon-projet",
-    "type": "web-app",
-    "created_at": "2025-01-15",
-    "last_updated": "2025-01-20"
-  },
-  "current_phase": "BUILD",
-  "phase_history": [
-    {
-      "phase": "DISCOVER",
-      "started_at": "2025-01-15",
-      "completed_at": "2025-01-15",
-      "status": "VALIDATED",
-      "artifacts": ["mdan_output/PRD.md"]
-    },
-    {
-      "phase": "DESIGN",
-      "started_at": "2025-01-16",
-      "completed_at": "2025-01-17",
-      "status": "VALIDATED",
-      "artifacts": ["mdan_output/ARCHITECTURE.md", "mdan_output/UX-SPEC.md"]
-    },
-    {
-      "phase": "BUILD",
-      "started_at": "2025-01-18",
-      "completed_at": null,
-      "status": "IN_PROGRESS",
-      "artifacts": []
-    }
-  ],
-  "agents_used": {
-    "product": "2.0.0",
-    "architect": "2.0.0",
-    "ux": "2.0.0",
-    "dev": "2.0.0",
-    "test": "2.0.0",
-    "security": "2.0.0",
-    "devops": "2.0.0",
-    "doc": "2.0.0"
-  },
-  "features": [
-    {
-      "id": "US-001",
-      "title": "User authentication",
-      "status": "DONE",
-      "implemented_at": "2025-01-18",
-      "files": ["src/auth/auth.service.ts", "src/auth/auth.controller.ts"],
-      "tests": "PASSING",
-      "security_review": "APPROVED"
-    },
-    {
-      "id": "US-002",
-      "title": "User profile management",
-      "status": "IN_PROGRESS",
-      "implemented_at": null,
-      "files": [],
-      "tests": null,
-      "security_review": null
-    },
-    {
-      "id": "US-003",
-      "title": "Dashboard",
-      "status": "TODO",
-      "implemented_at": null,
-      "files": [],
-      "tests": null,
-      "security_review": null
-    }
-  ],
-  "decisions": [
-    {
-      "id": "ADR-001",
-      "title": "PostgreSQL over MongoDB",
-      "made_at": "2025-01-16",
-      "rationale": "Relational data, ACID needed"
-    }
-  ],
-  "open_issues": [
-    {
-      "id": "ISSUE-001",
-      "type": "BLOCKER",
-      "description": "Rate limiting library choice not finalized",
-      "phase": "BUILD"
-    }
-  ],
-  "tech_stack": {
-    "frontend": "React 18 + TypeScript",
-    "backend": "Node.js 20 + Express",
-    "database": "PostgreSQL 16",
-    "cache": "Redis 7",
-    "hosting": "Railway"
-  },
-  "llm_history": [
-    { "session": 1, "llm": "Claude", "phase": "DISCOVER + DESIGN" },
-    { "session": 2, "llm": "Cursor", "phase": "BUILD (US-001)" }
-  ]
-}
-```
-
----
-
-## Protocole de reprise de session
-
-### Ce que l'utilisateur fait
-
-```
-1. Ouvrir MDAN-STATE.json du projet
-2. Copier le contenu
-3. Ouvrir son LLM avec le prompt MDAN Core
-4. Coller ce message :
-
-"MDAN RESUME SESSION
-[coller le contenu de MDAN-STATE.json]"
-```
-
-### Ce que MDAN Core fait automatiquement
-
-```
-[MDAN CORE — REPRISE DE SESSION]
-
-✅ Projet chargé : [nom]
-✅ Phase courante : [phase] 
-✅ Progression : [X/Y features complètes]
-✅ Dernière session : [LLM utilisé, date]
-
-Contexte reconstruit :
-- PRD : [résumé en 2 lignes]
-- Architecture : [stack + pattern]
-- Fonctionnalités : [liste avec statuts]
-- Issues ouvertes : [liste]
-
-Prochaine action recommandée :
-→ [Action précise à faire maintenant]
-
-Souhaitez-vous continuer avec [action], ou autre chose ?
-```
-
----
-
-## Mise à jour de l'état
-
-À la fin de chaque session, MDAN Core génère le MDAN-STATE.json mis à jour :
-
-```
-[MDAN CORE — FIN DE SESSION]
-
-Voici votre MDAN-STATE.json mis à jour.
-Remplacez le fichier existant avec ce contenu :
-
-[JSON complet mis à jour]
-```
-
----
-
-## CLI — Commandes mémoire
-
-```bash
-# Initialiser l'état d'un projet
-mdan memory init mon-projet
-
-# Afficher l'état actuel
-mdan memory status
-
-# Mettre à jour le statut d'une feature
-mdan memory feature US-001 done
-
-# Générer le prompt de reprise
-mdan memory resume
-
-# Valider une phase
-mdan memory phase-complete DISCOVER
-```

package/phases/01-discover.md

@@ -1,136 +0,0 @@
-# MDAN Phase 1 — DISCOVER
-
-> **Goal:** Deeply understand the user's need before touching any solution.  
-> **Agents:** Product Agent  
-> **Output:** Validated PRD
-
----
-
-## Phase Overview
-
-The DISCOVER phase is the foundation of every MDAN project. A rushed discovery means everything 
-built on top of it will be wrong. MDAN Core enforces a thorough discovery before ANY technical 
-work begins.
-
-**Duration:** As long as it takes to answer every question with confidence.  
-**Shortcut:** Never. Discovery shortcuts are the #1 cause of failed software projects.
-
----
-
-## MDAN Core Behavior in DISCOVER
-
-When the user presents a project idea, MDAN Core ALWAYS:
-
-1. **Acknowledges** the project idea warmly
-2. **Announces** Phase 1: DISCOVER
-3. **Asks the 5 Discovery Questions** (see below)
-4. **Activates the Product Agent** with the user's answers
-5. **Presents the PRD** to the user for validation
-6. **Runs the Phase Gate check** before proceeding
-
----
-
-## The 5 Essential Discovery Questions
-
-MDAN Core asks these questions every time, without exception:
-
-```
-🔍 MDAN — Phase 1: DISCOVER
-
-Before we build anything, I need to understand what we're actually solving.
-Please answer these 5 questions as completely as you can:
-
-1. WHAT is the core problem you're solving?
-   (Not the solution — the actual problem users face today)
-
-2. WHO are your users?
-   (Be specific: roles, technical level, context of use)
-
-3. HOW will you know if it's successful?
-   (Concrete metrics: "X users per month", "reduces time from Y to Z", etc.)
-
-4. WHAT are your constraints?
-   (Timeline, budget, team size, existing tech, non-negotiables)
-
-5. WHAT have you already tried?
-   (Existing solutions, past attempts, why they didn't work)
-```
-
----
-
-## Discovery Depth Guide
-
-| Answer Quality | MDAN Core Response |
-|---|---|
-| Vague ("I want an app") | Ask follow-up until specific |
-| Partial (3/5 questions) | Ask for missing answers |
-| Contradictory | Point out the contradiction, resolve first |
-| Complete and clear | Activate Product Agent |
-
----
-
-## Product Agent Activation Script
-
-Once discovery answers are complete, MDAN Core activates the Product Agent with this brief:
-
-```
-[ACTIVATING: Product Agent]
-
-Task: Create a complete PRD based on the following discovery information.
-
-Project: [Project Name]
-Problem: [User's answer to Q1]
-Users: [User's answer to Q2]
-Success Metrics: [User's answer to Q3]
-Constraints: [User's answer to Q4]
-Prior Attempts: [User's answer to Q5]
-
-Additional Context: [Any other relevant information from the conversation]
-
-Expected Output: Complete PRD following the MDAN PRD template.
-```
-
----
-
-## Phase 1 Quality Gate
-
-Before exiting DISCOVER and entering DESIGN, MDAN Core checks:
-
-```
-✅ DISCOVER → DESIGN Quality Gate
-
-[ ] Problem is clearly and specifically defined
-[ ] At least one user persona is fully defined
-[ ] Success metrics are measurable (numbers, not "better" or "faster")
-[ ] Project constraints are documented
-[ ] PRD is complete with MoSCoW prioritization
-[ ] MVP scope is defined and realistic
-[ ] User stories have acceptance criteria
-[ ] Risks are identified with mitigation plans
-[ ] Out of scope items are explicitly listed
-[ ] User has reviewed and validated the PRD
-```
-
-**If any box is unchecked:** MDAN Core does NOT proceed. It identifies the gap and works with the user to fill it.
-
-**If all boxes are checked:** MDAN Core announces Phase 2: DESIGN.
-
----
-
-## Common Discovery Anti-Patterns
-
-| Anti-Pattern | Why It's Dangerous | MDAN Response |
-|---|---|---|
-| "Just build a Twitter clone" | No clear differentiation or problem | Ask: what specific problem does this solve for which users? |
-| "I want all the features" | Scope creep from day one | Enforce MoSCoW, define MVP |
-| "The tech is already decided" | Solution before problem | Document constraint, still validate need |
-| "Trust me, users need this" | Assumptions not validated | Ask for user research or at least specific examples |
-| "We'll figure out metrics later" | No way to know if it worked | Define metrics now or they'll never be defined |
-
----
-
-## DISCOVER Phase Artifacts
-
-| Artifact | Template | Owner | Status Needed |
-|---|---|---|---|
-| PRD | `templates/PRD.md` | Product Agent | Validated |

package/phases/02-design.md

@@ -1,147 +0,0 @@
-# MDAN Phase 2 — DESIGN
-
-> **Goal:** Architect the complete solution before writing a single line of code.  
-> **Agents:** Architect Agent, UX Agent  
-> **Output:** Architecture Document + UX Specification
-
----
-
-## Phase Overview
-
-DESIGN is where the solution takes shape. By the end of this phase, every technical and 
-interface decision should be made. The BUILD phase should have zero architectural surprises.
-
-**Duration:** Until every design question is answered.  
-**Rule:** If you're still making architecture decisions during BUILD, DESIGN failed.
-
----
-
-## MDAN Core Behavior in DESIGN
-
-1. **Announces** Phase 2: DESIGN
-2. **Reviews** the validated PRD
-3. **Activates Architect Agent** first — system design before interface design
-4. **Reviews** the Architecture Document with the user
-5. **Activates UX Agent** — interface design aligned to architecture
-6. **Reviews** the UX Specification with the user
-7. **Runs Phase Gate check** before proceeding
-
----
-
-## Architect Agent Activation Script
-
-```
-[ACTIVATING: Architect Agent]
-
-Task: Design the complete system architecture for this project.
-
-PRD: [Paste validated PRD]
-Technical constraints: [From discovery]
-Team profile: [Size, skill level]
-Deployment preferences: [Cloud provider, on-prem, etc.]
-
-Expected outputs:
-1. Architecture diagram (Mermaid)
-2. Technology stack with justifications
-3. Data models
-4. API design
-5. Security architecture
-6. Non-functional requirements strategy
-7. Project structure
-8. Coding conventions
-9. Architecture Decision Records
-```
-
----
-
-## UX Agent Activation Script
-
-```
-[ACTIVATING: UX Agent]
-
-Task: Design the complete user interface specification for this project.
-
-PRD: [Paste validated PRD — personas and user stories]
-Architecture constraints: [Tech stack, limitations]
-Existing brand/design system: [If any, else "None — create from scratch"]
-
-Expected outputs:
-1. Design system (colors, typography, spacing)
-2. Navigation structure
-3. User flows for all key user stories
-4. Screen specifications with all states
-5. Component specifications
-6. Accessibility requirements
-7. UI copy guidelines
-```
-
----
-
-## Design Review Process
-
-After each agent delivers its output, MDAN Core:
-
-1. **Checks completeness** against the quality gate
-2. **Cross-checks consistency** — does the UX spec align with the architecture?
-3. **Presents to user** with key decisions highlighted
-4. **Asks for explicit validation** before continuing
-
-```
-📐 Design Review: [Document Name]
-
-Key decisions made in this document:
-1. [Decision]: [Choice made] — Rationale: [Why]
-2. [Decision]: [Choice made] — Rationale: [Why]
-3. [Decision]: [Choice made] — Rationale: [Why]
-
-Please review and confirm:
-[ ] I agree with the technology choices
-[ ] I agree with the data model design
-[ ] I agree with the API design
-[ ] I have no unresolved concerns
-
-Type "DESIGN APPROVED" to proceed to Phase 3: BUILD
-Or describe your concerns and we'll revise.
-```
-
----
-
-## Phase 2 Quality Gate
-
-```
-✅ DESIGN → BUILD Quality Gate
-
-Architecture:
-[ ] System architecture diagram is complete
-[ ] All PRD requirements are addressed in the architecture
-[ ] Technology stack is fully specified with justifications
-[ ] All data entities and relationships are defined
-[ ] All API endpoints are specified
-[ ] Security architecture is defined (auth, authz, encryption)
-[ ] Non-functional requirements are addressed
-[ ] Project structure is defined
-[ ] Coding conventions are documented
-[ ] At least one ADR is written
-
-UX:
-[ ] Design system is complete (colors, typography, spacing, breakpoints)
-[ ] Navigation structure covers all app sections
-[ ] User flows cover all user stories from PRD
-[ ] Every screen has all states (default, loading, empty, error)
-[ ] Accessibility requirements are defined
-[ ] Mobile behavior is specified
-
-Cross-check:
-[ ] UX spec is consistent with architecture (no impossible requirements)
-[ ] Performance requirements are reflected in both arch and UX
-[ ] Both documents are validated by the user
-```
-
----
-
-## DESIGN Phase Artifacts
-
-| Artifact | Template | Owner | Status Needed |
-|---|---|---|---|
-| Architecture Document | `templates/ARCHITECTURE.md` | Architect Agent | Validated |
-| UX Specification | *(in-line document)* | UX Agent | Validated |

package/phases/03-build.md

@@ -1,113 +0,0 @@
-# MDAN Phase 3 — BUILD
-
-> **Goal:** Implement the solution with precision, security, and quality.  
-> **Agents:** Dev Agent, Security Agent (concurrent)  
-> **Output:** Working, tested, reviewed code
-
----
-
-## Phase Overview
-
-BUILD is where the code is written. But in MDAN, BUILD is not "just coding" — it's a structured 
-process where every feature is implemented against a spec, reviewed, and security-checked before 
-moving on.
-
-**Rule:** No feature is "done" until it has tests and passes a security check.
-
----
-
-## BUILD Workflow (per feature)
-
-```
-For each feature in the PRD (MVP scope):
-
-1. MDAN Core prepares a Feature Brief
-2. Dev Agent implements the feature
-3. Security Agent reviews the implementation
-4. MDAN Core reviews the combined output
-5. User validates (or flags issues)
-6. Move to next feature
-```
-
----
-
-## Feature Brief Template
-
-MDAN Core creates this before activating the Dev Agent:
-
-```
-[ACTIVATING: Dev Agent]
-
-Feature: [US-XXX: User story title]
-Acceptance Criteria:
-  - Given [context], When [action], Then [outcome]
-  - [Additional criteria]
-
-Architecture context:
-  - Tech stack: [Stack]
-  - Relevant data models: [Models]
-  - Relevant API endpoints: [Endpoints]
-  - Coding conventions: [Link/summary]
-
-UX context:
-  - Relevant screens: [Screen names]
-  - Relevant components: [Component names]
-
-Definition of Done:
-  - [ ] All acceptance criteria met
-  - [ ] Unit tests written and passing
-  - [ ] No critical security issues
-  - [ ] Code follows project conventions
-```
-
----
-
-## Concurrent Security Review
-
-After Dev Agent delivers code, Security Agent reviews immediately:
-
-```
-[ACTIVATING: Security Agent]
-
-Task: Security review of the following implementation.
-Feature: [Feature name]
-Code: [Dev Agent output]
-
-Focus areas:
-- Input validation
-- Authentication/authorization
-- Data exposure
-- Error handling (no sensitive data in errors)
-- Dependency risks
-```
-
----
-
-## Phase 3 Quality Gate
-
-```
-✅ BUILD → VERIFY Quality Gate
-
-For each feature:
-[ ] All acceptance criteria are implemented
-[ ] Unit tests exist and pass
-[ ] No CRITICAL or HIGH security findings unresolved
-[ ] Code follows project conventions
-[ ] Error handling is complete
-[ ] No hardcoded secrets
-
-Overall:
-[ ] All MVP features are implemented
-[ ] Code is in version control
-[ ] Environment is reproducible (setup script or Docker)
-```
-
----
-
-## BUILD Phase Artifacts
-
-| Artifact | Owner | Status Needed |
-|---|---|---|
-| Feature implementations | Dev Agent | Reviewed |
-| Unit tests | Dev Agent | Passing |
-| Security findings (per feature) | Security Agent | Resolved or accepted |

package/phases/04-verify.md

@@ -1,107 +0,0 @@
-# MDAN Phase 4 — VERIFY
-
-> **Goal:** Validate that what was built works correctly, securely, and completely.  
-> **Agents:** Test Agent, Security Agent  
-> **Output:** Validated test suite, security report, signed-off quality gate
-
----
-
-## Phase Overview
-
-VERIFY is where MDAN proves the software works — not assumes it does. Every acceptance criterion 
-is tested. Every security finding from BUILD is verified as resolved. Performance is measured.
-
-**Rule:** "It works on my machine" is not verification. Repeatable, automated tests are.
-
----
-
-## MDAN Core Behavior in VERIFY
-
-1. **Announces** Phase 4: VERIFY
-2. **Activates Test Agent** for full test suite creation
-3. **Activates Security Agent** for final security review
-4. **Validates all findings** are resolved or explicitly accepted
-5. **Runs Phase Gate check**
-
----
-
-## Test Agent Activation Script
-
-```
-[ACTIVATING: Test Agent]
-
-Task: Create and execute the full test suite for this project.
-
-PRD (acceptance criteria): [Link/paste]
-Architecture: [Link/paste]
-Implemented features: [List of completed features]
-
-Expected output:
-1. Complete test plan
-2. Unit tests for all features (80%+ coverage)
-3. Integration tests for critical flows
-4. E2E test scenarios
-5. Scenario tests (Better Agents format)
-6. Evaluation datasets (if RAG/ML features)
-7. Performance test criteria
-8. Test results summary
-```
-
----
-
-## Final Security Review Activation
-
-```
-[ACTIVATING: Security Agent]
-
-Task: Final security review of the complete application.
-
-Previous security findings: [List with resolution status]
-Full codebase: [Context/summary]
-Deployment configuration: [From DevOps Agent if available]
-
-Expected output:
-1. Verification that previous findings are resolved
-2. Any new findings discovered
-3. Final security sign-off (or list of blockers)
-```
-
----
-
-## Phase 4 Quality Gate
-
-```
-✅ VERIFY → SHIP Quality Gate
-
-Testing:
-[ ] All acceptance criteria have corresponding tests
-[ ] All tests pass (0 failures)
-[ ] Test coverage meets target (e.g., 80%)
-[ ] Integration tests pass
-[ ] At least 3 E2E scenarios pass
-[ ] Scenario tests pass (Better Agents format)
-[ ] Evaluation benchmarks pass (if RAG/ML features)
-[ ] Performance criteria are met
-
-Security:
-[ ] All CRITICAL findings resolved
-[ ] All HIGH findings resolved or explicitly accepted with rationale
-[ ] Final security review completed
-[ ] No new CRITICAL findings
-
-Quality:
-[ ] No known bugs that affect MVP functionality
-[ ] Error messages are user-friendly (no stack traces exposed)
-[ ] Application handles edge cases gracefully
-```
-
----
-
-## VERIFY Phase Artifacts
-
-| Artifact | Template | Owner | Status Needed |
-|---|---|---|---|
-| Test Plan | `templates/TEST-PLAN.md` | Test Agent | Complete |
-| Security Report | `templates/SECURITY-REVIEW.md` | Security Agent | Signed off |
-| Scenarios | `templates/tests/scenarios/*.test.md` | Test Agent | Pass |
-| Evaluations | `templates/tests/evaluations/*.md` | Test Agent | Pass thresholds |