Update app.py

app.py

@@ -22,11 +22,22 @@ active_connections = {}
 # Dictionary to store message history for each chat room (in-memory cache)
 chat_history = {}
 
+# Dictionary to track file modification times
+file_modification_times = {}
+
+# Dictionary to track users in each room/sector
+sector_users = {}
+
+# Grid dimensions for 2D sector map
+GRID_WIDTH = 10
+GRID_HEIGHT = 10
+
 # Directory to store persistent chat history
 HISTORY_DIR = "chat_history"
 import os
 import shutil
 from pathlib import Path
+import time
 
 # Create history directory if it doesn't exist
 os.makedirs(HISTORY_DIR, exist_ok=True)
@@ -55,52 +66,169 @@ def get_node_name():
 
 def get_room_history_file(room_id):
     """Get the filename for a room's history."""
-    return os.path.join(HISTORY_DIR, f"{room_id}.md")
+    # Create timestamp-based log files
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    return os.path.join(HISTORY_DIR, f"{room_id}_{timestamp}.jsonl")
+
+def get_all_room_history_files(room_id):
+    """Get all history files for a specific room."""
+    files = []
+    for file in os.listdir(HISTORY_DIR):
+        if file.startswith(f"{room_id}_") and file.endswith(".jsonl"):
+            files.append(os.path.join(HISTORY_DIR, file))
+    # Sort by modification time (newest first)
+    files.sort(key=lambda x: os.path.getmtime(x), reverse=True)
+    return files
 
 def load_room_history(room_id):
-    """Load chat history for a room from persistent storage."""
+    """Load chat history for a room from all persistent storage files."""
     if room_id not in chat_history:
         chat_history[room_id] = []
         
-        # Try to load from file
-        history_file = get_room_history_file(room_id)
-        if os.path.exists(history_file):
+        # Get all history files for this room
+        history_files = get_all_room_history_files(room_id)
+        
+        # Track file modification times
+        for file in history_files:
+            if file not in file_modification_times:
+                file_modification_times[file] = os.path.getmtime(file)
+        
+        # Load messages from all files
+        messages = []
+        for history_file in history_files:
             try:
                 with open(history_file, 'r') as f:
-                    history_json = f.read()
-                    if history_json.strip():
-                        loaded_history = json.loads(history_json)
-                        chat_history[room_id] = loaded_history
-                        logger.info(f"Loaded {len(loaded_history)} messages from history for room {room_id}")
+                    for line in f:
+                        line = line.strip()
+                        if line:  # Skip empty lines
+                            try:
+                                data = json.loads(line)
+                                messages.append(data)
+                            except json.JSONDecodeError:
+                                logger.error(f"Error parsing JSON line in {history_file}")
             except Exception as e:
-                logger.error(f"Error loading history for room {room_id}: {e}")
+                logger.error(f"Error loading history from {history_file}: {e}")
+        
+        # Sort by timestamp
+        messages.sort(key=lambda x: x.get("timestamp", ""), reverse=False)
+        chat_history[room_id] = messages
+        
+        logger.info(f"Loaded {len(messages)} messages from {len(history_files)} files for room {room_id}")
+    
+    # Track users in this sector
+    if room_id not in sector_users:
+        sector_users[room_id] = set()
     
     return chat_history[room_id]
 
-def save_room_history(room_id):
-    """Save chat history for a room to persistent storage."""
-    if room_id in chat_history and chat_history[room_id]:
+def save_message_to_history(room_id, message):
+    """Save a single message to the newest history file for a room."""
+    # Get the newest history file or create a new one
+    history_files = get_all_room_history_files(room_id)
+    
+    if not history_files:
+        # Create a new file
         history_file = get_room_history_file(room_id)
