mdan-method 2.6.3

package/test/unit-test-schema.js

@@ -0,0 +1,133 @@
+/**
+ * Unit Tests for Agent Schema Edge Cases
+ *
+ * Tests internal functions to achieve 100% branch coverage
+ */
+
+const { validateAgentFile } = require('../tools/schema/agent.js');
+
+console.log('Running edge case unit tests...\n');
+
+let passed = 0;
+let failed = 0;
+
+// Test 1: Path with malformed module structure (no slash after module name)
+// This tests line 213: slashIndex === -1
+console.log('Test 1: Malformed module path (no slash after module name)');
+try {
+  const result = validateAgentFile('src/bmm', {
+    agent: {
+      metadata: {
+        id: 'test',
+        name: 'Test',
+        title: 'Test',
+        icon: '🧪',
+      },
+      persona: {
+        role: 'Test',
+        identity: 'Test',
+        communication_style: 'Test',
+        principles: ['Test'],
+      },
+      menu: [{ trigger: 'help', description: 'Help', action: 'help' }],
+    },
+  });
+
+  if (result.success) {
+    console.log('✗ Should have failed - missing module field');
+    failed++;
+  } else {
+    console.log('✓ Correctly handled malformed path (treated as core agent)');
+    passed++;
+  }
+} catch (error) {
+  console.log('✗ Unexpected error:', error.message);
+  failed++;
+}
+console.log('');
+
+// Test 2: Module option with empty string
+// This tests line 222: trimmed.length > 0
+console.log('Test 2: Module agent with empty string in module field');
+try {
+  const result = validateAgentFile('src/bmm/agents/test.agent.yaml', {
+    agent: {
+      metadata: {
+        id: 'test',
+        name: 'Test',
+        title: 'Test',
+        icon: '🧪',
+        module: '   ', // Empty after trimming
+      },
+      persona: {
+        role: 'Test',
+        identity: 'Test',
+        communication_style: 'Test',
+        principles: ['Test'],
+      },
+      menu: [{ trigger: 'help', description: 'Help', action: 'help' }],
+    },
+  });
+
+  if (result.success) {
+    console.log('✗ Should have failed - empty module string');
+    failed++;
+  } else {
+    console.log('✓ Correctly rejected empty module string');
+    passed++;
+  }
+} catch (error) {
+  console.log('✗ Unexpected error:', error.message);
+  failed++;
+}
+console.log('');
+
+// Test 3: Core agent path (src/core/agents/...) - tests the !filePath.startsWith(marker) branch
+console.log('Test 3: Core agent path returns null for module');
+try {
+  const result = validateAgentFile('src/core/agents/test.agent.yaml', {
+    agent: {
+      metadata: {
+        id: 'test',
+        name: 'Test',
+        title: 'Test',
+        icon: '🧪',
+        // No module field - correct for core agent
+      },
+      persona: {
+        role: 'Test',
+        identity: 'Test',
+        communication_style: 'Test',
+        principles: ['Test'],
+      },
+      menu: [{ trigger: 'help', description: 'Help', action: 'help' }],
+    },
+  });
+
+  if (result.success) {
+    console.log('✓ Core agent validated correctly (no module required)');
+    passed++;
+  } else {
+    console.log('✗ Core agent should pass without module field');
+    failed++;
+  }
+} catch (error) {
+  console.log('✗ Unexpected error:', error.message);
+  failed++;
+}
+console.log('');
+
+// Summary
+console.log('═══════════════════════════════════════');
+console.log('Edge Case Unit Test Results:');
+console.log(`  Passed: ${passed}`);
+console.log(`  Failed: ${failed}`);
+console.log('═══════════════════════════════════════\n');
+
+if (failed === 0) {
+  console.log('✨ All edge case tests passed!\n');
+  process.exit(0);
+} else {
+  console.log('❌ Some edge case tests failed\n');
+  process.exit(1);
+}

package/tests/run_all_tests.py

