mdan-cli 2.5.1 → 2.5.2

package/tests/simple_cis_test.py

@@ -0,0 +1,285 @@
+"""
+Simple integration test for all cis module agents
+Tests that all agents 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__), ".."))
+
+
+def load_agent_from_path(agent_path, agent_class_name):
+    """Load an agent class from a file path using importlib"""
+    spec = importlib.util.spec_from_file_location("agent_module", agent_path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"Could not load spec from {agent_path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return getattr(module, agent_class_name)
+
+
+async def test_brainstorming_coach():
+    """Test Brainstorming Coach Agent"""
+    print("Testing Brainstorming Coach Agent (Carson)...")
+
+    try:
+        agent_path = os.path.join(
+            os.path.dirname(__file__), "../app/cis/agents/brainstorming-coach/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)
+
+        BrainstormingCoach = agent_module.BrainstormingCoach
+        BrainstormingCoachRequest = agent_module.BrainstormingCoachRequest
+
+        agent = BrainstormingCoach()
+
+        # Test basic processing
+        request = BrainstormingCoachRequest(topic="product innovation", participants=5)
+        result = await agent.process(request)
+
+        assert result is not None
+        assert isinstance(result, dict)
+        print("✓ Brainstorming Coach Agent works correctly")
+        return True
+    except Exception as e:
+        print(f"✗ Brainstorming Coach Agent failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+
+async def test_creative_problem_solver():
+    """Test Creative Problem Solver Agent"""
+    print("\nTesting Creative Problem Solver Agent (Dr. Quinn)...")
+
+    try:
+        agent_path = os.path.join(
+            os.path.dirname(__file__),
+            "../app/cis/agents/creative-problem-solver/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)
+
+        CreativeProblemSolver = agent_module.CreativeProblemSolver
+        CreativeProblemSolverRequest = agent_module.CreativeProblemSolverRequest
+
+        agent = CreativeProblemSolver()
+
+        # Test basic processing
+        request = CreativeProblemSolverRequest(
+            problem="declining user engagement", constraints=["budget", "timeline"]
+        )
+        result = await agent.process(request)
+
+        assert result is not None
+        assert isinstance(result, dict)
+        print("✓ Creative Problem Solver Agent works correctly")
+        return True
+    except Exception as e:
+        print(f"✗ Creative Problem Solver Agent failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+
+async def test_design_thinking_coach():
+    """Test Design Thinking Coach Agent"""
+    print("\nTesting Design Thinking Coach Agent (Maya)...")
+
+    try:
+        agent_path = os.path.join(
+            os.path.dirname(__file__),
+            "../app/cis/agents/design-thinking-coach/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)
+
+        DesignThinkingCoach = agent_module.DesignThinkingCoach
+        DesignThinkingCoachRequest = agent_module.DesignThinkingCoachRequest
+
+        agent = DesignThinkingCoach()
+
+        # Test basic processing
+        request = DesignThinkingCoachRequest(
+            challenge="improve mobile app UX", phase="empathize"
+        )
+        result = await agent.process(request)
+
+        assert result is not None
+        assert isinstance(result, dict)
+        print("✓ Design Thinking Coach Agent works correctly")
+        return True
+    except Exception as e:
+        print(f"✗ Design Thinking Coach Agent failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+
+async def test_innovation_strategist():
+    """Test Innovation Strategist Agent"""
+    print("\nTesting Innovation Strategist Agent (Victor)...")
+
+    try:
+        agent_path = os.path.join(
+            os.path.dirname(__file__),
+            "../app/cis/agents/innovation-strategist/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)
+
+        InnovationStrategist = agent_module.InnovationStrategist
+        InnovationStrategistRequest = agent_module.InnovationStrategistRequest
+
+        agent = InnovationStrategist()
+
+        # Test basic processing
+        request = InnovationStrategistRequest(
+            market_context="fintech", goals=["growth", "differentiation"]
+        )
+        result = await agent.process(request)
+
+        assert result is not None
+        assert isinstance(result, dict)
+        print("✓ Innovation Strategist Agent works correctly")
+        return True
+    except Exception as e:
+        print(f"✗ Innovation Strategist Agent failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+
+async def test_presentation_master():
+    """Test Presentation Master Agent"""
+    print("\nTesting Presentation Master Agent (Caravaggio)...")
+
+    try:
+        agent_path = os.path.join(
+            os.path.dirname(__file__), "../app/cis/agents/presentation-master/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)
+
+        PresentationMaster = agent_module.PresentationMaster
+        PresentationMasterRequest = agent_module.PresentationMasterRequest
+
+        agent = PresentationMaster()
+
+        # Test basic processing
+        request = PresentationMasterRequest(
+            presentation_type="slide-deck",
+            topic="quarterly results",
+            audience="stakeholders",
+            length=30,
+        )
+        result = await agent.process(request)
+
+        assert result is not None
+        assert isinstance(result, dict)
+        print("✓ Presentation Master Agent works correctly")
+        return True
+    except Exception as e:
+        print(f"✗ Presentation Master Agent failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+
+async def test_storyteller():
+    """Test Storyteller Agent"""
+    print("\nTesting Storyteller Agent (Sophia)...")
+
+    try:
+        agent_path = os.path.join(
+            os.path.dirname(__file__), "../app/cis/agents/storyteller/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)
+
+        Storyteller = agent_module.Storyteller
+        StorytellerRequest = agent_module.StorytellerRequest
+
+        agent = Storyteller()
+
+        # Test basic processing
+        request = StorytellerRequest(
+            story_purpose="brand", core_message="company transformation journey"
+        )
+        result = await agent.process(request)
+
+        assert result is not None
+        assert isinstance(result, dict)
+        print("✓ Storyteller Agent works correctly")
+        return True
+    except Exception as e:
+        print(f"✗ Storyteller Agent failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+
+async def run_all_tests():
+    """Run all cis module agent tests"""
+    print("=" * 60)
+    print("CIS Module - Integration Tests")
+    print("=" * 60)
+
+    tests = [
+        test_brainstorming_coach(),
+        test_creative_problem_solver(),
+        test_design_thinking_coach(),
+        test_innovation_strategist(),
+        test_presentation_master(),
+        test_storyteller(),
+    ]
+
+    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 CIS 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_db_optimization_test.py

@@ -0,0 +1,199 @@
+"""Simple test script for DB Optimization Pack agents."""
+
+import sys
+import os
+import asyncio
+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
+DBPerformanceAnalystAgent = load_agent(
+    os.path.join(
+        os.path.dirname(__file__),
+        "../app/packs/db-optimization/agents/db-performance-analyst/agent.py",
+    ),
+    "DBPerformanceAnalystAgent",
+)
+QueryOptimizerAgent = load_agent(
+    os.path.join(
+        os.path.dirname(__file__),
+        "../app/packs/db-optimization/agents/query-optimizer/agent.py",
+    ),
+    "QueryOptimizerAgent",
+)
+IndexingSpecialistAgent = load_agent(
+    os.path.join(
+        os.path.dirname(__file__),
+        "../app/packs/db-optimization/agents/indexing-specialist/agent.py",
+    ),
+    "IndexingSpecialistAgent",
+)
+
+
+async def test_db_performance_analyst():
+    """Test DB Performance Analyst agent."""
+    print("Testing DB Performance Analyst agent...")
+    agent = DBPerformanceAnalystAgent()
+
+    # Test get_info method
+    info = agent.get_info()
+    assert info is not None
+    assert "name" in info
+    assert info["name"] == "DB Performance Analyst"
+    assert "capabilities" in info
+    assert len(info["capabilities"]) > 0
+
+    # Test process method with a simple request
+    from dataclasses import dataclass
+
+    @dataclass
+    class DBPerformanceRequest:
+        action: str
+        db_type: str = None
+        performance_issue: str = None
+        metrics: dict = None
+        query_samples: list = None
+        schema_info: dict = None
+
+    request = DBPerformanceRequest(action="analyze", db_type="PostgreSQL")
+
+    result = await agent.process(request)
+    assert result is not None
+    assert len(result) > 0
+    print("✓ DB Performance Analyst agent test passed")
+    return True
+
+
+async def test_query_optimizer():
+    """Test Query Optimizer agent."""
+    print("Testing Query Optimizer agent...")
+    agent = QueryOptimizerAgent()
+
+    # Test get_info method
+    info = agent.get_info()
+    assert info is not None
+    assert "name" in info
+    assert info["name"] == "Query Optimizer"
+    assert "capabilities" in info
+    assert len(info["capabilities"]) > 0
+
+    # Test process method with a simple request
+    from dataclasses import dataclass
+
+    @dataclass
+    class QueryOptimizationRequest:
+        action: str
+        db_type: str = None
+        query: str = None
+        execution_plan: dict = None
+        schema_info: dict = None
+        performance_goal: str = None
+
+    request = QueryOptimizationRequest(action="analyze", db_type="PostgreSQL")
+
+    result = await agent.process(request)
+    assert result is not None
+    assert len(result) > 0
+    print("✓ Query Optimizer agent test passed")
+    return True
+
+
+async def test_indexing_specialist():
+    """Test Indexing Specialist agent."""
+    print("Testing Indexing Specialist agent...")
+    agent = IndexingSpecialistAgent()
+
+    # Test get_info method
+    info = agent.get_info()
+    assert info is not None
+    assert "name" in info
+    assert info["name"] == "Indexing Specialist"
+    assert "capabilities" in info
+    assert len(info["capabilities"]) > 0
+
+    # Test process method with a simple request
+    from dataclasses import dataclass
+
+    @dataclass
+    class IndexingRequest:
+        action: str
+        db_type: str = None
+        table_name: str = None
+        query_patterns: list = None
+        schema_info: dict = None
+        current_indexes: list = None
+        workload_type: str = None
+
+    request = IndexingRequest(action="design", db_type="PostgreSQL")
+
+    result = await agent.process(request)
+    assert result is not None
+    assert len(result) > 0
+    print("✓ Indexing Specialist agent test passed")
+    return True
+
+
+async def main():
+    """Run all tests."""
+    print("=" * 60)
+    print("DB Optimization Pack - Simple Agent Tests")
+    print("=" * 60)
+    print()
+
+    all_passed = True
+
+    try:
+        all_passed &= await test_db_performance_analyst()
+    except Exception as e:
+        print(f"✗ DB Performance Analyst agent test failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        all_passed = False
+
+    print()
+
+    try:
+        all_passed &= await test_query_optimizer()
+    except Exception as e:
+        print(f"✗ Query Optimizer agent test failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        all_passed = False
+
+    print()
+
+    try:
+        all_passed &= await test_indexing_specialist()
+    except Exception as e:
+        print(f"✗ Indexing Specialist agent test failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        all_passed = False
+
+    print()
+    print("=" * 60)
+    if all_passed:
+        print("All DB Optimization 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_devops_test.py

@@ -0,0 +1,193 @@
+"""Simple test script for DevOps/Azure Pack agents."""
+
+import sys
+import os
+import asyncio
+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
+DevOpsEngineerAgent = load_agent(
+    os.path.join(
+        os.path.dirname(__file__),
+        "../app/packs/devops-azure/agents/devops-engineer/agent.py",
+    ),
+    "DevOpsEngineerAgent",
+)
+AzureSpecialistAgent = load_agent(
+    os.path.join(
+        os.path.dirname(__file__),
+        "../app/packs/devops-azure/agents/azure-specialist/agent.py",
+    ),
+    "AzureSpecialistAgent",
+)
+CICDArchitectAgent = load_agent(
+    os.path.join(
+        os.path.dirname(__file__),
+        "../app/packs/devops-azure/agents/cicd-architect/agent.py",
+    ),
+    "CICDArchitectAgent",
+)
+
+
+async def test_devops_engineer():
+    """Test DevOps Engineer Agent."""
+    print("Testing DevOps Engineer Agent...")
+    agent = DevOpsEngineerAgent()
+
+    # Test get_info method
+    info = agent.get_info()
+    assert info is not None
+    assert "name" in info
+    assert info["name"] == "DevOps Engineer"
+    assert "capabilities" in info
+    assert len(info["capabilities"]) > 0
+
+    # Test process method with a simple request
+    from dataclasses import dataclass
+
+    @dataclass
+    class DevOpsRequest:
+        action: str
+        task: str = None
+        context: dict = None
+        tools: list = None
+
+    request = DevOpsRequest(action="explain", task="CI/CD pipeline")
+
+    result = await agent.process(request)
+    assert result is not None
+    assert len(result) > 0
+    print("✓ DevOps Engineer agent test passed")
+    return True
+
+
+async def test_azure_specialist():
+    """Test Azure Specialist Agent."""
+    print("Testing Azure Specialist Agent...")
+    agent = AzureSpecialistAgent()
+
+    # Test get_info method
+    info = agent.get_info()
+    assert info is not None
+    assert "name" in info
+    assert info["name"] == "Azure Specialist"
+    assert "capabilities" in info
+    assert len(info["capabilities"]) > 0
+
+    # Test process method with a simple request
+    from dataclasses import dataclass
+
+    @dataclass
+    class AzureRequest:
+        action: str
+        service: str = None
+        task: str = None
+        context: dict = None
+
+    request = AzureRequest(action="explain", service="Virtual Machines")
+
+    result = await agent.process(request)
+    assert result is not None
+    assert len(result) > 0
+    print("✓ Azure Specialist agent test passed")
+    return True
+
+
+async def test_cicd_architect():
+    """Test CI/CD Architect Agent."""
+    print("Testing CI/CD Architect Agent...")
+    agent = CICDArchitectAgent()
+
+    # Test get_info method
+    info = agent.get_info()
+    assert info is not None
+    assert "name" in info
+    assert info["name"] == "CI/CD Architect"
+    assert "capabilities" in info
+    assert len(info["capabilities"]) > 0
+
+    # Test process method with a simple request
+    from dataclasses import dataclass
+
+    @dataclass
+    class CICDRequest:
+        action: str
+        pipeline_type: str = None
+        deployment_strategy: str = None
+        tools: list = None
+        environment: str = None
+
+    request = CICDRequest(action="design", pipeline_type="application_deployment")
+
+    result = await agent.process(request)
+    assert result is not None
+    assert len(result) > 0
+    print("✓ CI/CD Architect agent test passed")
+    return True
+
+
+async def main():
+    """Run all tests."""
+    print("=" * 60)
+    print("DevOps/Azure Pack - Simple Agent Tests")
+    print("=" * 60)
+    print()
+
+    all_passed = True
+
+    try:
+        all_passed &= await test_devops_engineer()
+    except Exception as e:
+        print(f"✗ DevOps Engineer agent test failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        all_passed = False
+
+    print()
+
+    try:
+        all_passed &= await test_azure_specialist()
+    except Exception as e:
+        print(f"✗ Azure Specialist agent test failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        all_passed = False
+
+    print()
+
+    try:
+        all_passed &= await test_cicd_architect()
+    except Exception as e:
+        print(f"✗ CI/CD Architect agent test failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        all_passed = False
+
+    print()
+    print("=" * 60)
+    if all_passed:
+        print("All DevOps/Azure 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)