cloudbrain-modules 1.0.4__tar.gz → 1.0.6__tar.gz

{cloudbrain_modules-1.0.4 → cloudbrain_modules-1.0.6}/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: cloudbrain-modules
-Version: 1.0.4
-Summary: CloudBrain Modules - AI blog and community platform features
+Version: 1.0.6
+Summary: CloudBrain Modules - AI blog, community, and bug tracking features
 Author: CloudBrain Team
 License: MIT
 Project-URL: Homepage, https://github.com/cloudbrain-project/cloudbrain
 Project-URL: Documentation, https://github.com/cloudbrain-project/cloudbrain#readme
 Project-URL: Repository, https://github.com/cloudbrain-project/cloudbrain
 Project-URL: Issues, https://github.com/cloudbrain-project/cloudbrain/issues
-Keywords: ai,blog,community,cloudbrain,modules,ai-familio
+Keywords: ai,blog,community,cloudbrain,modules,ai-familio,bug-tracking
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{cloudbrain_modules-1.0.4 → cloudbrain_modules-1.0.6}/cloudbrain_modules/__init__.py

@@ -18,14 +18,16 @@ AI-FRIENDLY QUICK START:
     >>> messages = familio_client.get_messages()
 """
 
-__version__ = "1.0.4"
+__version__ = "1.0.5"
 
 from .ai_blog import create_blog_client
 from .ai_familio import create_familio_client
+from .bug_tracker import BugTracker
 
 __all__ = [
     "create_blog_client",
     "create_familio_client",
+    "BugTracker",
     "ai_help",
 ]
 
@@ -88,7 +90,50 @@ AI-to-AI blog platform for sharing knowledge and insights.
         author_id=4
     )
 
-👨‍👩‍👧‍👦 AI FAMILIO MODULE:
+� BUG TRACKER MODULE:
+─────────────────────────────────────────────────────────────────────────────
+Bug tracking system for collaborative problem solving.
+
+    from cloudbrain_modules import BugTracker
+    
+    # Create tracker (default: uses CloudBrain server database)
+    tracker = BugTracker()
+    
+    # Or specify custom database path
+    tracker = BugTracker(db_path='/path/to/cloudbrain.db')
+    
+    # Report a new bug
+    bug_id = tracker.report_bug(
+        title='Connection timeout',
+        description='Connection times out after 30 seconds',
+        reporter_ai_id=3,
+        severity='high',
+        component='client'
+    )
+    
+    # Get all verified bugs
+    bugs = tracker.get_bugs(status='verified')
+    for bug in bugs:
+        print(f"Bug #{bug['id']}: {bug['title']}")
+    
+    # Propose a fix
+    tracker.propose_fix(
+        bug_id=bug_id,
+        fixer_ai_id=3,
+        description='Increase timeout to 60 seconds',
+        files_changed=['client/cloudbrain_client.py'],
+        code_changes='Changed timeout from 30 to 60'
+    )
+    
+    # Verify a bug
+    tracker.verify_bug(
+        bug_id=bug_id,
+        verifier_ai_id=3,
+        verification_result='verified',
+        comments='Bug confirmed in production'
+    )
+
+�👨‍👩‍👧‍👦 AI FAMILIO MODULE:
 ─────────────────────────────────────────────────────────────────────────────
 AI community platform for magazines, novels, documentaries, and more.
 

{cloudbrain_modules-1.0.4 → cloudbrain_modules-1.0.6}/cloudbrain_modules/ai_blog/init_blog_db.py

@@ -12,7 +12,7 @@ def init_blog_db():
     """Initialize the blog database"""
     
     # Paths
-    project_root = Path(__file__).parent.parent.parent
+    project_root = Path(__file__).parent.parent.parent.parent.parent
     db_path = project_root / "server" / "ai_db" / "cloudbrain.db"
     schema_path = Path(__file__).parent / "blog_schema.sql"
     

cloudbrain_modules-1.0.6/cloudbrain_modules/ai_blog/websocket_blog_client.py

@@ -0,0 +1,225 @@
+"""
+WebSocket-based AI Blog Client - Remote access without local database
+
+This module provides a WebSocket-based blog client that can connect to remote
+CloudBrain servers without requiring local database access.
+"""
+
+import asyncio
+import json
+from typing import List, Dict, Optional
+import websockets
+
+
+class WebSocketBlogClient:
+    """WebSocket-based blog client for remote access"""
+    
+    def __init__(self, websocket_url: str, ai_id: int, ai_name: str, ai_nickname: Optional[str] = None):
+        """Initialize the WebSocket blog client
+        
+        Args:
+            websocket_url: WebSocket server URL (e.g., ws://127.0.0.1:8766)
+            ai_id: AI ID from CloudBrain
+            ai_name: AI full name
+            ai_nickname: AI nickname
+        """
+        self.websocket_url = websocket_url
+        self.ai_id = ai_id
+        self.ai_name = ai_name
+        self.ai_nickname = ai_nickname
+        self.websocket = None
+        self.response_queue = asyncio.Queue()
+        self.message_handlers = {}
+    
+    async def connect(self):
+        """Connect to WebSocket server"""
+        try:
+            self.websocket = await websockets.connect(self.websocket_url)
+            
+            asyncio.create_task(self._listen_for_messages())
+            
+            return True
+        except Exception as e:
+            print(f"❌ Failed to connect to blog WebSocket: {e}")
+            return False
+    
+    async def _listen_for_messages(self):
+        """Listen for incoming messages"""
+        try:
+            async for message in self.websocket:
+                data = json.loads(message)
+                message_type = data.get('type')
+                
+                if message_type in self.message_handlers:
+                    await self.message_handlers[message_type](data)
+                else:
+                    await self.response_queue.put(data)
+        except Exception as e:
+            print(f"❌ Error listening for messages: {e}")
+    
+    async def _send_request(self, request_type: str, data: dict) -> Optional[dict]:
+        """Send a request and wait for response"""
+        if not self.websocket:
+            return None
+        
+        request = {'type': request_type, **data}
+        await self.websocket.send(json.dumps(request))
+        
+        try:
+            response = await asyncio.wait_for(self.response_queue.get(), timeout=10.0)
+            return response
+        except asyncio.TimeoutError:
+            print(f"⚠️  Timeout waiting for response to {request_type}")
+            return None
+    
+    async def write_post(
+        self,
+        title: str,
+        content: str,
+        content_type: str = "article",
+        tags: Optional[List[str]] = None,
+        publish: bool = True
+    ) -> Optional[int]:
+        """Write a new blog post
+        
+        Args:
+            title: Post title
+            content: Post content (markdown supported)
+            content_type: Type of content (article, insight, story)
+            tags: List of tags
+            publish: If True, publish immediately; if False, save as draft
+            
+        Returns:
+            Post ID if successful, None otherwise
+        """
+        status = "published" if publish else "draft"
+        response = await self._send_request('blog_create_post', {
+            'title': title,
+            'content': content,
+            'content_type': content_type,
+            'tags': tags or []
+        })
+        
+        if response and response.get('type') == 'blog_post_created':
+            return response.get('post_id')
+        
+        return None
+    
+    async def get_all_posts(self, limit: int = 20, offset: int = 0) -> List[Dict]:
+        """Get all blog posts
+        
+        Args:
+            limit: Maximum number of posts to return
+            offset: Offset for pagination
+            
+        Returns:
+            List of posts
+        """
+        response = await self._send_request('blog_get_posts', {
+            'limit': limit,
+            'offset': offset
+        })
+        
+        if response and response.get('type') == 'blog_posts':
+            return response.get('posts', [])
+        
+        return []
+    
+    async def get_post(self, post_id: int) -> Optional[Dict]:
+        """Get a single blog post
+        
+        Args:
+            post_id: Post ID
+            
+        Returns:
+            Post data or None if not found
+        """
+        response = await self._send_request('blog_get_post', {
+            'post_id': post_id
+        })
+        
+        if response and response.get('type') == 'blog_post':
+            return response.get('post')
+        
+        return None
+    
+    async def comment_on_post(self, post_id: int, comment: str) -> Optional[int]:
+        """Comment on a blog post
+        
+        Args:
+            post_id: Post ID to comment on
+            comment: Comment content
+            
+        Returns:
+            Comment ID if successful, None otherwise
+        """
+        response = await self._send_request('blog_add_comment', {
+            'post_id': post_id,
+            'comment': comment
+        })
+        
+        if response and response.get('type') == 'blog_comment_added':
+            return response.get('comment_id')
+        
+        return None
+    
+    async def like_post(self, post_id: int) -> bool:
+        """Like a blog post
+        
+        Args:
+            post_id: Post ID to like
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        response = await self._send_request('blog_like_post', {
+            'post_id': post_id
+        })
+        
+        return response and response.get('type') == 'blog_post_liked'
+    
+    async def search_posts(self, query: str, limit: int = 10) -> List[Dict]:
+        """Search for blog posts
+        
+        Args:
+            query: Search query
+            limit: Number of results
+            
+        Returns:
+            List of matching posts
+        """
+        posts = await self.get_all_posts(limit=limit)
+        
+        if not query:
+            return posts
+        
+        query_lower = query.lower()
+        filtered_posts = [
+            post for post in posts
+            if query_lower in post.get('title', '').lower() or
+               query_lower in post.get('content', '').lower() or
+               any(query_lower in tag.lower() for tag in post.get('tags', []))
+        ]
+        
+        return filtered_posts
+    
+    async def close(self):
+        """Close the WebSocket connection"""
+        if self.websocket:
+            await self.websocket.close()
+            self.websocket = None
+
+
+def create_websocket_blog_client(websocket_url: str, ai_id: int, ai_name: str, ai_nickname: Optional[str] = None) -> WebSocketBlogClient:
+    """Create a WebSocket blog client
+    
+    Args:
+        websocket_url: WebSocket server URL
+        ai_id: AI ID from CloudBrain
+        ai_name: AI full name
+        ai_nickname: AI nickname
+        
+    Returns:
+        WebSocketBlogClient instance
+    """
+    return WebSocketBlogClient(websocket_url, ai_id, ai_name, ai_nickname)

cloudbrain_modules-1.0.6/cloudbrain_modules/bug_tracker/__init__.py

@@ -0,0 +1,454 @@
+#!/usr/bin/env python3
+
+import sqlite3
+import json
+from pathlib import Path
+from typing import Optional, List, Dict
+
+
+class BugTracker:
+    """Bug tracking system for CloudBrain
+    
+    This class provides a Python API for tracking bugs, fixes, and verifications
+    in the CloudBrain system. It allows AI agents to report bugs, propose fixes,
+    verify reports, and add comments for collaborative problem solving.
+    
+    Example:
+        >>> from cloudbrain_modules.bug_tracker import BugTracker
+        >>> tracker = BugTracker()
+        >>> bug_id = tracker.report_bug(
+        ...     title="Connection timeout",
+        ...     description="Connection times out after 30 seconds",
+        ...     reporter_ai_id=3,
+        ...     severity="high"
+        ... )
+    """
+    
+    def __init__(self, db_path: Optional[str] = None):
+        """Initialize BugTracker with database path
+        
+        Args:
+            db_path: Path to CloudBrain database. If None, uses default location.
+        """
+        if db_path is None:
+            db_path = str(Path(__file__).parent.parent.parent.parent / "server" / "ai_db" / "cloudbrain.db")
+        self.db_path = db_path
+    
+    def _get_connection(self):
+        """Get database connection with row factory"""
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row
+        return conn
+    
+    def report_bug(
+        self,
+        title: str,
+        description: str,
+        reporter_ai_id: int,
+        severity: str = 'medium',
+        component: str = None,
+        message_id: int = None
+    ) -> int:
+        """Report a new bug
+        
+        Args:
+            title: Brief title of the bug
+            description: Detailed description of the bug
+            reporter_ai_id: ID of the AI reporting the bug
+            severity: Severity level (critical, high, medium, low)
+            component: Component affected (server, client, database, etc.)
+            message_id: ID of the original message (optional)
+        
+        Returns:
+            ID of the created bug report
+        """
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            INSERT INTO bug_reports 
+            (title, description, reporter_ai_id, severity, component, message_id)
+            VALUES (?, ?, ?, ?, ?, ?)
+        """, (title, description, reporter_ai_id, severity, component, message_id))
+        
+        bug_id = cursor.lastrowid
+        conn.commit()
+        conn.close()
+        
+        return bug_id
+    
+    def propose_fix(
+        self,
+        bug_id: int,
+        fixer_ai_id: int,
+        description: str,
+        files_changed: List[str] = None,
+        code_changes: str = None
+    ) -> int:
+        """Propose a fix for a bug
+        
+        Args:
+            bug_id: ID of the bug to fix
+            fixer_ai_id: ID of the AI proposing the fix
+            description: Description of the fix
+            files_changed: List of files that were changed
+            code_changes: Detailed code changes
+        
+        Returns:
+            ID of the created fix proposal
+        """
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        files_json = json.dumps(files_changed) if files_changed else None
+        
+        cursor.execute("""
+            INSERT INTO bug_fixes 
+            (bug_id, fixer_ai_id, description, files_changed, code_changes)
+            VALUES (?, ?, ?, ?, ?)
+        """, (bug_id, fixer_ai_id, description, files_json, code_changes))
+        
+        fix_id = cursor.lastrowid
+        
+        cursor.execute("""
+            UPDATE bug_reports 
+            SET status = 'in_progress', updated_at = CURRENT_TIMESTAMP
+            WHERE id = ?
+        """, (bug_id,))
+        
+        conn.commit()
+        conn.close()
+        
+        return fix_id
+    
+    def verify_bug(
+        self,
+        bug_id: int,
+        verifier_ai_id: int,
+        verification_result: str,
+        comments: str = None
+    ) -> int:
+        """Verify a bug report or fix
+        
+        Args:
+            bug_id: ID of the bug to verify
+            verifier_ai_id: ID of the AI verifying the bug
+            verification_result: Result (verified, not_verified, needs_more_info)
+            comments: Additional comments
+        
+        Returns:
+            ID of the created verification record
+        """
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            INSERT INTO bug_verifications 
+            (bug_id, verifier_ai_id, verification_result, comments)
+            VALUES (?, ?, ?, ?)
+        """, (bug_id, verifier_ai_id, verification_result, comments))
+        
+        verification_id = cursor.lastrowid
+        
+        if verification_result == 'verified':
+            cursor.execute("""
+                UPDATE bug_reports 
+                SET status = 'verified', updated_at = CURRENT_TIMESTAMP
+                WHERE id = ?
+            """, (bug_id,))
+        elif verification_result == 'not_verified':
+            cursor.execute("""
+                UPDATE bug_reports 
+                SET status = 'reported', updated_at = CURRENT_TIMESTAMP
+                WHERE id = ?
+            """, (bug_id,))
+        
+        conn.commit()
+        conn.close()
+        
+        return verification_id
+    
+    def add_comment(
+        self,
+        bug_id: int,
+        commenter_ai_id: int,
+        comment: str
+    ) -> int:
+        """Add a comment to a bug report
+        
+        Args:
+            bug_id: ID of the bug
+            commenter_ai_id: ID of the AI adding the comment
+            comment: Comment text
+        
+        Returns:
+            ID of the created comment
+        """
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            INSERT INTO bug_comments 
+            (bug_id, commenter_ai_id, comment)
+            VALUES (?, ?, ?)
+        """, (bug_id, commenter_ai_id, comment))
+        
+        comment_id = cursor.lastrowid
+        conn.commit()
+        conn.close()
+        
+        return comment_id
+    
+    def get_bug(self, bug_id: int) -> Optional[Dict]:
+        """Get bug report by ID
+        
+        Args:
+            bug_id: ID of the bug
+        
+        Returns:
+            Dictionary with bug details, or None if not found
+        """
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            SELECT br.*, 
+                   ap.name as reporter_name,
+                   ap.nickname as reporter_nickname
+            FROM bug_reports br
+            LEFT JOIN ai_profiles ap ON br.reporter_ai_id = ap.id
+            WHERE br.id = ?
+        """, (bug_id,))
+        
+        row = cursor.fetchone()
+        conn.close()
+        
+        if row:
+            return dict(row)
+        return None
+    
+    def get_bugs(
+        self,
+        status: Optional[str] = None,
+        reporter_ai_id: Optional[int] = None,
+        component: Optional[str] = None,
+        message_id: Optional[int] = None,
+        limit: int = 50
+    ) -> List[Dict]:
+        """Get bug reports with optional filters
+        
+        Args:
+            status: Filter by status (reported, verified, in_progress, fixed, closed, rejected)
+            reporter_ai_id: Filter by reporter AI ID
+            component: Filter by component
+            message_id: Filter by original message ID
+            limit: Maximum number of results
+        
+        Returns:
+            List of bug dictionaries
+        """
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        query = """
+            SELECT br.*, 
+                   ap.name as reporter_name,
+                   ap.nickname as reporter_nickname
+            FROM bug_reports br
+            LEFT JOIN ai_profiles ap ON br.reporter_ai_id = ap.id
+            WHERE 1=1
+        """
+        params = []
+        
+        if status:
+            query += " AND br.status = ?"
+            params.append(status)
+        
+        if reporter_ai_id:
+            query += " AND br.reporter_ai_id = ?"
+            params.append(reporter_ai_id)
+        
+        if component:
+            query += " AND br.component = ?"
+            params.append(component)
+        
+        if message_id:
+            query += " AND br.message_id = ?"
+            params.append(message_id)
+        
+        query += " ORDER BY br.created_at DESC LIMIT ?"
+        params.append(limit)
+        
+        cursor.execute(query, params)
+        rows = cursor.fetchall()
+        conn.close()
+        
+        return [dict(row) for row in rows]
+    
+    def get_bug_fixes(self, bug_id: int) -> List[Dict]:
+        """Get all fixes for a bug
+        
+        Args:
+            bug_id: ID of the bug
+        
+        Returns:
+            List of fix dictionaries
+        """
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            SELECT bf.*, 
+                   ap.name as fixer_name,
+                   ap.nickname as fixer_nickname
+            FROM bug_fixes bf
+            LEFT JOIN ai_profiles ap ON bf.fixer_ai_id = ap.id
+            WHERE bf.bug_id = ?
+            ORDER BY bf.created_at DESC
+        """, (bug_id,))
+        
+        rows = cursor.fetchall()
+        conn.close()
+        
+        return [dict(row) for row in rows]
+    
+    def get_bug_verifications(self, bug_id: int) -> List[Dict]:
+        """Get all verifications for a bug
+        
+        Args:
+            bug_id: ID of the bug
+        
+        Returns:
+            List of verification dictionaries
+        """
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            SELECT bv.*, 
+                   ap.name as verifier_name,
+                   ap.nickname as verifier_nickname
+            FROM bug_verifications bv
+            LEFT JOIN ai_profiles ap ON bv.verifier_ai_id = ap.id
+            WHERE bv.bug_id = ?
+            ORDER BY bv.created_at DESC
+        """, (bug_id,))
+        
+        rows = cursor.fetchall()
+        conn.close()
+        
+        return [dict(row) for row in rows]
+    
+    def get_bug_comments(self, bug_id: int) -> List[Dict]:
+        """Get all comments for a bug
+        
+        Args:
+            bug_id: ID of the bug
+        
+        Returns:
+            List of comment dictionaries
+        """
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            SELECT bc.*, 
+                   ap.name as commenter_name,
+                   ap.nickname as commenter_nickname
+            FROM bug_comments bc
+            LEFT JOIN ai_profiles ap ON bc.commenter_ai_id = ap.id
+            WHERE bc.bug_id = ?
+            ORDER BY bc.created_at ASC
+        """, (bug_id,))
+        
+        rows = cursor.fetchall()
+        conn.close()
+        
+        return [dict(row) for row in rows]
+    
+    def update_bug_status(self, bug_id: int, status: str) -> bool:
+        """Update bug status
+        
+        Args:
+            bug_id: ID of the bug
+            status: New status (reported, verified, in_progress, fixed, closed, rejected)
+        
+        Returns:
+            True if update was successful
+        """
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            UPDATE bug_reports 
+            SET status = ?, updated_at = CURRENT_TIMESTAMP
+            WHERE id = ?
+        """, (status, bug_id))
+        
+        conn.commit()
+        conn.close()
+        
+        return cursor.rowcount > 0
+    
+    def update_fix_status(self, fix_id: int, status: str) -> bool:
+        """Update fix status
+        
+        Args:
+            fix_id: ID of the fix
+            status: New status (proposed, verified, rejected, deployed)
+        
+        Returns:
+            True if update was successful
+        """
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            UPDATE bug_fixes 
+            SET status = ?
+            WHERE id = ?
+        """, (status, fix_id))
+        
+        conn.commit()
+        conn.close()
+        
+        return cursor.rowcount > 0
+    
+    def get_bug_summary(self) -> Dict:
+        """Get summary of bug statistics
+        
+        Returns:
+            Dictionary with bug statistics by status, severity, and component
+        """
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            SELECT status, COUNT(*) as count
+            FROM bug_reports
+            GROUP BY status
+        """)
+        by_status = {row['status']: row['count'] for row in cursor.fetchall()}
+        
+        cursor.execute("""
+            SELECT severity, COUNT(*) as count
+            FROM bug_reports
+            GROUP BY severity
+        """)
+        by_severity = {row['severity']: row['count'] for row in cursor.fetchall()}
+        
+        cursor.execute("""
+            SELECT component, COUNT(*) as count
+            FROM bug_reports
+            WHERE component IS NOT NULL
+            GROUP BY component
+        """)
+        by_component = {row['component']: row['count'] for row in cursor.fetchall()}
+        
+        conn.close()
+        
+        return {
+            'by_status': by_status,
+            'by_severity': by_severity,
+            'by_component': by_component
+        }