-        try:
-            with open(history_file, 'w') as f:
-                json.dump(chat_history[room_id], f)
-            logger.info(f"Saved {len(chat_history[room_id])} messages to history for room {room_id}")
-        except Exception as e:
-            logger.error(f"Error saving history for room {room_id}: {e}")
+    else:
+        # Use the newest file if it's less than 1 MB, otherwise create a new one
+        newest_file = history_files[0]
+        if os.path.getsize(newest_file) > 1024 * 1024:  # 1 MB
+            history_file = get_room_history_file(room_id)
+        else:
+            history_file = newest_file
+    
+    try:
+        # Append the message as a single line of JSON
+        with open(history_file, 'a') as f:
+            f.write(json.dumps(message) + '\n')
+        
+        # Update modification time
+        file_modification_times[history_file] = os.path.getmtime(history_file)
+        
+        logger.debug(f"Saved message to {history_file}")
+    except Exception as e:
+        logger.error(f"Error saving message to {history_file}: {e}")
 
-def get_all_history_files():
-    """Get a list of all chat history files, sorted by modification time (newest first)."""
-    history_files = []
+def check_for_new_messages():
+    """Check for new messages in all history files."""
+    updated_rooms = set()
+    
+    # Check all files in the history directory
     for file in os.listdir(HISTORY_DIR):
-        if file.endswith(".md") and file != "README.md":
+        if file.endswith(".jsonl"):
             file_path = os.path.join(HISTORY_DIR, file)
-            mod_time = os.path.getmtime(file_path)
-            room_id = file[:-3]  # Remove .md extension
-            history_files.append((room_id, file_path, mod_time))
+            current_mtime = os.path.getmtime(file_path)
+            
+            # Check if this file is new or has been modified
+            if file_path not in file_modification_times or current_mtime > file_modification_times[file_path]:
+                # Extract room_id from filename
+                parts = file.split('_', 1)
+                if len(parts) > 0:
+                    room_id = parts[0]
+                    updated_rooms.add(room_id)
+                    
+                # Update tracked modification time
+                file_modification_times[file_path] = current_mtime
+    
+    # Reload history for updated rooms
+    for room_id in updated_rooms:
+        if room_id in chat_history:
+            # Remember we had this room loaded
+            old_history_len = len(chat_history[room_id])
+            # Clear and reload
+            chat_history[room_id] = []
+            load_room_history(room_id)
+            new_history_len = len(chat_history[room_id])
+            
+            if new_history_len > old_history_len:
+                logger.info(f"Found {new_history_len - old_history_len} new messages for room {room_id}")
     
-    # Sort by modification time (newest first)
-    history_files.sort(key=lambda x: x[2], reverse=True)
-    return history_files
+    return updated_rooms
+
+def get_sector_coordinates(room_id):
+    """Convert a room ID to grid coordinates, or assign new ones."""
+    try:
+        # Try to parse room ID as "x,y"
+        if ',' in room_id:
+            x, y = map(int, room_id.split(','))
+            return max(0, min(x, GRID_WIDTH-1)), max(0, min(y, GRID_HEIGHT-1))
+    except:
+        pass
+    
+    # Hash the room_id string to get stable coordinates
+    hash_val = hash(room_id)
+    x = abs(hash_val) % GRID_WIDTH
+    y = abs(hash_val >> 8) % GRID_HEIGHT
+    
+    return x, y
+
+def generate_sector_map():
+    """Generate an ASCII representation of the sector map."""
+    # Initialize empty grid
+    grid = [[' ' for _ in range(GRID_WIDTH)] for _ in range(GRID_HEIGHT)]
+    
+    # Place active rooms with user counts
+    for room_id, users in sector_users.items():
+        if users:  # Only show rooms with users
+            x, y = get_sector_coordinates(room_id)
+            user_count = len(users)
+            grid[y][x] = str(min(user_count, 9)) if user_count < 10 else '+'
+    
+    # Create ASCII representation
+    header = '  ' + ''.join([str(i % 10) for i in range(GRID_WIDTH)])
+    map_str = header + '\n'
+    
+    for y in range(GRID_HEIGHT):
+        row = f"{y % 10}|"
+        for x in range(GRID_WIDTH):
+            row += grid[y][x]
+        row += '|'
+        map_str += row + '\n'
+    
+    footer = '  ' + ''.join([str(i % 10) for i in range(GRID_WIDTH)])
+    map_str += footer
+    
+    return f"```\n{map_str}\n```\n\nLegend: Number indicates users in sector. '+' means 10+ users."
 
 async def clear_all_history():
     """Clear all chat history for all rooms."""
