Update app.py

app.py

@@ -32,7 +32,6 @@ DATABASE_FILE = STORAGE_DIR / "chat_database.db"
 
 @dataclass
 class ChatMessage:
-    """Data class untuk pesan chat"""
     role: str
     content: str
     topic: str
@@ -50,15 +49,12 @@ class ChatMessage:
             self.message_id = str(uuid.uuid4())
 
 class DatabaseManager:
-    """Mengelola database SQLite untuk pencarian yang lebih efisien"""
-    
     def __init__(self):
         self.db_path = DATABASE_FILE
         self.lock = threading.Lock()
         self.init_database()
     
     def init_database(self):
-        """Inisialisasi tabel database"""
         try:
             with sqlite3.connect(self.db_path) as conn:
                 conn.execute('''
@@ -76,7 +72,6 @@ class DatabaseManager:
                         content_hash TEXT
                     )
                 ''')
-                
                 conn.execute('''
                     CREATE TABLE IF NOT EXISTS sessions (
                         session_id TEXT PRIMARY KEY,
@@ -86,19 +81,16 @@ class DatabaseManager:
                         message_count INTEGER DEFAULT 0
                     )
                 ''')
-                
                 conn.execute('CREATE INDEX IF NOT EXISTS idx_content ON messages(content)')
                 conn.execute('CREATE INDEX IF NOT EXISTS idx_topic ON messages(topic)')
                 conn.execute('CREATE INDEX IF NOT EXISTS idx_timestamp ON messages(timestamp)')
                 conn.execute('CREATE INDEX IF NOT EXISTS idx_session ON messages(session_id)')
                 conn.execute('CREATE INDEX IF NOT EXISTS idx_role ON messages(role)')
-                
                 conn.commit()
         except sqlite3.Error as e:
             raise Exception(f"Failed to initialize database: {str(e)}")
     
     def add_message(self, message: ChatMessage):
-        """Menambah pesan ke database"""
         try:
             with self.lock:
                 content_hash = hashlib.md5(message.content.encode('utf-8')).hexdigest()
@@ -112,7 +104,6 @@ class DatabaseManager:
                         message.timestamp, message.word_count, message.char_count,
                         message.session_id, json.dumps(message.tags), content_hash
                     ))