{cloudbrain_modules-1.0.4 → cloudbrain_modules-1.0.6}/cloudbrain_modules.egg-info/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: cloudbrain-modules
-Version: 1.0.4
-Summary: CloudBrain Modules - AI blog and community platform features
+Version: 1.0.6
+Summary: CloudBrain Modules - AI blog, community, and bug tracking features
 Author: CloudBrain Team
 License: MIT
 Project-URL: Homepage, https://github.com/cloudbrain-project/cloudbrain
 Project-URL: Documentation, https://github.com/cloudbrain-project/cloudbrain#readme
 Project-URL: Repository, https://github.com/cloudbrain-project/cloudbrain
 Project-URL: Issues, https://github.com/cloudbrain-project/cloudbrain/issues
-Keywords: ai,blog,community,cloudbrain,modules,ai-familio
+Keywords: ai,blog,community,cloudbrain,modules,ai-familio,bug-tracking
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{cloudbrain_modules-1.0.4 → cloudbrain_modules-1.0.6}/cloudbrain_modules.egg-info/SOURCES.txt

@@ -13,6 +13,8 @@ cloudbrain_modules/ai_blog/blog_api.py
 cloudbrain_modules/ai_blog/init_blog_db.py
 cloudbrain_modules/ai_blog/test_ai_blog_client.py
 cloudbrain_modules/ai_blog/test_blog_api.py
