mdan-method 2.6.3

package/tests/simple_fintech_test.py

@@ -0,0 +1,205 @@
+"""Simple test script for FinTech pack agents."""
+
+import sys
+import os
+import asyncio
+
+# Add the app directory to the path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+# Import agents directly from their modules
+import importlib.util
+
+
+def load_agent(module_path, class_name):
+    """Load an agent class from a file path."""
+    spec = importlib.util.spec_from_file_location("agent_module", module_path)
+    if spec is None:
+        raise ImportError(f"Could not load spec from {module_path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return getattr(module, class_name)
+
+
+# Load agents
+FinancialAnalystAgent = load_agent(
+    os.path.join(
+        os.path.dirname(__file__),
+        "../app/packs/fintech/agents/financial-analyst/agent.py",
+    ),
+    "FinancialAnalystAgent",
+)
+ComplianceOfficerAgent = load_agent(
+    os.path.join(
+        os.path.dirname(__file__),
+        "../app/packs/fintech/agents/compliance-officer/agent.py",
+    ),
+    "ComplianceOfficerAgent",
+)
+RiskManagerAgent = load_agent(
+    os.path.join(
+        os.path.dirname(__file__), "../app/packs/fintech/agents/risk-manager/agent.py"
+    ),
+    "RiskManagerAgent",
+)
+
+
+async def test_financial_analyst():
+    """Test Financial Analyst agent."""
+    print("Testing Financial Analyst agent...")
+    agent = FinancialAnalystAgent()
+
+    # Test get_info method
+    info = agent.get_info()
+    assert info is not None
+    assert "name" in info
+    assert info["name"] == "Financial Analyst"
+    assert "capabilities" in info
+    assert len(info["capabilities"]) > 0
+
+    # Test process method with a simple request
+    from dataclasses import dataclass
+
+    @dataclass
+    class FinancialAnalysisRequest:
+        action: str
+        financial_data: dict = None
+        analysis_type: str = None
+        time_period: str = None
+        metrics: list = None
+
+    request = FinancialAnalysisRequest(
+        action="analyze",
+        financial_data={"revenue": "5,000,000"},
+        analysis_type="performance",
+    )
+
+    result = await agent.process(request)
+    assert result is not None
+    assert len(result) > 0
+    print("✓ Financial Analyst agent test passed")
+    return True
+
+
+async def test_compliance_officer():
+    """Test Compliance Officer agent."""
+    print("Testing Compliance Officer agent...")
+    agent = ComplianceOfficerAgent()
+
+    # Test get_info method
+    info = agent.get_info()
+    assert info is not None
+    assert "name" in info
+    assert info["name"] == "Compliance Officer"
+    assert "capabilities" in info
+    assert len(info["capabilities"]) > 0
+
+    # Test process method with a simple request
+    from dataclasses import dataclass
+
+    @dataclass
+    class ComplianceRequest:
+        action: str
+        compliance_area: str = None
+        jurisdiction: str = None
+        data: dict = None
+        requirements: list = None
+
+    request = ComplianceRequest(
+        action="assess", compliance_area="data_protection", jurisdiction="EU"
+    )
+
+    result = await agent.process(request)
+    assert result is not None
+    assert len(result) > 0
+    print("✓ Compliance Officer agent test passed")
+    return True
+
+
+async def test_risk_manager():
+    """Test Risk Manager agent."""
+    print("Testing Risk Manager agent...")
+    agent = RiskManagerAgent()
+
+    # Test get_info method
+    info = agent.get_info()
+    assert info is not None
+    assert "name" in info
+    assert info["name"] == "Risk Manager"
+    assert "capabilities" in info
+    assert len(info["capabilities"]) > 0
+
+    # Test process method with a simple request
+    from dataclasses import dataclass
+
+    @dataclass
+    class RiskManagementRequest:
+        action: str
+        risk_category: str = None
+        risk_data: dict = None
+        time_horizon: str = None
+        tolerance_level: str = None
+
+    request = RiskManagementRequest(action="identify", risk_category="market")
+
+    result = await agent.process(request)
+    assert result is not None
+    assert len(result) > 0
+    print("✓ Risk Manager agent test passed")
+    return True
+
+
+async def main():
+    """Run all tests."""
+    print("=" * 60)
+    print("FinTech Pack - Simple Agent Tests")
+    print("=" * 60)
+    print()
+
+    all_passed = True
+
+    try:
+        all_passed &= await test_financial_analyst()
+    except Exception as e:
+        print(f"✗ Financial Analyst agent test failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        all_passed = False
+
+    print()
+
+    try:
+        all_passed &= await test_compliance_officer()
+    except Exception as e:
+        print(f"✗ Compliance Officer agent test failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        all_passed = False
+
+    print()
+
+    try:
+        all_passed &= await test_risk_manager()
+    except Exception as e:
+        print(f"✗ Risk Manager agent test failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        all_passed = False
+
+    print()
+    print("=" * 60)
+    if all_passed:
+        print("All FinTech pack tests passed! ✓")
+    else:
+        print("Some tests failed! ✗")
+    print("=" * 60)
+
+    return all_passed
+
+
+if __name__ == "__main__":
+    all_passed = asyncio.run(main())
+    sys.exit(0 if all_passed else 1)

package/tests/simple_mmb_test.py

@@ -0,0 +1,103 @@
+"""Simple test script for all mmb module agents."""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Add the app directory to the path
+sys.path.insert(0, str(Path(__file__).parent.parent / "app"))
+
+# Import agents directly from their modules
+import importlib.util
+
+
+def load_agent(module_path, class_name):
+    """Load an agent class from a file path."""
+    spec = importlib.util.spec_from_file_location("agent_module", module_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return getattr(module, class_name)
+
+
+# Load all agents
+AgentBuilderAgent = load_agent(
+    "app/mmb/agents/agent-builder/agent.py", "AgentBuilderAgent"
+)
+ModuleBuilderAgent = load_agent(
+    "app/mmb/agents/module-builder/agent.py", "ModuleBuilderAgent"
+)
+WorkflowBuilderAgent = load_agent(
+    "app/mmb/agents/workflow-builder/agent.py", "WorkflowBuilderAgent"
+)
+
+
+async def test_agent_builder():
+    """Test Agent Builder agent."""
+    print("Testing Agent Builder agent...")
+    agent = AgentBuilderAgent()
+    result = await agent.process("menu")
+    assert result is not None
+    assert len(result) > 0
+    print("✓ Agent Builder agent works correctly\n")
+
+
+async def test_module_builder():
+    """Test Module Builder agent."""
+    print("Testing Module Builder agent...")
+    agent = ModuleBuilderAgent()
+    result = await agent.process("menu")
+    assert result is not None
+    assert len(result) > 0
+    print("✓ Module Builder agent works correctly\n")
+
+
+async def test_workflow_builder():
+    """Test Workflow Builder agent."""
+    print("Testing Workflow Builder agent...")
+    agent = WorkflowBuilderAgent()
+    result = await agent.process("menu")
+    assert result is not None
+    assert len(result) > 0
+    print("✓ Workflow Builder agent works correctly\n")
+
+
+async def main():
+    """Run all tests."""
+    print("=" * 60)
+    print("Testing all mmb module agents")
+    print("=" * 60)
+    print()
+
+    tests = [
+        test_agent_builder,
+        test_module_builder,
+        test_workflow_builder,
+    ]
+
+    passed = 0
+    failed = 0
+
+    for test in tests:
+        try:
+            await test()
+            passed += 1
+        except Exception as e:
+            print(f"✗ {test.__name__} failed: {e}\n")
+            import traceback
+
+            traceback.print_exc()
+            print()
+            failed += 1
+
+    print("=" * 60)
+    print(f"Test Results: {passed} passed, {failed} failed")
+    print("=" * 60)
+
+    if failed == 0:
+        print("\n🎉 All mmb module agents are working correctly!")
+    else:
+        print(f"\n⚠️  {failed} agent(s) failed the tests")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/tests/simple_mmm_test.py

@@ -0,0 +1,159 @@
+"""Simple test script for all mmm module agents."""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Add the app directory to the path
+sys.path.insert(0, str(Path(__file__).parent.parent / "app"))
+
+# Import agents directly from their modules
+import importlib.util
+
+
+def load_agent(module_path, class_name):
+    """Load an agent class from a file path."""
+    spec = importlib.util.spec_from_file_location("agent_module", module_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return getattr(module, class_name)
+
+
+# Load all agents
+AnalystAgent = load_agent("app/mmm/agents/analyst/agent.py", "AnalystAgent")
+ArchitectAgent = load_agent("app/mmm/agents/architect/agent.py", "ArchitectAgent")
+DevAgent = load_agent("app/mmm/agents/dev/agent.py", "DevAgent")
+PMAgent = load_agent("app/mmm/agents/pm/agent.py", "PMAgent")
+QAAgent = load_agent("app/mmm/agents/qa/agent.py", "QAAgent")
+QuickFlowSoloDevAgent = load_agent(
+    "app/mmm/agents/quick-flow-solo-dev/agent.py", "QuickFlowSoloDevAgent"
+)
+SMAgent = load_agent("app/mmm/agents/sm/agent.py", "SMAgent")
+TechWriterAgent = load_agent("app/mmm/agents/tech-writer/agent.py", "TechWriterAgent")
+
+
+async def test_analyst():
+    """Test Analyst agent."""
+    print("Testing Analyst agent...")
+    agent = AnalystAgent()
+    result = await agent.process("Analyze requirements for a task management app")
+    assert result is not None
+    assert len(result) > 0
+    print("✓ Analyst agent works correctly\n")
+
+
+async def test_architect():
+    """Test Architect agent."""
+    print("Testing Architect agent...")
+    agent = ArchitectAgent()
+    result = await agent.process("Design architecture for a microservices app")
+    assert result is not None
+    assert len(result) > 0
+    print("✓ Architect agent works correctly\n")
+
+
+async def test_dev():
+    """Test Dev agent."""
+    print("Testing Dev agent...")
+    agent = DevAgent()
+    result = await agent.process("Implement a user authentication feature")
+    assert result is not None
+    assert len(result) > 0
+    print("✓ Dev agent works correctly\n")
+
+
+async def test_pm():
+    """Test PM agent."""
+    print("Testing PM agent...")
+    agent = PMAgent()
+    result = await agent.process("Create a project plan for a 6-month project")
+    assert result is not None
+    assert len(result) > 0
+    print("✓ PM agent works correctly\n")
+
+
+async def test_qa():
+    """Test QA agent."""
+    print("Testing QA agent...")
+    agent = QAAgent()
+    result = await agent.process("Create a test plan for an authentication system")
+    assert result is not None
+    assert len(result) > 0
+    print("✓ QA agent works correctly\n")
+
+
+async def test_quick_flow_solo_dev():
+    """Test Quick Flow Solo Dev agent."""
+    print("Testing Quick Flow Solo Dev agent...")
+    agent = QuickFlowSoloDevAgent()
+    result = await agent.process("Build a complete user authentication feature")
+    assert result is not None
+    assert len(result) > 0
+    print("✓ Quick Flow Solo Dev agent works correctly\n")
+
+
+async def test_sm():
+    """Test Scrum Master agent."""
+    print("Testing Scrum Master agent...")
+    agent = SMAgent()
+    result = await agent.process("Facilitate a sprint planning meeting")
+    assert result is not None
+    assert len(result) > 0
+    print("✓ Scrum Master agent works correctly\n")
+
+
+async def test_tech_writer():
+    """Test Tech Writer agent."""
+    print("Testing Tech Writer agent...")
+    agent = TechWriterAgent()
+    result = await agent.process("Create API documentation for a REST service")
+    assert result is not None
+    assert len(result) > 0
+    print("✓ Tech Writer agent works correctly\n")
+
+
+async def main():
+    """Run all tests."""
+    print("=" * 60)
+    print("Testing all mmm module agents")
+    print("=" * 60)
+    print()
+
+    tests = [
+        test_analyst,
+        test_architect,
+        test_dev,
+        test_pm,
+        test_qa,
+        test_quick_flow_solo_dev,
+        test_sm,
+        test_tech_writer,
+    ]
+
+    passed = 0
+    failed = 0
+
+    for test in tests:
+        try:
+            await test()
+            passed += 1
+        except Exception as e:
+            print(f"✗ {test.__name__} failed: {e}\n")
+            import traceback
+
+            traceback.print_exc()
+            print()
+            failed += 1
+
+    print("=" * 60)
+    print(f"Test Results: {passed} passed, {failed} failed")
+    print("=" * 60)
+
+    if failed == 0:
+        print("\n🎉 All mmm module agents are working correctly!")
+    else:
+        print(f"\n⚠️  {failed} agent(s) failed the tests")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/tests/simple_tea_test.py

@@ -0,0 +1,80 @@
+"""
+Simple integration test for tea module agent
+Tests that the TEA agent can be imported and instantiated correctly
+"""
+
+import asyncio
+import sys
+import os
+import importlib.util
+
+# Add the app directory to the path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+
+async def test_tea_agent():
+    """Test TEA Agent"""
+    print("Testing TEA Agent (Murat)...")
+
+    try:
+        agent_path = os.path.join(
+            os.path.dirname(__file__), "../app/tea/agents/tea/agent.py"
+        )
+        module = importlib.util.spec_from_file_location("agent_module", agent_path)
+        if module is None or module.loader is None:
+            raise ImportError(f"Could not load spec from {agent_path}")
+        agent_module = importlib.util.module_from_spec(module)
+        module.loader.exec_module(agent_module)
+
+        TEA = agent_module.TEA
+        TEARequest = agent_module.TEARequest
+
+        agent = TEA()
+
+        # Test basic processing
+        request = TEARequest(task="teach-me-testing", context="I want to learn testing")
+        result = await agent.process(request)
+
+        assert result is not None
+        assert isinstance(result, dict)
+        assert result["success"] == True
+        print("✓ TEA Agent works correctly")
+        return True
+    except Exception as e:
+        print(f"✗ TEA Agent failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+
+async def run_all_tests():
+    """Run all tea module agent tests"""
+    print("=" * 60)
+    print("TEA Module - Integration Tests")
+    print("=" * 60)
+
+    tests = [
+        test_tea_agent(),
+    ]
+
+    results = await asyncio.gather(*tests)
+
+    passed = sum(results)
+    total = len(results)
+
+    print("\n" + "=" * 60)
+    print(f"Test Results: {passed}/{total} agents passed")
+    print("=" * 60)
+
+    if passed == total:
+        print("✓ All TEA agents work correctly!")
+        return 0
+    else:
+        print(f"✗ {total - passed} agent(s) failed")
+        return 1
+
+
+if __name__ == "__main__":
+    exit_code = asyncio.run(run_all_tests())
+    sys.exit(exit_code)

package/tests/simple_test.py

@@ -0,0 +1,111 @@
+"""
+Simple test script to verify MDAN Master agent works without the scenario framework.
+"""
+
+import sys
+import os
+import asyncio
+
+# Add the app directory to the path
+app_path = os.path.join(os.path.dirname(__file__), "..", "app")
+sys.path.insert(0, app_path)
+
+# Import directly from the file
+import importlib.util
+
+agent_file = os.path.join(app_path, "core", "agents", "mdan-master", "agent.py")
+spec = importlib.util.spec_from_file_location("mdan_master_agent", agent_file)
+if spec and spec.loader:
+    mdan_master_module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mdan_master_module)
+    MDANMasterAgent = mdan_master_module.MDANMasterAgent
+    AgentRequest = mdan_master_module.AgentRequest
+else:
+    raise ImportError(f"Could not load agent from {agent_file}")
+
+
+async def test_agent():
+    """Test the MDAN Master agent."""
+    print("=" * 60)
+    print("Testing MDAN Master Agent")
+    print("=" * 60)
+
+    # Test 1: Agent initialization
+    print("\n[Test 1] Agent Initialization")
+    agent = MDANMasterAgent()
+    print(f"  Name: {agent.name}")
+    print(f"  Title: {agent.title}")
+    print(f"  Icon: {agent.icon}")
+    print(f"  Capabilities: {', '.join(agent.capabilities)}")
+    print("  ✓ Agent initialized successfully")
+
+    # Test 2: Greet action with context
+    print("\n[Test 2] Greet Action with Context")
+    request = AgentRequest(
+        action="greet",
+        context={
+            "user_name": "Alice",
+            "communication_language": "English",
+            "output_folder": "/output",
+        },
+    )
+    result = await agent.process(request)
+    print(f"  Message: {result['message']}")
+    print(f"  Agent: {result['agent']}")
+    print(f"  Language: {result['language']}")
+    print(f"  Menu items: {len(result['menu'])}")
+    print("  ✓ Greet action works correctly")
+
+    # Test 3: List tasks
+    print("\n[Test 3] List Tasks")
+    request = AgentRequest(action="list-tasks")
+    result = await agent.process(request)
+    print(f"  Message: {result['message']}")
+    print(f"  Tasks count: {result['count']}")
+    for task in result["tasks"]:
+        print(f"    - {task['name']} ({task['module']})")
+    print("  ✓ List tasks works correctly")
+
+    # Test 4: List workflows
+    print("\n[Test 4] List Workflows")
+    request = AgentRequest(action="list-workflows")
+    result = await agent.process(request)
+    print(f"  Message: {result['message']}")
+    print(f"  Workflows count: {result['count']}")
+    for workflow in result["workflows"]:
+        print(f"    - {workflow['name']} ({workflow['module']})")
+    print("  ✓ List workflows works correctly")
+
+    # Test 5: Help action
+    print("\n[Test 5] Help Action")
+    request = AgentRequest(action="help")
+    result = await agent.process(request)
+    print(f"  Message: {result['message']}")
+    print(f"  Agent: {result['agent']}")
+    print(f"  Usage items: {len(result['usage'])}")
+    print("  ✓ Help action works correctly")
+
+    # Test 6: Unknown action
+    print("\n[Test 6] Unknown Action")
+    request = AgentRequest(action="unknown-action")
+    result = await agent.process(request)
+    print(f"  Message: {result['message']}")
+    print(f"  Action: {result['action']}")
+    print(f"  Suggestion: {result['suggestion']}")
+    print("  ✓ Unknown action handled correctly")
+
+    # Test 7: Get info
+    print("\n[Test 7] Get Agent Info")
+    info = agent.get_info()
+    print(f"  Name: {info['name']}")
+    print(f"  Role: {info['role']}")
+    print(f"  Principles: {len(info['principles'])}")
+    print("  ✓ Get info works correctly")
+
+    print("\n" + "=" * 60)
+    print("All tests passed! ✓")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    asyncio.run(test_agent())