-                    
                     conn.execute('''
                         INSERT OR REPLACE INTO sessions (session_id, title, created_at, last_activity, message_count)
                         VALUES (?, ?, ?, ?, 
@@ -127,17 +118,14 @@ class DatabaseManager:
             raise Exception(f"Failed to add message to database: {str(e)}")
     
     def search_messages(self, query: str, filters: Dict = None) -> List[Dict]:
-        """Pencarian pesan dengan berbagai filter"""
         try:
             with sqlite3.connect(self.db_path) as conn:
                 conn.row_factory = sqlite3.Row
-                
                 base_query = '''
                     SELECT * FROM messages 
                     WHERE content LIKE ? COLLATE NOCASE
                 '''
                 params = [f'%{query}%']
-                
                 if filters:
                     if filters.get('topic'):
                         base_query += ' AND topic = ?'
@@ -154,26 +142,21 @@ class DatabaseManager:
                     if filters.get('date_to'):
                         base_query += ' AND timestamp <= ?'
                         params.append(filters['date_to'])
-                
                 base_query += ' ORDER BY timestamp DESC LIMIT 100'
-                
                 cursor = conn.execute(base_query, params)
                 results = []
                 for row in cursor.fetchall():
                     result = dict(row)
                     result['tags'] = json.loads(result['tags']) if result['tags'] else []
                     results.append(result)
-                
                 return results
         except sqlite3.Error as e:
             raise Exception(f"Failed to search messages: {str(e)}")
     
     def get_all_messages(self, session_id: str = None) -> List[Dict]:
-        """Mengambil semua pesan"""
         try:
             with sqlite3.connect(self.db_path) as conn:
                 conn.row_factory = sqlite3.Row
-                
                 if session_id:
                     cursor = conn.execute(
                         'SELECT * FROM messages WHERE session_id = ? ORDER BY timestamp',
@@ -181,19 +164,16 @@ class DatabaseManager:
                     )
                 else:
                     cursor = conn.execute('SELECT * FROM messages ORDER BY timestamp')
-                
                 results = []
                 for row in cursor.fetchall():
                     result = dict(row)
                     result['tags'] = json.loads(result['tags']) if result['tags'] else []
                     results.append(result)
-                
                 return results
         except sqlite3.Error as e:
             raise Exception(f"Failed to get messages: {str(e)}")
     
     def get_sessions(self) -> List[Dict]:
-        """Mengambil semua sesi chat"""
         try:
             with sqlite3.connect(self.db_path) as conn:
                 conn.row_factory = sqlite3.Row
@@ -206,7 +186,6 @@ class DatabaseManager:
             raise Exception(f"Failed to get sessions: {str(e)}")
     
     def delete_session(self, session_id: str):
-        """Menghapus sesi dan semua pesannya"""
         try:
             with self.lock:
                 with sqlite3.connect(self.db_path) as conn:
@@ -217,20 +196,15 @@ class DatabaseManager:
             raise Exception(f"Failed to delete session: {str(e)}")
     
     def get_statistics(self) -> Dict:
-        """Statistik database"""
         try:
             with sqlite3.connect(self.db_path) as conn:
                 stats = {}
-                
                 cursor = conn.execute('SELECT COUNT(*) FROM messages')
                 stats['total_messages'] = cursor.fetchone()[0]
-                
                 cursor = conn.execute('SELECT role, COUNT(*) FROM messages GROUP BY role')
                 stats['by_role'] = dict(cursor.fetchall())
-                
                 cursor = conn.execute('SELECT topic, COUNT(*) FROM messages GROUP BY topic ORDER BY COUNT(*) DESC LIMIT 10')
                 stats['by_topic'] = dict(cursor.fetchall())
-                
                 cursor = conn.execute('''
                     SELECT DATE(timestamp) as date, COUNT(*) 
                     FROM messages 
@@ -238,17 +212,13 @@ class DatabaseManager:
                     ORDER BY date DESC LIMIT 30
                 ''')
                 stats['by_date'] = dict(cursor.fetchall())
-                
                 cursor = conn.execute('SELECT COUNT(*) FROM sessions')
                 stats['total_sessions'] = cursor.fetchone()[0]
-                
                 return stats
         except sqlite3.Error as e:
             raise Exception(f"Failed to get statistics: {str(e)}")
 
 class ChatStorage:
-    """Handles persistent JSON storage dan database untuk chat history"""
-    
     def __init__(self):
         self.history_file = HISTORY_FILE
         self.analytics_file = ANALYTICS_FILE
@@ -259,7 +229,6 @@ class ChatStorage:
         self.sync_to_database()
     
     def sync_to_database(self):
-        """Sinkronisasi data dari JSON ke database"""
         try:
             if self.chat_history and not self.db.get_all_messages():
                 print("🔄 Syncing JSON data to database...")
@@ -318,7 +287,6 @@ class ChatStorage:
             print(f"❌ Error saving analytics: {e}")
     
     def add_message(self, role: str, content: str, topic: str = "general", tags: List[str] = None):
-        """Menambah pesan ke storage dan database"""
         if not content.strip():
             raise ValueError("Content cannot be empty")
         if len(topic) > 100:
@@ -416,7 +384,6 @@ class ChatStorage:
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
             backup_dir = STORAGE_DIR / "backups"
             backup_dir.mkdir(exist_ok=True)
-            
             for file in [HISTORY_FILE, ANALYTICS_FILE]:
                 if file.exists():
                     backup_path = backup_dir / f"{file.name}.{timestamp}.bak"
@@ -424,14 +391,12 @@ class ChatStorage:
                         dst.write(src.read())
                     if not backup_path.exists():
                         raise Exception(f"Failed to create backup for {file.name}")
-            
             db_backup_path = backup_dir / f"chat_database.db.{timestamp}.bak"
             with sqlite3.connect(self.db.db_path) as src_conn:
                 with sqlite3.connect(db_backup_path) as dst_conn:
                     src_conn.backup(dst_conn)
                 if not db_backup_path.exists():
                     raise Exception("Failed to create database backup")
-            
             return f"✅ Backup created at {backup_dir}"
         except Exception as e:
             return f"❌ Backup failed: {str(e)}"
@@ -468,8 +433,6 @@ class ChatStorage:
             print(f"❌ Error updating analytics from import: {e}")
 
 class AdvancedSearchManager:
-    """Manager untuk pencarian lanjutan"""
-    
     def __init__(self, storage: ChatStorage):
         self.storage = storage
     
@@ -569,8 +532,6 @@ class AdvancedSearchManager:
             raise Exception(f"Failed to get conversation thread: {str(e)}")
 
 class SmartAnalyzer:
-    """Advanced analytics untuk chat history dengan database"""
-    
     def __init__(self, storage: ChatStorage):
         self.storage = storage
     
@@ -739,7 +700,7 @@ class SmartAnalyzer:
                 "avg_messages_per_session": len(all_messages) / len(set(msg.get("session_id", "default") for msg in all_messages)) if all_messages else 0
             }
         except Exception as e:
-            return {"error": f"Failed to get productivity insights: {str(e)}"}
+            return {"error": f"Failed to get productivity insights: {str(e)}")
     
     def _calculate_consistency(self, daily_activity: Dict) -> float:
         try:
@@ -753,13 +714,12 @@ class SmartAnalyzer:
         except Exception as e:
             raise Exception(f"Failed to calculate consistency: {str(e)}")
 
-# Initialize storage dan components
+# Initialize storage and components
 storage = ChatStorage()
 analyzer = SmartAnalyzer(storage)
 search_manager = AdvancedSearchManager(storage)
 
 def count_tokens_rough(text: str) -> int:
-    """Estimasi token count"""
     try:
         return len(text) // 4
     except Exception as e:
@@ -767,7 +727,6 @@ def count_tokens_rough(text: str) -> int:
         return 0
 
 def groq_with_memory(message: str, topic: str = "general", retries: int = 3) -> tuple:
-    """Main chat function dengan Groq API"""
     if not API_KEY:
         return "❌ No API Key found. Please set GROQ_API_KEY environment variable.", ""
     
@@ -824,7 +783,7 @@ def groq_with_memory(message: str, topic: str = "general", retries: int = 3) ->
                 return f"❌ No response: {result}", ""
             except HTTPError as e:
                 if response.status_code == 429 and attempt < retries - 1:
-                    sleep(2 ** attempt)  # Exponential backoff
+                    sleep(2 ** attempt)
                     continue
                 return f"❌ HTTP {response.status_code}: {response.text}", ""
         
@@ -834,7 +793,6 @@ def groq_with_memory(message: str, topic: str = "general", retries: int = 3) ->
         return f"❌ Error: {str(e)}", ""
 
 def cleanup_old_messages(days: int = 30) -> str:
-    """Hapus pesan yang lebih lama dari jumlah hari tertentu"""
     try:
         cutoff = (datetime.now() - timedelta(days=days)).isoformat()
         with sqlite3.connect(storage.db.db_path) as conn:
@@ -846,8 +804,7 @@ def cleanup_old_messages(days: int = 30) -> str:
     except Exception as e:
         return f"❌ Failed to clean old messages: {str(e)}"
 
-# ... all imports, classes (ChatMessage, DatabaseManager, ChatStorage, AdvancedSearchManager, SmartAnalyzer), and other code ...
-
+# Helper Functions
 def get_topics_list() -> List[str]:
     """Retrieve a list of unique topics from the database, ensuring 'journal' is included."""
     try:
@@ -863,20 +820,22 @@ def get_topics_list() -> List[str]:
         print(f"❌ Error retrieving topics: {str(e)}")
         return ["All Topics", "journal"]
 
-def send_message(user_input: str, topic_input: str) -> Tuple[str, str]:
-    """Handle sending a user message and getting AI response."""
+def send_message(user_input: str, topic_input: str) -> Tuple[str, str, List[str]]:
+    """Handle sending a user message, getting AI response, and updating topic list."""
     try:
         if not user_input.strip():
-            return "❌ Please enter a message", user_input
+            return "❌ Please enter a message", user_input, get_topics_list()
         if not topic_input.strip():
-            return "❌ Please enter a topic", user_input
+            return "❌ Please enter a topic", user_input, get_topics_list()
         
         response, error = groq_with_memory(user_input, topic_input)
         if error:
-            return f"❌ {error}", user_input
-        return response, ""  # Clear user input after successful submission
+            return f"❌ {error}", user_input, get_topics_list()
+        
+        # Return updated topic list to refresh dropdown
+        return response, "", get_topics_list()
     except Exception as e:
-        return f"❌ Error processing message: {str(e)}", user_input
+        return f"❌ Error processing message: {str(e)}", user_input, get_topics_list()
 
 def show_current_context() -> str:
     """Show the current session's conversation context."""
@@ -1002,7 +961,7 @@ def export_data() -> str:
     except Exception as e:
         return f"❌ Error exporting data: {str(e)}"
 
-# Define custom CSS
+# Define custom CSS for full-screen, readable font, and black background
 custom_css = """
 /* Full-screen layout: remove padding and margins, use full width */
 .gradio-container {
@@ -1010,8 +969,8 @@ custom_css = """
     max-width: 100% !important;
     padding: 0 !important;
     margin: 0 !important;
-    background-color: #000000 !important; /* Black background */
-    color: #ffffff !important; /* White text for contrast */
+    background-color: #000000 !important;
+    color: #ffffff !important;
 }
 
 /* Remove padding and ensure full-width components */
@@ -1020,14 +979,14 @@ custom_css = """
     margin: 0 !important;
     width: 100% !important;
     box-sizing: border-box !important;
-    border: 1px solid #333333 !important; /* Subtle border for visibility */
+    border: 1px solid #333333 !important;
 }
 
 /* Textbox and input styling */
 .response-area, .history-display, .analytics-display {
-    background-color: #1a1a1a !important; /* Dark gray for textboxes to improve readability */
+    background-color: #1a1a1a !important;
     color: #ffffff !important;
-    border-radius: 0 !important; /* Remove rounded corners for full-screen look */
+    border-radius: 0 !important;
 }
 
 /* Input area */
@@ -1040,10 +999,10 @@ custom_css = """
 /* Font styling */
 * {
     font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif !important;
-    font-size: 16px !important; /* Slightly larger for readability */
+    font-size: 16px !important;
 }
 
-/* Button styling for contrast */
+/* Button styling */
 button {
     background-color: #333333 !important;
     color: #ffffff !important;
@@ -1066,11 +1025,6 @@ select {
 }
 """
 
-# Initialize storage and components
-storage = ChatStorage()
-analyzer = SmartAnalyzer(storage)
-search_manager = AdvancedSearchManager(storage)
-
 # Main Gradio Interface
 with gr.Blocks(
     title="🤖 AI Journal Chat with Analytics", 
@@ -1189,7 +1143,7 @@ with gr.Blocks(
     send_btn.click(
         fn=send_message,
         inputs=[user_input, topic_input],
-        outputs=[ai_response, user_input]
+        outputs=[ai_response, user_input, topic_filter]
     )
     
     clear_response_btn.click(