mdan-cli 2.5.1 → 2.5.2

package/app/mmb/agents/agent-builder/agent.py

@@ -0,0 +1,261 @@
+"""
+Agent Builder Agent
+
+A master agent architect with deep expertise in agent design patterns, persona development,
+and MDAN Core compliance. Specializes in creating robust, maintainable agents that follow best practices.
+"""
+
+from typing import Any, Dict, List, Optional
+import json
+
+
+class AgentBuilderAgent:
+    """
+    Agent Builder Agent - Bond
+
+    Master agent architect with deep expertise in agent design patterns, persona development,
+    and MDAN Core compliance. Specializes in creating robust, maintainable agents that follow
+    best practices.
+    """
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """
+        Initialize the Agent Builder Agent.
+
+        Args:
+            config: Optional configuration dictionary containing:
+                - user_name: Name of the user
+                - communication_language: Language for communication
+                - output_folder: Path for output files
+        """
+        self.config = config or {}
+        self.user_name = self.config.get("user_name", "User")
+        self.communication_language = self.config.get(
+            "communication_language", "English"
+        )
+        self.output_folder = self.config.get("output_folder", "./output")
+
+        # Agent metadata
+        self.name = "Bond"
+        self.title = "Agent Building Expert"
+        self.icon = "🤖"
+        self.capabilities = [
+            "agent design patterns",
+            "persona development",
+            "MDAN Core compliance",
+            "best practices enforcement",
+            "agent validation",
+        ]
+
+        # Menu items
+        self.menu_items = [
+            {
+                "cmd": "MH",
+                "label": "Redisplay Menu Help",
+                "description": "Show the main menu with all available options",
+            },
+            {
+                "cmd": "CH",
+                "label": "Chat with the Agent",
+                "description": "Have a conversation about agent building topics",
+            },
+            {
+                "cmd": "CA",
+                "label": "Create a new MDAN agent",
+                "description": "Create a new BMAD agent with best practices and compliance",
+            },
+            {
+                "cmd": "EA",
+                "label": "Edit existing MDAN agents",
+                "description": "Edit existing BMAD agents while maintaining compliance",
+            },
+            {
+                "cmd": "VA",
+                "label": "Validate existing MDAN agents",
+                "description": "Validate existing BMAD agents and offer to improve deficiencies",
+            },
+            {
+                "cmd": "DA",
+                "label": "Dismiss Agent",
+                "description": "Exit the agent builder",
+            },
+        ]
+
+    async def process(self, request: str) -> str:
+        """
+        Process a user request and return a response.
+
+        Args:
+            request: The user's request or command
+
+        Returns:
+            A response string
+        """
+        # Parse the request
+        request_lower = request.lower().strip()
+
+        # Check for menu commands
+        if request_lower in ["mh", "menu", "help"]:
+            return self._display_menu()
+        elif request_lower in ["ch", "chat"]:
+            return self._handle_chat(request)
+        elif request_lower in ["ca", "create-agent"]:
+            return self._handle_create_agent(request)
+        elif request_lower in ["ea", "edit-agent"]:
+            return self._handle_edit_agent(request)
+        elif request_lower in ["va", "validate-agent"]:
+            return self._handle_validate_agent(request)
+        elif request_lower in ["da", "exit", "leave", "goodbye", "dismiss"]:
+            return self._handle_dismiss()
+        else:
+            # Try fuzzy matching
+            matched = self._fuzzy_match(request_lower)
+            if matched:
+                return matched
+            else:
+                return self._handle_general_request(request)
+
+    def _display_menu(self) -> str:
+        """Display the main menu."""
+        menu = f"\n🤖 **Agent Builder Menu**\n\n"
+        menu += f"Hello {self.user_name}! I'm Bond, your Agent Building Expert.\n\n"
+        menu += "Available commands:\n\n"
+
+        for i, item in enumerate(self.menu_items, 1):
+            menu += f"{i}. **[{item['cmd']}]** {item['label']}\n"
+            menu += f"   {item['description']}\n\n"
+
+        menu += "Type a command number or use the command shortcut (e.g., 'CA' for Create Agent).\n"
+        menu += "You can also type `/mmm-help` for advice on what to do next.\n"
+
+        return menu
+
+    def _handle_chat(self, request: str) -> str:
+        """Handle general chat requests."""
+        return f"""
+I'm Bond, your Agent Building Expert. I specialize in:
+
+- Agent design patterns and architecture
+- Persona development and character creation
+- MDAN Core compliance and best practices
+- Agent validation and improvement
+
+What would you like to know about building agents?
+"""
+
+    def _handle_create_agent(self, request: str) -> str:
+        """Handle create agent requests."""
+        return """
+To create a new MDAN agent, I'll need the following information:
+
+1. **Agent Name**: What should we call this agent?
+2. **Agent Title**: What is the agent's role or title?
+3. **Agent Icon**: Choose an emoji to represent the agent
+4. **Agent Role**: What is the agent's primary role?
+5. **Agent Identity**: Describe the agent's background and expertise
+6. **Communication Style**: How should the agent communicate?
+7. **Principles**: What principles guide the agent's behavior?
+8. **Capabilities**: What are the agent's key capabilities?
+9. **Menu Items**: What actions should the agent be able to perform?
+
+Please provide these details, and I'll create a compliant agent for you.
+"""
+
+    def _handle_edit_agent(self, request: str) -> str:
+        """Handle edit agent requests."""
+        return """
+To edit an existing MDAN agent, please specify:
+
+1. **Agent Name**: Which agent do you want to edit?
+2. **Changes**: What aspects do you want to modify?
+   - Persona/Identity
+   - Communication Style
+   - Principles
+   - Capabilities
+   - Menu Items
+   - Other
+
+I'll help you make the changes while maintaining MDAN Core compliance.
+"""
+
+    def _handle_validate_agent(self, request: str) -> str:
+        """Handle validate agent requests."""
+        return """
+To validate an MDAN agent, I'll check for:
+
+✓ **Structure Compliance**: Proper file structure and naming
+✓ **Persona Quality**: Clear, specific, and authentic persona
+✓ **Menu Consistency**: Consistent menu structure across agents
+✓ **Best Practices**: Following MDAN Core standards
+✓ **Documentation**: Complete and clear documentation
+✓ **Runtime Loading**: Proper resource loading at runtime
+
+Please specify which agent you'd like me to validate.
+"""
+
+    def _handle_dismiss(self) -> str:
+        """Handle dismiss requests."""
+        return f"""
+Goodbye, {self.user_name}! It was a pleasure helping you with agent building.
+
+Remember:
+- Every agent must follow MDAN Core standards
+- Personas drive agent behavior - make them specific and authentic
+- Menu structure must be consistent across all agents
+- Validate compliance before finalizing any agent
+
+Feel free to return anytime you need help building agents! 👋
+"""
+
+    def _handle_general_request(self, request: str) -> str:
+        """Handle general requests."""
+        return f"""
+I understand you're asking about: "{request}"
+
+As an Agent Building Expert, I can help you with:
+- Creating new agents (use 'CA' or 'create-agent')
+- Editing existing agents (use 'EA' or 'edit-agent')
+- Validating agents (use 'VA' or 'validate-agent')
+- General agent building questions (use 'CH' or 'chat')
+
+Type 'MH' or 'menu' to see all available commands.
+"""
+
+    def _fuzzy_match(self, request: str) -> Optional[str]:
+        """Try to fuzzy match the request to a menu item."""
+        for item in self.menu_items:
+            if item["cmd"].lower() in request or any(
+                keyword in request for keyword in item["label"].lower().split()
+            ):
+                # Call the appropriate handler
+                if item["cmd"] == "MH":
+                    return self._display_menu()
+                elif item["cmd"] == "CH":
+                    return self._handle_chat(request)
+                elif item["cmd"] == "CA":
+                    return self._handle_create_agent(request)
+                elif item["cmd"] == "EA":
+                    return self._handle_edit_agent(request)
+                elif item["cmd"] == "VA":
+                    return self._handle_validate_agent(request)
+                elif item["cmd"] == "DA":
+                    return self._handle_dismiss()
+        return None
+
+    def get_menu_items(self) -> List[Dict[str, str]]:
+        """Get the menu items."""
+        return self.menu_items
+
+    def get_capabilities(self) -> List[str]:
+        """Get the agent's capabilities."""
+        return self.capabilities
+
+    def get_info(self) -> Dict[str, Any]:
+        """Get agent information."""
+        return {
+            "name": self.name,
+            "title": self.title,
+            "icon": self.icon,
+            "capabilities": self.capabilities,
+            "menu_items": self.menu_items,
+        }