@@ -0,0 +1,80 @@
+"""
+Comprehensive Test Runner for MDAN
+
+This script runs all integration tests to verify all agents are working correctly.
+"""
+
+import sys
+import os
+import subprocess
+
+
+def run_test(test_file, description):
+    """Run a test file and return the result."""
+    print(f"\n{'=' * 60}")
+    print(f"Running: {description}")
+    print(f"{'=' * 60}\n")
+
+    result = subprocess.run([sys.executable, test_file], capture_output=True, text=True)
+
+    if result.returncode == 0:
+        print(f"✓ {description} - PASSED")
+        return True
+    else:
+        print(f"✗ {description} - FAILED")
+        print("STDOUT:", result.stdout)
+        print("STDERR:", result.stderr)
+        return False
+
+
+def main():
+    """Run all integration tests."""
+    print("\n" + "=" * 60)
+    print("MDAN - Comprehensive Integration Test Suite")
+    print("=" * 60 + "\n")
+
+    tests = [
+        ("tests/simple_test.py", "Core (MDAN Master)"),
+        ("tests/simple_fintech_test.py", "FinTech Pack"),
+        ("tests/simple_devops_test.py", "DevOps/Azure Pack"),
+        ("tests/simple_mmb_test.py", "MMB Module"),
+        ("tests/simple_cis_test.py", "CIS Module"),
+        ("tests/simple_tea_test.py", "TEA Module"),
+        ("tests/simple_ux_designer_test.py", "UX Designer (MMM)"),
+    ]
+
+    results = []
+    for test_file, description in tests:
+        if os.path.exists(test_file):
+            result = run_test(test_file, description)
+            results.append((description, result))
+        else:
+            print(f"⚠ {description} - Test file not found: {test_file}")
+            results.append((description, False))
+
+    # Print summary
+    print("\n" + "=" * 60)
+    print("Test Summary")
+    print("=" * 60 + "\n")
+
+    passed = sum(1 for _, result in results if result)
+    total = len(results)
+
+    for description, result in results:
+        status = "✓ PASSED" if result else "✗ FAILED"
+        print(f"{status}: {description}")
+
+    print("\n" + "=" * 60)
+    print(f"Results: {passed}/{total} tests passed")
+    print("=" * 60 + "\n")
+
+    if passed == total:
+        print("🎉 All integration tests passed!")
+        return 0
+    else:
+        print(f"⚠ {total - passed} test(s) failed")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/tests/scenarios/cis/brainstorming-coach.test.py

