Fix unawaited Tokio spawn locks by moving macro clones and formatting allocations to blocking executor

server/src/handlers.rs

@@ -625,36 +625,40 @@ impl MemoryHandler {
                                 to_draw.push(r);
                             }
                         }
-                        let mut output = String::from("graph TD;\n");
+                        use std::fmt::Write;
+                        let mut output = String::with_capacity(included.len() * 40 + to_draw.len() * 60);
+                        output.push_str("graph TD;\n");
+                        
+                        let sanitize = |s: &str, id_mode: bool| -> String {
+                            let mut out = String::with_capacity(s.len());
+                            for c in s.chars() {
+                                if c != '"' && c != '(' && c != ')' {
+                                    if id_mode && (c == ' ' || c == '-' || c == '.') {
+                                        out.push('_');
+                                    } else {
+                                        out.push(c);
+                                    }
+                                }
+                            }
+                            out
+                        };
+
                         for name in &included {
-                            let safe = name.replace("\"", "").replace("(", "").replace(")", "");
+                            let _ = writeln!(
-                            output.push_str(&format!(
+                                output,
-                                "    id_{}[\"{}\"];\n",
+                                "    id_{}[\"{}\"];",
-                                safe.replace(" ", "_").replace("-", "_").replace(".", "_"),
+                                sanitize(name, true),
-                                safe
+                                sanitize(name, false)
-                            ));
+                            );
                         }
                         for r in to_draw {
-                            let safe_f = r
+                            let _ = writeln!(
-                                .from
+                                output,
-                                .replace(" ", "_")
+                                "    id_{}-->|\"{}\"|id_{};",
-                                .replace("-", "_")
+                                sanitize(&r.from, true),
-                                .replace(".", "_")
+                                r.relation_type.replace("\"", ""),
-                                .replace("\"", "")
+                                sanitize(&r.to, true)
-                                .replace("(", "")
+                            );
-                                .replace(")", "");
-                            let safe_t =
-                                r.to.replace(" ", "_")
-                                    .replace("-", "_")
-                                    .replace(".", "_")
-                                    .replace("\"", "")
-                                    .replace("(", "")
-                                    .replace(")", "");
-                            let safe_r = r.relation_type.replace("\"", "");
-                            output.push_str(&format!(
-                                "    id_{}-->|\"{}\"|id_{};\n",
-                                safe_f, safe_r, safe_t
-                            ));
                         }
                         if output == "graph TD;\n" {
                             output = "No nodes found to visualize.".to_string();

server/src/search.rs

@@ -54,14 +54,21 @@ impl MemoryIndex {
 
     pub fn index_entity(&self, e: &Entity) -> tokio::task::JoinHandle<tantivy::Result<()>> {
         let writer = Arc::clone(&self.writer);
-        let doc = doc!(
+        let e = e.clone();
-            self.id_field => e.name.clone(),
+        let id_field = self.id_field;
-            self.title_field => e.name.clone(),
+        let title_field = self.title_field;
-            self.body_field => e.observations.join(" "),
+        let body_field = self.body_field;
-            self.type_field => "entity",
+        let type_field = self.type_field;
-            self.namespace_field => e.namespace.clone()
+        let namespace_field = self.namespace_field;
-        );
+        
         tokio::task::spawn_blocking(move || {
+            let doc = doc!(
+                id_field => e.name.clone(),
+                title_field => e.name.clone(),
+                body_field => e.observations.join(" "),
+                type_field => "entity",
+                namespace_field => e.namespace.clone()
+            );
             let writer = writer.lock().unwrap();
             writer.add_document(doc)?;
             Ok(())
@@ -70,14 +77,21 @@ impl MemoryIndex {
 
     pub fn index_task(&self, t: &Task) -> tokio::task::JoinHandle<tantivy::Result<()>> {
         let writer = Arc::clone(&self.writer);
-        let doc = doc!(
+        let t = t.clone();
-            self.id_field => t.id.clone(),
+        let id_field = self.id_field;
-            self.title_field => t.title.clone(),
+        let title_field = self.title_field;
-            self.body_field => t.description.clone(),
+        let body_field = self.body_field;
-            self.type_field => "task",
+        let type_field = self.type_field;
-            self.namespace_field => "global"
+        let namespace_field = self.namespace_field;
-        );
+        
         tokio::task::spawn_blocking(move || {
+            let doc = doc!(
+                id_field => t.id.clone(),
+                title_field => t.title.clone(),
+                body_field => t.description.clone(),
+                type_field => "task",
+                namespace_field => "global"
+            );
             let writer = writer.lock().unwrap();
             writer.add_document(doc)?;
             Ok(())
@@ -151,14 +165,21 @@ impl MemoryIndex {
 
     pub fn index_snippet(&self, s: &Snippet) -> tokio::task::JoinHandle<tantivy::Result<()>> {
         let writer = Arc::clone(&self.writer);
-        let doc = doc!(
+        let s = s.clone();
-            self.id_field => s.name.clone(),
+        let id_field = self.id_field;
-            self.title_field => s.name.clone(),
+        let title_field = self.title_field;
-            self.body_field => format!("{} {}", s.language, s.description),
+        let body_field = self.body_field;
-            self.type_field => "snippet",
+        let type_field = self.type_field;
-            self.namespace_field => "global"
+        let namespace_field = self.namespace_field;
-        );
+        
         tokio::task::spawn_blocking(move || {
+            let doc = doc!(
+                id_field => s.name.clone(),
+                title_field => s.name.clone(),
+                body_field => format!("{} {}", s.language, s.description),
+                type_field => "snippet",
+                namespace_field => "global"
+            );
             let writer = writer.lock().unwrap();
             writer.add_document(doc)?;
             Ok(())
@@ -167,14 +188,21 @@ impl MemoryIndex {
 
     pub fn index_adr(&self, a: &Adr) -> tokio::task::JoinHandle<tantivy::Result<()>> {
         let writer = Arc::clone(&self.writer);
-        let doc = doc!(
+        let a = a.clone();
-            self.id_field => a.id.clone(),
+        let id_field = self.id_field;
-            self.title_field => a.title.clone(),
+        let title_field = self.title_field;
-            self.body_field => format!("{} {} {}", a.context, a.decision, a.consequence),
+        let body_field = self.body_field;
-            self.type_field => "adr",
+        let type_field = self.type_field;
-            self.namespace_field => "global"
+        let namespace_field = self.namespace_field;
-        );
+        
         tokio::task::spawn_blocking(move || {
+            let doc = doc!(
+                id_field => a.id.clone(),
+                title_field => a.title.clone(),
+                body_field => format!("{} {} {}", a.context, a.decision, a.consequence),
+                type_field => "adr",
+                namespace_field => "global"
+            );
             let writer = writer.lock().unwrap();
             writer.add_document(doc)?;
             Ok(())