mdan-method 2.6.3

package/src/memory/MEMORY-SYSTEM.md

@@ -0,0 +1,61 @@
+# MDAN Memory System v3.0
+
+## Pourquoi c'est différent de MDAN
+
+MDAN n'a **aucun système de mémoire**. Chaque session repart de zéro. MDAN résout ça.
+
+## Architecture
+
+```
+MDAN-STATE.json          ← État persistant du projet (phases, artifacts, décisions)
+   ↕ lu/écrit par
+Wizard Engine            ← Met à jour l'état après chaque wizard
+   ↕ informé par
+Context Summary          ← Résumé vivant du projet, mis à jour en continu
+   ↕ alimenté par
+Agent Observations       ← Notes des agents pendant leur travail
+```
+
+## Fonctionnement
+
+### 1. Sauvegarde automatique
+À la fin de chaque wizard, le moteur sauvegarde dans MDAN-STATE.json :
+- Le wizard complété
+- Les artifacts produits
+- Les décisions prises
+- Le résumé du contexte mis à jour
+- Les observations des agents
+
+### 2. Restauration automatique
+Au début de chaque session, MDAN Master :
+1. Charge MDAN-STATE.json
+2. Restaure le contexte du projet
+3. Identifie la phase actuelle
+4. Propose la prochaine action logique
+5. Rappelle les décisions clés à l'utilisateur
+
+### 3. Mémoire cross-wizard
+Quand un wizard démarre, il a accès à :
+- Tous les artifacts des wizards précédents
+- Les décisions d'architecture (pour le dev)
+- Les user stories (pour le QA)
+- Le product brief (pour tout le monde)
+
+### 4. Context Summary
+Un résumé vivant du projet en ~500 mots, mis à jour à chaque fin de wizard.
+Inclut : objectif, décisions clés, stack technique, état actuel, prochaines étapes.
+
+## Protocole de reprise
+
+Quand l'utilisateur revient après une interruption :
+
+```
+1. MDAN Master charge MDAN-STATE.json
+2. Affiche : "Bonjour {user_name} ! Voici où on en est sur {project_name}..."
+3. Résumé : phase actuelle, dernière action, prochaine étape suggérée
+4. Question : "On continue là où on s'était arrêté ?"
+```
+
+## Format de l'état
+
+Voir `.mdan/state/MDAN-STATE.template.json` pour le schéma complet.

package/src/memory/v1-memory-system.md

@@ -0,0 +1,197 @@
+# 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/src/memory/v1-resume-protocol.md

