style: apply rustfmt

Author: quangdang46

crates/bench/src/runner.rs

@@ -115,8 +115,9 @@ pub async fn run_benchmark(
     entries: &[BenchmarkEntry],
     config: &BenchmarkConfig,
 ) -> Result<BenchmarkResults> {
-    let embedder: Arc<dyn mempalace_core::embed::Embedder> =
-        resolve_embedder(&config.embed_model).map_err(anyhow::Error::msg)?.into();
+    let embedder: Arc<dyn mempalace_core::embed::Embedder> = resolve_embedder(&config.embed_model)
+        .map_err(anyhow::Error::msg)?
+        .into();
 
     let mut metrics = BenchmarkMetrics::new(config.ks.clone());
     let mut per_type_results: std::collections::HashMap<_, _> = Default::default();
@@ -223,8 +224,11 @@ mod tests {
 
     #[tokio::test]
     async fn test_rank_corpus_returns_sorted_indices() {
-        let embedder: Arc<dyn mempalace_core::embed::Embedder> =
-            Arc::from(resolve_embedder("all-MiniLM-L6-v2").map_err(anyhow::Error::msg).expect("resolve_embedder should succeed"));
+        let embedder: Arc<dyn mempalace_core::embed::Embedder> = Arc::from(
+            resolve_embedder("all-MiniLM-L6-v2")
+                .map_err(anyhow::Error::msg)
+                .expect("resolve_embedder should succeed"),
+        );
         let docs = vec![
             "I worked on the auth migration today".to_string(),
             "I still remember the happy high school experiences".to_string(),

crates/core/src/cli.rs

@@ -988,7 +988,10 @@ fn cmd_search(
         Some("vector") => Some(crate::palace::FusionMode::Vector),
         None => None,
         Some(other) => {
-            eprintln!("error: unknown fusion mode '{}' (expected: vector, ppr, hybrid)", other);
+            eprintln!(
+                "error: unknown fusion mode '{}' (expected: vector, ppr, hybrid)",
+                other
+            );
             return Err(anyhow::anyhow!("invalid fusion mode"));
         }
     };

crates/core/src/embed/tract.rs

@@ -10,7 +10,7 @@ use anyhow::Context;
 use async_trait::async_trait;
 use ndarray::Array2;
 use tokenizers::Tokenizer;
-use tract_onnx::prelude::{Framework, Tensor, TValue, tvec};
+use tract_onnx::prelude::{tvec, Framework, TValue, Tensor};
 
 use super::Embedder;
 
@@ -22,7 +22,11 @@ fn huggingface_cache_dir() -> PathBuf {
         .join("hub")
 }
 
-fn ensure_cached(model_name: &str, onnx_path: &PathBuf, tokenizer_path: &PathBuf) -> anyhow::Result<()> {
+fn ensure_cached(
+    model_name: &str,
+    onnx_path: &PathBuf,
+    tokenizer_path: &PathBuf,
+) -> anyhow::Result<()> {
     if onnx_path.exists() && tokenizer_path.exists() {
         return Ok(());
     }
@@ -57,17 +61,19 @@ fn download_from_huggingface(repo: &str, path: &str, dest: &PathBuf) -> anyhow::
         .with_context(|| format!("tract: download {} from HF: {}", path, url))?
         .error_for_status()
         .with_context(|| format!("tract: HF download failed for {}: {}", path, url))?;
-    let bytes = response.bytes()
+    let bytes = response
+        .bytes()
         .with_context(|| format!("tract: read body for {} from HF", path))?;
-    std::fs::write(dest, bytes)
-        .with_context(|| format!("tract: write {} to cache", path))?;
+    std::fs::write(dest, bytes).with_context(|| format!("tract: write {} to cache", path))?;
     Ok(())
 }
 
 fn normalize_l2(mut v: Vec<f32>) -> Vec<f32> {
     let norm: f32 = v.iter().map(|x| x * x).sum::<f32>().sqrt();
     if norm > 1e-9 {
-        for x in &mut v { *x /= norm; }
+        for x in &mut v {
+            *x /= norm;
+        }
     }
     v
 }
@@ -78,19 +84,25 @@ fn probe_dimension(model_path: &PathBuf) -> anyhow::Result<usize> {
     let inference_model = tract_onnx::onnx()
         .model_for_path(model_path)
         .context("tract: load for probe")?;
-    let runnable = inference_model.into_runnable().context("tract: build runnable for probe")?;
+    let runnable = inference_model
+        .into_runnable()
+        .context("tract: build runnable for probe")?;
 
     // Token IDs as f32 (most ONNX models expect float inputs for token IDs)
     let input_ids: Vec<f32> = vec![1.0, 2.0, 3.0];
     let input_tensor: Tensor = Array2::from_shape_vec((1, 3), input_ids)
         .map_err(|e| anyhow::anyhow!("tract: probe shape: {}", e))?
         .into();
     let input_tvalue: TValue = input_tensor.into();
-    let result = runnable.run(tvec!(input_tvalue))
+    let result = runnable
+        .run(tvec!(input_tvalue))
         .map_err(|e| anyhow::anyhow!("tract: probe run: {}", e))?;
-    let out = result.into_iter().next()
+    let out = result
+        .into_iter()
+        .next()
         .ok_or_else(|| anyhow::anyhow!("tract: no probe output"))?;
-    let view = out.to_array_view::<f32>()
+    let view = out
+        .to_array_view::<f32>()
         .map_err(|e| anyhow::anyhow!("tract: probe view: {}", e))?;
     let hidden = *view.shape().last().unwrap_or(&384);
     if hidden == 0 {
@@ -108,7 +120,10 @@ pub struct TractEmbedder {
 }
 
 impl TractEmbedder {
-    pub fn with_model(model_name: impl Into<String>, _cache_dir: Option<PathBuf>) -> anyhow::Result<Self> {
+    pub fn with_model(
+        model_name: impl Into<String>,
+        _cache_dir: Option<PathBuf>,
+    ) -> anyhow::Result<Self> {
         let model_name_owned = model_name.into();
 
         let cache = huggingface_cache_dir();
@@ -133,21 +148,32 @@ impl TractEmbedder {
 
 #[async_trait]
 impl Embedder for TractEmbedder {
-    fn dim(&self) -> usize { self.dim }
-    fn fingerprint(&self) -> &str { &self.fingerprint }
+    fn dim(&self) -> usize {
+        self.dim
+    }
+    fn fingerprint(&self) -> &str {
+        &self.fingerprint
+    }
 
     async fn embed(&self, text: &str) -> anyhow::Result<Vec<f32>> {
         let mut out = self.embed_batch(&[text]).await?;
         Ok(out.pop().unwrap_or_default())
     }
 
     async fn embed_batch(&self, texts: &[&str]) -> anyhow::Result<Vec<Vec<f32>>> {
-        if texts.is_empty() { return Ok(Vec::new()); }
+        if texts.is_empty() {
+            return Ok(Vec::new());
+        }
 
         let tokenizer_path = self.tokenizer_path.clone();
         let model_name = tokenizer_path
             .parent()
-            .map(|p| p.file_name().unwrap_or_default().to_string_lossy().into_owned())
+            .map(|p| {
+                p.file_name()
+                    .unwrap_or_default()
+                    .to_string_lossy()
+                    .into_owned()
+            })
             .unwrap_or_default();
 
         let owned: Vec<String> = texts.iter().map(|s| (*s).to_owned()).collect();
@@ -185,11 +211,19 @@ fn run_embed_batch(
 
     let encodings: Vec<_> = texts
         .iter()
-        .map(|s| tokenizer.encode(s.as_str(), true)
-            .map_err(|e| anyhow::anyhow!("tract: tokenize: {}", e)))
+        .map(|s| {
+            tokenizer
+                .encode(s.as_str(), true)
+                .map_err(|e| anyhow::anyhow!("tract: tokenize: {}", e))
+        })
         .collect::<Result<Vec<_>, _>>()?;
 
-    let max_len = encodings.iter().map(|e| e.get_ids().len()).max().unwrap_or(1).min(DEFAULT_MAX_LEN);
+    let max_len = encodings
+        .iter()
+        .map(|e| e.get_ids().len())
+        .max()
+        .unwrap_or(1)
+        .min(DEFAULT_MAX_LEN);
     let batch_size = encodings.len();
     let mut input_ids = vec![0f32; batch_size * max_len];
     let mut attention_mask = vec![0f32; batch_size * max_len];
@@ -206,23 +240,30 @@ fn run_embed_batch(
     let input_ids_tensor: Tensor = Array2::from_shape_vec((batch_size, max_len), input_ids)
         .map_err(|e| anyhow::anyhow!("tract: input_ids: {}", e))?
         .into();
-    let attention_mask_tensor: Tensor = Array2::from_shape_vec((batch_size, max_len), attention_mask)
-        .map_err(|e| anyhow::anyhow!("tract: attention_mask: {}", e))?
-        .into();
+    let attention_mask_tensor: Tensor =
+        Array2::from_shape_vec((batch_size, max_len), attention_mask)
+            .map_err(|e| anyhow::anyhow!("tract: attention_mask: {}", e))?
+            .into();
     let input_tvalue: TValue = input_ids_tensor.into();
     let mask_tvalue: TValue = attention_mask_tensor.into();
 
     let result = runnable.run(tvec!(input_tvalue, mask_tvalue))?;
 
-    let output = result.into_iter().next()
+    let output = result
+        .into_iter()
+        .next()
         .ok_or_else(|| anyhow::anyhow!("tract: no output tensor"))?;
 
-    let view = output.to_array_view::<f32>()
+    let view = output
+        .to_array_view::<f32>()
         .map_err(|e| anyhow::anyhow!("tract: output view: {}", e))?;
 
     let shape = view.shape();
     if shape.len() != 3 {
-        anyhow::bail!("tract: expected 3D output [batch, seq, dim], got {:?}", shape);
+        anyhow::bail!(
+            "tract: expected 3D output [batch, seq, dim], got {:?}",
+            shape
+        );
     }
 
     let seq_len = shape[1];
@@ -233,11 +274,15 @@ fn run_embed_batch(
         let mut sum = vec![0f32; dim];
         let mut count = 0f32;
         for j in 0..valid_len {
-            for k in 0..dim { sum[k] += view[[i, j, k]]; }
+            for k in 0..dim {
+                sum[k] += view[[i, j, k]];
+            }
             count += 1.0;
         }
         if count > 0.0 {
-            for x in &mut sum { *x /= count; }
+            for x in &mut sum {
+                *x /= count;
+            }
         }
         embeddings.push(normalize_l2(sum));
     }

crates/core/src/knowledge_graph.rs

@@ -174,10 +174,8 @@ CREATE INDEX IF NOT EXISTS idx_triples_subject ON triples(subject);
                 .execute("ALTER TABLE triples ADD COLUMN adapter_name TEXT", [])?;
         }
         if !names.iter().any(|n| n == "t_created") {
-            self.conn.execute(
-                "ALTER TABLE triples ADD COLUMN t_created TEXT",
-                [],
-            )?;
+            self.conn
+                .execute("ALTER TABLE triples ADD COLUMN t_created TEXT", [])?;
         }
         if !names.iter().any(|n| n == "t_expired") {
             self.conn
@@ -403,7 +401,10 @@ CREATE INDEX IF NOT EXISTS idx_triples_subject ON triples(subject);
                     let te: Option<String> = row.get("t_expired")?;
                     let vt: Option<String> = row.get("valid_to")?;
                     let tc: Option<String> = row.get("t_created")?;
-                    eprintln!("  ROW: t_created={:?}, t_expired={:?}, valid_to={:?}", tc, te, vt);
+                    eprintln!(
+                        "  ROW: t_created={:?}, t_expired={:?}, valid_to={:?}",
+                        tc, te, vt
+                    );
                     results.push(self.row_to_entity_result(row, "outgoing", eid)?);
                 }
                 eprintln!("TRACE: returned {} rows", cnt);
@@ -708,7 +709,7 @@ CREATE INDEX IF NOT EXISTS idx_triples_subject ON triples(subject);
                      AND (t.t_expired IS NULL OR t.t_expired >= ?3) \
                      AND (t.valid_from IS NULL OR t.valid_from <= ?4) \
                      AND (t.valid_to IS NULL OR t.valid_to >= ?5) \
-                     ORDER BY t.valid_from ASC LIMIT 100"
+                     ORDER BY t.valid_from ASC LIMIT 100",
                 )?;
                 let rows = stmt.query_map(params![eid, now, now, now, now], |row| {
                     Ok(Triple {

crates/core/src/layers.rs

@@ -565,8 +565,10 @@ pub struct DeepSearchStatus {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::palace::{DrawerId, MemoryScope, DrawerKind, MemoryTier, SearchScope, SearchHit, PalaceStore};
     use crate::embed::Embedder;
+    use crate::palace::{
+        DrawerId, DrawerKind, MemoryScope, MemoryTier, PalaceStore, SearchHit, SearchScope,
+    };
     use async_trait::async_trait;
     use tempfile::tempdir;
 
@@ -587,22 +589,38 @@ mod tests {
         async fn add_drawer(&self, _drawer: Drawer) -> anyhow::Result<DrawerId> {
             panic!("add_drawer not implemented in test adapter")
         }
-        async fn remember(&self, _content: String, _scope: MemoryScope) -> anyhow::Result<DrawerId> {
+        async fn remember(
+            &self,
+            _content: String,
+            _scope: MemoryScope,
+        ) -> anyhow::Result<DrawerId> {
             panic!("remember not implemented in test adapter")
         }
         async fn forget(&self, _id: &DrawerId) -> anyhow::Result<bool> {
             panic!("forget not implemented in test adapter")
         }
-        async fn search(&self, _query: &str, _scope: &SearchScope) -> anyhow::Result<Vec<SearchHit>> {
+        async fn search(
+            &self,
+            _query: &str,
+            _scope: &SearchScope,
+        ) -> anyhow::Result<Vec<SearchHit>> {
             panic!("search not implemented in test adapter")
         }
-        async fn search_with_embedding(&self, _query_vec: &[f32], _scope: &SearchScope) -> anyhow::Result<Vec<SearchHit>> {
+        async fn search_with_embedding(
+            &self,
+            _query_vec: &[f32],
+            _scope: &SearchScope,
+        ) -> anyhow::Result<Vec<SearchHit>> {
             panic!("search_with_embedding not implemented in test adapter")
         }
         async fn related(&self, _id: &DrawerId, _depth: usize) -> anyhow::Result<Vec<SearchHit>> {
             panic!("related not implemented in test adapter")
         }
-        async fn extract_from_transcript(&self, _transcript: &str, _session_id: &str) -> anyhow::Result<Vec<DrawerId>> {
+        async fn extract_from_transcript(
+            &self,
+            _transcript: &str,
+            _session_id: &str,
+        ) -> anyhow::Result<Vec<DrawerId>> {
             panic!("extract_from_transcript not implemented in test adapter")
         }
         async fn graph_stats(&self) -> anyhow::Result<crate::knowledge_graph::KgStats> {
@@ -617,7 +635,11 @@ mod tests {
         fn store(&self) -> &dyn PalaceStore {
             panic!("store not implemented in test adapter")
         }
-        async fn get_drawers(&self, scope: Option<&SearchScope>, limit: Option<usize>) -> anyhow::Result<Vec<Drawer>> {
+        async fn get_drawers(
+            &self,
+            scope: Option<&SearchScope>,
+            limit: Option<usize>,
+        ) -> anyhow::Result<Vec<Drawer>> {
             let wing = scope.and_then(|s| s.wing.as_deref());
             let room = scope.and_then(|s| s.room.as_deref());
             let limit = limit.unwrap_or(usize::MAX);
@@ -632,8 +654,14 @@ mod tests {
                         content,
                         kind: DrawerKind::default(),
                         tier: MemoryTier::default(),
-                        wing: metadata.get("wing").and_then(|v| v.as_str()).map(String::from),
-                        room: metadata.get("room").and_then(|v| v.as_str()).map(String::from),
+                        wing: metadata
+                            .get("wing")
+                            .and_then(|v| v.as_str())
+                            .map(String::from),
+                        room: metadata
+                            .get("room")
+                            .and_then(|v| v.as_str())
+                            .map(String::from),
                         metadata,
                         derived_from: Vec::new(),
                     });

crates/core/src/lib.rs

@@ -100,7 +100,6 @@ pub mod mine_pid_guard;
 #[deprecated(since = "0.2.0", note = "use palace:: or embed:: API instead")]
 pub mod normalize;
 #[doc(hidden)]
-
 #[doc(hidden)]
 #[deprecated(since = "0.2.0", note = "use palace:: or embed:: API instead")]
 pub mod palace_db;

crates/core/src/palace/store/embedvec.rs

@@ -89,12 +89,10 @@ impl PalaceStore for EmbedvecStore {
             return Ok(());
         }
 
-        let needs_write = self.model_name.is_some()
-            && self.palace_path.is_some()
-            && {
-                let inner = self.inner.lock().await;
-                inner.len() == 0
-            };
+        let needs_write = self.model_name.is_some() && self.palace_path.is_some() && {
+            let inner = self.inner.lock().await;
+            inner.len() == 0
+        };
 
         if needs_write {
             let manifest = EmbeddingManifest::from_embedder(
@@ -111,10 +109,9 @@ impl PalaceStore for EmbedvecStore {
             .into_iter()
             .enumerate()
             .map(|(i, d)| {
-                let id = d
-                    .id
-                    .map(|di| di.0)
-                    .unwrap_or_else(|| format!("drawer-{}", i));
+                let id =
+                    d.id.map(|di| di.0)
+                        .unwrap_or_else(|| format!("drawer-{}", i));
                 (id, d.content)
             })
             .collect();