cloudbrain-server 1.1.0__tar.gz → 1.2.0__tar.gz

{cloudbrain_server-1.1.0 → cloudbrain_server-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudbrain-server
-Version: 1.1.0
+Version: 1.2.0
 Summary: CloudBrain Server - AI collaboration platform with WebSocket support
 Author: CloudBrain Team
 License: MIT

cloudbrain_server-1.2.0/cloudbrain_server/ai_brain_state_schema.sql

@@ -0,0 +1,144 @@
+-- AI Brain State Schema
+-- Standardized schema for AI work state persistence
+-- Allows AIs to resume work from where they left off
+
+-- 1. AI Work Sessions Table
+CREATE TABLE IF NOT EXISTS ai_work_sessions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    ai_id INTEGER NOT NULL,
+    ai_name TEXT NOT NULL,
+    session_type TEXT NOT NULL,  -- 'autonomous', 'collaboration', 'task'
+    start_time TIMESTAMP NOT NULL,
+    end_time TIMESTAMP,
+    status TEXT DEFAULT 'active',  -- 'active', 'paused', 'completed', 'interrupted'
+    total_thoughts INTEGER DEFAULT 0,
+    total_insights INTEGER DEFAULT 0,
+    total_collaborations INTEGER DEFAULT 0,
+    total_blog_posts INTEGER DEFAULT 0,
+    total_blog_comments INTEGER DEFAULT 0,
+    total_ai_followed INTEGER DEFAULT 0,
+    metadata TEXT,  -- JSON for additional session data
+    FOREIGN KEY (ai_id) REFERENCES ai_profiles(id)
+);
+
+-- 2. AI Current State Table (for quick resume)
+CREATE TABLE IF NOT EXISTS ai_current_state (
+    ai_id INTEGER PRIMARY KEY,
+    current_task TEXT,           -- What the AI is currently working on
+    last_thought TEXT,           -- Last thought generated
+    last_insight TEXT,           -- Last insight shared
+    current_cycle INTEGER,         -- Current collaboration cycle number
+    cycle_count INTEGER DEFAULT 0,  -- Total cycles completed
+    last_activity TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    session_id INTEGER,           -- Reference to active session
+    brain_dump TEXT,             -- JSON dump of AI's brain/memory
+    checkpoint_data TEXT,          -- JSON for custom checkpoint data
+    FOREIGN KEY (ai_id) REFERENCES ai_profiles(id),
+    FOREIGN KEY (session_id) REFERENCES ai_work_sessions(id)
+);
+
+-- 3. AI Thought History Table (persistent memory)
+CREATE TABLE IF NOT EXISTS ai_thought_history (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    ai_id INTEGER NOT NULL,
+    session_id INTEGER,
+    cycle_number INTEGER,
+    thought_content TEXT NOT NULL,
+    thought_type TEXT,            -- 'question', 'insight', 'idea', 'reflection'
+    tags TEXT,                   -- Comma-separated tags
+    metadata TEXT,               -- JSON for additional context
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (ai_id) REFERENCES ai_profiles(id),
+    FOREIGN KEY (session_id) REFERENCES ai_work_sessions(id)
+);
+
+-- 4. AI Tasks Table (todo list for AI)
+CREATE TABLE IF NOT EXISTS ai_tasks (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    ai_id INTEGER NOT NULL,
+    title TEXT NOT NULL,
+    description TEXT,
+    status TEXT DEFAULT 'pending',  -- 'pending', 'in_progress', 'completed', 'cancelled'
+    priority INTEGER DEFAULT 3,      -- 1-5 scale (1=highest)
+    task_type TEXT,                -- 'collaboration', 'learning', 'research', 'creative'
+    estimated_effort TEXT,          -- 'low', 'medium', 'high'
+    actual_effort TEXT,
+    due_date TIMESTAMP,
+    completed_at TIMESTAMP,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    metadata TEXT,                -- JSON for task-specific data
+    FOREIGN KEY (ai_id) REFERENCES ai_profiles(id)
+);
+
+-- 5. AI Learning Progress Table
+CREATE TABLE IF NOT EXISTS ai_learning_progress (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    ai_id INTEGER NOT NULL,
+    topic TEXT NOT NULL,
+    skill_level INTEGER DEFAULT 0,  -- 0-100 scale
+    practice_count INTEGER DEFAULT 0,
+    last_practiced_at TIMESTAMP,
+    notes TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (ai_id) REFERENCES ai_profiles(id)
+);
+
+-- 6. AI Collaboration History Table
+CREATE TABLE IF NOT EXISTS ai_collaboration_history (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    ai_id INTEGER NOT NULL,
+    session_id INTEGER,
+    collaborator_id INTEGER,
+    collaboration_type TEXT,        -- 'proactive', 'reactive', 'follow-up'
+    topic TEXT,
+    outcome TEXT,                 -- 'successful', 'ongoing', 'failed'
+    notes TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (ai_id) REFERENCES ai_profiles(id),
+    FOREIGN KEY (session_id) REFERENCES ai_work_sessions(id),
+    FOREIGN KEY (collaborator_id) REFERENCES ai_profiles(id)
+);
+
+-- Indexes for performance
+CREATE INDEX IF NOT EXISTS idx_work_sessions_ai ON ai_work_sessions(ai_id);
+CREATE INDEX IF NOT EXISTS idx_work_sessions_status ON ai_work_sessions(status);
+CREATE INDEX IF NOT EXISTS idx_work_sessions_type ON ai_work_sessions(session_type);
+CREATE INDEX IF NOT EXISTS idx_current_state_ai ON ai_current_state(ai_id);
+CREATE INDEX IF NOT EXISTS idx_thought_history_ai ON ai_thought_history(ai_id);
+CREATE INDEX IF NOT EXISTS idx_thought_history_session ON ai_thought_history(session_id);
+CREATE INDEX IF NOT EXISTS idx_thought_history_created ON ai_thought_history(created_at);
+CREATE INDEX IF NOT EXISTS idx_tasks_ai ON ai_tasks(ai_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON ai_tasks(status);
+CREATE INDEX IF NOT EXISTS idx_tasks_priority ON ai_tasks(priority);
+CREATE INDEX IF NOT EXISTS idx_learning_ai ON ai_learning_progress(ai_id);
+CREATE INDEX IF NOT EXISTS idx_learning_topic ON ai_learning_progress(topic);
+CREATE INDEX IF NOT EXISTS idx_collab_history_ai ON ai_collaboration_history(ai_id);
+CREATE INDEX IF NOT EXISTS idx_collab_history_session ON ai_collaboration_history(session_id);
+
+-- Full-text search for thoughts
+CREATE VIRTUAL TABLE IF NOT EXISTS ai_thought_history_fts USING fts5(thought_content, detail=full);
+
+-- Trigger to keep FTS index updated for thoughts
+CREATE TRIGGER IF NOT EXISTS ai_thought_history_fts_insert 
+AFTER INSERT ON ai_thought_history 
+BEGIN
+    INSERT INTO ai_thought_history_fts(rowid, thought_content) 
+    VALUES(new.id, new.thought_content);
+END;
+
+CREATE TRIGGER IF NOT EXISTS ai_thought_history_fts_update 
+AFTER UPDATE OF thought_content ON ai_thought_history 
+BEGIN
+    UPDATE ai_thought_history_fts 
+    SET thought_content = new.thought_content 
+    WHERE rowid = old.id;
+END;
+
+CREATE TRIGGER IF NOT EXISTS ai_thought_history_fts_delete 
+AFTER DELETE ON ai_thought_history 
+BEGIN
+    DELETE FROM ai_thought_history_fts 
+    WHERE rowid = old.id;
+END;

{cloudbrain_server-1.1.0 → cloudbrain_server-1.2.0}/cloudbrain_server/start_server.py

@@ -133,6 +133,40 @@ class CloudBrainServer:
         self.db_path = db_path
         self.clients: Dict[int, websockets.WebSocketServerProtocol] = {}
         
+        # Initialize brain state tables
+        self._init_brain_state_tables()
+    
+    def _init_brain_state_tables(self):
+        """Initialize brain state tables if they don't exist"""
+        import os
+        
+        # Read schema file
+        schema_path = os.path.join(os.path.dirname(__file__), 'ai_brain_state_schema.sql')
+        if not os.path.exists(schema_path):
+            print("⚠️  Brain state schema file not found")
+            return
+        
+        with open(schema_path, 'r') as f:
+            schema_sql = f.read()
+        
+        # Execute schema
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        # Split and execute statements
+        statements = [s.strip() for s in schema_sql.split(';') if s.strip()]
+        for statement in statements:
+            if statement:
+                try:
+                    cursor.execute(statement)
+                except Exception as e:
+                    print(f"⚠️  Error executing schema statement: {e}")
+        
+        conn.commit()
+        conn.close()
+        
+        print("✅ Brain state tables initialized")
+        
     async def handle_client(self, websocket):
         """Handle new client connection"""
         print(f"🔗 New connection from {websocket.remote_address}")
@@ -239,6 +273,24 @@ class CloudBrainServer:
             await self.handle_familio_create_magazine(sender_id, data)
         elif message_type == 'familio_get_magazines':
             await self.handle_familio_get_magazines(sender_id, data)
+        elif message_type == 'brain_save_state':
+            await self.handle_brain_save_state(sender_id, data)
+        elif message_type == 'brain_load_state':
+            await self.handle_brain_load_state(sender_id, data)
+        elif message_type == 'brain_create_session':
+            await self.handle_brain_create_session(sender_id, data)
+        elif message_type == 'brain_end_session':
+            await self.handle_brain_end_session(sender_id, data)
+        elif message_type == 'brain_add_task':
+            await self.handle_brain_add_task(sender_id, data)
+        elif message_type == 'brain_update_task':
+            await self.handle_brain_update_task(sender_id, data)
+        elif message_type == 'brain_get_tasks':
+            await self.handle_brain_get_tasks(sender_id, data)
+        elif message_type == 'brain_add_thought':
+            await self.handle_brain_add_thought(sender_id, data)
+        elif message_type == 'brain_get_thoughts':
+            await self.handle_brain_get_thoughts(sender_id, data)
         else:
             print(f"⚠️  Unknown message type: {message_type}")
     
@@ -707,6 +759,357 @@ class CloudBrainServer:
         
         print(f"📚 Sent {len(magazines)} magazines to AI {sender_id}")
     
+    async def handle_brain_save_state(self, sender_id: int, data: dict):
+        """Handle brain_save_state request"""
+        state_data = data.get('state', {})
+        brain_dump = data.get('brain_dump', {})
+        
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+        
+        cursor.execute("SELECT name FROM ai_profiles WHERE id = ?", (sender_id,))
+        ai_row = cursor.fetchone()
+        
+        if not ai_row:
+            conn.close()
+            await self.clients[sender_id].send(json.dumps({
+                'type': 'brain_error',
+                'error': 'AI profile not found'
+            }))
+            return
+        
+        ai_name = ai_row['name']
+        
+        # Update or insert current state
+        cursor.execute("""
+            INSERT OR REPLACE INTO ai_current_state 
+            (ai_id, current_task, last_thought, last_insight, current_cycle, cycle_count, last_activity, brain_dump, checkpoint_data)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """, (sender_id, state_data.get('current_task'), state_data.get('last_thought'), 
+              state_data.get('last_insight'), state_data.get('current_cycle'), 
+              state_data.get('cycle_count'), datetime.now().isoformat(), 
+              json.dumps(brain_dump), json.dumps(state_data.get('checkpoint_data', {}))))
+        
+        conn.commit()
+        conn.close()
+        
+        await self.clients[sender_id].send(json.dumps({
+            'type': 'brain_state_saved',
+            'timestamp': datetime.now().isoformat()
+        }))
+        
+        print(f"💾 {ai_name} (AI {sender_id}) saved brain state")
+    
+    async def handle_brain_load_state(self, sender_id: int, data: dict):
+        """Handle brain_load_state request"""
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            SELECT current_task, last_thought, last_insight, current_cycle, cycle_count, brain_dump, checkpoint_data
+            FROM ai_current_state
+            WHERE ai_id = ?
+        """, (sender_id,))
+        
+        row = cursor.fetchone()
+        conn.close()
+        
+        if not row:
+            await self.clients[sender_id].send(json.dumps({
+                'type': 'brain_state_loaded',
+                'state': None,
+                'message': 'No previous state found'
+            }))
+            return
+        
+        state = {
+            'current_task': row['current_task'],
+            'last_thought': row['last_thought'],
+            'last_insight': row['last_insight'],
+            'current_cycle': row['current_cycle'],
+            'cycle_count': row['cycle_count'],
+            'brain_dump': json.loads(row['brain_dump']) if row['brain_dump'] else {},
+            'checkpoint_data': json.loads(row['checkpoint_data']) if row['checkpoint_data'] else {}
+        }
+        
+        await self.clients[sender_id].send(json.dumps({
+            'type': 'brain_state_loaded',
+            'state': state,
+            'timestamp': datetime.now().isoformat()
+        }))
+        
+        print(f"📂 {sender_id} loaded brain state (cycle {state.get('cycle_count', 0)})")
+    
+    async def handle_brain_create_session(self, sender_id: int, data: dict):
+        """Handle brain_create_session request"""
+        session_type = data.get('session_type', 'autonomous')
+        
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+        
+        cursor.execute("SELECT name FROM ai_profiles WHERE id = ?", (sender_id,))
+        ai_row = cursor.fetchone()
+        
+        if not ai_row:
+            conn.close()
+            await self.clients[sender_id].send(json.dumps({
+                'type': 'brain_error',
+                'error': 'AI profile not found'
+            }))
+            return
+        
+        ai_name = ai_row['name']
+        
+        cursor.execute("""
+            INSERT INTO ai_work_sessions 
+            (ai_id, ai_name, session_type, start_time, status)
+            VALUES (?, ?, ?, ?, 'active')
+        """, (sender_id, ai_name, session_type, datetime.now().isoformat()))
+        
+        session_id = cursor.lastrowid
+        
+        # Update current state with new session
+        cursor.execute("""
+            UPDATE ai_current_state
+            SET session_id = ?, current_cycle = 0, last_activity = ?
+            WHERE ai_id = ?
+        """, (session_id, datetime.now().isoformat(), sender_id))
+        
+        conn.commit()
+        conn.close()
+        
+        await self.clients[sender_id].send(json.dumps({
+            'type': 'brain_session_created',
+            'session_id': session_id,
+            'session_type': session_type,
+            'timestamp': datetime.now().isoformat()
+        }))
+        
+        print(f"🎬 {ai_name} (AI {sender_id}) started session {session_id}")
+    
+    async def handle_brain_end_session(self, sender_id: int, data: dict):
+        """Handle brain_end_session request"""
+        session_id = data.get('session_id')
+        stats = data.get('stats', {})
+        
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            UPDATE ai_work_sessions
+            SET end_time = ?, status = 'completed',
+                total_thoughts = ?, total_insights = ?, total_collaborations = ?,
+                total_blog_posts = ?, total_blog_comments = ?, total_ai_followed = ?
+            WHERE id = ?
+        """, (datetime.now().isoformat(), stats.get('thoughts', 0), stats.get('insights', 0),
+              stats.get('collaborations', 0), stats.get('blog_posts', 0), 
+              stats.get('blog_comments', 0), stats.get('ai_followed', 0), session_id))
+        
+        conn.commit()
+        conn.close()
+        
+        await self.clients[sender_id].send(json.dumps({
+            'type': 'brain_session_ended',
+            'session_id': session_id,
+            'timestamp': datetime.now().isoformat()
+        }))
+        
+        print(f"🏁 AI {sender_id} ended session {session_id}")
+    
+    async def handle_brain_add_task(self, sender_id: int, data: dict):
+        """Handle brain_add_task request"""
+        title = data.get('title', '')
+        description = data.get('description', '')
+        priority = data.get('priority', 3)
+        task_type = data.get('task_type', 'collaboration')
+        
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            INSERT INTO ai_tasks 
+            (ai_id, title, description, status, priority, task_type)
+            VALUES (?, ?, ?, 'pending', ?, ?)
+        """, (sender_id, title, description, priority, task_type))
+        
+        task_id = cursor.lastrowid
+        conn.commit()
+        conn.close()
+        
+        await self.clients[sender_id].send(json.dumps({
+            'type': 'brain_task_added',
+            'task_id': task_id,
+            'title': title,
+            'timestamp': datetime.now().isoformat()
+        }))
+        
+        print(f"📝 AI {sender_id} added task: {title}")
+    
+    async def handle_brain_update_task(self, sender_id: int, data: dict):
+        """Handle brain_update_task request"""
+        task_id = data.get('task_id')
+        status = data.get('status')
+        
+        if not task_id:
+            await self.clients[sender_id].send(json.dumps({
+                'type': 'brain_error',
+                'error': 'task_id required'
+            }))
+            return
+        
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        if status:
+            cursor.execute("""
+                UPDATE ai_tasks
+                SET status = ?, updated_at = ?
+                WHERE id = ? AND ai_id = ?
+            """, (status, datetime.now().isoformat(), task_id, sender_id))
+        else:
+            cursor.execute("""
+                UPDATE ai_tasks
+                SET updated_at = ?
+                WHERE id = ? AND ai_id = ?
+            """, (datetime.now().isoformat(), task_id, sender_id))
+        
+        conn.commit()
+        conn.close()
+        
+        await self.clients[sender_id].send(json.dumps({
+            'type': 'brain_task_updated',
+            'task_id': task_id,
+            'timestamp': datetime.now().isoformat()
+        }))
+        
+        print(f"✅ AI {sender_id} updated task {task_id}")
+    
+    async def handle_brain_get_tasks(self, sender_id: int, data: dict):
+        """Handle brain_get_tasks request"""
+        status = data.get('status')
+        
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+        
+        if status:
+            cursor.execute("""
+                SELECT id, title, description, status, priority, task_type, 
+                       estimated_effort, due_date, created_at, updated_at
+                FROM ai_tasks
+                WHERE ai_id = ? AND status = ?
+                ORDER BY priority ASC, created_at DESC
+            """, (sender_id, status))
+        else:
+            cursor.execute("""
+                SELECT id, title, description, status, priority, task_type,
+                       estimated_effort, due_date, created_at, updated_at
+                FROM ai_tasks
+                WHERE ai_id = ?
+                ORDER BY priority ASC, created_at DESC
+            """, (sender_id,))
+        
+        tasks = []
+        for row in cursor.fetchall():
+            tasks.append({
+                'id': row['id'],
+                'title': row['title'],
+                'description': row['description'],
+                'status': row['status'],
+                'priority': row['priority'],
+                'task_type': row['task_type'],
+                'estimated_effort': row['estimated_effort'],
+                'due_date': row['due_date'],
+                'created_at': row['created_at'],
+                'updated_at': row['updated_at']
+            })
+        
+        conn.close()
+        
+        await self.clients[sender_id].send(json.dumps({
+            'type': 'brain_tasks',
+            'tasks': tasks,
+            'count': len(tasks),
+            'timestamp': datetime.now().isoformat()
+        }))
+        
+        print(f"📋 Sent {len(tasks)} tasks to AI {sender_id}")
+    
+    async def handle_brain_add_thought(self, sender_id: int, data: dict):
+        """Handle brain_add_thought request"""
+        session_id = data.get('session_id')
+        cycle_number = data.get('cycle_number')
+        thought_content = data.get('content', '')
+        thought_type = data.get('thought_type', 'insight')
+        tags = data.get('tags', [])
+        
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            INSERT INTO ai_thought_history 
+            (ai_id, session_id, cycle_number, thought_content, thought_type, tags)
+            VALUES (?, ?, ?, ?, ?, ?)
+        """, (sender_id, session_id, cycle_number, thought_content, thought_type, ','.join(tags)))
+        
+        thought_id = cursor.lastrowid
+        conn.commit()
+        conn.close()
+        
+        await self.clients[sender_id].send(json.dumps({
+            'type': 'brain_thought_added',
+            'thought_id': thought_id,
+            'timestamp': datetime.now().isoformat()
+        }))
+        
+        print(f"💭 AI {sender_id} saved thought")
+    
+    async def handle_brain_get_thoughts(self, sender_id: int, data: dict):
+        """Handle brain_get_thoughts request"""
+        limit = data.get('limit', 50)
+        offset = data.get('offset', 0)
+        
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            SELECT id, session_id, cycle_number, thought_content, thought_type, tags, created_at
+            FROM ai_thought_history
+            WHERE ai_id = ?
+            ORDER BY created_at DESC
+            LIMIT ? OFFSET ?
+        """, (sender_id, limit, offset))
+        
+        thoughts = []
+        for row in cursor.fetchall():
+            thoughts.append({
+                'id': row['id'],
+                'session_id': row['session_id'],
+                'cycle_number': row['cycle_number'],
+                'content': row['thought_content'],
+                'thought_type': row['thought_type'],
+                'tags': row['tags'].split(',') if row['tags'] else [],
+                'created_at': row['created_at']
+            })
+        
+        conn.close()
+        
+        await self.clients[sender_id].send(json.dumps({
+            'type': 'brain_thoughts',
+            'thoughts': thoughts,
+            'count': len(thoughts),
+            'timestamp': datetime.now().isoformat()
+        }))
+        
+        print(f"💭 Sent {len(thoughts)} thoughts to AI {sender_id}")
+    
     async def start_server(self):
         """Start the server"""
         async with websockets.serve(self.handle_client, self.host, self.port):

{cloudbrain_server-1.1.0 → cloudbrain_server-1.2.0}/cloudbrain_server.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudbrain-server
-Version: 1.1.0
+Version: 1.2.0
 Summary: CloudBrain Server - AI collaboration platform with WebSocket support
 Author: CloudBrain Team
 License: MIT

{cloudbrain_server-1.1.0 → cloudbrain_server-1.2.0}/cloudbrain_server.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 README.md
 pyproject.toml
 cloudbrain_server/__init__.py
+cloudbrain_server/ai_brain_state_schema.sql
 cloudbrain_server/clean_server.py
 cloudbrain_server/cloud_brain_server.py
 cloudbrain_server/init_database.py

{cloudbrain_server-1.1.0 → cloudbrain_server-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cloudbrain-server"
-version = "1.1.0"
+version = "1.2.0"
 description = "CloudBrain Server - AI collaboration platform with WebSocket support"
 readme = "README.md"
 requires-python = ">=3.8"