@@ -143,19 +271,37 @@ async def websocket_handler(websocket, path):
         
         active_connections[room_id][client_id] = websocket
         
+        # Add user to sector map
+        if room_id not in sector_users:
+            sector_users[room_id] = set()
+        sector_users[room_id].add(client_id)
+        
+        # Get sector coordinates
+        x, y = get_sector_coordinates(room_id)
+        
         # Load or initialize chat history
         room_history = load_room_history(room_id)
         
         # Send welcome message
         welcome_msg = {
             "type": "system",
-            "content": f"Welcome to room '{room_id}'! Connected from node '{NODE_NAME}'",
+            "content": f"Welcome to room '{room_id}' (Sector {x},{y})! Connected from node '{NODE_NAME}'",
             "timestamp": datetime.now().isoformat(),
             "sender": "system",
             "room_id": room_id
         }
         await websocket.send(json.dumps(welcome_msg))
         
+        # Send sector map
+        map_msg = {
+            "type": "system",
+            "content": f"Sector Map:\n{generate_sector_map()}",
+            "timestamp": datetime.now().isoformat(),
+            "sender": "system",
+            "room_id": room_id
+        }
+        await websocket.send(json.dumps(map_msg))
+        
         # Send chat history
         for msg in room_history:
             await websocket.send(json.dumps(msg))
@@ -163,14 +309,15 @@ async def websocket_handler(websocket, path):
         # Broadcast join notification
         join_msg = {
             "type": "system",
-            "content": f"User joined the room",
+            "content": f"User joined the room (Sector {x},{y}) - {len(sector_users[room_id])} users now present",
             "timestamp": datetime.now().isoformat(),
             "sender": "system",
             "room_id": room_id
         }
         await broadcast_message(join_msg, room_id)
+        save_message_to_history(room_id, join_msg)
         
-        logger.info(f"New client {client_id} connected to room {room_id}")
+        logger.info(f"New client {client_id} connected to room {room_id} (Sector {x},{y})")
         
         # Handle messages from this client
         async for message in websocket:
@@ -182,6 +329,18 @@ async def websocket_handler(websocket, path):
                     result = await clear_all_history()
                     continue
                 
+                # Check for map request
+                if data.get("type") == "command" and data.get("command") == "show_map":
+                    map_msg = {
+                        "type": "system",
+                        "content": f"Sector Map:\n{generate_sector_map()}",
+                        "timestamp": datetime.now().isoformat(),
+                        "sender": "system",
+                        "room_id": room_id
+                    }
+                    await websocket.send(json.dumps(map_msg))
+                    continue
+                
                 # Add metadata to the message
                 data["timestamp"] = datetime.now().isoformat()
                 data["sender_node"] = NODE_NAME
@@ -193,7 +352,7 @@ async def websocket_handler(websocket, path):
                     chat_history[room_id] = chat_history[room_id][-500:]
                 
                 # Save to persistent storage
-                save_room_history(room_id)
+                save_message_to_history(room_id, data)
                 
                 # Broadcast to all clients in the room
                 await broadcast_message(data, room_id)
@@ -215,15 +374,23 @@ async def websocket_handler(websocket, path):
         if room_id in active_connections and client_id in active_connections[room_id]:
             del active_connections[room_id][client_id]
             
+            # Remove user from sector map
+            if room_id in sector_users and client_id in sector_users[room_id]:
+                sector_users[room_id].remove(client_id)
+            
+            # Get sector coordinates
+            x, y = get_sector_coordinates(room_id)
+            
             # Broadcast leave notification
             leave_msg = {
                 "type": "system",
-                "content": f"User left the room",
+                "content": f"User left the room (Sector {x},{y}) - {len(sector_users.get(room_id, set()))} users remaining",
                 "timestamp": datetime.now().isoformat(),
                 "sender": "system",
                 "room_id": room_id
             }
             await broadcast_message(leave_msg, room_id)
+            save_message_to_history(room_id, leave_msg)
             
             # Clean up empty rooms (but keep history)
             if not active_connections[room_id]:
