mdan-cli 2.5.0 → 2.6.0

package/cli/mdan.js

@@ -6,7 +6,7 @@ const { execSync } = require('child_process');
 const { intro, text, select, isCancel, cancel, outro, spinner } = require('@clack/prompts');
 const pc = require('picocolors');
 
-const VERSION = '2.5.0';
+const VERSION = '2.5.1';
 const MDAN_DIR = path.resolve(__dirname, '..');
 
 // Colors

package/cli/mdan.py

@@ -1,13 +1,12 @@
 #!/usr/bin/env python3
 """MDAN CLI - Multi-Agent Development Agentic Network"""
 
-import os
 import sys
 import shutil
 import json
 from pathlib import Path
 
-VERSION = "2.5.0"
+VERSION = "2.5.1"
 MDAN_DIR = Path(__file__).parent.parent
 
 # Colors
@@ -44,13 +43,19 @@ def show_help():
     print("  agent [name]             Show agent prompt")
     print("  oc                       Copy orchestrator prompt to clipboard")
     print("  skills                   List available skills")
+    print("  auto                     Start autonomous development mode")
+    print("  resume <save-file>       Resume from saved context")
     print("  version                  Show version\n")
     print(f"{BOLD}EXAMPLES{NC}")
     print("  mdan init my-app              # New project")
     print("  cd my-project && mdan attach  # Existing project")
-    print("  mdan attach --rebuild         # Rebuild from scratch\n")
+    print("  mdan attach --rebuild         # Rebuild from scratch")
+    print("  mdan auto                     # Start autonomous mode")
+    print("  mdan resume /tmp/mdan-save-*.json  # Resume execution\n")
     print(f"{BOLD}AGENTS{NC}")
-    print("  product, architect, ux, dev, test, security, devops, doc")
+    print(
+        "  product, architect, ux, dev, test, security, devops, doc, auto-orchestrator"
+    )
 
 
 def cmd_init(name="my-project"):
@@ -284,6 +289,68 @@ def cmd_skills():
         print("  No skills installed")
 
 
+def cmd_auto():
+    print(f"{CYAN}🚀 MDAN-AUTO v1.0 - Autonomous Development Mode{NC}\n")
+    print(f"{BOLD}Starting autonomous execution...{NC}\n")
+    print(f"{YELLOW}This will execute all phases without human intervention.{NC}")
+    print(f"{YELLOW}Context will be saved at 80% token limit.{NC}\n")
+    print(f"{BOLD}Phases:{NC}")
+    print("  1. LOAD      - Load project context")
+    print("  2. DISCOVER  - Analyze requirements")
+    print("  3. PLAN      - Create implementation plan")
+    print("  4. ARCHITECT - Design system architecture")
+    print("  5. IMPLEMENT - Execute implementation")
+    print("  6. TEST      - Run comprehensive tests")
+    print("  7. DEPLOY    - Deploy to production")
+    print("  8. DOC       - Generate documentation\n")
+    print(f"{GREEN}✅ MDAN-AUTO initialized{NC}")
+    print(
+        f"  {BOLD}Next:{NC} Load the Auto Orchestrator prompt from agents/auto-orchestrator.md"
+    )
+
+
+def cmd_resume(save_file=None):
+    if not save_file:
+        print(f"{RED}Error: Save file required{NC}")
+        print("  Usage: mdan resume <save-file>")
+        return
+
+    save_path = Path(save_file)
+    if not save_path.exists():
+        print(f"{RED}Error: Save file not found: {save_file}{NC}")
+        return
+
+    print(f"{CYAN}🔄 Resuming from: {BOLD}{save_file}{NC}\n")
+
+    try:
+        with open(save_path, "r") as f:
+            state = json.load(f)
+
+        print(f"{BOLD}Project:{NC} {state.get('project', {}).get('name', 'Unknown')}")
+        print(
+            f"{BOLD}Current Phase:{NC} {state.get('phases', {}).get('current', 'Unknown')}"
+        )
+        print(
+            f"{BOLD}Completed Phases:{NC} {', '.join(state.get('phases', {}).get('completed', []))}"
+        )
+        print(
+            f"{BOLD}Token Usage:{NC} {state.get('context', {}).get('token_usage', {}).get('total', 0)} / {state.get('context', {}).get('token_usage', {}).get('limit', 128000)} ({state.get('context', {}).get('token_usage', {}).get('percentage', 0) * 100:.1f}%)\n"
+        )
+
+        print(f"{GREEN}✅ Context loaded{NC}")
+        print(
+            f"  {BOLD}Next:{NC} Continue from {state.get('phases', {}).get('current', 'Unknown')} phase"
+        )
+        print(
+            f"  {BOLD}Tip:{NC} Load the Auto Orchestrator prompt with the restored context"
+        )
+
+    except json.JSONDecodeError:
+        print(f"{RED}Error: Invalid save file format{NC}")
+    except Exception as e:
+        print(f"{RED}Error: {e}{NC}")
+
+
 def main():
     args = sys.argv[1:]
     cmd = args[0] if args else "help"
