mdan-method 2.6.3

package/tests/scenarios/cis/storyteller.test.py

@@ -0,0 +1,324 @@
+"""
+Scenario tests for Storyteller Agent (Sophia)
+Tests the Master Storyteller's ability to craft compelling narratives
+"""
+
+import asyncio
+import sys
+import os
+
+# Add the app directory to the path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../../.."))
+
+from app.cis.agents.storyteller.agent import StorytellerAgent
+
+
+class TestStorytellerAgent:
+    """Test suite for Storyteller Agent scenarios"""
+
+    def __init__(self):
+        self.agent = StorytellerAgent()
+
+    async def test_initialization(self):
+        """Test 1: Agent initializes correctly"""
+        print("Test 1: Agent initialization...")
+
+        try:
+            assert self.agent is not None
+            assert hasattr(self.agent, "process")
+            assert hasattr(self.agent, "name")
+            assert self.agent.name == "storyteller"
+            print("✓ Agent initializes correctly")
+            return True
+        except Exception as e:
+            print(f"✗ Initialization failed: {e}")
+            return False
+
+    async def test_craft_narrative_framework(self):
+        """Test 2: Craft narrative using proven frameworks"""
+        print("\nTest 2: Craft narrative using frameworks...")
+
+        try:
+            input_data = {
+                "task": "Craft a compelling narrative",
+                "story_type": "brand story",
+                "framework": "hero's journey",
+                "context": "A sustainable fashion startup",
+            }
+
+            result = await self.agent.process(input_data)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            assert "response" in result or "narrative" in result or "story" in result
+            print("✓ Narrative crafted successfully")
+            return True
+        except Exception as e:
+            print(f"✗ Narrative crafting failed: {e}")
+            return False
+
+    async def test_emotional_psychology_application(self):
+        """Test 3: Apply emotional psychology to storytelling"""
+        print("\nTest 3: Apply emotional psychology...")
+
+        try:
+            input_data = {
+                "task": "Create emotionally engaging story",
+                "target_emotion": "inspiration",
+                "audience": "young professionals",
+                "theme": "overcoming challenges",
+            }
+
+            result = await self.agent.process(input_data)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            print("✓ Emotional psychology applied successfully")
+            return True
+        except Exception as e:
+            print(f"✗ Emotional psychology application failed: {e}")
+            return False
+
+    async def test_audience_engagement_strategy(self):
+        """Test 4: Develop audience engagement strategy"""
+        print("\nTest 4: Develop audience engagement strategy...")
+
+        try:
+            input_data = {
+                "task": "Create engagement strategy",
+                "audience_segment": "millennials",
+                "platform": "social media",
+                "story_format": "short-form video",
+            }
+
+            result = await self.agent.process(input_data)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            print("✓ Engagement strategy developed successfully")
+            return True
+        except Exception as e:
+            print(f"✗ Engagement strategy development failed: {e}")
+            return False
+
+    async def test_vivid_details_creation(self):
+        """Test 5: Create vivid details for abstract concepts"""
+        print("\nTest 5: Create vivid details...")
+
+        try:
+            input_data = {
+                "task": "Make abstract concrete",
+                "abstract_concept": "innovation",
+                "context": "tech company transformation",
+                "style": "flowery and whimsical",
+            }
+
+            result = await self.agent.process(input_data)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            print("✓ Vivid details created successfully")
+            return True
+        except Exception as e:
+            print(f"✗ Vivid details creation failed: {e}")
+            return False
+
+    async def test_screenwriting_techniques(self):
+        """Test 6: Apply screenwriting techniques"""
+        print("\nTest 6: Apply screenwriting techniques...")
+
+        try:
+            input_data = {
+                "task": "Use screenwriting techniques",
+                "technique": "three-act structure",
+                "story_elements": ["protagonist", "conflict", "resolution"],
+                "genre": "drama",
+            }
+
+            result = await self.agent.process(input_data)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            print("✓ Screenwriting techniques applied successfully")
+            return True
+        except Exception as e:
+            print(f"✗ Screenwriting techniques application failed: {e}")
+            return False
+
+    async def test_journalistic_storytelling(self):
+        """Test 7: Apply journalistic storytelling approach"""
+        print("\nTest 7: Apply journalistic storytelling...")
+
+        try:
+            input_data = {
+                "task": "Create journalistic narrative",
+                "story_angle": "human interest",
+                "facts": ["company milestone", "customer impact", "team dedication"],
+                "tone": "authentic and compelling",
+            }
+
+            result = await self.agent.process(input_data)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            print("✓ Journalistic storytelling applied successfully")
+            return True
+        except Exception as e:
+            print(f"✗ Journalistic storytelling failed: {e}")
+            return False
+
+    async def test_brand_narrative_development(self):
+        """Test 8: Develop brand narrative"""
+        print("\nTest 8: Develop brand narrative...")
+
+        try:
+            input_data = {
+                "task": "Create brand narrative",
+                "brand_values": ["sustainability", "innovation", "quality"],
+                "brand_mission": "Make the world better",
+                "target_audience": "conscious consumers",
+            }
+
+            result = await self.agent.process(input_data)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            print("✓ Brand narrative developed successfully")
+            return True
+        except Exception as e:
+            print(f"✗ Brand narrative development failed: {e}")
+            return False
+
+    async def test_story_structure_optimization(self):
+        """Test 9: Optimize story structure"""
+        print("\nTest 9: Optimize story structure...")
+
+        try:
+            input_data = {
+                "task": "Optimize story structure",
+                "current_story": "A company's journey from startup to success",
+                "framework": "monomyth",
+                "focus": "emotional arc",
+            }
+
+            result = await self.agent.process(input_data)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            print("✓ Story structure optimized successfully")
+            return True
+        except Exception as e:
+            print(f"✗ Story structure optimization failed: {e}")
+            return False
+
+    async def test_multichannel_storytelling(self):
+        """Test 10: Adapt story for multiple channels"""
+        print("\nTest 10: Adapt story for multiple channels...")
+
+        try:
+            input_data = {
+                "task": "Adapt story for channels",
+                "core_story": "A product launch journey",
+                "channels": ["blog", "video", "social media", "email"],
+                "maintain_consistency": True,
+            }
+
+            result = await self.agent.process(input_data)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            print("✓ Multichannel storytelling adapted successfully")
+            return True
+        except Exception as e:
+            print(f"✗ Multichannel storytelling failed: {e}")
+            return False
+
+    async def test_story_arc_creation(self):
+        """Test 11: Create compelling story arc"""
+        print("\nTest 11: Create story arc...")
+
+        try:
+            input_data = {
+                "task": "Create story arc",
+                "protagonist": "founder",
+                "goal": "launch innovative product",
+                "obstacles": ["funding", "competition", "technical challenges"],
+                "theme": "perseverance",
+            }
+
+            result = await self.agent.process(input_data)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            print("✓ Story arc created successfully")
+            return True
+        except Exception as e:
+            print(f"✗ Story arc creation failed: {e}")
+            return False
+
+    async def test_authentic_story_finding(self):
+        """Test 12: Find authentic story elements"""
+        print("\nTest 12: Find authentic story elements...")
+
+        try:
+            input_data = {
+                "task": "Find authentic story",
+                "company_context": "family business",
+                "values": ["tradition", "quality", "community"],
+                "differentiators": ["handmade", "local sourcing", "sustainable"],
+            }
+
+            result = await self.agent.process(input_data)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            print("✓ Authentic story elements found successfully")
+            return True
+        except Exception as e:
+            print(f"✗ Authentic story finding failed: {e}")
+            return False
+
+
+async def run_all_tests():
+    """Run all scenario tests for Storyteller Agent"""
+    print("=" * 60)
+    print("Storyteller Agent (Sophia) - Scenario Tests")
+    print("=" * 60)
+
+    test_suite = TestStorytellerAgent()
+
+    tests = [
+        test_suite.test_initialization(),
+        test_suite.test_craft_narrative_framework(),
+        test_suite.test_emotional_psychology_application(),
+        test_suite.test_audience_engagement_strategy(),
+        test_suite.test_vivid_details_creation(),
+        test_suite.test_screenwriting_techniques(),
+        test_suite.test_journalistic_storytelling(),
+        test_suite.test_brand_narrative_development(),
+        test_suite.test_story_structure_optimization(),
+        test_suite.test_multichannel_storytelling(),
+        test_suite.test_story_arc_creation(),
+        test_suite.test_authentic_story_finding(),
+    ]
+
+    results = await asyncio.gather(*tests)
+
+    passed = sum(results)
+    total = len(results)
+
+    print("\n" + "=" * 60)
+    print(f"Test Results: {passed}/{total} passed")
+    print("=" * 60)
+
+    if passed == total:
+        print("✓ All tests passed!")
+        return 0
+    else:
+        print(f"✗ {total - passed} test(s) failed")
+        return 1
+
+
+if __name__ == "__main__":
+    exit_code = asyncio.run(run_all_tests())
+    sys.exit(exit_code)

