aiecs 1.0.1__py3-none-any.whl → 1.7.17__py3-none-any.whl

aiecs/domain/community/collaborative_workflow.py

@@ -0,0 +1,648 @@
+"""
+Collaborative Workflow Engine
+
+Orchestrates collaborative workflows within agent communities,
+including brainstorming, problem-solving, and knowledge synthesis.
+"""
+
+import logging
+from datetime import datetime
+from typing import Dict, List, Any, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .community_manager import CommunityManager
+    from .resource_manager import ResourceManager
+    from .decision_engine import DecisionEngine
+import asyncio
+
+from .models.community_models import CollaborationSession
+from .exceptions import CommunityValidationError as TaskValidationError
+
+logger = logging.getLogger(__name__)
+
+
+class CollaborativeWorkflowEngine:
+    """
+    Engine for orchestrating collaborative workflows within agent communities.
+    """
+
+    def __init__(
+        self,
+        community_manager: Optional["CommunityManager"] = None,
+        resource_manager: Optional["ResourceManager"] = None,
+        decision_engine: Optional["DecisionEngine"] = None,
+    ) -> None:
+        """
+        Initialize the collaborative workflow engine.
+
+        Args:
+            community_manager: Reference to the community manager
+            resource_manager: Reference to the resource manager
+            decision_engine: Reference to the decision engine
+        """
+        self.community_manager = community_manager
+        self.resource_manager = resource_manager
+        self.decision_engine = decision_engine
+
+        # Active collaborative sessions
+        self.active_sessions: Dict[str, CollaborationSession] = {}
+
+        # Workflow templates
+        self.workflow_templates = {
+            "brainstorming": self._brainstorming_workflow,
+            "problem_solving": self._problem_solving_workflow,
+            "knowledge_synthesis": self._knowledge_synthesis_workflow,
+            "decision_making": self._decision_making_workflow,
+            "resource_creation": self._resource_creation_workflow,
+            "peer_review": self._peer_review_workflow,
+            "consensus_building": self._consensus_building_workflow,
+        }
+
+        logger.info("Collaborative workflow engine initialized")
+
+    async def start_collaborative_session(
+        self,
+        community_id: str,
+        session_leader_id: str,
+        session_type: str,
+        purpose: str,
+        participants: List[str],
+        agenda: Optional[List[str]] = None,
+        duration_minutes: int = 60,
+        session_config: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        """
+        Start a collaborative session.
+
+        Args:
+            community_id: ID of the community
+            session_leader_id: ID of the session leader
+            session_type: Type of collaborative session
+            purpose: Purpose of the session
+            participants: List of participant member IDs
+            agenda: Optional agenda items
+            duration_minutes: Expected duration in minutes
+            session_config: Optional session configuration
+
+        Returns:
+            Session ID
+        """
+        if not self.community_manager:
+            raise TaskValidationError("Community manager not available")
+
+        # Validate community and participants
+        community = self.community_manager.communities.get(community_id)
+        if not community:
+            raise TaskValidationError(f"Community not found: {community_id}")
+
+        # Create collaboration session
+        session = CollaborationSession(
+            community_id=community_id,
+            participants=participants,
+            session_leader=session_leader_id,
+            purpose=purpose,
+            session_type=session_type,
+            ended_at=None,
+            agenda=agenda or [],
+            metadata=session_config or {},
+        )
+
+        self.active_sessions[session.session_id] = session
+
+        # Execute workflow template if available
+        if session_type in self.workflow_templates:
+            workflow_func = self.workflow_templates[session_type]
+            await workflow_func(session)
+
+        logger.info(f"Started collaborative session: {session_type} ({session.session_id})")
+        return session.session_id
+
+    async def _brainstorming_workflow(self, session: CollaborationSession) -> None:
+        """
+        Execute brainstorming workflow.
+
+        Phases:
+        1. Idea generation
+        2. Idea collection and categorization
+        3. Idea evaluation and ranking
+        4. Action item creation
+        """
+        logger.info(f"Starting brainstorming workflow for session {session.session_id}")
+
+        # Phase 1: Idea Generation
+        await self._execute_phase(
+            session,
+            "idea_generation",
+            {
+                "instructions": "Generate creative ideas related to the session purpose",
+                "time_limit_minutes": 15,
+                "parallel_thinking": True,
+            },
+        )
+
+        # Phase 2: Idea Collection
+        await self._execute_phase(
+            session,
+            "idea_collection",
+            {
+                "instructions": "Collect and categorize all generated ideas",
+                "time_limit_minutes": 10,
+                "collaborative": True,
+            },
+        )
+
+        # Phase 3: Idea Evaluation
+        await self._execute_phase(
+            session,
+            "idea_evaluation",
+            {
+                "instructions": "Evaluate and rank ideas based on feasibility and impact",
+                "time_limit_minutes": 15,
+                "voting_enabled": True,
+            },
+        )
+
+        # Phase 4: Action Planning
+        await self._execute_phase(
+            session,
+            "action_planning",
+            {
+                "instructions": "Create action items for top-ranked ideas",
+                "time_limit_minutes": 10,
+                "assign_responsibilities": True,
+            },
+        )
+
+    async def _problem_solving_workflow(self, session: CollaborationSession) -> None:
+        """
+        Execute problem-solving workflow.
+
+        Phases:
+        1. Problem definition and analysis
+        2. Root cause analysis
+        3. Solution brainstorming
+        4. Solution evaluation and selection
+        5. Implementation planning
+        """
+        logger.info(f"Starting problem-solving workflow for session {session.session_id}")
+
+        # Phase 1: Problem Definition
+        await self._execute_phase(
+            session,
+            "problem_definition",
+            {
+                "instructions": "Define the problem clearly and analyze its scope",
+                "time_limit_minutes": 15,
+                "structured_analysis": True,
+            },
+        )
+
+        # Phase 2: Root Cause Analysis
+        await self._execute_phase(
+            session,
+            "root_cause_analysis",
+            {
+                "instructions": "Identify root causes using systematic analysis",
+                "time_limit_minutes": 20,
+                "analysis_methods": ["5_whys", "fishbone", "pareto"],
+            },
+        )
+
+        # Phase 3: Solution Brainstorming
+        await self._execute_phase(
+            session,
+            "solution_brainstorming",
+            {
+                "instructions": "Generate potential solutions for identified root causes",
+                "time_limit_minutes": 20,
+                "creative_thinking": True,
+            },
+        )
+
+        # Phase 4: Solution Evaluation
+        await self._execute_phase(
+            session,
+            "solution_evaluation",
+            {
+                "instructions": "Evaluate solutions based on criteria matrix",
+                "time_limit_minutes": 15,
+                "evaluation_criteria": [
+                    "feasibility",
+                    "impact",
+                    "cost",
+                    "timeline",
+                ],
+            },
+        )
+
+        # Phase 5: Implementation Planning
+        await self._execute_phase(
+            session,
+            "implementation_planning",
+            {
+                "instructions": "Create detailed implementation plan for selected solution",
+                "time_limit_minutes": 15,
+                "create_timeline": True,
+            },
+        )
+
+    async def _knowledge_synthesis_workflow(self, session: CollaborationSession) -> None:
+        """
+        Execute knowledge synthesis workflow.
+
+        Phases:
+        1. Knowledge gathering
+        2. Information analysis
+        3. Pattern identification
+        4. Synthesis and integration
+        5. Knowledge artifact creation
+        """
+        logger.info(f"Starting knowledge synthesis workflow for session {session.session_id}")
+
+        # Phase 1: Knowledge Gathering
+        await self._execute_phase(
+            session,
+            "knowledge_gathering",
+            {
+                "instructions": "Gather relevant knowledge from community resources and expertise",
+                "time_limit_minutes": 20,
+                "resource_search": True,
+            },
+        )
+
+        # Phase 2: Information Analysis
+        await self._execute_phase(
+            session,
+            "information_analysis",
+            {
+                "instructions": "Analyze gathered information for relevance and quality",
+                "time_limit_minutes": 15,
+                "quality_assessment": True,
+            },
+        )
+
+        # Phase 3: Pattern Identification
+        await self._execute_phase(
+            session,
+            "pattern_identification",
+            {
+                "instructions": "Identify patterns, themes, and connections in the information",
+                "time_limit_minutes": 20,
+                "pattern_analysis": True,
+            },
+        )
+
+        # Phase 4: Synthesis
+        await self._execute_phase(
+            session,
+            "synthesis",
+            {
+                "instructions": "Synthesize information into coherent knowledge structure",
+                "time_limit_minutes": 25,
+                "collaborative_editing": True,
+            },
+        )
+
+        # Phase 5: Artifact Creation
+        await self._execute_phase(
+            session,
+            "artifact_creation",
+            {
+                "instructions": "Create knowledge artifacts for community sharing",
+                "time_limit_minutes": 15,
+                "create_resources": True,
+            },
+        )
+
+    async def _decision_making_workflow(self, session: CollaborationSession) -> None:
+        """
+        Execute decision-making workflow.
+
+        Phases:
+        1. Decision framing
+        2. Option generation
+        3. Criteria definition
+        4. Option evaluation
+        5. Decision and commitment
+        """
+        logger.info(f"Starting decision-making workflow for session {session.session_id}")
+
+        # Phase 1: Decision Framing
+        await self._execute_phase(
+            session,
+            "decision_framing",
+            {
+                "instructions": "Frame the decision clearly with context and constraints",
+                "time_limit_minutes": 15,
+                "structured_framing": True,
+            },
+        )
+
+        # Phase 2: Option Generation
+        await self._execute_phase(
+            session,
+            "option_generation",
+            {
+                "instructions": "Generate multiple decision options",
+                "time_limit_minutes": 20,
+                "creative_options": True,
+            },
+        )
+
+        # Phase 3: Criteria Definition
+        await self._execute_phase(
+            session,
+            "criteria_definition",
+            {
+                "instructions": "Define evaluation criteria and their weights",
+                "time_limit_minutes": 10,
+                "criteria_weighting": True,
+            },
+        )
+
+        # Phase 4: Option Evaluation
+        await self._execute_phase(
+            session,
+            "option_evaluation",
+            {
+                "instructions": "Evaluate options against defined criteria",
+                "time_limit_minutes": 20,
+                "systematic_evaluation": True,
+            },
+        )
+
+        # Phase 5: Decision Making
+        await self._execute_phase(
+            session,
+            "decision_making",
+            {
+                "instructions": "Make final decision and create commitment plan",
+                "time_limit_minutes": 15,
+                "consensus_building": True,
+                "create_decision": True,
+            },
+        )
+
+    async def _resource_creation_workflow(self, session: CollaborationSession) -> None:
+        """Execute resource creation workflow."""
+        logger.info(f"Starting resource creation workflow for session {session.session_id}")
+
+        # Phase 1: Resource Planning
+        await self._execute_phase(
+            session,
+            "resource_planning",
+            {
+                "instructions": "Plan the resource to be created",
+                "time_limit_minutes": 15,
+            },
+        )
+
+        # Phase 2: Collaborative Creation
+        await self._execute_phase(
+            session,
+            "collaborative_creation",
+            {
+                "instructions": "Collaboratively create the resource",
+                "time_limit_minutes": 30,
+                "collaborative_editing": True,
+            },
+        )
+
+        # Phase 3: Review and Refinement
+        await self._execute_phase(
+            session,
+            "review_refinement",
+            {
+                "instructions": "Review and refine the created resource",
+                "time_limit_minutes": 15,
+                "peer_review": True,
+            },
+        )
+
+    async def _peer_review_workflow(self, session: CollaborationSession) -> None:
+        """
+        Execute peer review workflow.
+
+        Phases:
+        1. Reviewer assignment
+        2. Individual review
+        3. Review collection and synthesis
+        4. Feedback integration
+        5. Final approval
+        """
+        logger.info(f"Starting peer review workflow for session {session.session_id}")
+
+        # Phase 1: Reviewer Assignment
+        await self._execute_phase(
+            session,
+            "reviewer_assignment",
+            {
+                "instructions": "Assign reviewers based on expertise and availability",
+                "time_limit_minutes": 5,
+                "min_reviewers": 2,
+                "max_reviewers": 5,
+            },
+        )
+
+        # Phase 2: Individual Review
+        await self._execute_phase(
+            session,
+            "individual_review",
+            {
+                "instructions": "Conduct independent review of the material",
+                "time_limit_minutes": 30,
+                "review_criteria": [
+                    "accuracy",
+                    "completeness",
+                    "clarity",
+                    "quality",
+                ],
+                "parallel_reviews": True,
+            },
+        )
+
+        # Phase 3: Review Collection
+        await self._execute_phase(
+            session,
+            "review_collection",
+            {
+                "instructions": "Collect and synthesize all review feedback",
+                "time_limit_minutes": 15,
+                "identify_conflicts": True,
+                "aggregate_scores": True,
+            },
+        )
+
+        # Phase 4: Feedback Integration
+        await self._execute_phase(
+            session,
+            "feedback_integration",
+            {
+                "instructions": "Integrate reviewer feedback into the material",
+                "time_limit_minutes": 20,
+                "collaborative_editing": True,
+                "track_changes": True,
+            },
+        )
+
+        # Phase 5: Final Approval
+        await self._execute_phase(
+            session,
+            "final_approval",
+            {
+                "instructions": "Reviewers provide final approval or request changes",
+                "time_limit_minutes": 10,
+                "require_consensus": True,
+                "approval_threshold": 0.8,
+            },
+        )
+
+    async def _consensus_building_workflow(self, session: CollaborationSession) -> None:
+        """
+        Execute consensus building workflow.
+
+        Phases:
+        1. Issue presentation and clarification
+        2. Discussion round 1 - Position sharing
+        3. Common ground identification
+        4. Proposal refinement
+        5. Convergence check and agreement
+        """
+        logger.info(f"Starting consensus building workflow for session {session.session_id}")
+
+        # Phase 1: Issue Presentation
+        await self._execute_phase(
+            session,
+            "issue_presentation",
+            {
+                "instructions": "Present the issue clearly and allow clarification questions",
+                "time_limit_minutes": 15,
+                "clarification_enabled": True,
+            },
+        )
+
+        # Phase 2: Position Sharing
+        await self._execute_phase(
+            session,
+            "position_sharing",
+            {
+                "instructions": "Each member shares their position and rationale",
+                "time_limit_minutes": 20,
+                "equal_participation": True,
+                "capture_positions": True,
+            },
+        )
+
+        # Phase 3: Common Ground Identification
+        await self._execute_phase(
+            session,
+            "common_ground_identification",
+            {
+                "instructions": "Identify areas of agreement and shared values",
+                "time_limit_minutes": 15,
+                "find_overlaps": True,
+                "identify_blockers": True,
+            },
+        )
+
+        # Phase 4: Proposal Refinement
+        await self._execute_phase(
+            session,
+            "proposal_refinement",
+            {
+                "instructions": "Refine proposals to address concerns and maximize agreement",
+                "time_limit_minutes": 25,
+                "iterative_refinement": True,
+                "test_proposals": True,
+            },
+        )
+
+        # Phase 5: Convergence Check
+        await self._execute_phase(
+            session,
+            "convergence_check",
+            {
+                "instructions": "Check for consensus and finalize agreement",
+                "time_limit_minutes": 15,
+                "consensus_threshold": 0.9,
+                "allow_dissent": True,
+                "document_agreement": True,
+            },
+        )
+
+    async def _execute_phase(
+        self,
+        session: CollaborationSession,
+        phase_name: str,
+        phase_config: Dict[str, Any],
+    ) -> None:
+        """
+        Execute a workflow phase.
+
+        Args:
+            session: Collaboration session
+            phase_name: Name of the phase
+            phase_config: Phase configuration
+        """
+        logger.info(f"Executing phase '{phase_name}' for session {session.session_id}")
+
+        # Record phase execution
+        phase_result = {
+            "phase_name": phase_name,
+            "started_at": datetime.utcnow().isoformat(),
+            "config": phase_config,
+            "participants": session.participants,
+            "outputs": [],
+        }
+
+        # Simulate phase execution (in real implementation, this would
+        # coordinate agent activities)
+        phase_config.get("time_limit_minutes", 10)
+        await asyncio.sleep(1)  # Simulate processing time
+
+        phase_result["completed_at"] = datetime.utcnow().isoformat()
+        phase_result["status"] = "completed"
+
+        # Store phase result in session metadata
+        if "phases" not in session.metadata:
+            session.metadata["phases"] = []
+        session.metadata["phases"].append(phase_result)
+
+        logger.info(f"Completed phase '{phase_name}' for session {session.session_id}")
+
+    async def end_session(self, session_id: str) -> Dict[str, Any]:
+        """
+        End a collaborative session and generate summary.
+
+        Args:
+            session_id: ID of the session to end
+
+        Returns:
+            Session summary
+        """
+        if session_id not in self.active_sessions:
+            raise TaskValidationError(f"Session not found: {session_id}")
+
+        session = self.active_sessions[session_id]
+        session.status = "completed"
+        session.ended_at = datetime.utcnow()
+
+        # Generate session summary
+        summary = {
+            "session_id": session_id,
+            "session_type": session.session_type,
+            "purpose": session.purpose,
+            "participants": session.participants,
+            "duration_minutes": (session.ended_at - session.started_at).total_seconds() / 60,
+            "outcomes": session.action_items,
+            "resources_created": session.resources_created,
+            "decisions_made": session.decisions_made,
+            "phases_completed": len(session.metadata.get("phases", [])),
+            "status": session.status,
+        }
+
+        # Remove from active sessions
+        del self.active_sessions[session_id]
+
+        logger.info(f"Ended collaborative session {session_id}")
+        return summary