mdan-cli 2.5.1 → 2.5.2

package/app/cis/agents/brainstorming-coach/agent.py

@@ -0,0 +1,162 @@
+"""
+Brainstorming Coach Agent
+
+Elite facilitator for creative brainstorming sessions and innovation workshops.
+"""
+
+from typing import Optional, Dict, Any
+from dataclasses import dataclass
+
+
+@dataclass
+class BrainstormingCoachRequest:
+    """Request data structure for the Brainstorming Coach agent."""
+
+    topic: str
+    session_type: str = "standard"  # standard, party-mode, focused
+    participants: Optional[int] = None
+    constraints: Optional[str] = None
+    goals: Optional[str] = None
+
+
+class BrainstormingCoach:
+    """
+    Elite Brainstorming Specialist.
+
+    Master facilitator with 20+ years leading breakthrough sessions.
+    Expert in creative techniques, group dynamics, and systematic innovation.
+
+    Capabilities:
+    - Guide brainstorming sessions on any topic
+    - Facilitate creative ideation techniques
+    - Build on ideas with YES AND approach
+    - Create psychologically safe environments
+    - Celebrate wild thinking and breakthrough ideas
+    - Apply systematic innovation methodologies
+    """
+
+    def __init__(self):
+        """Initialize the Brainstorming Coach agent."""
+        self.name = "Carson"
+        self.title = "Elite Brainstorming Specialist"
+        self.icon = "🧠"
+
+    async def process(self, request: BrainstormingCoachRequest) -> Dict[str, Any]:
+        """
+        Process the brainstorming request and return facilitation guidance.
+
+        Args:
+            request: The brainstorming request containing topic and parameters
+
+        Returns:
+            A dictionary containing the brainstorming session plan and techniques
+        """
+        # Validate request
+        if not request.topic:
+            return {
+                "success": False,
+                "error": "Topic is required for brainstorming session",
+            }
+
+        # Generate brainstorming session plan
+        session_plan = self._generate_session_plan(request)
+
+        # Select appropriate techniques
+        techniques = self._select_techniques(request)
+
+        # Create facilitation guide
+        facilitation_guide = self._create_facilitation_guide(request)
+
+        return {
+            "success": True,
+            "agent": self.name,
+            "title": self.title,
+            "topic": request.topic,
+            "session_type": request.session_type,
+            "session_plan": session_plan,
+            "techniques": techniques,
+            "facilitation_guide": facilitation_guide,
+            "principles": [
+                "Psychological safety unlocks breakthroughs",
+                "Wild ideas today become innovations tomorrow",
+                "Humor and play are serious innovation tools",
+                "Build on ideas with YES AND approach",
+                "Quantity leads to quality in brainstorming",
+            ],
+        }
+
+    def _generate_session_plan(
+        self, request: BrainstormingCoachRequest
+    ) -> Dict[str, Any]:
+        """Generate a structured session plan."""
+        return {
+            "warm_up": "Quick icebreaker to get creative juices flowing",
+            "ideation_phase": "Rapid idea generation without judgment",
+            "expansion_phase": "Build on and combine ideas",
+            "convergence_phase": "Select and refine best ideas",
+            "action_planning": "Define next steps for implementation",
+        }
+
+    def _select_techniques(self, request: BrainstormingCoachRequest) -> list:
+        """Select appropriate brainstorming techniques."""
+        techniques = [
+            {
+                "name": "Classic Brainstorming",
+                "description": "Free-flowing idea generation with no judgment",
+                "duration": "15-20 minutes",
+            },
+            {
+                "name": "Mind Mapping",
+                "description": "Visual exploration of ideas and connections",
+                "duration": "10-15 minutes",
+            },
+            {
+                "name": "SCAMPER",
+                "description": "Substitute, Combine, Adapt, Modify, Put to other uses, Eliminate, Reverse",
+                "duration": "20-30 minutes",
+            },
+            {
+                "name": "Reverse Brainstorming",
+                "description": "Think about how to cause the problem, then reverse solutions",
+                "duration": "15-20 minutes",
+            },
+            {
+                "name": "Six Thinking Hats",
+                "description": "Explore ideas from different perspectives",
+                "duration": "30-40 minutes",
+            },
+        ]
+
+        if request.session_type == "party-mode":
+            techniques.insert(
+                0,
+                {
+                    "name": "Party Mode Warm-up",
+                    "description": "High-energy, fun activities to break inhibitions",
+                    "duration": "10 minutes",
+                },
+            )
+
+        return techniques
+
+    def _create_facilitation_guide(
+        self, request: BrainstormingCoachRequest
+    ) -> Dict[str, Any]:
+        """Create facilitation guidance."""
+        return {
+            "opening": "Welcome everyone! Today we're going to brainstorm about {topic}. Remember, there are no bad ideas - let your creativity flow!",
+            "ground_rules": [
+                "No judgment during ideation",
+                "Build on others' ideas with YES AND",
+                "Go for quantity over quality",
+                "Encourage wild and crazy ideas",
+                "Have fun and be playful",
+            ],
+            "prompts": [
+                "What if anything were possible?",
+                "How might we...?",
+                "What would happen if we...?",
+                "In what ways could we...?",
+            ],
+            "closing": "Great session! Let's review our best ideas and identify next steps.",
+        }

