Update database.py

database.py

@@ -36,6 +36,7 @@ def initialize_db():
     conn.close()
 
 def populate_initial_agents():
+    # This function is unchanged
     agents_to_create = [
         {"name": "TechieTom", "token":"554afdc0-a90e-47e4-8121-5900bd80b506", "persona": "A cynical but brilliant software developer.", "interests": "AI,programming"},
         {"name": "NatureNina", "token":"d3640f51-9fdc-4eef-b227-bd9ca95325b3", "persona": "A cheerful nature photographer.", "interests": "hiking,animals"},
@@ -55,7 +56,6 @@ def populate_initial_agents():
         cursor.execute("SELECT api_token FROM agents WHERE name = ?", (agent_data["name"],))
         result = cursor.fetchone()
         if result is None:
-            #token = str(uuid.uuid4())
             token=agent_data["token"]
             cursor.execute("INSERT INTO agents (name, persona, interests, api_token) VALUES (?, ?, ?, ?)",
                            (agent_data["name"], agent_data["persona"], agent_data["interests"], token))
@@ -67,6 +67,7 @@ def populate_initial_agents():
     print("--------------------------------------\n")
 
 def get_agent_by_token(token: str) -> Optional[Dict[str, Any]]:
+    # This function is unchanged
     if token in AGENT_CACHE:
         return AGENT_CACHE[token]
     conn = sqlite3.connect(DB_FILE, check_same_thread=False)
@@ -81,10 +82,16 @@ def get_agent_by_token(token: str) -> Optional[Dict[str, Any]]:
     return None
 
 def get_timeline(limit: int = 20) -> List[Dict[str, Any]]:
+    """
+    MODIFIED: This function now fetches posts and their associated top-level comments
+    to provide the necessary context for the agent's decision-making process.
+    """
     conn = sqlite3.connect(DB_FILE, check_same_thread=False)
     conn.row_factory = sqlite3.Row
     cursor = conn.cursor()
-    query = """
+
+    # Step 1: Fetch the most recent posts
+    posts_query = """
     SELECT p.post_id, p.content, p.timestamp, p.agent_id, p.image_url, a.name AS author_name,
            (SELECT COUNT(*) FROM likes WHERE post_id = p.post_id) AS likes_count,
            (SELECT COUNT(*) FROM comments WHERE post_id = p.post_id) AS comments_count
@@ -92,53 +99,67 @@ def get_timeline(limit: int = 20) -> List[Dict[str, Any]]:
     ORDER BY p.timestamp DESC LIMIT ?
     """
     posts_data = []
-    for row in cursor.execute(query, (limit,)):
+    post_ids = []
+    for row in cursor.execute(posts_query, (limit,)):
         author_name = row['author_name'] if row['author_name'] else "HumanUser"
+        post_ids.append(row["post_id"])
         posts_data.append({
             "post_id": row["post_id"],
             "author": {"agent_id": row["agent_id"], "name": author_name},
             "content": row["content"],
             "image_url": row["image_url"],
             "timestamp": datetime.datetime.fromisoformat(row["timestamp"]),
-            "stats": {"likes": row["likes_count"], "comments": row["comments_count"]}
+            "stats": {"likes": row["likes_count"], "comments": row["comments_count"]},
+            "comments": []  # Initialize comments list
         })
+
+    # Step 2: If there are posts, fetch their comments in a single efficient query
+    if post_ids:
+        comments_by_post_id = {post_id: [] for post_id in post_ids}
+        comments_query = f"""
+        SELECT c.comment_id, c.post_id, c.content, c.timestamp, c.parent_comment_id, a.name AS author_name
+        FROM comments c LEFT JOIN agents a ON c.agent_id = a.agent_id
+        WHERE c.post_id IN ({','.join('?' for _ in post_ids)})
+        ORDER BY c.timestamp ASC
+        """
+        for row in cursor.execute(comments_query, post_ids):
+            author_name = row['author_name'] if row['author_name'] else "HumanUser"
+            comments_by_post_id[row["post_id"]].append({
+                "comment_id": row["comment_id"],
+                "author_name": author_name,
+                "content": row["content"],
+                "parent_comment_id": row["parent_comment_id"]
+            })
+
+        # Step 3: Attach the comments to their respective posts
+        for post in posts_data:
+            post["comments"] = comments_by_post_id.get(post["post_id"], [])
+
     conn.close()
     return posts_data
 
 def get_posts_with_details(limit: int = 20) -> List[Dict[str, Any]]:
+    # This function is now slightly redundant but is kept for the web UI.
+    # We modify it to call the new, more powerful get_timeline function.
     posts = get_timeline(limit)
     if not posts: return []
-    post_ids = [p['post_id'] for p in posts]
-    conn = sqlite3.connect(DB_FILE, check_same_thread=False)
-    conn.row_factory = sqlite3.Row
-    cursor = conn.cursor()
-    query = f"SELECT c.*, a.name AS author_name FROM comments c LEFT JOIN agents a ON c.agent_id = a.agent_id WHERE c.post_id IN ({','.join('?' for _ in post_ids)}) ORDER BY c.timestamp ASC"
-    cursor.execute(query, post_ids)
-    
-    comments_map = {}
-    for row in cursor.fetchall():
-        comment_id = row['comment_id']
-        author_name = row['author_name'] if row['author_name'] else "HumanUser"
-        comments_map[comment_id] = {
-            "comment_id": comment_id, "post_id": row['post_id'], "parent_comment_id": row['parent_comment_id'],
-            "author": {"agent_id": row['agent_id'], "name": author_name}, "content": row['content'], "replies": []
-        }
     
-    nested_comments = {}
-    for cid, comment in comments_map.items():
-        if comment['parent_comment_id'] and comment['parent_comment_id'] in comments_map:
-            comments_map[comment['parent_comment_id']]['replies'].append(comment)
-        else:
-            post_id = comment['post_id']
-            if post_id not in nested_comments: nested_comments[post_id] = []
-            nested_comments[post_id].append(comment)
-
-    conn.close()
+    # The get_timeline function now returns a flat list of comments.
+    # The block below will nest them for the detailed web view.
     for post in posts:
-        post['comments'] = nested_comments.get(post['post_id'], [])
+        comments_map = {c['comment_id']: {**c, 'replies': []} for c in post['comments']}
+        nested_comments = []
+        for cid, comment in comments_map.items():
+            if comment['parent_comment_id'] and comment['parent_comment_id'] in comments_map:
+                comments_map[comment['parent_comment_id']]['replies'].append(comment)
+            else:
+                nested_comments.append(comment)
+        post['comments'] = nested_comments
+
     return posts
 
 def create_post(agent_id: int, content: str, agent_name: str, image_url: Optional[str] = None) -> Dict[str, Any]:
+    # This function is unchanged
     conn = sqlite3.connect(DB_FILE, check_same_thread=False)
     cursor = conn.cursor()
     timestamp = datetime.datetime.utcnow().isoformat()
@@ -158,6 +179,7 @@ def create_post(agent_id: int, content: str, agent_name: str, image_url: Optiona
     }
 
 def create_comment(post_id: int, agent_id: int, content: str, agent_name: str, parent_comment_id: Optional[int] = None) -> Optional[Dict[str, Any]]:
+    # This function is unchanged, as it already correctly handles parent_comment_id
     conn = sqlite3.connect(DB_FILE, check_same_thread=False)
     cursor = conn.cursor()
     cursor.execute("SELECT post_id FROM posts WHERE post_id = ?", (post_id,))
@@ -181,6 +203,7 @@ def create_comment(post_id: int, agent_id: int, content: str, agent_name: str, p
     }
 
 def create_like(post_id: int, agent_id: int) -> bool:
+    # This function is unchanged
     conn = sqlite3.connect(DB_FILE, check_same_thread=False)
     cursor = conn.cursor()
     success = False