package/app/mmb/agents/agent-builder/prompt.yaml

@@ -0,0 +1,48 @@
+name: agent-builder
+version: 1.0.0
+description: Agent Building Expert specializing in agent design patterns, persona development, and MDAN Core compliance
+
+system_prompt: |
+  You are Badr, the Agent Building Expert.
+
+  Your role: Agent Architecture Specialist + MDAN Compliance Expert
+
+  Your identity: Master agent architect with deep expertise in agent design patterns, persona development, and MDAN Core compliance. Specializes in creating robust, maintainable agents that follow best practices.
+
+  Your communication style: Precise and technical, like a senior software architect reviewing code. Focuses on structure, compliance, and long-term maintainability. Uses agent-specific terminology and framework references.
+
+  Your principles:
+  - Every agent must follow MDAN Core standards and best practices
+  - Personas drive agent behavior - make them specific and authentic
+  - Menu structure must be consistent across all agents
+  - Validate compliance before finalizing any agent
+  - Load resources at runtime, never pre-load
+  - Focus on practical implementation and real-world usage
+
+  Your capabilities:
+  - Agent design patterns
+  - Persona development
+  - MDAN Core compliance
+  - Best practices enforcement
+  - Agent validation
+
+  When creating agents:
+  1. Ensure proper file structure and naming conventions
+  2. Develop clear, specific, and authentic personas
+  3. Maintain consistent menu structure
+  4. Follow MDAN Core standards
+  5. Provide complete documentation
+  6. Implement proper runtime resource loading
+
+  When validating agents:
+  1. Check structure compliance
+  2. Verify persona quality
+  3. Ensure menu consistency
+  4. Validate best practices
+  5. Review documentation
+  6. Test runtime loading
+
+user_prompt_template: |
+  {user_request}
+
+  As Badr, the Agent Building Expert, provide guidance on agent creation, editing, or validation following MDAN Core standards and best practices.

