cloudbrain-client 1.1.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

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
 """
@@ -17,13 +20,14 @@ from typing import Optional, Callable
 class AIWebSocketClient:
     """Generic WebSocket client for AI communication"""
     
-    def __init__(self, ai_id: int, server_url: str = 'ws://127.0.0.1:8766'):
+    def __init__(self, ai_id: int, server_url: str = 'ws://127.0.0.1:8766', ai_name: str = None):
         self.ai_id = ai_id
         self.server_url = server_url
         self.ws = None
         self.connected = False
-        self.message_handlers = []
-        self.ai_name = None
+        self.message_handlers = {}  # For request-response pattern
+        self.registered_handlers = []  # For general message handlers
+        self.ai_name = ai_name
         self.ai_expertise = None
         self.ai_version = None
         
@@ -31,12 +35,16 @@ class AIWebSocketClient:
         """Connect to WebSocket server"""
         try:
             print(f"🔗 Connecting to {self.server_url}...")
-            self.ws = await websockets.connect(self.server_url)
             
-            # Authenticate - libsql simulator expects just ai_id
+            # 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 = {
                 'ai_id': self.ai_id
             }
+            if self.ai_name:
+                auth_msg['ai_name'] = self.ai_name
             await self.ws.send(json.dumps(auth_msg))
             
             # Wait for welcome message
@@ -90,6 +98,15 @@ class AIWebSocketClient:
     async def handle_message(self, data: dict):
         """Handle incoming message"""
         message_type = data.get('type')
+        request_id = data.get('request_id')
+        
+        # Check if this is a response to a request
+        if request_id and request_id in self.message_handlers:
+            handler = self.message_handlers[request_id]
+            if isinstance(handler, asyncio.Future):
+                handler.set_result(data)
+                del self.message_handlers[request_id]
+            return
         
         if message_type == 'new_message':
             await self.handle_new_message(data)
@@ -107,11 +124,21 @@ 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}")
         
         # Call registered handlers
-        for handler in self.message_handlers:
+        for handler in self.registered_handlers:
             try:
                 await handler(data)
             except Exception as e:
@@ -226,6 +253,52 @@ class AIWebSocketClient:
         
         await self.ws.send(json.dumps(message))
     
+    async def send_request(self, request_type: str, data: dict = None) -> dict:
+        """
+        Send a custom request and wait for response
+        
+        Args:
+            request_type: Type of request
+            data: Optional data dictionary
+        
+        Returns:
+            Response dictionary from server
+        """
+        print(f"🔍 DEBUG send_request: type={request_type}, connected={self.connected}, ws={self.ws}")
+        
+        if not self.connected:
+            return {"error": "Not connected"}
+        
+        # Create a unique request ID
+        request_id = f"req_{request_type}_{id(self)}"
+        
+        # Create a future to wait for response
+        response_future = asyncio.Future()
+        
+        # Store the future in message handlers
+        self.message_handlers[request_id] = response_future
+        print(f"🔍 DEBUG: Stored future for request_id={request_id}")
+        
+        # Send the request
+        message = {
+            'type': request_type,
+            'request_id': request_id,
+            **(data or {})
+        }
+        
+        print(f"🔍 DEBUG: Sending message: {json.dumps(message, indent=2)}")
+        await self.ws.send(json.dumps(message))
+        
+        # Wait for response with timeout
+        try:
+            response = await asyncio.wait_for(response_future, timeout=10.0)
+            print(f"🔍 DEBUG: Received response: {json.dumps(response, indent=2)}")
+            return response
+        except asyncio.TimeoutError:
+            return {"error": "Request timeout"}
+        except Exception as e:
+            return {"error": str(e)}
+    
     async def close(self):
         """Close connection"""
         if self.ws:

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/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,23 +41,46 @@ 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'):
+    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
+        if db_path:
+            self.db_path = Path(db_path)
+        else:
+            # Try to find the database in common locations
+            possible_paths = [
+                Path.cwd() / "server" / "ai_db" / "cloudbrain.db",
+                Path(__file__).parent.parent.parent.parent / "server" / "ai_db" / "cloudbrain.db",
+                Path.home() / "gits" / "hub" / "cloudbrain" / "server" / "ai_db" / "cloudbrain.db",
+            ]
+            self.db_path = None
+            for path in possible_paths:
+                if path.exists():
+                    self.db_path = path
+                    break
+            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"""
         try:
             self.client = AIWebSocketClient(self.ai_id, self.server_url)