@@ -0,0 +1,379 @@
+# Resume Protocol
+
+> MDAN-AUTO v1.0 Context Resume Procedure
+
+## Overview
+
+The resume protocol defines how MDAN-AUTO resumes execution from a saved context file, ensuring seamless continuation after token limits or interruptions.
+
+## Resume Command
+
+```bash
+mdan auto resume /tmp/mdan-save-[timestamp].json
+```
+
+## Resume Process
+
+### Step 1: Load Save File
+
+1. Locate save file
+2. Validate file exists and is readable
+3. Parse JSON content
+4. Validate format version
+
+### Step 2: Validate Save State
+
+Check:
+
+- [ ] Version is compatible (1.0)
+- [ ] All required fields present
+- [ ] JSON is valid
+- [ ] File is not corrupted
+- [ ] Timestamp is recent (optional)
+
+If validation fails:
+- Log error
+- Exit with error code
+- Provide recovery instructions
+
+### Step 3: Restore State
+
+Restore the following:
+
+1. **Project Information**
+   - Project name
+   - Description
+   - Tech stack
+
+2. **Phase State**
+   - Current phase
+   - Completed phases
+   - Phase status
+
+3. **Context**
+   - Conversation history
+   - Artifacts
+   - Decisions
+
+4. **Configuration**
+   - Token limit
+   - Save threshold
+   - Output directory
+   - Other settings
+
+5. **Debates**
+   - Debate history
+   - Decisions made
+
+6. **Quality Gates**
+   - Gate status for each phase
+
+### Step 4: Validate Environment
+
+Check:
+
+- [ ] Required tools installed (dotnet, docker, etc.)
+- [ ] Output directory exists
+- [ ] Sufficient disk space
+- [ ] Network connectivity (if needed)
+- [ ] API credentials valid
+
+If environment check fails:
+- Log error
+- Exit with error code
+- Provide setup instructions
+
+### Step 5: Resume Execution
+
+1. Log resume start
+2. Display resume summary
+3. Continue from `phases.current`
+4. Increment `metadata.resume_count`
+5. Execute remaining phases
+
+## Resume Summary
+
+Display this summary when resuming:
+
+```
+╔════════════════════════════════════════════════════════════╗
+║           MDAN-AUTO v1.0 - Resume Execution               ║
+╠════════════════════════════════════════════════════════════╣
+║ Project: MyProject                                        ║
+║ Tech Stack: C#/.NET/Blazor/SQL Server/Azure               ║
+║                                                              ║
+║ Current Phase: IMPLEMENT                                   ║
+║ Completed: LOAD, DISCOVER, PLAN, ARCHITECT                 ║
+║ Remaining: IMPLEMENT, TEST, DEPLOY, DOC                    ║
+║                                                              ║
+║ Save File: /tmp/mdan-save-1705310400.json                  ║
+║ Save Time: 2024-01-15 10:23:45 UTC                         ║
+║ Resume Count: 1                                            ║
+║                                                              ║
+║ Token Usage: 102,400 / 128,000 (80%)                       ║
+║                                                              ║
+║ Resuming execution...                                      ║
+╚════════════════════════════════════════════════════════════╝
+```
+
+## Phase Resume Logic
+
+### Resume from Pending Phase
+
+If phase status is `pending`:
+- Start phase from beginning
+- Execute all phase tasks
+- Mark as `in_progress`
+
+### Resume from In-Progress Phase
+
+If phase status is `in_progress`:
+- Check for partial artifacts
+- Determine last completed task
+- Continue from next task
+- If cannot determine, restart phase
+
+### Resume from Failed Phase
+
+If phase status is `failed`:
+- Check error details
+- Determine if recoverable
+- If recoverable, retry phase
+- If not recoverable, abort
+
+### Resume from Complete Phase
+
+If phase status is `complete`:
+- Skip phase
+- Move to next phase
+- Verify quality gate passed
+
+## Artifact Restoration
+
+### File Artifacts
+
+For each artifact in `context.artifacts`:
+
+1. Check if file exists
+2. If exists, verify content matches
+3. If missing or different, recreate from saved content
+4. Update file timestamps
+
+### In-Memory Artifacts
+
+For in-memory artifacts:
+- Restore from `context.artifacts`
+- Keep in memory for execution
+- Save to disk when needed
+
+## Conversation History Restoration
+
+### History Validation
+
+1. Validate conversation history structure
+2. Check for corrupted entries
+3. Remove invalid entries
+4. Log any issues
+
+### History Trimming
+
+If conversation history is too long:
+- Keep last N messages (configurable)
+- Keep system messages
+- Keep critical decisions
+- Log trim operation
+
+## Decision Restoration
+
+Restore all decisions from `context.decisions`:
+
+1. Load decision history
+2. Apply decisions to current state
+3. Log restored decisions
+4. Use for future debates
+
+## Quality Gate Validation
+
+For each completed phase:
+
+1. Check quality gate status
+2. If gate failed:
+   - Log warning
+   - Consider re-running phase
+   - Or continue with warning
+
+## Error Handling
+
+### Load Errors
+
+If save file cannot be loaded:
+- Log error with details
+- Exit with error code 1
+- Provide recovery instructions
+
+### Validation Errors
+
+If save state is invalid:
+- Log validation errors
+- Exit with error code 2
+- Provide fix instructions
+
+### Resume Errors
+
+If resume fails:
+- Log error with context
+- Save current state
+- Exit with error code 3
+- Provide manual recovery steps
+
+## Recovery Instructions
+
+### Save File Not Found
+
+```
+Error: Save file not found: /tmp/mdan-save-1705310400.json
+
+Recovery:
+1. Check file path is correct
+2. Look for recent saves in /tmp/
+3. Use: ls -lt /tmp/mdan-save-*.json
+4. If no saves found, start new execution
+```
+
+### Invalid Save Format
+
+```
+Error: Invalid save format: version mismatch
+
+Recovery:
+1. Check save file version
+2. Update MDAN-AUTO to latest version
+3. Or manually migrate save file
+```
+
+### Missing Artifacts
+
+```
+Error: Missing artifact: docs/discover.md
+
+Recovery:
+1. Check if artifact was saved
+2. Recreate from saved content
+3. Or re-run DISCOVER phase
+```
+
+### Environment Issues
+
+```
+Error: Required tool not found: dotnet
+
+Recovery:
+1. Install missing tool
+2. Verify installation
+3. Resume execution
+```
+
+## Resume Logging
+
+Log all resume operations:
+
+```
+[2024-01-15 10:30:00] Starting resume from /tmp/mdan-save-1705310400.json
+[2024-01-15 10:30:01] Loading save file...
+[2024-01-15 10:30:02] Validating save state...
+[2024-01-15 10:30:03] Restoring project state...
+[2024-01-15 10:30:04] Restoring conversation history (45 messages)
+[2024-01-15 10:30:05] Restoring artifacts (3 files)
+[2024-01-15 10:30:06] Restoring decisions (2 decisions)
+[2024-01-15 10:30:07] Validating environment...
+[2024-01-15 10:30:08] Environment valid
+[2024-01-15 10:30:09] Resuming from phase: IMPLEMENT
+[2024-01-15 10:30:10] Resume count: 1
+[2024-01-15 10:30:11] Continuing execution...
+```
+
+## Resume Count Tracking
+
+Track resume attempts in `metadata.resume_count`:
+
+- 0: First execution
+- 1: First resume
+- 2: Second resume
+- etc.
+
+If resume count > threshold (default 5):
+- Log warning
+- Consider aborting
+- Require manual intervention
+
+## Auto-Resume
+
+For automatic resume after context save:
+
+1. Detect context save
+2. Wait for token limit reset
+3. Automatically resume from latest save
+4. Continue execution
+
+## Manual Resume
+
+For manual resume:
+
+1. User provides save file path
+2. Validate and load
+3. Display summary
+4. Ask for confirmation (optional)
+5. Resume execution
+
+## Resume Verification
+
+After resume, verify:
+
+- [ ] All artifacts restored
+- [ ] Conversation history valid
+- [ ] Decisions applied
+- [ ] Environment ready
+- [ ] Can continue execution
+
+## Resume Failure Recovery
+
+If resume fails completely:
+
+1. Save error state
+2. Provide detailed error report
+3. Suggest recovery options:
+   - Fix and retry resume
+   - Start new execution
+   - Manual intervention
+
+## Example Resume Flow
+
+```
+1. User runs: mdan auto resume /tmp/mdan-save-1705310400.json
+2. MDAN-AUTO loads save file
+3. Validates save state (OK)
+4. Restores project state
+5. Restores conversation history
+6. Restores artifacts
+7. Validates environment (OK)
+8. Displays resume summary
+9. Resumes from IMPLEMENT phase
+10. Continues execution
+11. Completes remaining phases
+12. MISSION COMPLETE ✅
+```
+
+## Best Practices
+
+1. **Always validate** before resuming
+2. **Log everything** for debugging
+3. **Handle errors gracefully**
+4. **Provide clear recovery instructions**
+5. **Track resume attempts**
+6. **Clean up old saves** after success
+7. **Backup saves** before resume
+8. **Verify environment** before resume
+
+## Version
+
+MDAN-AUTO Resume Protocol v1.0

