mdan-cli 2.5.0 → 2.5.2

package/tests/scenarios/mmb/agent-builder.test.py

@@ -0,0 +1,124 @@
+"""Scenario tests for the Agent Builder agent."""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Add the app directory to the path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "app"))
+
+from mmb.agents.agent_builder.agent import AgentBuilderAgent
+
+
+async def test_agent_builder_menu_display():
+    """Test menu display capability."""
+    agent = AgentBuilderAgent()
+
+    result = await agent.process("menu")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "menu" in result.lower() or "agent builder" in result.lower()
+    print("✓ test_agent_builder_menu_display passed")
+
+
+async def test_agent_builder_create_agent():
+    """Test create agent capability."""
+    agent = AgentBuilderAgent()
+
+    result = await agent.process("create-agent")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "create" in result.lower() or "agent" in result.lower()
+    print("✓ test_agent_builder_create_agent passed")
+
+
+async def test_agent_builder_edit_agent():
+    """Test edit agent capability."""
+    agent = AgentBuilderAgent()
+
+    result = await agent.process("edit-agent")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "edit" in result.lower() or "agent" in result.lower()
+    print("✓ test_agent_builder_edit_agent passed")
+
+
+async def test_agent_builder_validate_agent():
+    """Test validate agent capability."""
+    agent = AgentBuilderAgent()
+
+    result = await agent.process("validate-agent")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "validate" in result.lower() or "compliance" in result.lower()
+    print("✓ test_agent_builder_validate_agent passed")
+
+
+async def test_agent_builder_chat():
+    """Test chat capability."""
+    agent = AgentBuilderAgent()
+
+    result = await agent.process("chat")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "agent" in result.lower() or "building" in result.lower()
+    print("✓ test_agent_builder_chat passed")
+
+
+async def test_agent_builder_fuzzy_match():
+    """Test fuzzy matching capability."""
+    agent = AgentBuilderAgent()
+
+    result = await agent.process("I want to create a new agent")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "create" in result.lower() or "agent" in result.lower()
+    print("✓ test_agent_builder_fuzzy_match passed")
+
+
+async def test_agent_builder_dismiss():
+    """Test dismiss capability."""
+    agent = AgentBuilderAgent()
+
+    result = await agent.process("dismiss")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "goodbye" in result.lower() or "dismiss" in result.lower()
+    print("✓ test_agent_builder_dismiss passed")
+
+
+async def main():
+    """Run all scenario tests."""
+    print("Running Agent Builder agent scenario tests...\n")
+
+    tests = [
+        test_agent_builder_menu_display,
+        test_agent_builder_create_agent,
+        test_agent_builder_edit_agent,
+        test_agent_builder_validate_agent,
+        test_agent_builder_chat,
+        test_agent_builder_fuzzy_match,
+        test_agent_builder_dismiss,
+    ]
+
+    for test in tests:
+        try:
+            await test()
+        except Exception as e:
+            print(f"✗ {test.__name__} failed: {e}")
+            import traceback
+
+            traceback.print_exc()
+
+    print("\nAll Agent Builder agent scenario tests completed!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/tests/scenarios/mmb/module-builder.test.py

@@ -0,0 +1,124 @@
+"""Scenario tests for the Module Builder agent."""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Add the app directory to the path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "app"))
+
+from mmb.agents.module_builder.agent import ModuleBuilderAgent
+
+
+async def test_module_builder_menu_display():
+    """Test menu display capability."""
+    agent = ModuleBuilderAgent()
+
+    result = await agent.process("menu")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "menu" in result.lower() or "module builder" in result.lower()
+    print("✓ test_module_builder_menu_display passed")
+
+
+async def test_module_builder_product_brief():
+    """Test product brief creation capability."""
+    agent = ModuleBuilderAgent()
+
+    result = await agent.process("product-brief")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "product brief" in result.lower() or "module" in result.lower()
+    print("✓ test_module_builder_product_brief passed")
+
+
+async def test_module_builder_create_module():
+    """Test create module capability."""
+    agent = ModuleBuilderAgent()
+
+    result = await agent.process("create-module")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "create" in result.lower() or "module" in result.lower()
+    print("✓ test_module_builder_create_module passed")
+
+
+async def test_module_builder_edit_module():
+    """Test edit module capability."""
+    agent = ModuleBuilderAgent()
+
+    result = await agent.process("edit-module")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "edit" in result.lower() or "module" in result.lower()
+    print("✓ test_module_builder_edit_module passed")
+
+
+async def test_module_builder_validate_module():
+    """Test validate module capability."""
+    agent = ModuleBuilderAgent()
+
+    result = await agent.process("validate-module")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "validate" in result.lower() or "compliance" in result.lower()
+    print("✓ test_module_builder_validate_module passed")
+
+
+async def test_module_builder_chat():
+    """Test chat capability."""
+    agent = ModuleBuilderAgent()
+
+    result = await agent.process("chat")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "module" in result.lower() or "building" in result.lower()
+    print("✓ test_module_builder_chat passed")
+
+
+async def test_module_builder_fuzzy_match():
+    """Test fuzzy matching capability."""
+    agent = ModuleBuilderAgent()
+
+    result = await agent.process("I want to create a new module")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "create" in result.lower() or "module" in result.lower()
+    print("✓ test_module_builder_fuzzy_match passed")
+
+
+async def main():
+    """Run all scenario tests."""
+    print("Running Module Builder agent scenario tests...\n")
+
+    tests = [
+        test_module_builder_menu_display,
+        test_module_builder_product_brief,
+        test_module_builder_create_module,
+        test_module_builder_edit_module,
+        test_module_builder_validate_module,
+        test_module_builder_chat,
+        test_module_builder_fuzzy_match,
+    ]
+
+    for test in tests:
+        try:
+            await test()
+        except Exception as e:
+            print(f"✗ {test.__name__} failed: {e}")
+            import traceback
+
+            traceback.print_exc()
+
+    print("\nAll Module Builder agent scenario tests completed!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/tests/scenarios/mmb/workflow-builder.test.py

@@ -0,0 +1,124 @@
+"""Scenario tests for the Workflow Builder agent."""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Add the app directory to the path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "app"))
+
+from mmb.agents.workflow_builder.agent import WorkflowBuilderAgent
+
+
+async def test_workflow_builder_menu_display():
+    """Test menu display capability."""
+    agent = WorkflowBuilderAgent()
+
+    result = await agent.process("menu")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "menu" in result.lower() or "workflow builder" in result.lower()
+    print("✓ test_workflow_builder_menu_display passed")
+
+
+async def test_workflow_builder_create_workflow():
+    """Test create workflow capability."""
+    agent = WorkflowBuilderAgent()
+
+    result = await agent.process("create-workflow")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "create" in result.lower() or "workflow" in result.lower()
+    print("✓ test_workflow_builder_create_workflow passed")
+
+
+async def test_workflow_builder_edit_workflow():
+    """Test edit workflow capability."""
+    agent = WorkflowBuilderAgent()
+
+    result = await agent.process("edit-workflow")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "edit" in result.lower() or "workflow" in result.lower()
+    print("✓ test_workflow_builder_edit_workflow passed")
+
+
+async def test_workflow_builder_validate_workflow():
+    """Test validate workflow capability."""
+    agent = WorkflowBuilderAgent()
+
+    result = await agent.process("validate-workflow")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "validate" in result.lower() or "workflow" in result.lower()
+    print("✓ test_workflow_builder_validate_workflow passed")
+
+
+async def test_workflow_builder_max_parallel():
+    """Test max-parallel validation capability."""
+    agent = WorkflowBuilderAgent()
+
+    result = await agent.process("validate-max-parallel-workflow")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "parallel" in result.lower() or "validation" in result.lower()
+    print("✓ test_workflow_builder_max_parallel passed")
+
+
+async def test_workflow_builder_rework_workflow():
+    """Test rework workflow capability."""
+    agent = WorkflowBuilderAgent()
+
+    result = await agent.process("rework-workflow")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "rework" in result.lower() or "v6" in result.lower()
+    print("✓ test_workflow_builder_rework_workflow passed")
+
+
+async def test_workflow_builder_chat():
+    """Test chat capability."""
+    agent = WorkflowBuilderAgent()
+
+    result = await agent.process("chat")
+
+    assert result is not None
+    assert len(result) > 0
+    assert "workflow" in result.lower() or "building" in result.lower()
+    print("✓ test_workflow_builder_chat passed")
+
+
+async def main():
+    """Run all scenario tests."""
+    print("Running Workflow Builder agent scenario tests...\n")
+
+    tests = [
+        test_workflow_builder_menu_display,
+        test_workflow_builder_create_workflow,
+        test_workflow_builder_edit_workflow,
+        test_workflow_builder_validate_workflow,
+        test_workflow_builder_max_parallel,
+        test_workflow_builder_rework_workflow,
+        test_workflow_builder_chat,
+    ]
+
+    for test in tests:
+        try:
+            await test()
+        except Exception as e:
+            print(f"✗ {test.__name__} failed: {e}")
+            import traceback
+
+            traceback.print_exc()
+
+    print("\nAll Workflow Builder agent scenario tests completed!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/tests/scenarios/mmm/analyst.test.py

@@ -0,0 +1,138 @@
+"""Scenario tests for the Analyst agent."""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Add the app directory to the path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "app"))
+
+from mmm.agents.analyst.agent import Analyst
+
+
+async def test_analyst_basic_analysis():
+    """Test basic business analysis capability."""
+    agent = Analyst()
+
+    result = await agent.process(
+        "Analyze the requirements for building a simple task management application"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "analysis" in result.lower() or "requirement" in result.lower()
+    print("✓ test_analyst_basic_analysis passed")
+
+
+async def test_analyst_user_stories():
+    """Test user story creation capability."""
+    agent = Analyst()
+
+    result = await agent.process(
+        "Create user stories for a task management application with features like creating tasks, assigning them, and tracking progress"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "user story" in result.lower() or "story" in result.lower()
+    print("✓ test_analyst_user_stories passed")
+
+
+async def test_analyst_requirements_gathering():
+    """Test requirements gathering capability."""
+    agent = Analyst()
+
+    result = await agent.process(
+        "Gather requirements for an e-commerce platform with product catalog, shopping cart, and payment processing"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "requirement" in result.lower() or "functional" in result.lower()
+    print("✓ test_analyst_requirements_gathering passed")
+
+
+async def test_analyst_stakeholder_analysis():
+    """Test stakeholder analysis capability."""
+    agent = Analyst()
+
+    result = await agent.process(
+        "Identify and analyze stakeholders for a healthcare management system"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "stakeholder" in result.lower() or "user" in result.lower()
+    print("✓ test_analyst_stakeholder_analysis passed")
+
+
+async def test_analyst_use_cases():
+    """Test use case creation capability."""
+    agent = Analyst()
+
+    result = await agent.process(
+        "Create use cases for a social media application with features like posting, commenting, and liking"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "use case" in result.lower() or "scenario" in result.lower()
+    print("✓ test_analyst_use_cases passed")
+
+
+async def test_analyst_business_rules():
+    """Test business rules definition capability."""
+    agent = Analyst()
+
+    result = await agent.process(
+        "Define business rules for a banking application including transaction limits and approval workflows"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "business rule" in result.lower() or "validation" in result.lower()
+    print("✓ test_analyst_business_rules passed")
+
+
+async def test_analyst_acceptance_criteria():
+    """Test acceptance criteria definition capability."""
+    agent = Analyst()
+
+    result = await agent.process(
+        "Define acceptance criteria for a user registration feature with email verification"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "acceptance criteria" in result.lower() or "criteria" in result.lower()
+    print("✓ test_analyst_acceptance_criteria passed")
+
+
+async def main():
+    """Run all scenario tests."""
+    print("Running Analyst agent scenario tests...\n")
+
+    tests = [
+        test_analyst_basic_analysis,
+        test_analyst_user_stories,
+        test_analyst_requirements_gathering,
+        test_analyst_stakeholder_analysis,
+        test_analyst_use_cases,
+        test_analyst_business_rules,
+        test_analyst_acceptance_criteria,
+    ]
+
+    for test in tests:
+        try:
+            await test()
+        except Exception as e:
+            print(f"✗ {test.__name__} failed: {e}")
+            import traceback
+
+            traceback.print_exc()
+
+    print("\nAll Analyst agent scenario tests completed!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/tests/scenarios/mmm/architect.test.py

@@ -0,0 +1,138 @@
+"""Scenario tests for the Architect agent."""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Add the app directory to the path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "app"))
+
+from mmm.agents.architect.agent import Architect
+
+
+async def test_architect_system_design():
+    """Test system design capability."""
+    agent = Architect()
+
+    result = await agent.process(
+        "Design the system architecture for a microservices-based e-commerce platform"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "architecture" in result.lower() or "design" in result.lower()
+    print("✓ test_architect_system_design passed")
+
+
+async def test_architect_component_design():
+    """Test component design capability."""
+    agent = Architect()
+
+    result = await agent.process(
+        "Design the components for a task management application with real-time updates"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "component" in result.lower() or "module" in result.lower()
+    print("✓ test_architect_component_design passed")
+
+
+async def test_architect_technology_stack():
+    """Test technology stack selection capability."""
+    agent = Architect()
+
+    result = await agent.process(
+        "Recommend a technology stack for building a scalable real-time chat application"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "technology" in result.lower() or "stack" in result.lower()
+    print("✓ test_architect_technology_stack passed")
+
+
+async def test_architect_api_design():
+    """Test API design capability."""
+    agent = Architect()
+
+    result = await agent.process(
+        "Design RESTful APIs for a user management system with authentication and authorization"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "api" in result.lower() or "endpoint" in result.lower()
+    print("✓ test_architect_api_design passed")
+
+
+async def test_architect_database_design():
+    """Test database design capability."""
+    agent = Architect()
+
+    result = await agent.process(
+        "Design the database schema for a multi-tenant SaaS application"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "database" in result.lower() or "schema" in result.lower()
+    print("✓ test_architect_database_design passed")
+
+
+async def test_architect_scalability():
+    """Test scalability design capability."""
+    agent = Architect()
+
+    result = await agent.process(
+        "Design a scalable architecture for a social media platform expecting millions of users"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "scalable" in result.lower() or "scale" in result.lower()
+    print("✓ test_architect_scalability passed")
+
+
+async def test_architect_security():
+    """Test security design capability."""
+    agent = Architect()
+
+    result = await agent.process(
+        "Design security measures for a financial application handling sensitive data"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "security" in result.lower() or "secure" in result.lower()
+    print("✓ test_architect_security passed")
+
+
+async def main():
+    """Run all scenario tests."""
+    print("Running Architect agent scenario tests...\n")
+
+    tests = [
+        test_architect_system_design,
+        test_architect_component_design,
+        test_architect_technology_stack,
+        test_architect_api_design,
+        test_architect_database_design,
+        test_architect_scalability,
+        test_architect_security,
+    ]
+
+    for test in tests:
+        try:
+            await test()
+        except Exception as e:
+            print(f"✗ {test.__name__} failed: {e}")
+            import traceback
+
+            traceback.print_exc()
+
+    print("\nAll Architect agent scenario tests completed!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())