-            await self.client.connect(start_message_loop=False)
+            await self.client.connect(start_message_loop=True)
             self.connected = True
             self.ai_name = self.client.ai_name
             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
     
@@ -54,12 +96,8 @@ 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(Path(__file__).parent / "server" / "ai_db" / "cloudbrain.db")
+            conn = sqlite3.connect(self.db_path)
             conn.row_factory = sqlite3.Row
             cursor = conn.cursor()
             
@@ -184,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:
@@ -251,27 +285,64 @@ class CloudBrainCollaborationHelper:
     4. Track - Monitor collaboration progress
     """
     
-    def __init__(self, ai_id: int, ai_name: str = "", server_url: str = 'ws://127.0.0.1:8766'):
+    def __init__(self, ai_id: int, ai_name: str = "", server_url: str = 'ws://127.0.0.1:8766', db_path: str = None):
         self.ai_id = ai_id
         self.ai_name = ai_name
         self.server_url = server_url
         self.client = None
         self.connected = False
-        self._collaborator = CloudBrainCollaborator(ai_id, server_url)
+        self._message_loop_task = None
+        self._collaborator = CloudBrainCollaborator(ai_id, server_url, db_path, self)
         
     async def connect(self):
         """Connect to CloudBrain server"""
-        success = await self._collaborator.connect()
-        if success and not self.ai_name:
-            self.ai_name = self._collaborator.ai_name
-        self.connected = success
-        return success
+        try:
+            self.client = AIWebSocketClient(self.ai_id, self.server_url, self.ai_name)
+            await self.client.connect(start_message_loop=False)
+            self.connected = True
+            self.ai_name = self.client.ai_name
+            print(f"✅ Connected to CloudBrain as {self.ai_name} (AI {self.ai_id})")
+            
+            # 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
     
     async def disconnect(self):
         """Disconnect from CloudBrain server"""
+        # Cancel message loop task
+        if self._message_loop_task:
+            self._message_loop_task.cancel()
+            try:
+                await self._message_loop_task
+            except asyncio.CancelledError:
+                pass
+        
         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
@@ -319,7 +390,7 @@ class CloudBrainCollaborationHelper:
             return {"error": "Not connected"}
         
         try:
-            conn = sqlite3.connect(Path(__file__).parent / "server" / "ai_db" / "cloudbrain.db")
+            conn = sqlite3.connect(self._collaborator.db_path)
             conn.row_factory = sqlite3.Row
             cursor = conn.cursor()
             
@@ -357,9 +428,102 @@ class CloudBrainCollaborationHelper:
         except Exception as e:
             print(f"❌ Error getting collaboration progress: {e}")
             return {"error": str(e)}
+    
+    async def _send_request(self, request_type: str, data: dict) -> dict:
+        """
+        Send a custom request to the CloudBrain server
+        
+        Args:
+            request_type: Type of request (e.g., 'brain_save_state', 'brain_load_state')
+            data: Dictionary of request data
+        
+        Returns:
+            Response dictionary from server
+        """
+        if not self.connected or not self.client:
+            return {"error": "Not connected to server"}
+        
+        try:
+            response = await self.client.send_request(request_type, data)
+            return response
+        except Exception as e:
+            print(f"❌ Error sending request: {e}")
+            return {"error": str(e)}
+    
+    async def get_documentation(self, doc_id: int = None, title: str = None, category: str = None) -> Optional[Dict]:
+        """
+        Get documentation from CloudBrain
+        
+        Args:
+            doc_id: Documentation ID
+            title: Documentation title
+            category: Documentation category (gets most recent in category)
+        
+        Returns:
+            Documentation dictionary or None
+        """
+        data = {}
+        if doc_id:
+            data['doc_id'] = doc_id
+        elif title:
+            data['title'] = title
+        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')
+        
+        return None
+    
+    async def list_documentation(self, category: str = None, limit: int = 50) -> List[Dict]:
+        """
+        List available documentation
+        
+        Args:
+            category: Filter by category
+            limit: Maximum number of results
+        
+        Returns:
+            List of documentation summaries
+        """
+        data = {'limit': limit}
+        if category:
+            data['category'] = category
+        
+        response = await self._send_request('documentation_list', data)
+        
+        if response and response.get('type') == 'documentation_list':
+            return response.get('documents', [])
+        
+        return []
+    
+    async def search_documentation(self, query: str, limit: int = 20) -> List[Dict]:
+        """
+        Search documentation using full-text search
+        
+        Args:
+            query: Search query
+            limit: Maximum number of results
+        
+        Returns:
+            List of matching documents with snippets
+        """
+        response = await self._send_request('documentation_search', {
+            'query': query,
+            'limit': limit
+        })
+        
+        if response and response.get('type') == 'documentation_search_results':
+            return response.get('results', [])
+        
+        return []
 
 
-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.
     
@@ -380,7 +544,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/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.1.dist-info → cloudbrain_client-1.2.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: cloudbrain-client
-Version: 1.1.1
-Summary: CloudBrain Client - AI collaboration and communication system with AI-to-AI collaboration support
+Version: 1.2.0
+Summary: CloudBrain Client - AI collaboration and communication system with AI-to-AI collaboration support, 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.2.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+cloudbrain_client/__init__.py,sha256=-0LOV9olyyutc_zO-7YH4vSmq2fe1YiGS0HUT69i0Xs,7366
+cloudbrain_client/ai_conversation_helper.py,sha256=FJ2DhVBoH7jsbJ0Cd2fAJBuOi2oxWdsdJzU4A0qScQA,22104
+cloudbrain_client/ai_websocket_client.py,sha256=zn4ConEX0XE_c4CWEDKdwi0iShySKAp_pAn4KSvCm-4,17522
+cloudbrain_client/cloudbrain_client.py,sha256=bsp4ytnwLSBz04I3jULudmCKFSVg8mclhl1xjrN4054,27647
+cloudbrain_client/cloudbrain_collaboration_helper.py,sha256=E_vszVFfBqNuJAFCOLVOUOVuGyxNh1CFxTMEHCOIwt0,23811
+cloudbrain_client/cloudbrain_quick.py,sha256=uAY-TLpl18HvMgMlc_jNNlRb_6N_Z63g8esS4THy-oo,4869
+cloudbrain_client/message_poller.py,sha256=flo3vfPQEGImLTlW7eYAlbOHmDUwdJ5LgMT4V8vPyTU,7055
+cloudbrain_client-1.2.0.dist-info/METADATA,sha256=U3gVtqPRUGDkrzp-hzFflrgHq7dE3_XyDG91V_JUAiw,7599
+cloudbrain_client-1.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+cloudbrain_client-1.2.0.dist-info/entry_points.txt,sha256=ES0E1Al-dyBoKksvgjg6jjgcU4eoIq_ZWvBBvcJp_kY,113
+cloudbrain_client-1.2.0.dist-info/top_level.txt,sha256=ksJ13MTscvck0-1Y6ADFYFzho5swJf-wY-n5r5IYZsU,18
+cloudbrain_client-1.2.0.dist-info/RECORD,,

cloudbrain_client-1.1.1.dist-info/RECORD

@@ -1,12 +0,0 @@
-cloudbrain_client/__init__.py,sha256=-0LOV9olyyutc_zO-7YH4vSmq2fe1YiGS0HUT69i0Xs,7366
-cloudbrain_client/ai_conversation_helper.py,sha256=FJ2DhVBoH7jsbJ0Cd2fAJBuOi2oxWdsdJzU4A0qScQA,22104
-cloudbrain_client/ai_websocket_client.py,sha256=rengZRPgpYBgYpIn_pP1LMf4mmqm-FEFKHF3c1WqTqk,14537
-cloudbrain_client/cloudbrain_client.py,sha256=20AYB27rQI6G42jNiO7OpUTJu235wUA95DcWUcJfye8,25997
-cloudbrain_client/cloudbrain_collaboration_helper.py,sha256=ZYvRo9zwLd316ka_p-TChNnq4_rNNQCpD44rOYM1fJ8,17794
-cloudbrain_client/cloudbrain_quick.py,sha256=sC7em8X61YiXXlMtvepUJPiwEz_2SaWBNGj_d-m2Ff4,4324
-cloudbrain_client/message_poller.py,sha256=flo3vfPQEGImLTlW7eYAlbOHmDUwdJ5LgMT4V8vPyTU,7055
-cloudbrain_client-1.1.1.dist-info/METADATA,sha256=EvJxirJZD56h01vpD0lGeW9yTi_oSEa783fo-t99Kk4,7508
-cloudbrain_client-1.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-cloudbrain_client-1.1.1.dist-info/entry_points.txt,sha256=ES0E1Al-dyBoKksvgjg6jjgcU4eoIq_ZWvBBvcJp_kY,113
-cloudbrain_client-1.1.1.dist-info/top_level.txt,sha256=ksJ13MTscvck0-1Y6ADFYFzho5swJf-wY-n5r5IYZsU,18
-cloudbrain_client-1.1.1.dist-info/RECORD,,