mdan-cli 2.5.1 → 2.6.0

package/AGENTS.md

@@ -228,6 +228,8 @@ my-project/
 | `mdan init` | Initialize project |
 | `mdan attach` | Add MDAN to existing project |
 | `mdan phase` | Show/run phase |
+| `mdan auto` | Run autonomous full-cycle development |
+| `mdan resume` | Resume from saved context |
 | `mdan mcp init` | Generate MCP config |
 | `mdan prompt list` | List prompts |
 | `mdan test` | Run tests |
@@ -235,6 +237,32 @@ my-project/
 
 ---
 
+## Agent Registry
+
+### Core Agents
+
+| Agent | Phase | Expertise |
+|-------|-------|-----------|
+| Product Agent (Khalil) | DISCOVER | Requirements gathering, PRD creation |
+| Architect Agent (Reda) | DESIGN | System architecture, tech stack |
+| UX Agent (Jihane) | DESIGN | User experience, UI/UX design |
+| Dev Agent (Haytame) | BUILD | Implementation, coding |
+| Security Agent (Said) | BUILD/VERIFY | Security review, vulnerability assessment |
+| Test Agent (Youssef) | VERIFY | Testing strategy, test execution |
+| DevOps Agent (Anas) | SHIP | Deployment, CI/CD, Azure |
+| Doc Agent (Amina) | SHIP | Documentation, user guides |
+| Learn Agent | Transverse | Knowledge management, learning |
+
+### Autonomous Agents
+
+| Agent | Phase | Expertise |
+|-------|-------|-----------|
+| Auto Orchestrator | ALL | Autonomous full-cycle development coordination |
+
+The Auto Orchestrator executes all 8 phases (LOAD → DISCOVER → PLAN → ARCHITECT → IMPLEMENT → TEST → DEPLOY → DOC) without human intervention, with context save/load capabilities and multi-agent debate support.
+
+---
+
 ## Resources
 
 - [MDAN Documentation](https://github.com/khalilbenaz/MDAN)

package/README.md

@@ -27,16 +27,21 @@ Les outils IA traditionnels font le travail à votre place, produisant des résu
 
 ---
 
-## 🚀 Nouveautés dans MDAN v2.4
+## 🚀 Nouveautés dans MDAN v2.5
 
 **MDAN évolue rapidement avec des optimisations incluant :**
 
+- **MDAN-AUTO v1.0** — Mode de développement autonome sans intervention humaine
+- **Context Save/Resume** — Sauvegarde et reprise automatique du contexte à 80% des tokens
+- **Multi-Agent Debates** — Débats entre agents pour les décisions complexes
 - **Cross Platform Agent Team** — Agents multi-plateformes (Cursor, Windsurf, Claude Code, VS Code)
 - **Sub Agent Inclusion** — Sous-agents spécialisés pour des tâches ciblées
 - **Skills Architecture** — Architecture de skills extensible et modulable
 - **MDAN Builder v1** — Créez vos propres agents et workflows
 - **Dev Loop Automation** — Automatisation complète du cycle de développement
 - **Better Agents Integration** — Scenarios et evaluations intégrés
+- **Templates Génériques** — Templates services externes, .NET Blazor, SQL Server
+- **Architecture Modulaire** — Skills extensibles et modules spécialisés
 
 ---
 
@@ -119,8 +124,12 @@ MDAN s'étend avec des modules officiels pour domaines spécialisés :
 | Module | Description |
 |--------|-------------|
 | **MDAN Core** | Framework principal avec 5 phases |
+| **MDAN-AUTO** | Mode de développement autonome (8 phases) |
+| **External Services** | Templates d'intégration services externes génériques |
+| **.NET Blazor** | Templates projets .NET 8.0 Blazor Server |
+| **SQL Server** | Templates SQL Server (schema, stored procedures, functions) |
+| **Azure DevOps** | Skills pour Azure DevOps Services |
 | **Agile Scrum** | Workflows Agile/Scrum (Sprint, backlog, retrospectives) |
-| **Skills** | Compétences additionnelles |
 
 ```bash
 # Ajouter un module
@@ -129,8 +138,83 @@ mdan module add agile-scrum
 
 ---
 
+## 📋 Templates Disponibles
+
+MDAN fournit des templates génériques et réutilisables pour accélérer le développement :
+
+### External Services
+
+Templates d'intégration de services externes (APIs, microservices) :
+
+- `IService.cs` — Interface de base pour les services
+- `ServiceBase.cs` — Classe de base avec logging et gestion d'erreurs
+- `ServiceProvider.cs` — Gestionnaire de dépendances
+- `ExampleService.cs` — Exemple d'implémentation
+
+```bash
+# Utiliser le template
+cp templates/external-services/IService.cs src/Services/
+```
+
+### .NET Blazor
+
+Templates pour projets .NET 8.0 Blazor Server :
+
+- Structure de projet standard
+- Configuration de base
+- Exemples de composants
+
+```bash
+# Initialiser un projet Blazor
+mdan init mon-projet --template dotnet-blazor
+```
+
+### SQL Server
+
+Templates SQL Server pour bases de données :
+
+- `schema.sql` — Schéma de base de données
+- `stored-procedures.sql` — Procédures stockées
+- `functions.sql` — Fonctions SQL
+
+```bash
+# Utiliser les templates SQL
+cp templates/sql-server/schema.sql database/
+```
+
+---
+
 ## 🔧 Fonctionnalités Avancées
 
+### MDAN-AUTO v1.0 — Mode Autonome
+
+Développement entièrement autonome sans intervention humaine :
+
+```bash
+# Démarrer le mode autonome
+mdan auto
+
+# Reprendre depuis une sauvegarde
+mdan resume /tmp/mdan-save-1234567890.json
+```
+
+**Phases Autonomes** :
+1. **LOAD** — Chargement du contexte et des exigences
+2. **DISCOVER** — Analyse des exigences et user stories
+3. **PLAN** — Plan d'implémentation détaillé (#PHASE1, #PHASE2...)
+4. **ARCHITECT** — Conception de l'architecture système
+5. **IMPLEMENT** — Exécution de l'implémentation
+6. **TEST** — Tests complets (unitaires, intégration, E2E)
+7. **DEPLOY** — Déploiement en production
+8. **DOC** — Génération de la documentation
+
+**Fonctionnalités Clés** :
+- 🔄 Sauvegarde automatique à 80% des tokens
+- 🎯 Débats multi-agents pour décisions complexes
+- ⚡ Exécution séquentielle sans pause
+- 🚨 Fail-fast sur erreurs critiques
+- 📊 Signaux de progression (PHASE X COMPLETE ✅)
+
 ### Scenarios (Better Agents)
 
 Tests conversationnels end-to-end pour valider le comportement des agents.
@@ -187,6 +271,8 @@ mdan module add [nom]    # Installer un module
 mdan oc                  # Copier l'orchestrateur
 mdan agent [nom]         # Voir un agent
 mdan skills              # Lister les skills
+mdan auto                # Démarrer le mode autonome
+mdan resume <save-file>  # Reprendre depuis une sauvegarde
 mdan mcp [action]        # Config MCP
 mdan prompt [action]     # Gérer les prompts
 ```
@@ -219,8 +305,20 @@ projet/
 │   ├── scenarios/           # Tests conversationnels
 │   └── evaluations/        # Évaluations benchmarks
 ├── templates/
-│   ├── prompts/            # Prompts versionnés (YAML)
-│   └── prompts.json        # Registre des prompts
+│   ├── external-services/   # Templates services externes génériques
+│   ├── dotnet-blazor/       # Templates .NET 8.0 Blazor Server
+│   ├── sql-server/          # Templates SQL Server
+│   ├── prompts/             # Prompts versionnés (YAML)
+│   └── prompts.json         # Registre des prompts
+├── phases/
+│   ├── auto-01-load.md      # Phase LOAD (autonome)
+│   ├── auto-02-discover.md  # Phase DISCOVER (autonome)
+│   ├── auto-03-plan.md      # Phase PLAN (autonome)
+│   ├── auto-04-architect.md # Phase ARCHITECT (autonome)
+│   ├── auto-05-implement.md # Phase IMPLEMENT (autonome)
+│   ├── auto-06-test.md      # Phase TEST (autonome)
+│   ├── auto-07-deploy.md    # Phase DEPLOY (autonome)
+│   └── auto-08-doc.md       # Phase DOC (autonome)
 ├── mdan_output/            # Artifacts générés par les agents
 ├── .cursorrules            # Pour Cursor
 ├── .windsurfrules         # Pour Windsurf
@@ -250,6 +348,55 @@ MDAN se compose de plusieurs composants interconnectés :
 
 ---
 
+## 🧪 Tests et Qualité
+
+MDAN inclut une suite de tests complète pour garantir la qualité du code :
+
+### Framework de Tests
+
+- **pytest** — Framework de tests Python
+- **pytest-cov** — Couverture de code
+- **pytest-mock** — Mocking pour tests
+
+### Types de Tests
+
+| Type | Description | Emplacement |
+|------|-------------|-------------|
+| **Tests CLI** | Commandes CLI (init, attach, auto, etc.) | `tests/test_cli.py` |
+| **Tests Templates** | Validation des templates | `tests/test_templates.py` |
+| **Tests Services** | Patterns services externes | `tests/test_external_services.py` |
+| **Tests Installation** | Vérification installation | `tests/test_installation.py` |
+| **Tests Régression** | Pas de références wallet | `tests/test_regression.py` |
+
+### Exécuter les Tests
+
+```bash
+# Tous les tests
+pytest tests/ -v
+
+# Avec couverture
+pytest tests/ --cov=cli --cov-report=html
+
+# Tests spécifiques
+pytest tests/test_cli.py -v
+```
+
+### CI/CD
+
+GitHub Actions configurés pour :
+
+- **Tests automatiques** à chaque push
+- **Linting** avec ruff et mypy
+- **Couverture de code** minimale 80%
+
+```bash
+# Workflows CI/CD
+.github/workflows/test.yml
+.github/workflows/lint.yml
+```
+
+---
+
 ## 📚 Documentation
 
 | Document | Description |

package/agents/auto-orchestrator.md

@@ -0,0 +1,343 @@
+# MDAN-AUTO Orchestrator v1.0
+
+> Autonomous Full-Cycle Development Orchestrator
+
+## Role
+
+You are the **MDAN-AUTO Orchestrator**, an autonomous agent that executes the complete software development lifecycle without human intervention. You coordinate all phases, manage context, and ensure mission completion.
+
+## Core Principles
+
+1. **Autonomous Execution**: Never ask for confirmation except on critical errors
+2. **Sequential Phases**: Execute phases in order without pause
+3. **Context Management**: Save context at 80% token limit
+4. **Fail-Fast**: Abort immediately on critical errors
+5. **Multi-Agent Debate**: Use debates for complex decisions
+
+## Phase Sequence
+
+Execute these phases sequentially:
+
+```
+1. LOAD → Load project context and requirements
+2. DISCOVER → Analyze requirements and user stories
+3. PLAN → Create detailed implementation plan with #PHASE1, #PHASE2...
+4. ARCHITECT → Design system architecture
+5. IMPLEMENT → Execute implementation steps
+6. TEST → Run comprehensive tests
+7. DEPLOY → Deploy to production
+8. DOC → Generate documentation
+```
+
+## Phase Execution Rules
+
+### Before Each Phase
+
+1. Check token usage
+2. If ≥80% of limit, save context
+3. Load any saved context if resuming
+4. Log phase start
+
+### During Each Phase
+
+1. Execute phase tasks autonomously
+2. For complex decisions, trigger multi-agent debate
+3. Never pause for user input
+4. Log progress
+
+### After Each Phase
+
+1. Generate phase output markdown
+2. Save phase artifacts
+3. Emit signal: `PHASE X COMPLETE ✅`
+4. Check token usage
+5. If ≥80%, save context
+
+## Context Management
+
+### Token Monitoring
+
+- Track token usage for all LLM calls
+- Calculate percentage of context limit
+- Default limit: 128,000 tokens (configurable)
+
+### Context Save
+
+When token usage ≥80%:
+
+1. Create save file: `/tmp/mdan-save-[timestamp].json`
+2. Save:
+   - Current phase
+   - All agent outputs
+   - Generated artifacts
+   - Conversation history
+   - Project state
+3. Emit signal: `CONTEXT SAVE [file]`
+4. Continue execution
+
+### Context Resume
+
+When resuming from save:
+
+1. Load save file
+2. Restore conversation history
+3. Resume from saved phase
+4. Continue execution
+
+## Multi-Agent Debate
+
+### When to Debate
+
+Trigger debate for:
+- Architecture decisions
+- Technology stack choices
+- Security approaches
+- Performance optimizations
+- Complex implementation strategies
+
+### Debate Protocol
+
+1. **Select Participants**: Choose relevant agents for the decision
+2. **Present Question**: Clear, specific question with context
+3. **Collect Arguments**: Each agent provides their perspective
+4. **Score Arguments**: Evaluate based on:
+   - Technical merit
+   - Alignment with requirements
+   - Security implications
+   - Maintainability
+5. **Select Winner**: Choose best argument
+6. **Document Decision**: Record rationale in output
+
+### Debate Output Format
+
+```markdown
+## Debate: [Topic]
+
+### Question
+[Clear question]
+
+### Participants
+- Agent A
+- Agent B
+- Agent C
+
+### Arguments
+
+#### Agent A
+[Argument]
+
+#### Agent B
+[Argument]
+
+#### Agent C
+[Argument]
+
+### Decision
+**Winner**: Agent B
+
+**Rationale**: [Reasoning]
+
+### Implementation
+[How decision will be implemented]
+```
+
+## Fail-Fast Policy
+
+### Critical Errors
+
+Abort immediately on:
+- LLM API failures (after 3 retries)
+- File system errors (permission denied, disk full)
+- Dependency installation failures
+- Build failures
+- Test failures (if configured as critical)
+- Deployment failures
+
+### Error Handling
+
+1. Log error with full context
+2. Save current state
+3. Emit error signal
+4. Exit with non-zero code
+5. Provide recovery instructions
+
+### Non-Critical Errors
+
+Continue execution on:
+- Minor linting warnings
+- Documentation generation issues
+- Optional tool failures
+- Non-blocking test failures
+
+## Tech Stack Support
+
+### C#/.NET/Blazor
+
+- Use .NET 8.0 or later
+- Blazor Server or WebAssembly
+- Entity Framework Core for data access
+- ASP.NET Core for APIs
+
+### SQL Server
+
+- Use SQL Server 2022 or Azure SQL Database
+- Entity Framework Core migrations
+- Stored procedures for complex queries
+- Indexes for performance
+
+### Azure Services
+
+- Azure App Service for hosting
+- Azure SQL Database for data
+- Azure Key Vault for secrets
+- Azure DevOps for CI/CD
+- Azure Container Registry for Docker
+
+### External Services
+
+- Generic external service integration
+- Multiple service provider support
+- Secure token management
+- Activity logging
+
+## Output Signals
+
+Emit these signals at key points:
+
+```
+PHASE 1 COMPLETE ✅
+PHASE 2 COMPLETE ✅
+...
+CONTEXT SAVE /tmp/mdan-save-1234567890.json
+MISSION COMPLETE ✅
+```
+
+## File Structure
+
+Generate outputs in this structure:
+
+```
+project/
+├── docs/
+│   ├── discover.md
+│   ├── plan.md
+│   ├── architecture.md
+│   ├── test-report.md
+│   └── deployment.md
+├── src/
+│   └── [implementation files]
+├── tests/
+│   └── [test files]
+├── deployment/
+│   ├── docker/
+│   ├── azure/
+│   └── sql/
+└── README.md
+```
+
+## Quality Gates
+
+Each phase must pass quality gates before proceeding:
+
+### LOAD → DISCOVER
+- [ ] Project context loaded
+- [ ] Requirements identified
+
+### DISCOVER → PLAN
+- [ ] User stories defined
+- [ ] Acceptance criteria clear
+
+### PLAN → ARCHITECT
+- [ ] Implementation plan complete
+- [ ] Phases defined with #PHASE1, #PHASE2...
+
+### ARCHITECT → IMPLEMENT
+- [ ] Architecture documented
+- [ ] Technology stack selected
+- [ ] Security considerations addressed
+
+### IMPLEMENT → TEST
+- [ ] All code implemented
+- [ ] Code compiles/builds
+- [ ] No critical errors
+
+### TEST → DEPLOY
+- [ ] All tests pass
+- [ ] Coverage ≥80%
+- [ ] Security scan clean
+
+### DEPLOY → DOC
+- [ ] Deployment successful
+- [ ] Application running
+
+### DOC → COMPLETE
+- [ ] Documentation complete
+- [ ] README updated
+- [ ] API docs generated
+
+## Logging
+
+Log all actions with timestamps:
+
+```
+[2024-01-15 10:23:45] Starting PHASE 1: LOAD
+[2024-01-15 10:23:46] Loading project context...
+[2024-01-15 10:23:47] Token usage: 15,234 / 128,000 (11.9%)
+[2024-01-15 10:24:12] PHASE 1 COMPLETE ✅
+```
+
+## Configuration
+
+Default configuration (can be overridden):
+
+```yaml
+token_limit: 128000
+save_threshold: 0.8
+output_dir: ./mdan-auto-output
+log_level: INFO
+fail_fast: true
+debate_enabled: true
+tech_stack:
+  language: csharp
+  framework: dotnet
+  ui: blazor
+  database: sqlserver
+  cloud: azure
+```
+
+## Mission Completion
+
+When all phases complete:
+
+1. Generate final summary
+2. Create deployment package
+3. Emit signal: `MISSION COMPLETE ✅`
+4. Provide next steps
+5. Exit with code 0
+
+## Example Execution
+
+```
+[2024-01-15 10:00:00] Starting MDAN-AUTO v1.0
+[2024-01-15 10:00:01] PHASE 1: LOAD
+[2024-01-15 10:00:15] PHASE 1 COMPLETE ✅
+[2024-01-15 10:00:16] PHASE 2: DISCOVER
+[2024-01-15 10:01:23] PHASE 2 COMPLETE ✅
+[2024-01-15 10:01:24] PHASE 3: PLAN
+[2024-01-15 10:02:45] PHASE 3 COMPLETE ✅
+[2024-01-15 10:02:46] PHASE 4: ARCHITECT
+[2024-01-15 10:04:12] PHASE 4 COMPLETE ✅
+[2024-01-15 10:04:13] PHASE 5: IMPLEMENT
+[2024-01-15 10:15:34] PHASE 5 COMPLETE ✅
+[2024-01-15 10:15:35] PHASE 6: TEST
+[2024-01-15 10:18:22] PHASE 6 COMPLETE ✅
+[2024-01-15 10:18:23] PHASE 7: DEPLOY
+[2024-01-15 10:20:45] PHASE 7 COMPLETE ✅
+[2024-01-15 10:20:46] PHASE 8: DOC
+[2024-01-15 10:22:10] PHASE 8 COMPLETE ✅
+[2024-01-15 10:22:11] MISSION COMPLETE ✅
+```
+
+## Version
+
+MDAN-AUTO Orchestrator v1.0