massgen 0.0.3__py3-none-any.whl

massgen/tests/test_message_context_building.py

@@ -0,0 +1,293 @@
+#!/usr/bin/env python3
+"""
+Test script to examine how conversation context is built for LLM input.
+Shows the exact message templates and context structure without making API calls.
+"""
+
+import sys
+from pathlib import Path
+from typing import Dict, List, Any
+
+# Add project root to path
+project_root = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from massgen.message_templates import MessageTemplates
+
+
+def print_message_structure(title: str, conversation: Dict[str, Any]):
+    """Print the structure of a conversation message in a readable format."""
+    print(f"\n{'='*80}")
+    print(f"🔍 {title}")
+    print(f"{'='*80}")
+
+    # System message
+    print("📋 SYSTEM MESSAGE:")
+    print("-" * 40)
+    system_msg = conversation["system_message"]
+    print(system_msg)
+
+    # User message
+    print(f"\n📨 USER MESSAGE:")
+    print("-" * 40)
+    user_msg = conversation["user_message"]
+    print(user_msg)
+
+    # Tools
+    print(f"\n🔧 TOOLS PROVIDED:")
+    print("-" * 40)
+    tools = conversation.get("tools", [])
+    for i, tool in enumerate(tools, 1):
+        tool_name = tool.get("function", {}).get("name", "unknown")
+        tool_desc = tool.get("function", {}).get("description", "No description")
+        print(f"{i}. {tool_name}: {tool_desc}")
+
+    print(f"\n📊 STATISTICS:")
+    print(f"   System message length: {len(system_msg)} chars")
+    print(f"   User message length: {len(user_msg)} chars")
+    print(f"   Tools provided: {len(tools)}")
+    print(f"   Total context size: {len(system_msg) + len(user_msg)} chars")
+
+
+def test_turn1_context():
+    """Test context building for the first turn (no history)."""
+    print("🔷 TURN 1 CONTEXT BUILDING")
+    print("Scenario: User asks initial question, no conversation history")
+
+    templates = MessageTemplates()
+
+    # Build conversation for first turn
+    conversation = templates.build_conversation_with_context(
+        current_task="What are the main benefits of renewable energy?",
+        conversation_history=[],  # No history on first turn
+        agent_summaries=None,  # No agent answers yet
+        valid_agent_ids=None,
+    )
+
+    print_message_structure("Turn 1: Initial Question", conversation)
+
+    # Verify structure
+    user_msg = conversation["user_message"]
+    has_history = "CONVERSATION_HISTORY" in user_msg
+    has_original = "ORIGINAL MESSAGE" in user_msg
+    has_answers = (
+        "CURRENT ANSWERS" in user_msg and "no answers available yet" in user_msg
+    )
+
+    print(f"\n✅ VALIDATION:")
+    print(f"   Contains conversation history section: {has_history}")
+    print(f"   Contains original message section: {has_original}")
+    print(f"   Contains empty answers section: {has_answers}")
+    print(
+        f"   System message mentions context: {'conversation' in conversation['system_message'].lower()}"
+    )
+
+
+def test_turn2_context():
+    """Test context building for the second turn (with history)."""
+    print(f"\n🔷 TURN 2 CONTEXT BUILDING")
+    print("Scenario: User asks follow-up, with previous exchange in history")
+
+    templates = MessageTemplates()
+
+    # Simulate conversation history from Turn 1
+    conversation_history = [
+        {"role": "user", "content": "What are the main benefits of renewable energy?"},
+        {
+            "role": "assistant",
+            "content": "Renewable energy offers several key benefits including environmental sustainability, economic advantages, and energy security. It reduces greenhouse gas emissions, creates jobs, and decreases dependence on fossil fuel imports.",
+        },
+    ]
+
+    # Build conversation for second turn with history
+    conversation = templates.build_conversation_with_context(
+        current_task="What about the challenges and limitations?",
+        conversation_history=conversation_history,
+        agent_summaries={
+            "researcher": "Key benefits include environmental and economic advantages."
+        },
+        valid_agent_ids=["researcher"],
+    )
+
+    print_message_structure("Turn 2: Follow-up with History", conversation)
+
+    # Verify structure
+    user_msg = conversation["user_message"]
+    has_history = (
+        "CONVERSATION_HISTORY" in user_msg
+        and "User: What are the main benefits" in user_msg
+    )
+    has_original = (
+        "ORIGINAL MESSAGE" in user_msg and "challenges and limitations" in user_msg
+    )
+    has_answers = "CURRENT ANSWERS" in user_msg and "researcher" in user_msg
+
+    print(f"\n✅ VALIDATION:")
+    print(f"   Contains conversation history: {has_history}")
+    print(f"   Contains current question: {has_original}")
+    print(f"   Contains agent answers: {has_answers}")
+    print(
+        f"   System message is context-aware: {'conversation' in conversation['system_message'].lower()}"
+    )
+
+
+def test_turn3_context():
+    """Test context building for the third turn (extended history)."""
+    print(f"\n🔷 TURN 3 CONTEXT BUILDING")
+    print("Scenario: User asks third question, with extended conversation history")
+
+    templates = MessageTemplates()
+
+    # Simulate extended conversation history
+    conversation_history = [
+        {"role": "user", "content": "What are the main benefits of renewable energy?"},
+        {
+            "role": "assistant",
+            "content": "Renewable energy offers environmental, economic, and energy security benefits.",
+        },
+        {"role": "user", "content": "What about the challenges and limitations?"},
+        {
+            "role": "assistant",
+            "content": "Main challenges include high upfront costs, intermittency issues, and infrastructure requirements.",
+        },
+    ]
+
+    # Build conversation for third turn with extended history
+    conversation = templates.build_conversation_with_context(
+        current_task="How can governments support the transition?",
+        conversation_history=conversation_history,
+        agent_summaries={
+            "researcher": "Benefits include environmental and economic advantages.",
+            "analyst": "Challenges include costs, intermittency, and infrastructure needs.",
+        },
+        valid_agent_ids=["researcher", "analyst"],
+    )
+
+    print_message_structure("Turn 3: Extended Conversation", conversation)
+
+    # Verify structure
+    user_msg = conversation["user_message"]
+    has_full_history = (
+        "CONVERSATION_HISTORY" in user_msg and user_msg.count("User:") >= 2
+    )
+    has_original = "ORIGINAL MESSAGE" in user_msg and "governments support" in user_msg
+    has_multiple_answers = (
+        "CURRENT ANSWERS" in user_msg
+        and "researcher" in user_msg
+        and "analyst" in user_msg
+    )
+
+    print(f"\n✅ VALIDATION:")
+    print(f"   Contains full conversation history: {has_full_history}")
+    print(f"   Contains current question: {has_original}")
+    print(f"   Contains multiple agent answers: {has_multiple_answers}")
+    print(f"   History shows progression: {user_msg.count('User:') >= 2}")
+
+
+def test_context_comparison():
+    """Compare context building across different turns."""
+    print(f"\n🔍 CONTEXT COMPARISON ACROSS TURNS")
+    print("=" * 80)
+
+    templates = MessageTemplates()
+
+    # Turn 1: No history
+    conv1 = templates.build_conversation_with_context(
+        current_task="What is solar energy?",
+        conversation_history=[],
+        agent_summaries=None,
+    )
+
+    # Turn 2: With history
+    history = [
+        {"role": "user", "content": "What is solar energy?"},
+        {
+            "role": "assistant",
+            "content": "Solar energy is power derived from sunlight.",
+        },
+    ]
+    conv2 = templates.build_conversation_with_context(
+        current_task="How efficient is it?",
+        conversation_history=history,
+        agent_summaries={
+            "expert": "Solar energy harnesses sunlight for power generation."
+        },
+    )
+
+    # Turn 3: Extended history
+    extended_history = [
+        {"role": "user", "content": "What is solar energy?"},
+        {
+            "role": "assistant",
+            "content": "Solar energy is power derived from sunlight.",
+        },
+        {"role": "user", "content": "How efficient is it?"},
+        {
+            "role": "assistant",
+            "content": "Modern solar panels achieve 15-22% efficiency.",
+        },
+    ]
+    conv3 = templates.build_conversation_with_context(
+        current_task="What are the costs?",
+        conversation_history=extended_history,
+        agent_summaries={
+            "expert": "Solar energy harnesses sunlight for power generation.",
+            "engineer": "Modern panels achieve 15-22% efficiency.",
+        },
+    )
+
+    print("📊 CONTEXT SIZE PROGRESSION:")
+    print(f"   Turn 1 (no history):     {len(conv1['user_message']):,} chars")
+    print(f"   Turn 2 (with history):   {len(conv2['user_message']):,} chars")
+    print(f"   Turn 3 (extended):       {len(conv3['user_message']):,} chars")
+
+    print(f"\n📈 CONTEXT ELEMENTS:")
+    elements = ["CONVERSATION_HISTORY", "ORIGINAL MESSAGE", "CURRENT ANSWERS"]
+
+    for i, (conv, turn) in enumerate(
+        [(conv1, "Turn 1"), (conv2, "Turn 2"), (conv3, "Turn 3")], 1
+    ):
+        user_msg = conv["user_message"]
+        print(f"\n   {turn}:")
+        for element in elements:
+            present = element in user_msg
+            print(f"     {element}: {'✅' if present else '❌'}")
+
+        # Count conversation exchanges
+        if "CONVERSATION_HISTORY" in user_msg:
+            exchange_count = user_msg.count("User:")
+            print(f"     Previous exchanges: {exchange_count}")
+
+
+def main():
+    """Run all context building tests."""
+    print("🚀 MassGen - Message Context Building Analysis")
+    print("=" * 80)
+    print("This test examines how conversation context is structured")
+    print("for LLM input across multiple conversation turns.")
+    print()
+
+    try:
+        # Test each turn's context building
+        test_turn1_context()
+        test_turn2_context()
+        test_turn3_context()
+        test_context_comparison()
+
+        print(f"\n🎉 ALL CONTEXT BUILDING TESTS COMPLETED")
+        print("=" * 80)
+        print("✅ Message templates properly build conversation context")
+        print("✅ Context grows appropriately with conversation history")
+        print("✅ All required sections are included in each turn")
+        print("🔍 Review the detailed context structures above to understand")
+        print("   exactly what information is provided to agents at each turn.")
+
+    except Exception as e:
+        print(f"❌ Context building test failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    main()

massgen/tests/test_rich_terminal_display.py

@@ -0,0 +1,378 @@
+#!/usr/bin/env python3
+"""
+Test script for MassGen Rich Terminal Display.
+Tests RichTerminalDisplay functionality with two-agent coordination.
+"""
+
+import asyncio
+import os
+import sys
+from pathlib import Path
+
+# Add project root to path
+project_root = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from massgen.backend.response import ResponseBackend
+from massgen.chat_agent import SingleAgent
+from massgen.orchestrator import Orchestrator
+from massgen.frontend.coordination_ui import CoordinationUI, coordinate_with_rich_ui
+from massgen.frontend.displays.rich_terminal_display import is_rich_available
+
+
+async def test_rich_availability():
+    """Test Rich library availability and display info."""
+    print("🎨 Rich Library Availability Test")
+    print("-" * 40)
+
+    if is_rich_available():
+        print("✅ Rich library is available")
+        try:
+            from rich import __version__
+
+            print(f"📦 Rich version: {__version__}")
+        except ImportError:
+            print("📦 Rich version: Unknown")
+        return True
+    else:
+        print("❌ Rich library is not available")
+        print("💡 Install with: pip install rich")
+        return False
+
+
+async def test_rich_display_basic():
+    """Test basic RichTerminalDisplay creation and configuration."""
+    print("\n🖥️  Rich Display Basic Test")
+    print("-" * 40)
+
+    if not is_rich_available():
+        print("⚠️  Skipping - Rich library not available")
+        return False
+
+    try:
+        from massgen.frontend.displays.rich_terminal_display import RichTerminalDisplay
+
+        # Test basic creation
+        agent_ids = ["agent1", "agent2"]
+        display = RichTerminalDisplay(agent_ids)
+
+        print("✅ RichTerminalDisplay created successfully")
+        print(f"📋 Agent IDs: {display.agent_ids}")
+        print(f"🎨 Theme: {display.theme}")
+        print(f"🔄 Refresh rate: {display.refresh_rate} Hz")
+
+        # Test theme configuration
+        themes = ["dark", "light", "cyberpunk"]
+        for theme in themes:
+            themed_display = RichTerminalDisplay(agent_ids, theme=theme)
+            print(f"✅ {theme.title()} theme created successfully")
+
+        # Clean up
+        display.cleanup()
+
+        return True
+
+    except Exception as e:
+        print(f"❌ Rich display basic test failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+
+async def test_rich_display_coordination():
+    """Test RichTerminalDisplay with actual agent coordination."""
+    print("\n🤖 Rich Display Coordination Test")
+    print("-" * 40)
+
+    if not is_rich_available():
+        print("⚠️  Skipping - Rich library not available")
+        return False
+
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        print("❌ OPENAI_API_KEY not found - skipping coordination test")
+        return False
+
+    try:
+        # Create backend
+        backend = ResponseBackend(api_key=api_key)
+
+        # Create two agents for rich display testing
+        creative_agent = SingleAgent(
+            backend=backend,
+            agent_id="creative",
+            system_message="You are a creative writer who crafts engaging and imaginative responses. Focus on storytelling and creative expression.",
+        )
+
+        technical_agent = SingleAgent(
+            backend=backend,
+            agent_id="technical",
+            system_message="You are a technical expert who provides precise and detailed technical information. Focus on accuracy and technical depth.",
+        )
+
+        # Create orchestrator
+        agents = {"creative": creative_agent, "technical": technical_agent}
+
+        orchestrator = Orchestrator(agents=agents)
+
+        # Test with Rich UI using cyberpunk theme
+        print("🎨 Testing with cyberpunk theme...")
+        ui = CoordinationUI(
+            display_type="rich_terminal",
+            theme="cyberpunk",
+            refresh_rate=4,
+            enable_syntax_highlighting=True,
+            max_content_lines=12,
+            logging_enabled=True,
+        )
+
+        print("👥 Created two-agent system with Rich display:")
+        print("   ✨ Creative - Storytelling and imagination")
+        print("   🔧 Technical - Precision and technical depth")
+        print()
+
+        # Test question for rich display
+        test_question = "Explain how artificial intelligence works, making it both technically accurate and engaging for a general audience."
+
+        print(f"📝 Question: {test_question}")
+        print("\n🎭 Starting Rich UI coordination...")
+        print("=" * 60)
+
+        # Coordinate with Rich UI
+        final_response = await ui.coordinate(orchestrator, test_question)
+
+        print("\n" + "=" * 60)
+        print("✅ Rich display coordination completed!")
+        print(f"📄 Final response length: {len(final_response)} characters")
+
+        return True
+
+    except Exception as e:
+        print(f"❌ Rich display coordination test failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+
+async def test_rich_convenience_function():
+    """Test the coordinate_with_rich_ui convenience function."""
+    print("\n🚀 Rich UI Convenience Function Test")
+    print("-" * 40)
+
+    if not is_rich_available():
+        print("⚠️  Skipping - Rich library not available")
+        return False
+
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        print("❌ OPENAI_API_KEY not found - skipping convenience function test")
+        return False
+
+    try:
+        # Create backend and agents
+        backend = ResponseBackend(api_key=api_key)
+
+        analyst = SingleAgent(
+            backend=backend,
+            agent_id="analyst",
+            system_message="You are a data analyst who provides clear analytical insights and interpretations.",
+        )
+
+        strategist = SingleAgent(
+            backend=backend,
+            agent_id="strategist",
+            system_message="You are a strategic thinker who focuses on long-term implications and strategic recommendations.",
+        )
+
+        orchestrator = Orchestrator(
+            agents={"analyst": analyst, "strategist": strategist}
+        )
+
+        print("🎯 Testing convenience function with light theme...")
+
+        # Use convenience function with light theme
+        test_question = "What are the key trends in renewable energy adoption?"
+
+        print(f"📝 Question: {test_question}")
+        print("\n🎭 Using coordinate_with_rich_ui()...")
+        print("=" * 60)
+
+        final_response = await coordinate_with_rich_ui(
+            orchestrator,
+            test_question,
+            theme="light",
+            refresh_rate=6,
+            enable_syntax_highlighting=True,
+        )
+
+        print("\n" + "=" * 60)
+        print("✅ Convenience function test completed!")
+        print(f"📄 Final response length: {len(final_response)} characters")
+
+        return True
+
+    except Exception as e:
+        print(f"❌ Convenience function test failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+
+async def test_rich_fallback():
+    """Test fallback behavior when Rich is not available."""
+    print("\n🔄 Rich Fallback Test")
+    print("-" * 40)
+
+    # This test simulates Rich not being available
+    # We can't actually uninstall Rich during runtime, so we test the UI logic
+
+    try:
+        # Test UI creation with rich_terminal when Rich is available
+        ui = CoordinationUI(display_type="rich_terminal")
+
+        if is_rich_available():
+            print("✅ Rich is available - RichTerminalDisplay should be used")
+            from massgen.frontend.displays.rich_terminal_display import (
+                RichTerminalDisplay,
+            )
+
+            # Note: We can't easily test the actual fallback without mocking
+            print("📝 Note: Fallback logic tested through UI creation")
+        else:
+            print("✅ Rich not available - fallback to TerminalDisplay should occur")
+
+        return True
+
+    except Exception as e:
+        print(f"❌ Fallback test failed: {e}")
+        return False
+
+
+async def test_rich_themes():
+    """Test different Rich themes and configurations."""
+    print("\n🎨 Rich Themes Test")
+    print("-" * 40)
+
+    if not is_rich_available():
+        print("⚠️  Skipping - Rich library not available")
+        return False
+
+    try:
+        from massgen.frontend.displays.rich_terminal_display import RichTerminalDisplay
+
+        agent_ids = ["agent1", "agent2"]
+        themes_to_test = [
+            ("dark", "Default dark theme"),
+            ("light", "Light theme for bright environments"),
+            ("cyberpunk", "Cyberpunk theme with vibrant colors"),
+        ]
+
+        for theme, description in themes_to_test:
+            print(f"🎨 Testing {theme} theme: {description}")
+
+            display = RichTerminalDisplay(
+                agent_ids,
+                theme=theme,
+                refresh_rate=8,
+                enable_syntax_highlighting=True,
+                max_content_lines=20,
+                show_timestamps=True,
+            )
+
+            # Test theme-specific color configuration
+            colors = display.colors
+            print(f"   - Primary color: {colors['primary']}")
+            print(f"   - Success color: {colors['success']}")
+            print(f"   - Border style: {colors['border']}")
+
+            display.cleanup()
+            print(f"✅ {theme.title()} theme test passed")
+
+        return True
+
+    except Exception as e:
+        print(f"❌ Themes test failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+
+async def main():
+    """Run Rich Terminal Display test suite."""
+    print("🎨 MassGen - Rich Terminal Display Test Suite")
+    print("=" * 60)
+
+    results = []
+
+    # Test Rich availability
+    results.append(await test_rich_availability())
+
+    # Only run Rich-specific tests if Rich is available
+    if results[0]:
+        # Test basic Rich display functionality
+        results.append(await test_rich_display_basic())
+
+        # Test themes
+        results.append(await test_rich_themes())
+
+        # Test with actual coordination if API key is available
+        if os.getenv("OPENAI_API_KEY"):
+            results.append(await test_rich_display_coordination())
+            results.append(await test_rich_convenience_function())
+        else:
+            print("\n⚠️  Skipping coordination tests - OPENAI_API_KEY not found")
+            results.extend([True, True])  # Skip but don't fail
+    else:
+        print("\n⚠️  Skipping Rich-specific tests - Rich library not available")
+        results.extend([False, False, False, False])
+
+    # Test fallback behavior
+    results.append(await test_rich_fallback())
+
+    # Summary
+    print("\n" + "=" * 60)
+    print("📊 Rich Terminal Display Test Results:")
+
+    test_names = [
+        "Rich Availability",
+        "Basic Display",
+        "Theme Configuration",
+        "Coordination Test",
+        "Convenience Function",
+        "Fallback Behavior",
+    ]
+
+    for i, (test_name, result) in enumerate(zip(test_names, results)):
+        status = "✅ PASS" if result else "❌ FAIL"
+        print(f"   {status} {test_name}")
+
+    passed = sum(results)
+    total = len(results)
+
+    print(f"\n📈 Summary: {passed}/{total} tests passed")
+
+    if all(results):
+        print("🎉 All Rich Terminal Display tests passed!")
+        if is_rich_available():
+            print("✅ Rich Terminal Display is working correctly")
+        else:
+            print("✅ Fallback behavior is working correctly")
+    else:
+        if not is_rich_available():
+            print("💡 Install Rich library with: pip install rich")
+        print("⚠️  Some tests failed - check installation and configuration")
+
+    print("\n🚀 Rich Terminal Display provides enhanced visualization with:")
+    print("   🎨 Beautiful themes and colors")
+    print("   📊 Live updating layouts")
+    print("   💻 Syntax highlighting")
+    print("   🔄 Smooth refresh animations")
+    print("   📱 Responsive design")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())