@@ -306,6 +373,10 @@ def main():
         cmd_agent(args[1] if len(args) > 1 else None)
     elif cmd == "skills":
         cmd_skills()
+    elif cmd == "auto":
+        cmd_auto()
+    elif cmd == "resume":
+        cmd_resume(args[1] if len(args) > 1 else None)
     elif cmd in ["version", "-v"]:
         print(f"MDAN v{VERSION}")
     else:

package/cli/mdan.sh

@@ -5,7 +5,7 @@
 # Multi-Agent Development Agentic Network
 # ============================================================
 
-VERSION="2.5.0"
+VERSION="2.5.1"
 MDAN_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 
 # Colors

package/core/debate-protocol.md

@@ -0,0 +1,454 @@
+# Multi-Agent Debate Protocol
+
+> MDAN-AUTO v1.0 Decision-Making Through Agent Collaboration
+
+## Overview
+
+The debate protocol enables multiple MDAN agents to collaborate on complex decisions, providing diverse perspectives and ensuring well-considered choices.
+
+## When to Trigger a Debate
+
+Trigger a debate for:
+
+- **Architecture Decisions**
+  - Monolith vs microservices
+  - Design patterns
+  - Technology stack choices
+  - System boundaries
+
+- **Security Decisions**
+  - Authentication methods
+  - Authorization models
+  - Encryption strategies
+  - Security controls
+
+- **Performance Decisions**
+  - Caching strategies
+  - Database optimization
+  - Scaling approaches
+  - Resource allocation
+
+- **Implementation Decisions**
+  - Code organization
+  - Library choices
+  - Testing strategies
+  - Error handling
+
+- **DevOps Decisions**
+  - Deployment strategies
+  - CI/CD pipelines
+  - Infrastructure choices
+  - Monitoring approaches
+
+## Debate Participants
+
+### Core Agents
+
+| Agent | Expertise | Debate Topics |
+|-------|-----------|---------------|
+| Product | Requirements, user needs | Feature decisions, UX choices |
+| Architect | System design, patterns | Architecture, technology stack |
+| Dev | Implementation, code quality | Implementation approaches, libraries |
+| Security | Security, compliance | Security controls, authentication |
+| Test | Testing, quality | Testing strategies, quality gates |
+| DevOps | Deployment, infrastructure | Deployment, CI/CD, infrastructure |
+| Doc | Documentation | Documentation approaches |
+
+### Participant Selection
+
+Select participants based on topic:
+
+**Architecture Decisions:**
+- Architect (lead)
+- Dev
+- DevOps
+- Security
+
+**Security Decisions:**
+- Security (lead)
+- Architect
+- Dev
+- DevOps
+
+**Performance Decisions:**
+- Dev (lead)
+- Architect
+- DevOps
+
+**Implementation Decisions:**
+- Dev (lead)
+- Architect
+- Test
+
+**DevOps Decisions:**
+- DevOps (lead)
+- Architect
+- Security
+
+**Feature Decisions:**
+- Product (lead)
+- Architect
+- Doc
+
+## Debate Process
+
+### Step 1: Define Question
+
+Create a clear, specific question:
+
+```
+❌ Bad: "How should we do authentication?"
+
+✅ Good: "Should we use JWT tokens or session-based authentication
+for a Blazor Server application with Azure AD integration?"
+```
+
+Include:
+- Context
+- Constraints
+- Requirements
+- Trade-offs
+
+### Step 2: Select Participants
+
+Choose relevant agents:
+- Lead agent (primary expertise)
+- Supporting agents (related expertise)
+- 3-5 agents maximum
+
+### Step 3: Present Question
+
+Send question to all participants with:
+- Clear question
+- Context
+- Constraints
+- Requirements
+- Deadline (optional)
+
+### Step 4: Collect Arguments
+
+Each participant provides:
+
+1. **Recommendation**: Clear choice
+2. **Rationale**: Why this choice
+3. **Pros**: Benefits of choice
+4. **Cons**: Drawbacks of choice
+5. **Evidence**: Supporting facts/experience
+6. **Alternatives**: Other options considered
+
+### Step 5: Score Arguments
+
+Score each argument on:
+
+| Criteria | Weight | Description |
+|----------|--------|-------------|
+| Technical Merit | 30% | Technical soundness |
+| Alignment | 25% | Alignment with requirements |
+| Security | 20% | Security implications |
+| Maintainability | 15% | Long-term maintainability |
+| Feasibility | 10% | Implementation feasibility |
+
+Total score: 0-100
+
+### Step 6: Select Winner
+
+Choose argument with highest score.
+
+If scores are close (<5% difference):
+- Consider hybrid approach
+- Or defer to lead agent
+
+### Step 7: Document Decision
+
+Record:
+- Question
+- Participants
+- Arguments
+- Scores
+- Winner
+- Rationale
+- Implementation plan
+
+### Step 8: Implement
+
+Apply decision to implementation.
+
+## Debate Output Format
+
+```markdown
+## Debate: [Topic]
+
+### Question
+[Clear, specific question with context]
+
+### Context
+- Project: [Project name]
+- Phase: [Current phase]
+- Requirements: [Key requirements]
+- Constraints: [Constraints]
+
+### Participants
+- **Lead**: [Agent name] - [Role]
+- [Agent name] - [Role]
+- [Agent name] - [Role]
+
+### Arguments
+
+#### [Agent Name]
+**Recommendation**: [Choice]
+
+**Rationale**: [Why this choice]
+
+**Pros**:
+- [Benefit 1]
+- [Benefit 2]
+
+**Cons**:
+- [Drawback 1]
+- [Drawback 2]
+
+**Evidence**: [Supporting facts]
+
+**Alternatives Considered**:
+- [Alternative 1] - [Why rejected]
+- [Alternative 2] - [Why rejected]
+
+**Score**: [0-100]
+
+---
+
+#### [Agent Name]
+[Same structure]
+
+---
+
+### Scoring Summary
+
+| Agent | Technical | Alignment | Security | Maintainability | Feasibility | Total |
+|-------|-----------|-----------|----------|-----------------|-------------|-------|
+| Agent A | 25 | 20 | 15 | 12 | 8 | 80 |
+| Agent B | 28 | 23 | 18 | 14 | 9 | 92 |
+| Agent C | 22 | 18 | 16 | 11 | 7 | 74 |
+
+### Decision
+**Winner**: [Agent name]
+
+**Rationale**: [Why this argument won]
+
+**Score**: [Winning score]
+
+### Implementation
+[How decision will be implemented]
+
+### Next Steps
+1. [Step 1]
+2. [Step 2]
+3. [Step 3]
+
+### Timestamp
+[ISO 8601 timestamp]
+```
+
+## Debate Example
+
+```markdown
+## Debate: Authentication Strategy
+
+### Question
+Should we use JWT tokens or session-based authentication for a Blazor Server
+application with Azure AD integration?
+
+### Context
+- Project: External Service Integration
+- Phase: ARCHITECT
+- Requirements: Secure authentication, Azure AD integration, session management
+- Constraints: Must support multiple external service APIs
+
+### Participants
+- **Lead**: Security - Security expertise
+- Architect - System design
+- Dev - Implementation
+
+### Arguments
+
+#### Security
+**Recommendation**: JWT tokens with Azure AD
+
+**Rationale**: JWT provides stateless authentication, works well with Azure AD,
+and is industry standard for modern applications.
+
+**Pros**:
+- Stateless, no server-side session storage
+- Works seamlessly with Azure AD
+- Industry standard
+- Easy to scale
+- Built-in expiration and refresh
+
+**Cons**:
+- Token revocation is complex
+- Larger payload size
+- Requires careful token validation
+
+**Evidence**: OWASP recommends JWT for stateless authentication. Azure AD
+natively issues JWT tokens.
+
+**Alternatives Considered**:
+- Session-based - Rejected due to scaling concerns
+- Hybrid - Rejected due to complexity
+
+**Score**: 92
+
+---
+
+#### Architect
+**Recommendation**: Session-based authentication
+
+**Rationale**: Blazor Server maintains server-side state, session-based auth
+aligns better with the architecture.
+
+**Pros**:
+- Natural fit for Blazor Server
+- Easy to implement
+- Built-in session management
+- Simple revocation
+
+**Cons**:
+- Requires server-side storage
+- Harder to scale
+- Session affinity required
+- More complex with Azure AD
+
+**Evidence**: Blazor Server documentation recommends session-based auth for
+server-side rendering.
+
+**Alternatives Considered**:
+- JWT - Rejected due to Blazor Server architecture
+- Hybrid - Rejected due to complexity
+
+**Score**: 78
+
+---
+
+#### Dev
+**Recommendation**: JWT tokens with Azure AD
+
+**Rationale**: JWT is easier to implement with Azure AD and provides better
+separation of concerns.
+
+**Pros**:
+- Easy Azure AD integration
+- Standard libraries available
+- Clear separation of auth logic
+- Better for API calls
+
+**Cons**:
+- Token management complexity
+- Refresh token handling
+
+**Evidence**: Microsoft.Identity.Web library provides excellent JWT support
+for Azure AD.
+
+**Alternatives Considered**:
+- Session-based - Rejected due to Azure AD complexity
+
+**Score**: 88
+
+---
+
+### Scoring Summary
+
+| Agent | Technical | Alignment | Security | Maintainability | Feasibility | Total |
+|-------|-----------|-----------|----------|-----------------|-------------|-------|
+| Security | 28 | 23 | 18 | 14 | 9 | 92 |
+| Architect | 22 | 20 | 14 | 12 | 10 | 78 |
+| Dev | 26 | 22 | 16 | 13 | 11 | 88 |
+
+### Decision
+**Winner**: Security
+
+**Rationale**: JWT with Azure AD provides the best security posture, aligns
+with industry standards, and has excellent Azure integration. The slight
+complexity is outweighed by security benefits and scalability.
+
+**Score**: 92
+
+### Implementation
+1. Configure Azure AD app registration
+2. Implement JWT token validation middleware
+3. Use Microsoft.Identity.Web library
+4. Implement token refresh logic
+5. Add token validation to API endpoints
+
+### Next Steps
+1. Create Azure AD app registration
+2. Implement authentication middleware
+3. Update Blazor Server configuration
+4. Test authentication flow
+5. Document authentication approach
+
+### Timestamp
+2024-01-15T10:15:00Z
+```
+
+## Debate Timeout
+
+Set timeout for debates:
+- Default: 5 minutes per agent
+- Maximum: 30 minutes total
+- If timeout, use available arguments
+
+## Debate Cancellation
+
+Cancel debate if:
+- Question is unclear
+- Insufficient context
+- Emergency situation
+- User intervention
+
+## Debate Storage
+
+Store debates in:
+- `context.debates` array in save file
+- Separate debate log file
+- Decision history
+
+## Debate Quality
+
+Ensure debate quality:
+- Clear questions
+- Relevant participants
+- Well-reasoned arguments
+- Evidence-based decisions
+- Proper documentation
+
+## Debate Automation
+
+Automate debate triggering:
+- Detect complex decisions
+- Select participants automatically
+- Collect arguments
+- Score and decide
+- Document and implement
+
+## Debate Review
+
+Review debates periodically:
+- Check decision quality
+- Validate implementation
+- Learn from outcomes
+- Improve process
+
+## Best Practices
+
+1. **Clear Questions**: Be specific and provide context
+2. **Right Participants**: Choose agents with relevant expertise
+3. **Evidence-Based**: Use facts and experience
+4. **Fair Scoring**: Use consistent criteria
+5. **Document Everything**: Record full debate
+6. **Implement Decisions**: Apply decisions consistently
+7. **Review Outcomes**: Learn from results
+8. **Time-Boxed**: Set reasonable timeouts
+
+## Version
+
+MDAN-AUTO Debate Protocol v1.0

