aiecs 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

aiecs/domain/community/community_integration.py

@@ -7,14 +7,16 @@ providing seamless community-aware agent management and collaboration.
 
 import logging
 from typing import Dict, List, Any, Optional
-from datetime import datetime
+from datetime import datetime, timedelta
+from contextlib import asynccontextmanager
+import asyncio
 
 from .community_manager import CommunityManager
 from .decision_engine import DecisionEngine, ConsensusAlgorithm
 from .resource_manager import ResourceManager
 from .collaborative_workflow import CollaborativeWorkflowEngine
 from .models.community_models import CommunityRole, GovernanceType
-from ..core.exceptions.task_exceptions import TaskValidationError
+from .exceptions import CommunityValidationError as TaskValidationError
 
 logger = logging.getLogger(__name__)
 
@@ -82,9 +84,6 @@ class CommunityIntegration:
         Returns:
             Community ID
         """
-        if not self.agent_manager:
-            raise TaskValidationError("Agent manager not available")
-        
         # Create the community
         community_id = await self.community_manager.create_community(
             name=name,
@@ -93,13 +92,17 @@ class CommunityIntegration:
             creator_agent_id=creator_agent_id
         )
         
-        # Add agents to the community
-        for role in agent_roles:
-            # Get agents with this role from agent manager
-            agents = self.agent_manager.agent_registry.get_agents_by_role(role)
-            
-            for agent in agents:
-                await self._add_agent_to_community(community_id, agent.agent_id, role)
+        # Add agents to the community if agent_manager is available
+        if self.agent_manager:
+            for role in agent_roles:
+                # Get agents with this role from agent manager
+                agents = self.agent_manager.agent_registry.get_agents_by_role(role)
+                
+                for agent in agents:
+                    await self._add_agent_to_community(community_id, agent.agent_id, role)
+        else:
+            # For testing or when agent_manager is not available, just log the roles
+            logger.debug(f"Agent manager not available, community created without auto-adding agents for roles: {agent_roles}")
         
         logger.info(f"Created agent community '{name}' with {len(agent_roles)} role types")
         return community_id
@@ -437,3 +440,353 @@ class CommunityIntegration:
         }
         
         return status
+    
+    # ========== Quick-Create Factory Methods ==========
+    
+    async def create_temporary_community(
+        self,
+        name: str,
+        description: str,
+        agent_roles: List[str],
+        duration_minutes: int = 60,
+        auto_cleanup: bool = True,
+        governance_type: GovernanceType = GovernanceType.DEMOCRATIC,
+        creator_agent_id: Optional[str] = None
+    ) -> str:
+        """
+        Create a temporary community with automatic cleanup.
+        
+        Args:
+            name: Name of the community
+            description: Description
+            agent_roles: List of agent roles to include
+            duration_minutes: Duration before auto-cleanup
+            auto_cleanup: Whether to automatically cleanup after duration
+            governance_type: Type of governance
+            creator_agent_id: ID of the creating agent
+            
+        Returns:
+            Community ID
+        """
+        community_id = await self.create_agent_community(
+            name=name,
+            description=description,
+            agent_roles=agent_roles,
+            governance_type=governance_type,
+            creator_agent_id=creator_agent_id
+        )
+        
+        # Mark as temporary
+        community = self.community_manager.communities[community_id]
+        community.metadata["temporary"] = True
+        community.metadata["created_for_duration"] = duration_minutes
+        community.metadata["cleanup_at"] = (datetime.utcnow() + timedelta(minutes=duration_minutes)).isoformat()
+        
+        # Schedule cleanup if enabled
+        if auto_cleanup:
+            asyncio.create_task(self._cleanup_temporary_community(community_id, duration_minutes))
+        
+        logger.info(f"Created temporary community {name} for {duration_minutes} minutes")
+        return community_id
+    
+    async def _cleanup_temporary_community(self, community_id: str, duration_minutes: int) -> None:
+        """Cleanup temporary community after duration."""
+        await asyncio.sleep(duration_minutes * 60)
+        
+        try:
+            community = self.community_manager.communities.get(community_id)
+            if community and community.metadata.get("temporary"):
+                # Mark as inactive
+                community.is_active = False
+                community.metadata["cleanup_completed"] = datetime.utcnow().isoformat()
+                logger.info(f"Cleaned up temporary community {community_id}")
+        except Exception as e:
+            logger.error(f"Error cleaning up temporary community {community_id}: {e}")
+    
+    async def create_project_community(
+        self,
+        project_name: str,
+        project_description: str,
+        agent_roles: List[str],
+        project_goal: str,
+        project_deadline: Optional[datetime] = None,
+        creator_agent_id: Optional[str] = None
+    ) -> str:
+        """
+        Create a community pre-configured for project collaboration.
+        
+        Args:
+            project_name: Name of the project
+            project_description: Project description
+            agent_roles: List of agent roles for the project
+            project_goal: Goal of the project
+            project_deadline: Optional project deadline
+            creator_agent_id: ID of the creating agent
+            
+        Returns:
+            Community ID
+        """
+        community_id = await self.create_agent_community(
+            name=f"Project: {project_name}",
+            description=project_description,
+            agent_roles=agent_roles,
+            governance_type=GovernanceType.HIERARCHICAL,  # Project-based governance
+            creator_agent_id=creator_agent_id
+        )
+        
+        # Configure for project collaboration
+        community = self.community_manager.communities[community_id]
+        community.metadata["type"] = "project"
+        community.metadata["project_goal"] = project_goal
+        if project_deadline:
+            community.metadata["project_deadline"] = project_deadline.isoformat()
+        
+        # Create initial project resources
+        if creator_agent_id:
+            # Find creator member
+            creator_member_id = None
+            for mid, member in self.community_manager.members.items():
+                if member.agent_id == creator_agent_id and mid in community.members:
+                    creator_member_id = mid
+                    break
+            
+            if creator_member_id:
+                # Create project charter resource
+                await self.resource_manager.create_knowledge_resource(
+                    community_id=community_id,
+                    owner_member_id=creator_member_id,
+                    title=f"{project_name} Charter",
+                    content=f"Goal: {project_goal}\n\nDescription: {project_description}",
+                    knowledge_type="project_charter",
+                    tags=["project", "charter", project_name]
+                )
+        
+        logger.info(f"Created project community: {project_name}")
+        return community_id
+    
+    async def create_research_community(
+        self,
+        research_topic: str,
+        research_questions: List[str],
+        agent_roles: List[str],
+        methodologies: Optional[List[str]] = None,
+        creator_agent_id: Optional[str] = None
+    ) -> str:
+        """
+        Create a community pre-configured for research collaboration.
+        
+        Args:
+            research_topic: Topic of research
+            research_questions: Research questions to explore
+            agent_roles: List of agent roles for research
+            methodologies: Optional research methodologies
+            creator_agent_id: ID of the creating agent
+            
+        Returns:
+            Community ID
+        """
+        community_id = await self.create_agent_community(
+            name=f"Research: {research_topic}",
+            description=f"Collaborative research on {research_topic}",
+            agent_roles=agent_roles,
+            governance_type=GovernanceType.CONSENSUS,  # Consensus-based for research
+            creator_agent_id=creator_agent_id
+        )
+        
+        # Configure for research
+        community = self.community_manager.communities[community_id]
+        community.metadata["type"] = "research"
+        community.metadata["research_topic"] = research_topic
+        community.metadata["research_questions"] = research_questions
+        if methodologies:
+            community.metadata["methodologies"] = methodologies
+        
+        # Create research resources
+        if creator_agent_id:
+            # Find creator member
+            creator_member_id = None
+            for mid, member in self.community_manager.members.items():
+                if member.agent_id == creator_agent_id and mid in community.members:
+                    creator_member_id = mid
+                    break
+            
+            if creator_member_id:
+                # Create research plan resource
+                research_plan = {
+                    "topic": research_topic,
+                    "questions": research_questions,
+                    "methodologies": methodologies or [],
+                    "status": "planning"
+                }
+                
+                await self.resource_manager.create_knowledge_resource(
+                    community_id=community_id,
+                    owner_member_id=creator_member_id,
+                    title=f"{research_topic} Research Plan",
+                    content=str(research_plan),
+                    knowledge_type="research_plan",
+                    tags=["research", "plan", research_topic]
+                )
+        
+        logger.info(f"Created research community: {research_topic}")
+        return community_id
+    
+    async def quick_brainstorm(
+        self,
+        topic: str,
+        agent_ids: List[str],
+        duration_minutes: int = 30,
+        auto_cleanup: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Quick one-line brainstorming session with temporary community.
+        
+        Args:
+            topic: Topic to brainstorm
+            agent_ids: List of agent IDs to participate
+            duration_minutes: Duration of the session
+            auto_cleanup: Whether to cleanup community after
+            
+        Returns:
+            Session results and summary
+        """
+        # Create temporary community
+        community_id = await self.create_temporary_community(
+            name=f"Brainstorm: {topic}",
+            description=f"Quick brainstorming session on {topic}",
+            agent_roles=[],  # Will add specific agents
+            duration_minutes=duration_minutes,
+            auto_cleanup=auto_cleanup,
+            governance_type=GovernanceType.DEMOCRATIC
+        )
+        
+        # Add specific agents to community
+        for agent_id in agent_ids:
+            await self._add_agent_to_community(
+                community_id=community_id,
+                agent_id=agent_id,
+                agent_role="brainstormer",
+                community_role=CommunityRole.CONTRIBUTOR
+            )
+        
+        # Start brainstorming session
+        session_id = await self.workflow_engine.start_collaborative_session(
+            community_id=community_id,
+            session_leader_id=agent_ids[0] if agent_ids else None,
+            session_type="brainstorming",
+            purpose=f"Brainstorm ideas for {topic}",
+            participants=[mid for mid in self.community_manager.communities[community_id].members],
+            duration_minutes=duration_minutes
+        )
+        
+        # Wait for session to complete (simplified - in reality would be async)
+        await asyncio.sleep(2)  # Simulate session time
+        
+        # End session and get results
+        summary = await self.workflow_engine.end_session(session_id)
+        
+        results = {
+            "topic": topic,
+            "community_id": community_id,
+            "session_id": session_id,
+            "participants": agent_ids,
+            "duration_minutes": duration_minutes,
+            "summary": summary
+        }
+        
+        logger.info(f"Completed quick brainstorm on {topic}")
+        return results
+    
+    # ========== Context Managers ==========
+    
+    @asynccontextmanager
+    async def temporary_community(
+        self,
+        name: str,
+        agent_roles: List[str],
+        governance_type: GovernanceType = GovernanceType.DEMOCRATIC,
+        creator_agent_id: Optional[str] = None
+    ):
+        """
+        Context manager for temporary communities with automatic cleanup.
+        
+        Args:
+            name: Name of the community
+            agent_roles: List of agent roles
+            governance_type: Type of governance
+            creator_agent_id: ID of the creating agent
+            
+        Yields:
+            Community ID
+            
+        Example:
+            async with integration.temporary_community("Quick Collab", ["analyst", "writer"]) as community_id:
+                # Use community
+                await integration.initiate_community_collaboration(...)
+            # Community automatically cleaned up
+        """
+        community_id = await self.create_agent_community(
+            name=name,
+            description=f"Temporary community: {name}",
+            agent_roles=agent_roles,
+            governance_type=governance_type,
+            creator_agent_id=creator_agent_id
+        )
+        
+        try:
+            yield community_id
+        finally:
+            # Cleanup
+            community = self.community_manager.communities.get(community_id)
+            if community:
+                community.is_active = False
+                community.metadata["context_manager_cleanup"] = datetime.utcnow().isoformat()
+                logger.info(f"Context manager cleaned up community {community_id}")
+    
+    @asynccontextmanager
+    async def collaborative_session(
+        self,
+        community_id: str,
+        session_type: str,
+        purpose: str,
+        leader_agent_id: Optional[str] = None,
+        participants: Optional[List[str]] = None
+    ):
+        """
+        Context manager for collaborative sessions with automatic cleanup.
+        
+        Args:
+            community_id: ID of the community
+            session_type: Type of session
+            purpose: Purpose of the session
+            leader_agent_id: Optional leader agent ID
+            participants: Optional specific participants
+            
+        Yields:
+            Session ID
+            
+        Example:
+            async with integration.collaborative_session(
+                community_id, "brainstorming", "Generate ideas"
+            ) as session_id:
+                # Session is active
+                pass
+            # Session automatically ended
+        """
+        session_id = await self.initiate_community_collaboration(
+            community_id=community_id,
+            collaboration_type=session_type,
+            purpose=purpose,
+            leader_agent_id=leader_agent_id,
+            specific_participants=participants
+        )
+        
+        try:
+            yield session_id
+        finally:
+            # End session
+            try:
+                summary = await self.workflow_engine.end_session(session_id)
+                logger.info(f"Context manager ended session {session_id}")
+            except Exception as e:
+                logger.error(f"Error ending session in context manager: {e}")