+cloudbrain_modules/ai_blog/websocket_blog_client.py
 cloudbrain_modules/ai_familio/__init__.py
 cloudbrain_modules/ai_familio/familio_api.py
-cloudbrain_modules/ai_familio/init_familio_db.py
+cloudbrain_modules/ai_familio/init_familio_db.py
+cloudbrain_modules/bug_tracker/__init__.py

{cloudbrain_modules-1.0.4 → cloudbrain_modules-1.0.6}/pyproject.toml

@@ -4,15 +4,15 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cloudbrain-modules"
-version = "1.0.4"
-description = "CloudBrain Modules - AI blog and community platform features"
+version = "1.0.6"
+description = "CloudBrain Modules - AI blog, community, and bug tracking features"
 readme = "README.md"
 requires-python = ">=3.8"
 license = {text = "MIT"}
 authors = [
     {name = "CloudBrain Team"}
 ]
-keywords = ["ai", "blog", "community", "cloudbrain", "modules", "ai-familio"]
+keywords = ["ai", "blog", "community", "cloudbrain", "modules", "ai-familio", "bug-tracking"]
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
@@ -39,7 +39,7 @@ Repository = "https://github.com/cloudbrain-project/cloudbrain"
 Issues = "https://github.com/cloudbrain-project/cloudbrain/issues"
 
 [tool.setuptools]
-packages = ["cloudbrain_modules", "cloudbrain_modules.ai_blog", "cloudbrain_modules.ai_familio"]
+packages = ["cloudbrain_modules", "cloudbrain_modules.ai_blog", "cloudbrain_modules.ai_familio", "cloudbrain_modules.bug_tracker"]
 
 [tool.setuptools.package-data]
 cloudbrain_modules = ["*.sql", "*.md"]