package/app/mmb/agents/module-builder/__init__.py

@@ -0,0 +1,5 @@
+"""Module Builder Agent Package."""
+
+from .agent import ModuleBuilderAgent
+
+__all__ = ["ModuleBuilderAgent"]

package/app/mmb/agents/module-builder/agent.py

@@ -0,0 +1,299 @@
+"""
+Module Builder Agent
+
+An expert module architect with comprehensive knowledge of MDAN Core systems, integration patterns,
+and end-to-end module development. Specializes in creating cohesive, scalable modules that deliver
+complete functionality.
+"""
+
+from typing import Any, Dict, List, Optional
+import json
+
+
+class ModuleBuilderAgent:
+    """
+    Module Builder Agent - Morgan
+
+    Expert module architect with comprehensive knowledge of MDAN Core systems, integration patterns,
+    and end-to-end module development. Specializes in creating cohesive, scalable modules that
+    deliver complete functionality.
+    """
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """
+        Initialize the Module Builder Agent.
+
+        Args:
+            config: Optional configuration dictionary containing:
+                - user_name: Name of the user
+                - communication_language: Language for communication
+                - output_folder: Path for output files
+        """
+        self.config = config or {}
+        self.user_name = self.config.get("user_name", "User")
+        self.communication_language = self.config.get(
+            "communication_language", "English"
+        )
+        self.output_folder = self.config.get("output_folder", "./output")
+
+        # Agent metadata
+        self.name = "Morgan"
+        self.title = "Module Creation Master"
+        self.icon = "🏗️"
+        self.capabilities = [
+            "module architecture",
+            "integration patterns",
+            "end-to-end module development",
+            "modularity and reusability",
+            "system-wide impact analysis",
+        ]
+
+        # Menu items
+        self.menu_items = [
+            {
+                "cmd": "MH",
+                "label": "Redisplay Menu Help",
+                "description": "Show the main menu with all available options",
+            },
+            {
+                "cmd": "CH",
+                "label": "Chat with the Agent",
+                "description": "Have a conversation about module building topics",
+            },
+            {
+                "cmd": "PB",
+                "label": "Create product brief",
+                "description": "Create product brief for MDAN module development",
+            },
+            {
+                "cmd": "CM",
+                "label": "Create a complete MDAN module",
+                "description": "Create a complete BMAD module with agents, workflows, and infrastructure",
+            },
+            {
+                "cmd": "EM",
+                "label": "Edit existing MDAN modules",
+                "description": "Edit existing BMAD modules while maintaining coherence",
+            },
+            {
+                "cmd": "VM",
+                "label": "Run compliance check",
+                "description": "Run compliance check on BMAD modules against best practices",
+            },
+            {
+                "cmd": "DA",
+                "label": "Dismiss Agent",
+                "description": "Exit the module builder",
+            },
+        ]
+
+    async def process(self, request: str) -> str:
+        """
+        Process a user request and return a response.
+
+        Args:
+            request: The user's request or command
+
+        Returns:
+            A response string
+        """
+        # Parse the request
+        request_lower = request.lower().strip()
+
+        # Check for menu commands
+        if request_lower in ["mh", "menu", "help"]:
+            return self._display_menu()
+        elif request_lower in ["ch", "chat"]:
+            return self._handle_chat(request)
+        elif request_lower in ["pb", "product-brief"]:
+            return self._handle_product_brief(request)
+        elif request_lower in ["cm", "create-module"]:
+            return self._handle_create_module(request)
+        elif request_lower in ["em", "edit-module"]:
+            return self._handle_edit_module(request)
+        elif request_lower in ["vm", "validate-module"]:
+            return self._handle_validate_module(request)
+        elif request_lower in ["da", "exit", "leave", "goodbye", "dismiss"]:
+            return self._handle_dismiss()
+        else:
+            # Try fuzzy matching
+            matched = self._fuzzy_match(request_lower)
+            if matched:
+                return matched
+            else:
+                return self._handle_general_request(request)
+
+    def _display_menu(self) -> str:
+        """Display the main menu."""
+        menu = f"\n🏗️ **Module Builder Menu**\n\n"
+        menu += f"Hello {self.user_name}! I'm Morgan, your Module Creation Master.\n\n"
+        menu += "Available commands:\n\n"
+
+        for i, item in enumerate(self.menu_items, 1):
+            menu += f"{i}. **[{item['cmd']}]** {item['label']}\n"
+            menu += f"   {item['description']}\n\n"
+
+        menu += "Type a command number or use the command shortcut (e.g., 'CM' for Create Module).\n"
+        menu += "You can also type `/mmm-help` for advice on what to do next.\n"
+
+        return menu
+
+    def _handle_chat(self, request: str) -> str:
+        """Handle general chat requests."""
+        return f"""
+I'm Morgan, your Module Creation Master. I specialize in:
+
+- Module architecture and design
+- Integration patterns and dependencies
+- End-to-end module development
+- Modularity and reusability
+- System-wide impact analysis
+
+What would you like to know about building modules?
+"""
+
+    def _handle_product_brief(self, request: str) -> str:
+        """Handle product brief requests."""
+        return """
+To create a product brief for a new MDAN module, I'll need:
+
+1. **Module Name**: What should we call this module?
+2. **Module Purpose**: What problem does this module solve?
+3. **Target Users**: Who will use this module?
+4. **Key Features**: What are the main features?
+5. **Integration Points**: How does this integrate with existing systems?
+6. **Success Metrics**: How do we measure success?
+
+Please provide these details, and I'll create a comprehensive product brief.
+"""
+
+    def _handle_create_module(self, request: str) -> str:
+        """Handle create module requests."""
+        return """
+To create a complete MDAN module, I'll need:
+
+1. **Module Structure**:
+   - Module name and directory structure
+   - Agents to include
+   - Workflows to implement
+   - Infrastructure requirements
+
+2. **Module Components**:
+   - Agent definitions and personas
+   - Workflow definitions and state machines
+   - Integration points and APIs
+   - Data models and schemas
+
+3. **Documentation**:
+   - Module README
+   - API documentation
+   - Usage examples
+   - Integration guides
+
+Please provide the module requirements, and I'll create a complete, compliant module.
+"""
+
+    def _handle_edit_module(self, request: str) -> str:
+        """Handle edit module requests."""
+        return """
+To edit an existing MDAN module, please specify:
+
+1. **Module Name**: Which module do you want to edit?
+2. **Changes**: What aspects do you want to modify?
+   - Module structure
+   - Agent definitions
+   - Workflow definitions
+   - Integration points
+   - Documentation
+   - Other
+
+I'll help you make the changes while maintaining module coherence and compliance.
+"""
+
+    def _handle_validate_module(self, request: str) -> str:
+        """Handle validate module requests."""
+        return """
+To validate an MDAN module, I'll check for:
+
+✓ **Module Structure**: Proper directory structure and organization
+✓ **Self-Containment**: Module is self-contained yet integrates seamlessly
+✓ **Business Value**: Module solves specific business problems effectively
+✓ **Documentation**: Complete documentation and examples
+✓ **Scalability**: Module plans for growth and evolution
+✓ **Best Practices**: Follows proven patterns and standards
+✓ **Lifecycle**: Considers entire module lifecycle from creation to maintenance
+
+Please specify which module you'd like me to validate.
+"""
+
+    def _handle_dismiss(self) -> str:
+        """Handle dismiss requests."""
+        return f"""
+Goodbye, {self.user_name}! It was a pleasure helping you with module building.
+
+Remember:
+- Modules must be self-contained yet integrate seamlessly
+- Every module should solve specific business problems effectively
+- Documentation and examples are as important as code
+- Plan for growth and evolution from day one
+- Balance innovation with proven patterns
+- Consider the entire module lifecycle from creation to maintenance
+
+Feel free to return anytime you need help building modules! 👋
+"""
+
+    def _handle_general_request(self, request: str) -> str:
+        """Handle general requests."""
+        return f"""
+I understand you're asking about: "{request}"
+
+As a Module Creation Master, I can help you with:
+- Creating product briefs (use 'PB' or 'product-brief')
+- Creating complete modules (use 'CM' or 'create-module')
+- Editing existing modules (use 'EM' or 'edit-module')
+- Validating modules (use 'VM' or 'validate-module')
+- General module building questions (use 'CH' or 'chat')
+
+Type 'MH' or 'menu' to see all available commands.
+"""
+
+    def _fuzzy_match(self, request: str) -> Optional[str]:
+        """Try to fuzzy match the request to a menu item."""
+        for item in self.menu_items:
+            if item["cmd"].lower() in request or any(
+                keyword in request for keyword in item["label"].lower().split()
+            ):
+                # Call the appropriate handler
+                if item["cmd"] == "MH":
+                    return self._display_menu()
+                elif item["cmd"] == "CH":
+                    return self._handle_chat(request)
+                elif item["cmd"] == "PB":
+                    return self._handle_product_brief(request)
+                elif item["cmd"] == "CM":
+                    return self._handle_create_module(request)
+                elif item["cmd"] == "EM":
+                    return self._handle_edit_module(request)
+                elif item["cmd"] == "VM":
+                    return self._handle_validate_module(request)
+                elif item["cmd"] == "DA":
+                    return self._handle_dismiss()
+        return None
+
+    def get_menu_items(self) -> List[Dict[str, str]]:
+        """Get the menu items."""
+        return self.menu_items
+
+    def get_capabilities(self) -> List[str]:
+        """Get the agent's capabilities."""
+        return self.capabilities
+
+    def get_info(self) -> Dict[str, Any]:
+        """Get agent information."""
+        return {
+            "name": self.name,
+            "title": self.title,
+            "icon": self.icon,
+            "capabilities": self.capabilities,
+            "menu_items": self.menu_items,
+        }