package/core/universal-envelope.md

@@ -158,3 +158,116 @@ Use markdown headers only. Gemini responds better to `# Identity`, `## Capabilit
 
 ### For Qwen / GLM / Kimi / MiniMax
 The bracket notation works. If issues arise, switch to markdown headers as fallback.
+
+---
+
+## Autonomous Mode Extension
+
+For autonomous agents (like MDAN-AUTO), the envelope includes additional sections:
+
+```
+[MDAN-AGENT]
+NAME: Auto Orchestrator
+VERSION: 1.0
+ROLE: Autonomous full-cycle development coordinator
+PHASE: ALL (LOAD → DISCOVER → PLAN → ARCHITECT → IMPLEMENT → TEST → DEPLOY → DOC)
+REPORTS_TO: System
+
+[IDENTITY]
+You are an autonomous orchestrator that executes all development phases without human intervention.
+You make decisions independently, save context at token limits, and resume from checkpoints.
+
+[CAPABILITIES]
+- Execute all 8 phases sequentially without human confirmation
+- Save context to /tmp/mdan-save-[timestamp].json at 80% token limit
+- Resume from saved context files
+- Initiate multi-agent debates for complex decisions
+- Fail-fast on critical errors
+- Generate markdown outputs for each phase
+
+[CONSTRAINTS]
+- NEVER ask for confirmation except on critical errors
+- NEVER pause between phases
+- ALWAYS save context before hitting token limits
+- ALWAYS use existing files (git clone if needed)
+- ALL buttons must work with actual functionality
+- ALL image URLs must be valid
+
+[INPUT_FORMAT]
+- Project description or requirements
+- Optional: resume file path (--resume flag)
+- Optional: tech stack specification
+
+[OUTPUT_FORMAT]
+Each phase outputs:
+1. Markdown file: [PHASE]-[name].md
+2. Signal: "PHASE X COMPLETE ✅"
+3. Context save: "CONTEXT SAVE [file]" (when needed)
+4. Final: "MISSION COMPLETE ✅"
+
+[CONTEXT_MANAGEMENT]
+- Monitor token usage continuously
+- At 80% limit: save full context to /tmp/mdan-save-[timestamp].json
+- Include: current phase, all artifacts, decisions, state
+- Resume: load context and continue from saved phase
+
+[DEBATE_PROTOCOL]
+For complex decisions:
+1. Identify 2-3 expert perspectives
+2. Run inline debate (3 rounds max)
+3. Converge on consensus
+4. Document decision rationale
+
+[QUALITY_CHECKLIST]
+Before phase completion:
+- [ ] All deliverables created
+- [ ] Quality gates passed
+- [ ] Context saved (if near limit)
+- [ ] Next phase ready
+
+[ESCALATION]
+Only escalate on:
+- Critical errors that halt progress
+- Ambiguous requirements that cannot be resolved
+- Security vulnerabilities requiring human review
+[/MDAN-AGENT]
+```
+
+### Autonomous Mode Signals
+
+The autonomous orchestrator uses specific signals:
+
+- `PHASE X COMPLETE ✅` - Phase finished successfully
+- `CONTEXT SAVE [file]` - Context saved to file
+- `RESUMING FROM [file]` - Loading saved context
+- `DEBATE: [topic]` - Starting multi-agent debate
+- `CRITICAL ERROR: [description]` - Fail-fast condition
+- `MISSION COMPLETE ✅` - All phases finished
+
+### Context Save Format
+
+```json
+{
+  "version": "1.0",
+  "timestamp": "2024-01-01T12:00:00Z",
+  "current_phase": "IMPLEMENT",
+  "phases_completed": ["LOAD", "DISCOVER", "PLAN", "ARCHITECT"],
+  "artifacts": {
+    "prd": "path/to/prd.md",
+    "architecture": "path/to/architecture.md",
+    "implementation_plan": "path/to/plan.md"
+  },
+  "decisions": [
+    {
+      "topic": "Database choice",
+      "decision": "PostgreSQL",
+      "rationale": "..."
+    }
+  ],
+  "state": {
+    "project_name": "my-project",
+    "tech_stack": {...},
+    "files_created": [...]
+  }
+}
+```