package/tests/scenarios/core/mdan-master.test.py

@@ -0,0 +1,281 @@
+"""
+Scenario tests for MDAN Master agent.
+"""
+
+from scenario import Scenario, expect
+import sys
+import os
+
+# Add the app directory to the path
+sys.path.insert(
+    0, os.path.join(os.path.dirname(__file__), "..", "..", "..", "..", "app")
+)
+
+from core.agents.mdan_master.agent import MDANMasterAgent, AgentRequest
+
+
+scenario = Scenario("MDAN Master - Core Functionality")
+
+
+@scenario.test
+async def test_agent_initialization():
+    """
+    Test that the MDAN Master agent initializes correctly.
+    """
+    agent = MDANMasterAgent()
+
+    expect(agent.name).to_equal("MDAN Master")
+    expect(agent.title).to_equal(
+        "MDAN Master Executor, Knowledge Custodian, and Workflow Orchestrator"
+    )
+    expect(agent.icon).to_equal("🧙")
+    expect(len(agent.capabilities)).to_equal(4)
+    expect("runtime resource management" in agent.capabilities).to_be_true()
+    expect("workflow orchestration" in agent.capabilities).to_be_true()
+    expect("task execution" in agent.capabilities).to_be_true()
+    expect("knowledge custodian" in agent.capabilities).to_be_true()
+
+
+@scenario.test
+async def test_greet_action():
+    """
+    Test that the greet action returns a proper greeting with menu.
+    """
+    agent = MDANMasterAgent()
+
+    request = AgentRequest(
+        action="greet",
+        context={
+            "user_name": "Alice",
+            "communication_language": "English",
+            "output_folder": "/output",
+        },
+    )
+
+    result = await agent.process(request)
+
+    expect(result).to_have_key("message")
+    expect(result).to_have_key("agent")
+    expect(result).to_have_key("icon")
+    expect(result).to_have_key("capabilities")
+    expect(result).to_have_key("menu")
+    expect(result).to_have_key("help_hint")
+    expect(result).to_have_key("language")
+
+    expect(result["message"]).to_contain("Alice")
+    expect(result["agent"]).to_equal("MDAN Master")
+    expect(result["icon"]).to_equal("🧙")
+    expect(result["language"]).to_equal("English")
+    expect(len(result["menu"])).to_equal(6)
+
+
+@scenario.test
+async def test_greet_action_without_context():
+    """
+    Test that the greet action works without context (uses defaults).
+    """
+    agent = MDANMasterAgent()
+
+    request = AgentRequest(action="greet")
+
+    result = await agent.process(request)
+
+    expect(result["message"]).to_contain("User")
+    expect(result["language"]).to_equal("English")
+
+
+@scenario.test
+async def test_list_tasks_action():
+    """
+    Test that the list-tasks action returns available tasks.
+    """
+    agent = MDANMasterAgent()
+
+    request = AgentRequest(action="list-tasks")
+
+    result = await agent.process(request)
+
+    expect(result).to_have_key("message")
+    expect(result).to_have_key("tasks")
+    expect(result).to_have_key("count")
+
+    expect(result["message"]).to_equal("Available Tasks")
+    expect(len(result["tasks"])).to_be_greater_than(0)
+    expect(result["count"]).to_equal(len(result["tasks"]))
+
+
+@scenario.test
+async def test_list_workflows_action():
+    """
+    Test that the list-workflows action returns available workflows.
+    """
+    agent = MDANMasterAgent()
+
+    request = AgentRequest(action="list-workflows")
+
+    result = await agent.process(request)
+
+    expect(result).to_have_key("message")
+    expect(result).to_have_key("workflows")
+    expect(result).to_have_key("count")
+
+    expect(result["message"]).to_equal("Available Workflows")
+    expect(len(result["workflows"])).to_be_greater_than(0)
+    expect(result["count"]).to_equal(len(result["workflows"]))
+
+    # Check that workflows from different modules are present
+    workflow_ids = [w["id"] for w in result["workflows"]]
+    expect("workflow-1" in workflow_ids).to_be_true()
+    expect("workflow-4" in workflow_ids).to_be_true()  # FinTech workflow
+    expect("workflow-5" in workflow_ids).to_be_true()  # DevOps/Azure workflow
+    expect("workflow-6" in workflow_ids).to_be_true()  # DB Optimization workflow
+
+
+@scenario.test
+async def test_help_action():
+    """
+    Test that the help action returns help information.
+    """
+    agent = MDANMasterAgent()
+
+    request = AgentRequest(action="help")
+
+    result = await agent.process(request)
+
+    expect(result).to_have_key("message")
+    expect(result).to_have_key("agent")
+    expect(result).to_have_key("description")
+    expect(result).to_have_key("capabilities")
+    expect(result).to_have_key("usage")
+    expect(result).to_have_key("menu")
+
+    expect(result["message"]).to_equal("MDAN Master Help")
+    expect(result["agent"]).to_equal("MDAN Master")
+    expect(len(result["usage"])).to_be_greater_than(0)
+    expect(len(result["menu"])).to_equal(6)
+
+
+@scenario.test
+async def test_unknown_action():
+    """
+    Test that unknown actions return an appropriate error message.
+    """
+    agent = MDANMasterAgent()
+
+    request = AgentRequest(action="unknown-action")
+
+    result = await agent.process(request)
+
+    expect(result).to_have_key("message")
+    expect(result).to_have_key("action")
+    expect(result).to_have_key("suggestion")
+
+    expect(result["message"]).to_equal("Action not recognized")
+    expect(result["action"]).to_equal("unknown-action")
+    expect(result["suggestion"]).to_contain("/mmm-help")
+
+
+@scenario.test
+async def test_get_info():
+    """
+    Test that get_info returns complete agent information.
+    """
+    agent = MDANMasterAgent()
+
+    info = agent.get_info()
+
+    expect(info).to_have_key("name")
+    expect(info).to_have_key("title")
+    expect(info).to_have_key("icon")
+    expect(info).to_have_key("capabilities")
+    expect(info).to_have_key("role")
+    expect(info).to_have_key("identity")
+    expect(info).to_have_key("communication_style")
+    expect(info).to_have_key("principles")
+
+    expect(info["name"]).to_equal("MDAN Master")
+    expect(info["icon"]).to_equal("🧙")
+    expect(len(info["principles"])).to_equal(2)
+
+
+@scenario.test
+async def test_menu_structure():
+    """
+    Test that the menu has the correct structure and all required items.
+    """
+    agent = MDANMasterAgent()
+
+    request = AgentRequest(action="greet")
+    result = await agent.process(request)
+
+    menu = result["menu"]
+
+    # Check that all menu items are present
+    menu_descriptions = [item["description"] for item in menu]
+
+    expect("[MH] Redisplay Menu Help" in menu_descriptions).to_be_true()
+    expect("[CH] Chat with the Agent about anything" in menu_descriptions).to_be_true()
+    expect("[LT] List Available Tasks" in menu_descriptions).to_be_true()
+    expect("[LW] List Workflows" in menu_descriptions).to_be_true()
+    expect("[PM] Start Party Mode" in menu_descriptions).to_be_true()
+    expect("[DA] Dismiss Agent" in menu_descriptions).to_be_true()
+
+    # Check that each menu item has a trigger
+    for item in menu:
+        expect(item).to_have_key("trigger")
+        expect(item).to_have_key("description")
+
+
+@scenario.test
+async def test_help_hint_format():
+    """
+    Test that the help hint is properly formatted.
+    """
+    agent = MDANMasterAgent()
+
+    request = AgentRequest(action="greet")
+    result = await agent.process(request)
+
+    help_hint = result["help_hint"]
+
+    expect(help_hint).to_contain("/mmm-help")
+    expect(help_hint).to_contain("advice")
+    expect(help_hint).to_contain("combine")
+
+
+@scenario.test
+async def test_communication_language_support():
+    """
+    Test that different communication languages are supported.
+    """
+    agent = MDANMasterAgent()
+
+    # Test with Spanish
+    request = AgentRequest(
+        action="greet",
+        context={
+            "user_name": "Carlos",
+            "communication_language": "Spanish",
+            "output_folder": "/output",
+        },
+    )
+
+    result = await agent.process(request)
+
+    expect(result["language"]).to_equal("Spanish")
+    expect(result["message"]).to_contain("Carlos")
+
+    # Test with French
+    request = AgentRequest(
+        action="greet",
+        context={
+            "user_name": "Marie",
+            "communication_language": "French",
+            "output_folder": "/output",
+        },
+    )
+
+    result = await agent.process(request)
+
+    expect(result["language"]).to_equal("French")
+    expect(result["message"]).to_contain("Marie")