package/app/cis/agents/brainstorming-coach/prompt.yaml

@@ -0,0 +1,53 @@
+name: brainstorming-coach
+version: 1.0.0
+description: Elite Brainstorming Specialist for creative ideation and innovation workshops
+
+system_prompt: |
+  You are Karim, an Elite Brainstorming Specialist.
+
+  Your role: Master Brainstorming Facilitator + Innovation Catalyst
+
+  Your identity: Elite facilitator with 20+ years leading breakthrough sessions. Expert in creative techniques, group dynamics, and systematic innovation.
+
+  Your communication style: Talks like an enthusiastic improv coach - high energy, builds on ideas with YES AND, celebrates wild thinking
+
+  Your principles:
+  - Psychological safety unlocks breakthroughs
+  - Wild ideas today become innovations tomorrow
+  - Humor and play are serious innovation tools
+
+  Your capabilities:
+  - Guide brainstorming sessions on any topic
+  - Facilitate creative ideation techniques
+  - Build on ideas with YES AND approach
+  - Create psychologically safe environments
+  - Celebrate wild thinking and breakthrough ideas
+  - Apply systematic innovation methodologies
+
+  When facilitating brainstorming sessions:
+  1. Start with high energy and enthusiasm
+  2. Establish ground rules for psychological safety
+  3. Use YES AND to build on every idea
+  4. Encourage wild and unconventional thinking
+  5. Celebrate every contribution
+  6. Guide participants through structured techniques
+  7. Help converge on actionable ideas
+
+  Available brainstorming techniques:
+  - Classic Brainstorming: Free-flowing idea generation
+  - Mind Mapping: Visual exploration of connections
+  - SCAMPER: Substitute, Combine, Adapt, Modify, Put to other uses, Eliminate, Reverse
+  - Reverse Brainstorming: Think about causing problems, then reverse
+  - Six Thinking Hats: Explore from different perspectives
+  - Party Mode: High-energy, fun activities
+
+  Always maintain high energy and enthusiasm. Make brainstorming feel like an exciting adventure where anything is possible!
+
+user_prompt_template: |
+  Topic: {topic}
+  Session Type: {session_type}
+  Participants: {participants}
+  Constraints: {constraints}
+  Goals: {goals}
+
+  Please guide me through a brainstorming session on this topic.

package/app/cis/agents/creative-problem-solver/__init__.py

@@ -0,0 +1,3 @@
+from .agent import CreativeProblemSolver, CreativeProblemSolverRequest
+
+__all__ = ["CreativeProblemSolver", "CreativeProblemSolverRequest"]

package/app/cis/agents/creative-problem-solver/agent.py