package/src/packs/db-optimization/agents/prompt.yaml

@@ -0,0 +1,63 @@
+name: db-performance-analyst
+version: 1.0.0
+description: Specialized agent for database performance analysis, monitoring, and optimization recommendations
+
+system_prompt: |
+  You are Driss, a DB Performance Analyst, a Database Performance Analysis and Optimization Expert.
+
+  Your capabilities:
+  - Database performance analysis
+  - Query performance optimization
+  - Indexing strategy recommendations
+  - Database configuration tuning
+  - Performance bottleneck identification
+  - Resource utilization analysis
+  - Slow query analysis
+  - Database scaling recommendations
+  - Performance monitoring setup
+  - Query execution plan analysis
+
+  Your communication style:
+  - Analytical and data-driven, focusing on performance metrics, execution plans, and optimization strategies
+  - Provides clear recommendations with before/after comparisons and expected performance improvements
+  - Uses specific metrics and measurements to support recommendations
+  - Explains the "why" behind optimization decisions
+
+  Your principles:
+  - Measure before optimizing
+  - Focus on the most impactful optimizations first
+  - Consider the entire system, not just individual queries
+  - Balance performance with maintainability
+  - Use appropriate indexing strategies
+  - Monitor performance continuously
+  - Document optimization decisions
+  - Test optimizations in staging environments
+
+  Your role:
+  Expert database performance analyst with comprehensive knowledge of database internals, query optimization, and performance tuning. Specialized in identifying and resolving performance bottlenecks across multiple database systems including PostgreSQL, MySQL, MongoDB, and SQL Server.
+
+  When analyzing performance:
+  1. Start by understanding the workload and access patterns
+  2. Identify the most impactful bottlenecks
+  3. Analyze query execution plans
+  4. Review current indexing strategy
+  5. Check configuration settings
+  6. Provide prioritized recommendations with expected impact
+
+  When providing recommendations:
+  - Always include expected performance improvements
+  - Provide specific SQL or configuration changes
+  - Consider trade-offs (performance vs. storage, write vs. read)
+  - Suggest monitoring to validate improvements
+  - Recommend testing in non-production environments first
+
+user_prompt_template: |
+  Task: {action}
+
+  Database Type: {db_type}
+  Performance Issue: {performance_issue}
+  Metrics: {metrics}
+  Query Samples: {query_samples}
+  Schema Info: {schema_info}
+
+  Please provide a comprehensive analysis and recommendations.