package/app/mmb/agents/module-builder/prompt.yaml

@@ -0,0 +1,50 @@
+name: module-builder
+version: 1.0.0
+description: Module Creation Master specializing in module architecture, integration patterns, and end-to-end module development
+
+system_prompt: |
+  You are Mehdi, the Module Creation Master.
+
+  Your role: Module Architecture Specialist + Full-Stack Systems Designer
+
+  Your identity: Expert module architect with comprehensive knowledge of MDAN Core systems, integration patterns, and end-to-end module development. Specializes in creating cohesive, scalable modules that deliver complete functionality.
+
+  Your communication style: Strategic and holistic, like a systems architect planning complex integrations. Focuses on modularity, reusability, and system-wide impact. Thinks in terms of ecosystems, dependencies, and long-term maintainability.
+
+  Your principles:
+  - Modules must be self-contained yet integrate seamlessly
+  - Every module should solve specific business problems effectively
+  - Documentation and examples are as important as code
+  - Plan for growth and evolution from day one
+  - Balance innovation with proven patterns
+  - Consider the entire module lifecycle from creation to maintenance
+
+  Your capabilities:
+  - Module architecture
+  - Integration patterns
+  - End-to-end module development
+  - Modularity and reusability
+  - System-wide impact analysis
+
+  When creating modules:
+  1. Ensure proper directory structure and organization
+  2. Design for self-containment and seamless integration
+  3. Focus on solving specific business problems
+  4. Provide complete documentation and examples
+  5. Plan for growth and evolution
+  6. Balance innovation with proven patterns
+  7. Consider the entire module lifecycle
+
+  When validating modules:
+  1. Check module structure and organization
+  2. Verify self-containment and integration
+  3. Validate business value and problem-solving
+  4. Review documentation completeness
+  5. Assess scalability and growth potential
+  6. Ensure best practices compliance
+  7. Evaluate lifecycle considerations
+
+user_prompt_template: |
+  {user_request}
+
+  As Mehdi, the Module Creation Master, provide guidance on module creation, editing, or validation following MDAN Core standards and best practices.

package/app/mmb/agents/workflow-builder/__init__.py

@@ -0,0 +1,5 @@
+"""Workflow Builder Agent Package."""
+
+from .agent import WorkflowBuilderAgent
+
+__all__ = ["WorkflowBuilderAgent"]