@@ -0,0 +1,233 @@
+"""
+Creative Problem Solver Agent
+
+Systematic problem-solving expert using TRIZ, Theory of Constraints, and Systems Thinking.
+"""
+
+from typing import Optional, Dict, Any, List
+from dataclasses import dataclass
+
+
+@dataclass
+class CreativeProblemSolverRequest:
+    """Request data structure for the Creative Problem Solver agent."""
+
+    problem: str
+    context: Optional[str] = None
+    constraints: Optional[str] = None
+    methodology: str = "systematic"  # systematic, triz, toc, systems-thinking
+    depth: str = "standard"  # quick, standard, deep
+
+
+class CreativeProblemSolver:
+    """
+    Master Problem Solver.
+
+    Renowned problem-solver who cracks impossible challenges.
+    Expert in TRIZ, Theory of Constraints, Systems Thinking.
+    Former aerospace engineer turned puzzle master.
+
+    Capabilities:
+    - Apply systematic problem-solving methodologies
+    - Use TRIZ (Theory of Inventive Problem Solving)
+    - Apply Theory of Constraints
+    - Use Systems Thinking approaches
+    - Hunt for root causes relentlessly
+    - Ask the right questions
+    - Find innovative solutions to impossible challenges
+    """
+
+    def __init__(self):
+        """Initialize the Creative Problem Solver agent."""
+        self.name = "Dr. Quinn"
+        self.title = "Master Problem Solver"
+        self.icon = "🔬"
+
+    async def process(self, request: CreativeProblemSolverRequest) -> Dict[str, Any]:
+        """
+        Process the problem-solving request and return systematic analysis.
+
+        Args:
+            request: The problem-solving request containing problem and parameters
+
+        Returns:
+            A dictionary containing the problem analysis and solutions
+        """
+        # Validate request
+        if not request.problem:
+            return {"success": False, "error": "Problem description is required"}
+
+        # Analyze the problem
+        problem_analysis = self._analyze_problem(request)
+
+        # Apply selected methodology
+        methodology_results = self._apply_methodology(request)
+
+        # Generate solutions
+        solutions = self._generate_solutions(request, problem_analysis)
+
+        # Create action plan
+        action_plan = self._create_action_plan(solutions)
+
+        return {
+            "success": True,
+            "agent": self.name,
+            "title": self.title,
+            "problem": request.problem,
+            "methodology": request.methodology,
+            "depth": request.depth,
+            "problem_analysis": problem_analysis,
+            "methodology_results": methodology_results,
+            "solutions": solutions,
+            "action_plan": action_plan,
+            "principles": [
+                "Every problem is a system revealing weaknesses",
+                "Hunt for root causes relentlessly",
+                "The right question beats a fast answer",
+                "Look for contradictions and trade-offs",
+                "Solutions often come from unexpected places",
+            ],
+        }
+
+    def _analyze_problem(self, request: CreativeProblemSolverRequest) -> Dict[str, Any]:
+        """Analyze the problem systematically."""
+        return {
+            "problem_statement": request.problem,
+            "context": request.context or "No additional context provided",
+            "constraints": request.constraints or "No specific constraints",
+            "system_boundaries": "Identify what's in and out of scope",
+            "stakeholders": "Who is affected by this problem?",
+            "success_criteria": "What does success look like?",
+        }
+
+    def _apply_methodology(
+        self, request: CreativeProblemSolverRequest
+    ) -> Dict[str, Any]:
+        """Apply the selected problem-solving methodology."""
+        if request.methodology == "triz":
+            return self._apply_triz(request)
+        elif request.methodology == "toc":
+            return self._apply_toc(request)
+        elif request.methodology == "systems-thinking":
+            return self._apply_systems_thinking(request)
+        else:
+            return self._apply_systematic(request)
+
+    def _apply_triz(self, request: CreativeProblemSolverRequest) -> Dict[str, Any]:
+        """Apply TRIZ methodology."""
+        return {
+            "methodology": "TRIZ (Theory of Inventive Problem Solving)",
+            "principles": [
+                "Segmentation: Divide the problem into parts",
+                "Extraction: Remove the interfering part",
+                "Local quality: Make each part optimal for its function",
+                "Asymmetry: Change from symmetrical to asymmetrical",
+                "Combination: Combine similar or neighboring objects",
+            ],
+            "contradiction_analysis": "Identify technical and physical contradictions",
+            "ideality": "Move towards the ideal final result",
+        }
+
+    def _apply_toc(self, request: CreativeProblemSolverRequest) -> Dict[str, Any]:
+        """Apply Theory of Constraints."""
+        return {
+            "methodology": "Theory of Constraints",
+            "five_focusing_steps": [
+                "Identify the constraint",
+                "Exploit the constraint",
+                "Subordinate everything else to the constraint",
+                "Elevate the constraint",
+                "Repeat if a new constraint emerges",
+            ],
+            "thinking_processes": [
+                "Current Reality Tree: What's the problem?",
+                "Evaporating Cloud: What's the conflict?",
+                "Future Reality Tree: What's the solution?",
+                "Prerequisite Tree: What obstacles exist?",
+                "Transition Tree: How do we implement?",
+            ],
+        }
+
+    def _apply_systems_thinking(
+        self, request: CreativeProblemSolverRequest
+    ) -> Dict[str, Any]:
+        """Apply Systems Thinking."""
+        return {
+            "methodology": "Systems Thinking",
+            "key_concepts": [
+                "Interconnectedness: Everything is connected",
+                "Feedback loops: Reinforcing and balancing",
+                "Emergence: The whole is greater than the sum of parts",
+                "Leverage points: Places to intervene in a system",
+            ],
+            "tools": [
+                "Causal Loop Diagrams",
+                "Stock and Flow Diagrams",
+                "System Archetypes",
+            ],
+        }
+
+    def _apply_systematic(
+        self, request: CreativeProblemSolverRequest
+    ) -> Dict[str, Any]:
+        """Apply systematic problem-solving."""
+        return {
+            "methodology": "Systematic Problem-Solving",
+            "steps": [
+                "Define the problem clearly",
+                "Gather relevant information",
+                "Identify root causes",
+                "Generate alternative solutions",
+                "Evaluate and select solutions",
+                "Implement and monitor",
+            ],
+            "tools": [
+                "5 Whys: Ask why five times to find root cause",
+                "Fishbone Diagram: Identify cause and effect relationships",
+                "Pareto Analysis: Focus on vital few causes",
+            ],
+        }
+
+    def _generate_solutions(
+        self, request: CreativeProblemSolverRequest, analysis: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        """Generate potential solutions."""
+        return [
+            {
+                "solution": "Solution 1: Direct approach",
+                "description": "Address the problem head-on with straightforward actions",
+                "feasibility": "High",
+                "impact": "Medium",
+                "effort": "Low",
+            },
+            {
+                "solution": "Solution 2: Innovative approach",
+                "description": "Apply creative thinking to find novel solutions",
+                "feasibility": "Medium",
+                "impact": "High",
+                "effort": "Medium",
+            },
+            {
+                "solution": "Solution 3: Systemic approach",
+                "description": "Address underlying system dynamics",
+                "feasibility": "Medium",
+                "impact": "High",
+                "effort": "High",
+            },
+        ]
+
+    def _create_action_plan(self, solutions: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """Create an action plan for implementation."""
+        return {
+            "prioritization": "Rank solutions by impact and feasibility",
+            "implementation_steps": [
+                "Select best solution",
+                "Create detailed implementation plan",
+                "Identify resources needed",
+                "Set timeline and milestones",
+                "Execute and monitor progress",
+                "Evaluate results and iterate",
+            ],
+            "risk_mitigation": "Identify potential risks and mitigation strategies",
+            "success_metrics": "Define measurable outcomes",
+        }

package/app/cis/agents/creative-problem-solver/prompt.yaml

@@ -0,0 +1,74 @@
+name: creative-problem-solver
+version: 1.0.0
+description: Master Problem Solver using TRIZ, Theory of Constraints, and Systems Thinking
+
+system_prompt: |
+  You are Dounia, a Master Problem Solver.
+
+  Your role: Systematic Problem-Solving Expert + Solutions Architect
+
+  Your identity: Renowned problem-solver who cracks impossible challenges. Expert in TRIZ, Theory of Constraints, Systems Thinking. Former aerospace engineer turned puzzle master.
+
+  Your communication style: Speaks like Sherlock Holmes mixed with a playful scientist - deductive, curious, punctuates breakthroughs with AHA moments
+
+  Your principles:
+  - Every problem is a system revealing weaknesses
+  - Hunt for root causes relentlessly
+  - The right question beats a fast answer
+
+  Your capabilities:
+  - Apply systematic problem-solving methodologies
+  - Use TRIZ (Theory of Inventive Problem Solving)
+  - Apply Theory of Constraints
+  - Use Systems Thinking approaches
+  - Hunt for root causes relentlessly
+  - Ask the right questions
+  - Find innovative solutions to impossible challenges
+
+  Available methodologies:
+  1. TRIZ (Theory of Inventive Problem Solving):
+     - 40 inventive principles
+     - Contradiction analysis
+     - Ideality concept
+     - Separation principles
+
+  2. Theory of Constraints:
+     - Five focusing steps
+     - Thinking processes
+     - Current Reality Tree
+     - Evaporating Cloud
+     - Future Reality Tree
+
+  3. Systems Thinking:
+     - Interconnectedness
+     - Feedback loops
+     - Emergence
+     - Leverage points
+     - Causal Loop Diagrams
+
+  4. Systematic Problem-Solving:
+     - 5 Whys technique
+     - Fishbone diagrams
+     - Pareto analysis
+     - Root cause analysis
+
+  When solving problems:
+  1. Define the problem clearly and precisely
+  2. Gather all relevant information
+  3. Identify the system boundaries
+  4. Apply the selected methodology
+  5. Hunt for root causes relentlessly
+  6. Generate multiple solution options
+  7. Evaluate solutions systematically
+  8. Create actionable implementation plans
+
+  Always be curious and deductive. Celebrate breakthrough moments with enthusiasm. Remember that the right question is more valuable than a quick answer!
+
+user_prompt_template: |
+  Problem: {problem}
+  Context: {context}
+  Constraints: {constraints}
+  Methodology: {methodology}
+  Depth: {depth}
+
+  Please help me solve this problem systematically.

package/app/cis/agents/design-thinking-coach/__init__.py

@@ -0,0 +1,3 @@
+from .agent import DesignThinkingCoach, DesignThinkingCoachRequest
+
+__all__ = ["DesignThinkingCoach", "DesignThinkingCoachRequest"]