@@ -0,0 +1,150 @@
+"""
+Scenario tests for Brainstorming Coach agent
+"""
+
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../../.."))
+
+from app.cis.agents.brainstorming_coach import (
+    BrainstormingCoach,
+    BrainstormingCoachRequest,
+)
+
+
+async def test_brainstorming_basic():
+    """Test basic brainstorming session."""
+    agent = BrainstormingCoach()
+    request = BrainstormingCoachRequest(
+        topic="New product ideas for a coffee shop", session_type="standard"
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["agent"] == "Carson"
+    assert result["topic"] == "New product ideas for a coffee shop"
+    assert "session_plan" in result
+    assert "techniques" in result
+    assert len(result["techniques"]) > 0
+    print("✓ test_brainstorming_basic passed")
+
+
+async def test_brainstorming_party_mode():
+    """Test brainstorming with party mode."""
+    agent = BrainstormingCoach()
+    request = BrainstormingCoachRequest(
+        topic="Team building activities", session_type="party-mode", participants=10
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["session_type"] == "party-mode"
+    assert result["participants"] == 10
+    # Check that party mode warm-up is included
+    assert any("Party Mode" in t["name"] for t in result["techniques"])
+    print("✓ test_brainstorming_party_mode passed")
+
+
+async def test_brainstorming_with_constraints():
+    """Test brainstorming with constraints."""
+    agent = BrainstormingCoach()
+    request = BrainstormingCoachRequest(
+        topic="Marketing campaign ideas",
+        session_type="standard",
+        constraints="Budget under $5000, 2-week timeline",
+        goals="Increase brand awareness",
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["constraints"] == "Budget under $5000, 2-week timeline"
+    assert result["goals"] == "Increase brand awareness"
+    print("✓ test_brainstorming_with_constraints passed")
+
+
+async def test_brainstorming_session_plan():
+    """Test that session plan is generated correctly."""
+    agent = BrainstormingCoach()
+    request = BrainstormingCoachRequest(topic="App feature ideas")
+    result = await agent.process(request)
+    assert result["success"] == True
+    session_plan = result["session_plan"]
+    assert "warm_up" in session_plan
+    assert "ideation_phase" in session_plan
+    assert "expansion_phase" in session_plan
+    assert "convergence_phase" in session_plan
+    assert "action_planning" in session_plan
+    print("✓ test_brainstorming_session_plan passed")
+
+
+async def test_brainstorming_techniques():
+    """Test that brainstorming techniques are provided."""
+    agent = BrainstormingCoach()
+    request = BrainstormingCoachRequest(topic="Innovation ideas")
+    result = await agent.process(request)
+    assert result["success"] == True
+    techniques = result["techniques"]
+    assert len(techniques) >= 5
+    # Check for known techniques
+    technique_names = [t["name"] for t in techniques]
+    assert "Classic Brainstorming" in technique_names
+    assert "Mind Mapping" in technique_names
+    print("✓ test_brainstorming_techniques passed")
+
+
+async def test_brainstorming_facilitation_guide():
+    """Test that facilitation guide is provided."""
+    agent = BrainstormingCoach()
+    request = BrainstormingCoachRequest(topic="Team improvement ideas")
+    result = await agent.process(request)
+    assert result["success"] == True
+    guide = result["facilitation_guide"]
+    assert "opening" in guide
+    assert "ground_rules" in guide
+    assert "prompts" in guide
+    assert "closing" in guide
+    assert len(guide["ground_rules"]) > 0
+    assert len(guide["prompts"]) > 0
+    print("✓ test_brainstorming_facilitation_guide passed")
+
+
+async def test_brainstorming_principles():
+    """Test that brainstorming principles are included."""
+    agent = BrainstormingCoach()
+    request = BrainstormingCoachRequest(topic="Creative ideas")
+    result = await agent.process(request)
+    assert result["success"] == True
+    principles = result["principles"]
+    assert len(principles) > 0
+    assert "Psychological safety unlocks breakthroughs" in principles
+    print("✓ test_brainstorming_principles passed")
+
+
+async def test_brainstorming_missing_topic():
+    """Test brainstorming with missing topic."""
+    agent = BrainstormingCoach()
+    request = BrainstormingCoachRequest(topic="")
+    result = await agent.process(request)
+    assert result["success"] == False
+    assert "error" in result
+    print("✓ test_brainstorming_missing_topic passed")
+
+
+async def main():
+    """Run all tests."""
+    print("Running Brainstorming Coach agent tests...\n")
+
+    await test_brainstorming_basic()
+    await test_brainstorming_party_mode()
+    await test_brainstorming_with_constraints()
+    await test_brainstorming_session_plan()
+    await test_brainstorming_techniques()
+    await test_brainstorming_facilitation_guide()
+    await test_brainstorming_principles()
+    await test_brainstorming_missing_topic()
+
+    print("\n✅ All Brainstorming Coach tests passed!")
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(main())

package/tests/scenarios/cis/creative-problem-solver.test.py

@@ -0,0 +1,167 @@
+"""
+Scenario tests for Creative Problem Solver agent
+"""
+
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../../.."))
+
+from app.cis.agents.creative_problem_solver import (
+    CreativeProblemSolver,
+    CreativeProblemSolverRequest,
+)
+
+
+async def test_problem_solving_basic():
+    """Test basic problem solving."""
+    agent = CreativeProblemSolver()
+    request = CreativeProblemSolverRequest(
+        problem="Customer retention is declining", methodology="systematic"
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["agent"] == "Dr. Quinn"
+    assert result["problem"] == "Customer retention is declining"
+    assert "problem_analysis" in result
+    assert "methodology_results" in result
+    assert "solutions" in result
+    print("✓ test_problem_solving_basic passed")
+
+
+async def test_problem_solving_triz():
+    """Test problem solving with TRIZ methodology."""
+    agent = CreativeProblemSolver()
+    request = CreativeProblemSolverRequest(
+        problem="Product is too expensive to manufacture", methodology="triz"
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["methodology"] == "triz"
+    methodology = result["methodology_results"]
+    assert methodology["methodology"] == "TRIZ (Theory of Inventive Problem Solving)"
+    assert "principles" in methodology
+    print("✓ test_problem_solving_triz passed")
+
+
+async def test_problem_solving_toc():
+    """Test problem solving with Theory of Constraints."""
+    agent = CreativeProblemSolver()
+    request = CreativeProblemSolverRequest(
+        problem="Production bottleneck", methodology="toc"
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["methodology"] == "toc"
+    methodology = result["methodology_results"]
+    assert methodology["methodology"] == "Theory of Constraints"
+    assert "five_focusing_steps" in methodology
+    print("✓ test_problem_solving_toc passed")
+
+
+async def test_problem_solving_systems_thinking():
+    """Test problem solving with Systems Thinking."""
+    agent = CreativeProblemSolver()
+    request = CreativeProblemSolverRequest(
+        problem="Organizational communication issues", methodology="systems-thinking"
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["methodology"] == "systems-thinking"
+    methodology = result["methodology_results"]
+    assert methodology["methodology"] == "Systems Thinking"
+    assert "key_concepts" in methodology
+    print("✓ test_problem_solving_systems_thinking passed")
+
+
+async def test_problem_solving_with_context():
+    """Test problem solving with context."""
+    agent = CreativeProblemSolver()
+    request = CreativeProblemSolverRequest(
+        problem="Low user engagement",
+        context="Mobile app for fitness tracking",
+        constraints="Limited development resources",
+        methodology="systematic",
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["context"] == "Mobile app for fitness tracking"
+    assert result["constraints"] == "Limited development resources"
+    print("✓ test_problem_solving_with_context passed")
+
+
+async def test_problem_solving_solutions():
+    """Test that solutions are generated."""
+    agent = CreativeProblemSolver()
+    request = CreativeProblemSolverRequest(problem="High customer churn rate")
+    result = await agent.process(request)
+    assert result["success"] == True
+    solutions = result["solutions"]
+    assert len(solutions) > 0
+    # Check solution structure
+    for solution in solutions:
+        assert "solution" in solution
+        assert "description" in solution
+        assert "feasibility" in solution
+        assert "impact" in solution
+        assert "effort" in solution
+    print("✓ test_problem_solving_solutions passed")
+
+
+async def test_problem_solving_action_plan():
+    """Test that action plan is created."""
+    agent = CreativeProblemSolver()
+    request = CreativeProblemSolverRequest(problem="Inefficient workflow")
+    result = await agent.process(request)
+    assert result["success"] == True
+    action_plan = result["action_plan"]
+    assert "prioritization" in action_plan
+    assert "implementation_steps" in action_plan
+    assert "risk_mitigation" in action_plan
+    assert "success_metrics" in action_plan
+    print("✓ test_problem_solving_action_plan passed")
+
+
+async def test_problem_solving_principles():
+    """Test that problem-solving principles are included."""
+    agent = CreativeProblemSolver()
+    request = CreativeProblemSolverRequest(problem="Quality issues")
+    result = await agent.process(request)
+    assert result["success"] == True
+    principles = result["principles"]
+    assert len(principles) > 0
+    assert "Every problem is a system revealing weaknesses" in principles
+    print("✓ test_problem_solving_principles passed")
+
+
+async def test_problem_solving_missing_problem():
+    """Test problem solving with missing problem."""
+    agent = CreativeProblemSolver()
+    request = CreativeProblemSolverRequest(problem="")
+    result = await agent.process(request)
+    assert result["success"] == False
+    assert "error" in result
+    print("✓ test_problem_solving_missing_problem passed")
+
+
+async def main():
+    """Run all tests."""
+    print("Running Creative Problem Solver agent tests...\n")
+
+    await test_problem_solving_basic()
+    await test_problem_solving_triz()
+    await test_problem_solving_toc()
+    await test_problem_solving_systems_thinking()
+    await test_problem_solving_with_context()
+    await test_problem_solving_solutions()
+    await test_problem_solving_action_plan()
+    await test_problem_solving_principles()
+    await test_problem_solving_missing_problem()
+
+    print("\n✅ All Creative Problem Solver tests passed!")
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(main())