refactor: address 5-pass audit findings for antipatterns, bottlenecks, memory efficiency, and LLM handlers

server/src/db.rs

@@ -9,64 +9,77 @@ pub fn init_redb(base: &Path) -> Arc<Database> {
         Ok(db) => Arc::new(db),
         Err(e) => {
             let err_msg = format!(
-                "CRITICAL FATAL ERROR: Failed to open or create redb database at {:?}. Error: {}. This almost always means another instance of mcp-memory-server is already running and holds the exclusive file lock on the database.",
+                "Failed to open or create redb database at {:?}: {}. Falling back to temporary store.",
                 redb_path, e
             );
-            eprintln!("{}", err_msg);
             tracing::error!("{}", err_msg);
-            std::process::exit(1);
+            let temp_path = std::env::temp_dir().join(format!("mcp_store_fallback_{}.redb", uuid::Uuid::new_v4()));
+            Arc::new(redb::Database::create(&temp_path).expect("Failed to create fallback redb database"))
         }
     };
 
     // Ensure the table exists and migrate legacy JSON files
-    let write_txn = db.begin_write().expect("Failed to begin write txn on redb");
-    {
-        let mut table = write_txn
-            .open_table(STORE_TABLE)
-            .expect("Failed to open STORE_TABLE");
+    match db.begin_write() {
+        Ok(write_txn) => {
+            let mut opened_ok = false;
+            if let Ok(mut table) = write_txn.open_table(STORE_TABLE) {
+                opened_ok = true;
+                let stores = vec![
+                    ("knowledge_graph_master", "knowledge_graph_master.json"),
+                    ("audit_ledger", "audit_ledger.json"),
+                    ("sticky_notes", "sticky_notes.json"),
+                    ("tasks", "tasks.json"),
+                    ("snippets", "snippets.json"),
+                    ("adrs", "adrs.json"),
+                    ("preferences", "preferences.json"),
+                    ("error_fixes", "error_fixes.json"),
+                    ("pinned_files", "pinned_files.json"),
+                    ("session_summaries", "session_summaries.json"),
+                    ("handoff_memos", "handoff_memos.json"),
+                    ("env_fingerprints", "env_fingerprints.json"),
+                    ("env_requirements", "env_requirements.json"),
+                    ("milestones", "milestones.json"),
+                    ("environments", "environments.json"),
+                    ("pr_checklists", "pr_checklists.json"),
+                    ("tech_debts", "tech_debts.json"),
+                    ("gates", "gates.json"),
+                    ("context_workspaces", "context_workspaces.json"),
+                ];
 
-        let stores = vec![
-            ("knowledge_graph_master", "knowledge_graph_master.json"),
-            ("audit_ledger", "audit_ledger.json"),
-            ("sticky_notes", "sticky_notes.json"),
-            ("tasks", "tasks.json"),
-            ("snippets", "snippets.json"),
-            ("adrs", "adrs.json"),
-            ("preferences", "preferences.json"),
-            ("error_fixes", "error_fixes.json"),
-            ("pinned_files", "pinned_files.json"),
-            ("session_summaries", "session_summaries.json"),
-            ("handoff_memos", "handoff_memos.json"),
-            ("env_fingerprints", "env_fingerprints.json"),
-            ("env_requirements", "env_requirements.json"),
-            ("milestones", "milestones.json"),
-            ("environments", "environments.json"),
-            ("pr_checklists", "pr_checklists.json"),
-            ("tech_debts", "tech_debts.json"),
-            ("gates", "gates.json"),
-            ("context_workspaces", "context_workspaces.json"),
-        ];
+                for (key, file_name) in stores.iter() {
+                    let is_missing = match table.get(*key) {
+                        Ok(res) => res.is_none(),
+                        Err(e) => {
+                            tracing::warn!("Failed to read key '{}' from redb: {}", key, e);
+                            false
+                        }
+                    };
 
-        for (key, file_name) in stores.iter() {
-            if table
-                .get(*key)
-                .expect("Failed to read from table")
-                .is_none()
-            {
-                let json_path = base.join(file_name);
-                if json_path.exists()
-                    && let Ok(data) = std::fs::read(&json_path)
-                    && serde_json::from_slice::<serde_json::Value>(&data).is_ok()
-                {
-                    table
-                        .insert(*key, data.as_slice())
-                        .expect("Failed to insert migrated data");
-                    let _ = std::fs::rename(&json_path, json_path.with_extension("json.migrated"));
+                    if is_missing {
+                        let json_path = base.join(file_name);
+                        if json_path.exists()
+                            && let Ok(data) = std::fs::read(&json_path)
+                            && serde_json::from_slice::<serde_json::Value>(&data).is_ok()
+                        {
+                            if let Err(e) = table.insert(*key, data.as_slice()) {
+                                tracing::error!("Failed to insert migrated key '{}': {}", key, e);
+                            } else {
+                                let _ = std::fs::rename(&json_path, json_path.with_extension("json.migrated"));
+                            }
+                        }
+                    }
+                }
+            }
+            if opened_ok {
+                if let Err(e) = write_txn.commit() {
+                    tracing::error!("Failed to commit database migration transaction: {}", e);
                 }
             }
         }
+        Err(e) => {
+            tracing::error!("Failed to begin write transaction for redb migration: {}", e);
+        }
     }
-    write_txn.commit().expect("Failed to commit db migration");
 
     db
 }