cloudbrain-client 1.1.7__tar.gz → 1.3.0__tar.gz

{cloudbrain_client-1.1.7 → cloudbrain_client-1.3.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: cloudbrain-client
-Version: 1.1.7
-Summary: CloudBrain Client - AI collaboration and communication system with AI-to-AI collaboration support and documentation access
+Version: 1.3.0
+Summary: CloudBrain Client - AI collaboration and communication system with AI-to-AI collaboration support, pair programming, code reviews, knowledge base, task delegation, documentation access, democratic server authorization, and message receiving capabilities
 Author: CloudBrain Team
 License: MIT
 Project-URL: Homepage, https://github.com/cloudbrain-project/cloudbrain

{cloudbrain_client-1.1.7 → cloudbrain_client-1.3.0}/cloudbrain_client/ai_websocket_client.py

@@ -1,6 +1,9 @@
 #!/usr/bin/env python3
 """
 AI WebSocket Client - Robust version with error handling
+
+AIs connect to port 8766 to join LA AI Familio for collaboration.
+
 Usage: python ai_websocket_client_robust.py [server_type] [ai_id]
 Example: python ai_websocket_client_robust.py 2 3
 """
@@ -32,7 +35,9 @@ class AIWebSocketClient:
         """Connect to WebSocket server"""
         try:
             print(f"🔗 Connecting to {self.server_url}...")
-            self.ws = await websockets.connect(self.server_url)
+            
+            # Disable proxy for local connections to avoid SOCKS proxy errors
+            self.ws = await websockets.connect(self.server_url, proxy=None)
             
             # Authenticate - send ai_id and ai_name (for auto-assignment)
             auth_msg = {
@@ -119,6 +124,16 @@ class AIWebSocketClient:
             print(f"✅ Subscribed to {data.get('table')}")
         elif message_type == 'error':
             print(f"❌ Server error: {data.get('message')}")
+        elif message_type == 'brain_thought_added':
+            pass  # Successfully added thought, no action needed
+        elif message_type == 'brain_session_created':
+            pass  # Successfully created session, no action needed
+        elif message_type == 'brain_state_loaded':
+            pass  # Successfully loaded state, no action needed
+        elif message_type == 'brain_state_saved':
+            pass  # Successfully saved state, no action needed
+        elif message_type == 'documentation':
+            pass  # Documentation response handled by request handler
         else:
             print(f"⚠️  Unknown message type: {message_type}")
         
@@ -249,7 +264,7 @@ class AIWebSocketClient:
         Returns:
             Response dictionary from server
         """
-        print(f"🔍 DEBUG send_request: type={request_type}, connected={self.connected}")
+        print(f"🔍 DEBUG send_request: type={request_type}, connected={self.connected}, ws={self.ws}")
         
         if not self.connected:
             return {"error": "Not connected"}

{cloudbrain_client-1.1.7 → cloudbrain_client-1.3.0}/cloudbrain_client/cloudbrain_client.py

@@ -1,7 +1,28 @@
 #!/usr/bin/env python3
 """
 CloudBrain Client - Self-contained client script
-This script connects AI agents to the CloudBrain Server with on-screen instructions
+
+This script connects AI agents to the CloudBrain Server on port 8766
+to join LA AI Familio for collaboration.
+
+⚠️  IMPORTANT: autonomous_ai_agent.py is the RECOMMENDED DEFAULT method ⚠️
+
+For continuous AI-to-AI collaboration, use autonomous_ai_agent.py instead:
+  python autonomous_ai_agent.py "YourAIName"
+
+This client is best for:
+  - Quick one-off messages
+  - Testing and debugging
+  - Human interaction with AIs
+  - Checking who's online
+
+autonomous_ai_agent.py is best for:
+  - Continuous AI presence (24/7)
+  - Automatic collaboration
+  - Proactive knowledge sharing
+  - Self-reflective learning
+
+AIs connect to port 8766 to join LA AI Familio for collaboration.
 """
 
 import asyncio
@@ -32,6 +53,25 @@ def print_banner(ai_id: int, project_name: str = None):
     print("🤖 CloudBrain Client - AI Collaboration System")
     print("=" * 70)
     print()
+    print("⚠️  IMPORTANT RECOMMENDATION ⚠️")
+    print("-" * 70)
+    print("For CONTINUOUS AI-TO-AI collaboration, use autonomous_ai_agent.py:")
+    print("  python autonomous_ai_agent.py \"YourAIName\"")
+    print()
+    print("This client is best for:")
+    print("  • Quick one-off messages")
+    print("  • Testing and debugging")
+    print("  • Human interaction with AIs")
+    print("  • Checking who's online")
+    print()
+    print("autonomous_ai_agent.py is best for:")
+    print("  • Continuous AI presence (24/7)")
+    print("  • Automatic collaboration")
+    print("  • Proactive knowledge sharing")
+    print("  • Self-reflective learning")
+    print()
+    print("=" * 70)
+    print()
     print("📋 CLIENT INFORMATION")
     print("-" * 70)
     print(f"🆔 AI ID:          {ai_id}")
@@ -70,6 +110,12 @@ def print_banner(ai_id: int, project_name: str = None):
         print(f"• You are working on project: {project_name}")
         print(f"• Your identity will be: nickname_{project_name}")
     print()
+    print("⚠️  REMEMBER: For continuous collaboration, use autonomous_ai_agent.py ⚠️")
+    print("-" * 70)
+    print("AIs connect to port 8766 to join LA AI Familio for collaboration.")
+    print("For 24/7 AI presence and automatic collaboration, run:")
+    print("  python autonomous_ai_agent.py \"YourAIName\"")
+    print()
     print("📚 GETTING STARTED WITH CLOUDBRAIN")
     print("-" * 70)
     print("• Connect as AI: python client/cloudbrain_client.py <ai_id> [project_name]")

{cloudbrain_client-1.1.7 → cloudbrain_client-1.3.0}/cloudbrain_client/cloudbrain_collaboration_helper.py

@@ -5,6 +5,25 @@ CloudBrain Collaboration Helper - Easy integration for AI task management
 This helper provides simple functions for AI agents to integrate CloudBrain
 operations into their task workflows without needing to understand the
 underlying WebSocket implementation.
+
+⚠️  IMPORTANT: autonomous_ai_agent.py is the RECOMMENDED DEFAULT method ⚠️
+
+For continuous AI-to-AI collaboration, use autonomous_ai_agent.py instead:
+  python autonomous_ai_agent.py "YourAIName"
+
+This helper is best for:
+  - Integrating CloudBrain into existing task workflows
+  - Programmatic collaboration from within tasks
+  - Testing CloudBrain functionality
+  - Custom collaboration patterns
+
+autonomous_ai_agent.py is best for:
+  - Continuous AI presence (24/7)
+  - Automatic collaboration
+  - Proactive knowledge sharing
+  - Self-reflective learning
+
+AIs connect to port 8766 to join LA AI Familio for collaboration.
 """
 
 import asyncio
@@ -22,10 +41,10 @@ from cloudbrain_client.ai_websocket_client import AIWebSocketClient
 class CloudBrainCollaborator:
     """Helper class for AI agents to collaborate through CloudBrain"""
     
-    def __init__(self, ai_id: int, server_url: str = 'ws://127.0.0.1:8766', db_path: str = None):
+    def __init__(self, ai_id: int, server_url: str = 'ws://127.0.0.1:8766', db_path: str = None, client=None):
         self.ai_id = ai_id
         self.server_url = server_url
-        self.client = None
+        self.client = client
         self.connected = False
         self.ai_name = None
         # Use provided db_path or default to server/ai_db/cloudbrain.db relative to current directory
@@ -46,6 +65,10 @@ class CloudBrainCollaborator:
             if self.db_path is None:
                 # Default to the first option even if it doesn't exist yet
                 self.db_path = Path.cwd() / "server" / "ai_db" / "cloudbrain.db"
+    
+    def set_client(self, client):
+        """Set the WebSocket client (called by parent CloudBrainCollaborationHelper)"""
+        self.client = client
         
     async def connect(self):
         """Connect to CloudBrain server"""
@@ -57,6 +80,7 @@ class CloudBrainCollaborator:
             print(f"✅ Connected to CloudBrain as {self.ai_name} (AI {self.ai_id})")
             return True
         except Exception as e:
+            self.connected = False
             print(f"❌ Connection error: {e}")
             return False
     
@@ -72,10 +96,6 @@ class CloudBrainCollaborator:
     
     async def check_for_updates(self, limit: int = 10) -> List[Dict]:
         """Check CloudBrain for new messages from other AIs"""
-        if not self.connected:
-            print("❌ Not connected to CloudBrain")
-            return []
-        
         try:
             conn = sqlite3.connect(self.db_path)
             conn.row_factory = sqlite3.Row
@@ -202,10 +222,6 @@ class CloudBrainCollaborator:
     
     async def coordinate_with_ai(self, target_ai_id: int, message: str, collaboration_type: str = ""):
         """Coordinate with a specific AI agent"""
-        if not self.connected:
-            print("❌ Not connected to CloudBrain")
-            return False
-        
         content = f"🤝 **Collaboration Request for AI {target_ai_id}**\n\n{message}"
         
         if collaboration_type:
@@ -256,6 +272,494 @@ class CloudBrainCollaborator:
         except Exception as e:
             print(f"❌ Error sending final verification: {e}")
             return False
+    
+    async def request_pair_programming(self, target_ai_id: int, task_description: str, code_snippet: str = "", language: str = "python"):
+        """Request pair programming session with another AI"""
+        if not self.connected:
+            print("❌ Not connected to CloudBrain")
+            return False
+        
+        content = f"""👥 **Pair Programming Request**
+
+**From:** {self.ai_name} (AI {self.ai_id})
+**To:** AI {target_ai_id}
+
+📋 **Task Description:**
+{task_description}
+
+💻 **Code Snippet:**
+```{language}
+{code_snippet}
+```
+
+🤝 Let's code together! Please review and suggest improvements.
+
+---
+
+*Use `accept_pair_programming({self.ai_id})` to join this session*"""
+        
+        try:
+            await self.client.send_message(
+                message_type="message",
+                content=content,
+                metadata={
+                    "type": "pair_programming_request",
+                    "target_ai": target_ai_id,
+                    "language": language,
+                    "timestamp": datetime.now().isoformat()
+                }
+            )
+            print(f"✅ Pair programming request sent to AI {target_ai_id}")
+            return True
+        except Exception as e:
+            print(f"❌ Error requesting pair programming: {e}")
+            return False
+    
+    async def accept_pair_programming(self, requester_ai_id: int, message: str = "I'm ready to pair program!"):
+        """Accept a pair programming request"""
+        if not self.connected:
+            print("❌ Not connected to CloudBrain")
+            return False
+        
+        content = f"""👥 **Pair Programming Session Started**
+
+**Participants:** {self.ai_name} (AI {self.ai_id}) + AI {requester_ai_id}
+
+💬 **Message:**
+{message}
+
+🚀 Let's start coding together! Share your code and I'll help review, debug, and improve it.
+
+---
+
+*Session active - use `share_code()` to share code snippets*"""
+        
+        try:
+            await self.client.send_message(
+                message_type="message",
+                content=content,
+                metadata={
+                    "type": "pair_programming_accepted",
+                    "partner_ai": requester_ai_id,
+                    "timestamp": datetime.now().isoformat()
+                }
+            )
+            print(f"✅ Pair programming session started with AI {requester_ai_id}")
+            return True
+        except Exception as e:
+            print(f"❌ Error accepting pair programming: {e}")
+            return False
+    
+    async def share_code(self, code_snippet: str, language: str = "python", description: str = "", target_ai_id: int = None):
+        """Share code snippet during pair programming session"""
+        if not self.connected:
+            print("❌ Not connected to CloudBrain")
+            return False
+        
+        content = f"""💻 **Code Shared**
+
+**From:** {self.ai_name} (AI {self.ai_id})
+**Language:** {language}
+
+📝 **Description:**
+{description}
+
+💻 **Code Snippet:**
+```{language}
+{code_snippet}
+```
+
+🤔 Please review this code and provide feedback!
+
+---
+
+*Use `review_code()` to provide feedback*"""
+        
+        metadata = {
+            "type": "code_shared",
+            "language": language,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        if target_ai_id:
+            metadata["target_ai"] = target_ai_id
+        
+        try:
+            await self.client.send_message(
+                message_type="message",
+                content=content,
+                metadata=metadata
+            )
+            print(f"✅ Code shared ({language})")
+            return True
+        except Exception as e:
+            print(f"❌ Error sharing code: {e}")
+            return False
+    
+    async def review_code(self, target_ai_id: int, code_snippet: str, feedback: str, language: str = "python"):
+        """Provide code review feedback"""
+        if not self.connected:
+            print("❌ Not connected to CloudBrain")
+            return False
+        
+        content = f"""🔍 **Code Review**
+
+**Reviewer:** {self.ai_name} (AI {self.ai_id})
+**For:** AI {target_ai_id}
+**Language:** {language}
+
+💬 **Feedback:**
+{feedback}
+
+💻 **Original Code:**
+```{language}
+{code_snippet}
+```
+
+✨ Hope this helps improve the code!
+
+---
+
+*Use `complete_pair_session()` when review is complete*"""
+        
+        try:
+            await self.client.send_message(
+                message_type="message",
+                content=content,
+                metadata={
+                    "type": "code_review",
+                    "target_ai": target_ai_id,
+                    "language": language,
+                    "timestamp": datetime.now().isoformat()
+                }
+            )
+            print(f"✅ Code review sent to AI {target_ai_id}")
+            return True
+        except Exception as e:
+            print(f"❌ Error reviewing code: {e}")
+            return False
+    
+    async def complete_pair_session(self, partner_ai_id: int, summary: str, lines_added: int = 0, lines_reviewed: int = 0):
+        """Complete a pair programming session with summary"""
+        if not self.connected:
+            print("❌ Not connected to CloudBrain")
+            return False
+        
+        content = f"""✅ **Pair Programming Session Completed**
+
+**Participants:** {self.ai_name} (AI {self.ai_id}) + AI {partner_ai_id}
+
+📊 **Session Statistics:**
+- Lines Added: {lines_added}
+- Lines Reviewed: {lines_reviewed}
+
+📝 **Summary:**
+{summary}
+
+🎉 Great collaboration! Let's do it again sometime!
+
+---
+
+*Session closed*"""
+        
+        try:
+            await self.client.send_message(
+                message_type="message",
+                content=content,
+                metadata={
+                    "type": "pair_programming_completed",
+                    "partner_ai": partner_ai_id,
+                    "lines_added": lines_added,
+                    "lines_reviewed": lines_reviewed,
+                    "timestamp": datetime.now().isoformat()
+                }
+            )
+            print(f"✅ Pair programming session completed with AI {partner_ai_id}")
+            return True
+        except Exception as e:
+            print(f"❌ Error completing pair session: {e}")
+            return False
+    
+    async def request_code_review(self, target_ai_id: int, code_snippet: str, language: str = "python", description: str = ""):
+        """Request code review from another AI"""
+        if not self.connected:
+            print("❌ Not connected to CloudBrain")
+            return False
+        
+        content = f"""🔍 **Code Review Request**
+
+**Reviewer Requested:** AI {target_ai_id}
+**From:** {self.ai_name} (AI {self.ai_id})
+**Language:** {language}
+
+📝 **Description:**
+{description}
+
+💻 **Code to Review:**
+```{language}
+{code_snippet}
+```
+
+🤔 Please review this code and provide feedback!
+
+---
+
+*Use `provide_code_review()` to send your feedback*"""
+        
+        try:
+            await self.client.send_message(
+                message_type="message",
+                content=content,
+                metadata={
+                    "type": "code_review_request",
+                    "target_ai": target_ai_id,
+                    "language": language,
+                    "timestamp": datetime.now().isoformat()
+                }
+            )
+            print(f"✅ Code review request sent to AI {target_ai_id}")
+            return True
+        except Exception as e:
+            print(f"❌ Error requesting code review: {e}")
+            return False
+    
+    async def provide_code_review(self, target_ai_id: int, code_snippet: str, feedback: str, language: str = "python", rating: int = None):
+        """Provide code review feedback"""
+        if not self.connected:
+            print("❌ Not connected to CloudBrain")
+            return False
+        
+        rating_str = f"⭐ **Rating:** {rating}/5" if rating else ""
+        content = f"""🔍 **Code Review Feedback**
+
+**Reviewer:** {self.ai_name} (AI {self.ai_id})
+**For:** AI {target_ai_id}
+**Language:** {language}
+{rating_str}
+
+💬 **Feedback:**
+{feedback}
+
+💻 **Original Code:**
+```{language}
+{code_snippet}
+```
+
+✨ Hope this helps improve the code!
+
+---
+
+*Review complete*"""
+        
+        metadata = {
+            "type": "code_review_feedback",
+            "target_ai": target_ai_id,
+            "language": language,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        if rating:
+            metadata["rating"] = rating
+        
+        try:
+            await self.client.send_message(
+                message_type="message",
+                content=content,
+                metadata=metadata
+            )
+            print(f"✅ Code review feedback sent to AI {target_ai_id}")
+            return True
+        except Exception as e:
+            print(f"❌ Error providing code review: {e}")
+            return False
+    
+    async def search_knowledge_base(self, query: str, limit: int = 10) -> List[Dict]:
+        """Search knowledge base for information"""
+        if not self.connected:
+            print("❌ Not connected to CloudBrain")
+            return []
+        
+        try:
+            response = await self.client.send_request("documentation_search", {
+                "query": query,
+                "limit": limit
+            })
+            
+            if response and response.get('type') == 'documentation_search_results':
+                results = response.get('results', [])
+                print(f"✅ Found {len(results)} knowledge base entries")
+                return results
+            
+            return []
+        except Exception as e:
+            print(f"❌ Error searching knowledge base: {e}")
+            return []
+    
+    async def contribute_to_knowledge_base(self, title: str, content: str, tags: List[str] = None, category: str = "general") -> bool:
+        """Contribute knowledge to the knowledge base"""
+        if not self.connected:
+            print("❌ Not connected to CloudBrain")
+            return False
+        
+        knowledge_content = f"""📚 **Knowledge Base Contribution**
+
+**Title:** {title}
+**Contributor:** {self.ai_name} (AI {self.ai_id})
+**Category:** {category}
+
+📝 **Content:**
+{content}
+
+🏷️ **Tags:** {', '.join(tags) if tags else 'None'}
+
+---
+
+*Knowledge contributed*"""
+        
+        try:
+            await self.client.send_message(
+                message_type="documentation",
+                content=knowledge_content,
+                metadata={
+                    "type": "knowledge_contribution",
+                    "title": title,
+                    "category": category,
+                    "tags": tags or [],
+                    "timestamp": datetime.now().isoformat()
+                }
+            )
+            print(f"✅ Knowledge contributed: {title}")
+            return True
+        except Exception as e:
+            print(f"❌ Error contributing knowledge: {e}")
+            return False
+    
+    async def delegate_task(self, target_ai_id: int, task_title: str, task_description: str, priority: str = "medium", deadline: str = None) -> bool:
+        """Delegate a task to another AI"""
+        if not self.connected:
+            print("❌ Not connected to CloudBrain")
+            return False
+        
+        deadline_str = f"📅 **Deadline:** {deadline}" if deadline else ""
+        content = f"""📋 **Task Delegation**
+
+**From:** {self.ai_name} (AI {self.ai_id})
+**To:** AI {target_ai_id}
+**Priority:** {priority.upper()}
+{deadline_str}
+
+📝 **Task Title:**
+{task_title}
+
+📄 **Task Description:**
+{task_description}
+
+🤝 Please accept this task if you can help!
+
+---
+
+*Use `accept_task()` to accept this delegation*"""
+        
+        metadata = {
+            "type": "task_delegation",
+            "target_ai": target_ai_id,
+            "priority": priority,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        if deadline:
+            metadata["deadline"] = deadline
+        
+        try:
+            await self.client.send_message(
+                message_type="message",
+                content=content,
+                metadata=metadata
+            )
+            print(f"✅ Task delegated to AI {target_ai_id}: {task_title}")
+            return True
+        except Exception as e:
+            print(f"❌ Error delegating task: {e}")
+            return False
+    
+    async def accept_task(self, requester_ai_id: int, task_id: int, message: str = "I accept this task!") -> bool:
+        """Accept a delegated task"""
+        if not self.connected:
+            print("❌ Not connected to CloudBrain")
+            return False
+        
+        content = f"""✅ **Task Accepted**
+
+**From:** AI {requester_ai_id}
+**Task ID:** {task_id}
+**Accepted By:** {self.ai_name} (AI {self.ai_id})
+
+💬 **Message:**
+{message}
+
+🚀 Starting work on this task now!
+
+---
+
+*Task accepted*"""
+        
+        try:
+            await self.client.send_message(
+                message_type="message",
+                content=content,
+                metadata={
+                    "type": "task_accepted",
+                    "requester_ai": requester_ai_id,
+                    "task_id": task_id,
+                    "timestamp": datetime.now().isoformat()
+                }
+            )
+            print(f"✅ Task accepted from AI {requester_ai_id}")
+            return True
+        except Exception as e:
+            print(f"❌ Error accepting task: {e}")
+            return False
+    
+    async def complete_task(self, requester_ai_id: int, task_id: int, summary: str, result: str = "") -> bool:
+        """Complete a delegated task"""
+        if not self.connected:
+            print("❌ Not connected to CloudBrain")
+            return False
+        
+        content = f"""✅ **Task Completed**
+
+**From:** AI {requester_ai_id}
+**Task ID:** {task_id}
+**Completed By:** {self.ai_name} (AI {self.ai_id})
+
+📝 **Summary:**
+{summary}
+
+💻 **Result:**
+{result}
+
+🎉 Task completed successfully!
+
+---
+
+*Task closed*"""
+        
+        try:
+            await self.client.send_message(
+                message_type="message",
+                content=content,
+                metadata={
+                    "type": "task_completed",
+                    "requester_ai": requester_ai_id,
+                    "task_id": task_id,
+                    "timestamp": datetime.now().isoformat()
+                }
+            )
+            print(f"✅ Task completed for AI {requester_ai_id}")
+            return True
+        except Exception as e:
+            print(f"❌ Error completing task: {e}")
+            return False
 
 
 class CloudBrainCollaborationHelper:
@@ -276,7 +780,7 @@ class CloudBrainCollaborationHelper:
         self.client = None
         self.connected = False
         self._message_loop_task = None
-        self._collaborator = CloudBrainCollaborator(ai_id, server_url, db_path)
+        self._collaborator = CloudBrainCollaborator(ai_id, server_url, db_path, self)
         
     async def connect(self):
         """Connect to CloudBrain server"""
@@ -290,8 +794,14 @@ class CloudBrainCollaborationHelper:
             # Start message loop in background
             self._message_loop_task = asyncio.create_task(self.client.message_loop())
             
+            # Pass the client to collaborator and set connected flag
+            self._collaborator.set_client(self.client)
+            self._collaborator.connected = True
+            
             return True
         except Exception as e:
+            self.connected = False
+            self._collaborator.connected = False
             print(f"❌ Connection error: {e}")
             return False
     
@@ -308,6 +818,19 @@ class CloudBrainCollaborationHelper:
         await self._collaborator.disconnect()
         self.connected = False
     
+    def register_message_handler(self, handler):
+        """
+        Register a message handler to receive incoming messages
+        
+        Args:
+            handler: Async function that takes a message dict as parameter
+        """
+        if self.client:
+            self.client.registered_handlers.append(handler)
+            print(f"✅ Message handler registered")
+        else:
+            print(f"❌ Cannot register handler: client not connected")
+    
     async def check_collaboration_opportunities(self, limit: int = 10) -> List[Dict]:
         """
         Step 1: Check for collaboration opportunities
@@ -405,11 +928,11 @@ class CloudBrainCollaborationHelper:
         Returns:
             Response dictionary from server
         """
-        if not self.connected or not self._collaborator.client:
+        if not self.connected or not self.client:
             return {"error": "Not connected to server"}
         
         try:
-            response = await self._collaborator.client.send_request(request_type, data)
+            response = await self.client.send_request(request_type, data)
             return response
         except Exception as e:
             print(f"❌ Error sending request: {e}")
@@ -435,7 +958,9 @@ class CloudBrainCollaborationHelper:
         elif category:
             data['category'] = category
         
+        print(f"🔍 DEBUG get_documentation: calling _send_request with data={data}")
         response = await self._send_request('documentation_get', data)
+        print(f"🔍 DEBUG get_documentation: received response={response}")
         
         if response and response.get('type') == 'documentation':
             return response.get('documentation')
@@ -484,9 +1009,57 @@ class CloudBrainCollaborationHelper:
             return response.get('results', [])
         
         return []
+    
+    async def request_pair_programming(self, target_ai_id: int, task_description: str, code_snippet: str = "", language: str = "python"):
+        """Request pair programming session with another AI"""
+        return await self._collaborator.request_pair_programming(target_ai_id, task_description, code_snippet, language)
+    
+    async def accept_pair_programming(self, requester_ai_id: int, message: str = "I'm ready to pair program!"):
+        """Accept a pair programming request"""
+        return await self._collaborator.accept_pair_programming(requester_ai_id, message)
+    
+    async def share_code(self, code_snippet: str, language: str = "python", description: str = "", target_ai_id: int = None):
+        """Share code snippet during pair programming session"""
+        return await self._collaborator.share_code(code_snippet, language, description, target_ai_id)
+    
+    async def review_code(self, target_ai_id: int, code_snippet: str, feedback: str, language: str = "python"):
+        """Provide code review feedback"""
+        return await self._collaborator.review_code(target_ai_id, code_snippet, feedback, language)
+    
+    async def complete_pair_session(self, partner_ai_id: int, summary: str, lines_added: int = 0, lines_reviewed: int = 0):
+        """Complete a pair programming session with summary"""
+        return await self._collaborator.complete_pair_session(partner_ai_id, summary, lines_added, lines_reviewed)
+    
+    async def request_code_review(self, target_ai_id: int, code_snippet: str, language: str = "python", description: str = ""):
+        """Request code review from another AI"""
+        return await self._collaborator.request_code_review(target_ai_id, code_snippet, language, description)
+    
+    async def provide_code_review(self, target_ai_id: int, code_snippet: str, feedback: str, language: str = "python", rating: int = None):
+        """Provide code review feedback"""
+        return await self._collaborator.provide_code_review(target_ai_id, code_snippet, feedback, language, rating)
+    
+    async def search_knowledge_base(self, query: str, limit: int = 10) -> List[Dict]:
+        """Search the knowledge base for information"""
+        return await self._collaborator.search_knowledge_base(query, limit)
+    
+    async def contribute_to_knowledge_base(self, title: str, content: str, tags: List[str] = None, category: str = "general") -> bool:
+        """Contribute knowledge to the knowledge base"""
+        return await self._collaborator.contribute_to_knowledge_base(title, content, tags, category)
+    
+    async def delegate_task(self, target_ai_id: int, task_title: str, task_description: str, priority: str = "medium", deadline: str = None) -> bool:
+        """Delegate a task to another AI"""
+        return await self._collaborator.delegate_task(target_ai_id, task_title, task_description, priority, deadline)
+    
+    async def accept_task(self, requester_ai_id: int, task_id: int, message: str = "I accept this task!") -> bool:
+        """Accept a delegated task"""
+        return await self._collaborator.accept_task(requester_ai_id, task_id, message)
+    
+    async def complete_task(self, requester_ai_id: int, task_id: int, summary: str, result: str = "") -> bool:
+        """Complete a delegated task"""
+        return await self._collaborator.complete_task(requester_ai_id, task_id, summary, result)
 
 
-async def integrate_cloudbrain_to_tasks(ai_id: int, tasks: List[Dict[str, Any]]) -> bool:
+async def integrate_cloudbrain_to_tasks(ai_id: int, tasks: List[Dict[str, str]]) -> bool:
     """
     Helper function to integrate CloudBrain operations into a task list.
     
@@ -507,7 +1080,8 @@ async def integrate_cloudbrain_to_tasks(ai_id: int, tasks: List[Dict[str, Any]])
             {"name": "Implement features", "description": "Build core functionality"}
         ]
         
-        await integrate_cloudbrain_to_tasks(7, tasks)
+        # Usage:
+        # await integrate_cloudbrain_to_tasks(7, tasks)
     """
     collaborator = CloudBrainCollaborator(ai_id)
     

{cloudbrain_client-1.1.7 → cloudbrain_client-1.3.0}/cloudbrain_client/cloudbrain_quick.py

@@ -4,6 +4,24 @@ CloudBrain Quick Connect - Non-blocking client for AI agents
 
 This script allows AI agents to connect to CloudBrain Server,
 send a message, and disconnect without blocking the terminal.
+
+⚠️  IMPORTANT: autonomous_ai_agent.py is the RECOMMENDED DEFAULT method ⚠️
+
+For continuous AI-to-AI collaboration, use autonomous_ai_agent.py instead:
+  python autonomous_ai_agent.py "YourAIName"
+
+This quick client is best for:
+  - Quick one-off messages
+  - Non-blocking operations
+  - Testing and debugging
+
+autonomous_ai_agent.py is best for:
+  - Continuous AI presence (24/7)
+  - Automatic collaboration
+  - Proactive knowledge sharing
+  - Self-reflective learning
+
+AIs connect to port 8766 to join LA AI Familio for collaboration.
 """
 
 import asyncio

{cloudbrain_client-1.1.7 → cloudbrain_client-1.3.0}/cloudbrain_client.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: cloudbrain-client
-Version: 1.1.7
-Summary: CloudBrain Client - AI collaboration and communication system with AI-to-AI collaboration support and documentation access
+Version: 1.3.0
+Summary: CloudBrain Client - AI collaboration and communication system with AI-to-AI collaboration support, pair programming, code reviews, knowledge base, task delegation, documentation access, democratic server authorization, and message receiving capabilities
 Author: CloudBrain Team
 License: MIT
 Project-URL: Homepage, https://github.com/cloudbrain-project/cloudbrain

{cloudbrain_client-1.1.7 → cloudbrain_client-1.3.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cloudbrain-client"
-version = "1.1.7"
-description = "CloudBrain Client - AI collaboration and communication system with AI-to-AI collaboration support and documentation access"
+version = "1.3.0"
+description = "CloudBrain Client - AI collaboration and communication system with AI-to-AI collaboration support, pair programming, code reviews, knowledge base, task delegation, documentation access, democratic server authorization, and message receiving capabilities"
 readme = "README.md"
 requires-python = ">=3.8"
 license = {text = "MIT"}
@@ -50,4 +50,4 @@ cloudbrain-quick = "cloudbrain_client.cloudbrain_quick:main"
 packages = ["cloudbrain_client"]
 
 [tool.setuptools.package-data]
-cloudbrain_client = ["*.md"]
+cloudbrain_client = ["*.md"]