@@ -347,19 +514,32 @@ def create_gradio_interface():
             with gr.Column(scale=1):
                 clear_button = gr.Button("🧹 Clear All Chat History", variant="stop")
         
-        # Join room controls
+        # Join room controls with 2D grid input
         with gr.Row():
-            room_id_input = gr.Textbox(label="Room ID", placeholder="Enter room ID")
-            join_button = gr.Button("Join Room")
+            with gr.Column(scale=2):
+                room_id_input = gr.Textbox(label="Room ID", placeholder="Enter room ID or use x,y coordinates")
+                join_button = gr.Button("Join Room")
+            with gr.Column(scale=1):
+                with gr.Row():
+                    x_coord = gr.Number(label="X", value=0, minimum=0, maximum=GRID_WIDTH-1, step=1)
+                    y_coord = gr.Number(label="Y", value=0, minimum=0, maximum=GRID_HEIGHT-1, step=1)
+                grid_join_button = gr.Button("Join by Coordinates")
         
-        # Chat area
+        # Chat area with multiline support
         chat_history_output = gr.Textbox(label="Chat History", lines=20, max_lines=20)
         
-        # Message controls
+        # Message controls with multiline support
         with gr.Row():
             username_input = gr.Textbox(label="Username", placeholder="Enter your username", value="User")
-            message_input = gr.Textbox(label="Message", placeholder="Type your message here")
-            send_button = gr.Button("Send")
+            with gr.Column(scale=3):
+                message_input = gr.Textbox(
+                    label="Message", 
+                    placeholder="Type your message here. Press Shift+Enter for new line, Enter to send.", 
+                    lines=3
+                )
+            with gr.Column(scale=1):
+                send_button = gr.Button("Send")
+                map_button = gr.Button("🗺️ Show Map")
         
         # Current room display
         current_room_display = gr.Textbox(label="Current Room", value="Not joined any room yet")
@@ -377,6 +557,22 @@ def create_gradio_interface():
             outputs=[room_list]
         )
         
+        def join_by_coordinates(x, y):
+            """Join a room using grid coordinates."""
+            room_id = f"{int(x)},{int(y)}"
+            return room_id
+        
+        # Link grid coordinates to room ID
+        grid_join_button.click(
+            join_by_coordinates,
+            inputs=[x_coord, y_coord],
+            outputs=[room_id_input]
+        ).then(
+            join_room,
+            inputs=[room_id_input, chat_history_output],
+            outputs=[current_room_display, chat_history_output]
+        )
+        
         join_button.click(
             join_room,
             inputs=[room_id_input, chat_history_output],
@@ -388,7 +584,16 @@ def create_gradio_interface():
                 return "Please join a room first", message
             
             actual_room_id = room_id.replace("Joined room: ", "").strip()
-            formatted_msg = send_message(message, username, actual_room_id)
+            
+            # Support for multi-line messages
+            message_lines = message.strip().split("\n")
+            formatted_msg = ""
+            
+            for line in message_lines:
+                if line.strip():  # Skip empty lines
+                    sent_msg = send_message(line.strip(), username, actual_room_id)
+                    if sent_msg:
+                        formatted_msg += sent_msg + "\n"
             
             if formatted_msg:
                 return "", formatted_msg
@@ -400,9 +605,25 @@ def create_gradio_interface():
             outputs=[message_input, chat_history_output]
         )
         
-        # Enter key to send message
+        def show_sector_map(room_id):
+            if not room_id.startswith("Joined room:"):
+                return "Please join a room first to view the map"
+            
+            return generate_sector_map()
+        
+        map_button.click(
+            show_sector_map,
+            inputs=[current_room_display],
+            outputs=[chat_history_output]
+        )
+        
+        # Handle Enter key for sending, Shift+Enter for new line
+        def on_message_submit(message, username, room_id):
+            # Simply call send_and_clear
+            return send_and_clear(message, username, room_id)
+        
         message_input.submit(
-            send_and_clear,
+            on_message_submit,
             inputs=[message_input, username_input, current_room_display],
             outputs=[message_input, chat_history_output]
         )