chore: fix strict clippy violations and apply rustfmt (#8)

* Updated Test Coverage

* Fixed the test

* Implement intent-based query adjustments and add tolerance to score weight normalization

* Updated features

* Updated the chunker

* Fixed the error in the CI

* Resolved clippy warnings and apply rustfmt across workspace

* fix: remove duplicate markdown chunker tests causing E0428

Author: anaslimem

clippy.toml

@@ -5,4 +5,4 @@
 # allow-clippy-pedantic-in-test = true
 
 # Specific lints
-warn-on-all-items-with-docs = true
+# Keep this file limited to options supported by the current Clippy version.

crates/cortexadb-core/benches/storage_bench.rs

@@ -1,7 +1,7 @@
 use cortexadb_core::engine::{CapacityPolicy, SyncPolicy};
 use cortexadb_core::store::CheckpointPolicy;
 use cortexadb_core::{CortexaDB, CortexaDBConfig, IndexMode};
-use criterion::{Criterion, criterion_group, criterion_main};
+use criterion::{criterion_group, criterion_main, Criterion};
 use tempfile::tempdir;
 
 fn bench_ingestion(c: &mut Criterion) {

crates/cortexadb-core/src/bin/manual_store.rs

@@ -30,14 +30,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let store = CortexaDBStore::new(&wal, &seg, 3)?;
 
     store.insert_memory(
-        MemoryEntry::new(
-            MemoryId(1),
-            "agent1".to_string(),
-            b"Rust WAL design".to_vec(),
-            1000,
-        )
-        .with_embedding(vec![1.0, 0.0, 0.0])
-        .with_importance(0.8),
+        MemoryEntry::new(MemoryId(1), "agent1".to_string(), b"Rust WAL design".to_vec(), 1000)
+            .with_embedding(vec![1.0, 0.0, 0.0])
+            .with_importance(0.8),
     )?;
 
     store.insert_memory(

crates/cortexadb-core/src/bin/monkey_verify.rs

@@ -20,24 +20,17 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // With insert-only workload, recovered state size must match surviving WAL commands.
     if entries != wal_len {
-        return Err(format!(
-            "recovery mismatch: state_entries={} wal_len={}",
-            entries, wal_len
-        )
-        .into());
+        return Err(
+            format!("recovery mismatch: state_entries={} wal_len={}", entries, wal_len).into()
+        );
     }
 
     // IDs should be contiguous from 0..entries-1 for this controlled writer.
     for id in 0..entries {
-        state
-            .get_memory(MemoryId(id))
-            .map_err(|_| format!("missing recovered id {id}"))?;
+        state.get_memory(MemoryId(id)).map_err(|_| format!("missing recovered id {id}"))?;
     }
 
-    println!(
-        "Monkey recovery OK: recovered {} valid records (WAL len {}).",
-        entries, wal_len
-    );
+    println!("Monkey recovery OK: recovered {} valid records (WAL len {}).", entries, wal_len);
 
     Ok(())
 }

crates/cortexadb-core/src/bin/startup_bench.rs

@@ -3,10 +3,10 @@
 //! Measures cold open time, snapshot load time, and WAL replay time
 //! against the <100ms target for small/medium databases.
 
-use cortexadb_core::IndexMode;
 use cortexadb_core::engine::{CapacityPolicy, SyncPolicy};
 use cortexadb_core::facade::{CortexaDB, CortexaDBConfig};
 use cortexadb_core::store::CheckpointPolicy;
+use cortexadb_core::IndexMode;
 use std::time::Instant;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {

crates/cortexadb-core/src/bin/sync_bench.rs

@@ -102,10 +102,7 @@ impl BenchConfig {
                 }
                 "--vector-dim" => {
                     i += 1;
-                    vector_dim = args
-                        .get(i)
-                        .ok_or("missing value for --vector-dim")?
-                        .parse()?;
+                    vector_dim = args.get(i).ok_or("missing value for --vector-dim")?.parse()?;
                 }
                 "--namespace" => {
                     i += 1;
@@ -121,24 +118,18 @@ impl BenchConfig {
                 }
                 "--batch-max-ops" => {
                     i += 1;
-                    batch_max_ops = args
-                        .get(i)
-                        .ok_or("missing value for --batch-max-ops")?
-                        .parse()?;
+                    batch_max_ops =
+                        args.get(i).ok_or("missing value for --batch-max-ops")?.parse()?;
                 }
                 "--batch-max-delay-ms" => {
                     i += 1;
-                    batch_max_delay_ms = args
-                        .get(i)
-                        .ok_or("missing value for --batch-max-delay-ms")?
-                        .parse()?;
+                    batch_max_delay_ms =
+                        args.get(i).ok_or("missing value for --batch-max-delay-ms")?.parse()?;
                 }
                 "--async-interval-ms" => {
                     i += 1;
-                    async_interval_ms = args
-                        .get(i)
-                        .ok_or("missing value for --async-interval-ms")?
-                        .parse()?;
+                    async_interval_ms =
+                        args.get(i).ok_or("missing value for --async-interval-ms")?.parse()?;
                 }
                 "-h" | "--help" => {
                     print_help();
@@ -153,31 +144,19 @@ impl BenchConfig {
 
         let policy = match mode.to_ascii_lowercase().as_str() {
             "strict" => SyncPolicy::Strict,
-            "batch" => SyncPolicy::Batch {
-                max_ops: batch_max_ops,
-                max_delay_ms: batch_max_delay_ms,
-            },
-            "async" => SyncPolicy::Async {
-                interval_ms: async_interval_ms,
-            },
+            "batch" => {
+                SyncPolicy::Batch { max_ops: batch_max_ops, max_delay_ms: batch_max_delay_ms }
+            }
+            "async" => SyncPolicy::Async { interval_ms: async_interval_ms },
             _ => return Err(format!("invalid mode: {} (use strict|batch|async)", mode).into()),
         };
 
-        Ok(Self {
-            ops,
-            vector_dim,
-            namespace,
-            data_dir,
-            policy,
-        })
+        Ok(Self { ops, vector_dim, namespace, data_dir, policy })
     }
 }
 
 fn build_paths(cfg: &BenchConfig) -> (PathBuf, PathBuf) {
-    let nonce = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map(|d| d.as_millis())
-        .unwrap_or(0);
+    let nonce = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_millis()).unwrap_or(0);
     let run_dir = cfg.data_dir.join(format!("run_{}", nonce));
     let wal = run_dir.join("bench.wal");
     let seg = run_dir.join("segments");

crates/cortexadb-core/src/chunker.rs

@@ -88,11 +88,7 @@ fn chunk_fixed(text: &str, chunk_size: usize, overlap: usize) -> Vec<ChunkResult
 
         let chunk_text = chunk_words.join(" ");
         if !chunk_text.is_empty() {
-            chunks.push(ChunkResult {
-                text: chunk_text,
-                index: chunks.len(),
-                metadata: None,
-            });
+            chunks.push(ChunkResult { text: chunk_text, index: chunks.len(), metadata: None });
         }
 
         // No unseen words remain, so a trailing overlap-only chunk would be redundant.
@@ -157,7 +153,7 @@ fn chunk_recursive(text: &str, chunk_size: usize, overlap: usize) -> Vec<ChunkRe
         }
 
         let mut split_done = false;
-        for (_i, sep) in separators.iter().enumerate() {
+        for sep in separators.iter() {
             if *sep == " " {
                 continue;
             }
@@ -306,11 +302,11 @@ fn chunk_markdown(text: &str, preserve_headers: bool, overlap: usize) -> Vec<Chu
             }
         } else if list_regex.is_match(line) {
             if !last_header.is_empty() && !current_section.is_empty() {
-                current_section.push_str("\n");
+                current_section.push('\n');
             }
             current_section.push_str(trimmed);
         } else if !trimmed.starts_with("```") {
-            current_section.push_str(" ");
+            current_section.push(' ');
             current_section.push_str(trimmed);
         }
 
@@ -430,7 +426,7 @@ fn apply_overlap(chunks: Vec<ChunkResult>, overlap: usize) -> Vec<ChunkResult> {
                 combined.push_str(word);
             }
             if !combined.is_empty() {
-                combined.push_str(" ");
+                combined.push(' ');
             }
             combined.push_str(&chunk.text);
 
@@ -523,8 +519,7 @@ mod tests {
         // All words from the original text should appear in some chunk.
         let text = "alpha beta gamma delta epsilon zeta";
         let chunks = chunk_fixed(text, 12, 0);
-        let combined: String =
-            chunks.iter().map(|c| c.text.as_str()).collect::<Vec<_>>().join(" ");
+        let combined: String = chunks.iter().map(|c| c.text.as_str()).collect::<Vec<_>>().join(" ");
         for word in text.split_whitespace() {
             assert!(combined.contains(word), "word '{}' missing from chunked output", word);
         }
@@ -547,8 +542,7 @@ mod tests {
         // A word too long to fit in chunk_size must not be split.
         let text = "x superlongwordthatexceedschunksize y";
         let chunks = chunk_fixed(text, 5, 0);
-        let combined: String =
-            chunks.iter().map(|c| c.text.as_str()).collect::<Vec<_>>().join(" ");
+        let combined: String = chunks.iter().map(|c| c.text.as_str()).collect::<Vec<_>>().join(" ");
         assert!(combined.contains("superlongwordthatexceedschunksize"));
     }
 
@@ -719,7 +713,11 @@ mod tests {
             let chunks = chunk_markdown(text, preserve, 0);
             assert!(!chunks.is_empty());
             let combined = chunks.iter().map(|c| c.text.as_str()).collect::<Vec<_>>().join(" ");
-            assert!(combined.contains("Body content"), "body text must be present (preserve={})", preserve);
+            assert!(
+                combined.contains("Body content"),
+                "body text must be present (preserve={})",
+                preserve
+            );
         }
     }
 
@@ -859,8 +857,7 @@ mod tests {
 
     #[test]
     fn test_apply_overlap_single_chunk_unchanged() {
-        let input =
-            vec![ChunkResult { text: "only one".to_string(), index: 0, metadata: None }];
+        let input = vec![ChunkResult { text: "only one".to_string(), index: 0, metadata: None }];
         let out = apply_overlap(input, 5);
         assert_eq!(out.len(), 1);
         assert_eq!(out[0].text, "only one");
@@ -877,7 +874,7 @@ mod tests {
         assert_eq!(out.len(), 2);
         assert_eq!(out[0].text, "one");
         // "one" is the last (and only) word from chunk[0], so it is prepended to chunk[1]
-        assert!(out[1].text.starts_with("one "), "got '{}'" , out[1].text);
+        assert!(out[1].text.starts_with("one "), "got '{}'", out[1].text);
         assert!(out[1].text.contains("two three"));
     }
 
@@ -914,7 +911,7 @@ mod tests {
         let text = "# Title\nContent.\n\n## Subtitle\nMore content.";
         let strategy = ChunkingStrategy::Markdown { preserve_headers: true, overlap: 0 };
         let chunks = chunk(text, strategy);
-        assert!(chunks.len() >= 1);
+        assert!(!chunks.is_empty());
         let combined = chunks.iter().map(|c| c.text.as_str()).collect::<Vec<_>>().join(" ");
         assert!(combined.contains("Title"), "header text must be in output");
         assert!(combined.contains("Content"));
@@ -928,7 +925,15 @@ mod tests {
         let strategy = ChunkingStrategy::Json { overlap: 0 };
         let chunks = chunk(text, strategy);
         assert_eq!(chunks.len(), 2);
-        assert!(chunks.iter().any(|c| c.metadata.as_ref().map(|m| m.key.as_ref().unwrap() == "data.id" && m.value.as_ref().unwrap() == "123").unwrap_or(false)));
-        assert!(chunks.iter().any(|c| c.metadata.as_ref().map(|m| m.key.as_ref().unwrap() == "data.name" && m.value.as_ref().unwrap() == "Test").unwrap_or(false)));
+        assert!(chunks.iter().any(|c| c
+            .metadata
+            .as_ref()
+            .map(|m| m.key.as_ref().unwrap() == "data.id" && m.value.as_ref().unwrap() == "123")
+            .unwrap_or(false)));
+        assert!(chunks.iter().any(|c| c
+            .metadata
+            .as_ref()
+            .map(|m| m.key.as_ref().unwrap() == "data.name" && m.value.as_ref().unwrap() == "Test")
+            .unwrap_or(false)));
     }
 }

crates/cortexadb-core/src/core/state_machine.rs

@@ -71,7 +71,7 @@ impl StateMachine {
         self.memories.insert(id, entry);
 
         // Add to temporal index
-        self.temporal_index.entry(timestamp).or_insert_with(Vec::new).push(id);
+        self.temporal_index.entry(timestamp).or_default().push(id);
 
         // Keep temporal index sorted for determinism
         if let Some(ids) = self.temporal_index.get_mut(&timestamp) {
@@ -118,7 +118,7 @@ impl StateMachine {
             });
         }
 
-        let edges = self.graph.entry(from).or_insert_with(Vec::new);
+        let edges = self.graph.entry(from).or_default();
         // Avoid duplicate edges
         if !edges.iter().any(|e| e.to == to && e.relation == relation) {
             edges.push(Edge { to, relation });

crates/cortexadb-core/src/facade.rs

@@ -75,10 +75,7 @@ impl CortexaDBBuilder {
             config: CortexaDBConfig {
                 vector_dimension,
                 sync_policy: SyncPolicy::Strict,
-                checkpoint_policy: CheckpointPolicy::Periodic {
-                    every_ops: 1000,
-                    every_ms: 30_000,
-                },
+                checkpoint_policy: CheckpointPolicy::Periodic { every_ops: 1000, every_ms: 30_000 },
                 capacity_policy: CapacityPolicy::new(None, None),
                 index_mode: IndexMode::Exact,
             },
@@ -171,12 +168,12 @@ impl QueryEmbedder for StaticEmbedder {
 /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
 /// // Create a default DB with vector dimension 3
 /// let db = CortexaDB::open("my_agent.db", 3)?;
-/// 
+///
 /// // Or use the builder for advanced config
 /// let db_advanced = CortexaDB::builder("advanced.db", 1536)
 ///     .with_sync_policy(cortexadb_core::engine::SyncPolicy::Async { interval_ms: 1000 })
 ///     .build()?;
-/// 
+///
 /// let id = db.remember(vec![1.0, 0.0, 0.0], None)?;
 /// let hits = db.ask(vec![1.0, 0.0, 0.0], 5, None)?;
 /// # Ok(())
@@ -636,7 +633,10 @@ mod tests {
         db.delete_memory(id).unwrap();
 
         let hits = db.ask(vec![1.0, 0.0, 0.0], 10, None).unwrap();
-        assert!(hits.iter().all(|h| h.id != id), "deleted memory must not appear in search results");
+        assert!(
+            hits.iter().all(|h| h.id != id),
+            "deleted memory must not appear in search results"
+        );
     }
 
     #[test]
@@ -747,8 +747,16 @@ mod tests {
         // Ask for top-2 in ns_sparse — both must be returned.
         let hits = db.ask_in_namespace("ns_sparse", vec![1.0, 0.0, 0.0], 2, None).unwrap();
         let hit_ids: Vec<u64> = hits.iter().map(|h| h.id).collect();
-        assert!(hit_ids.contains(&id_a), "id_a must appear in ns_sparse results; got {:?}", hit_ids);
-        assert!(hit_ids.contains(&id_b), "id_b must appear in ns_sparse results; got {:?}", hit_ids);
+        assert!(
+            hit_ids.contains(&id_a),
+            "id_a must appear in ns_sparse results; got {:?}",
+            hit_ids
+        );
+        assert!(
+            hit_ids.contains(&id_b),
+            "id_b must appear in ns_sparse results; got {:?}",
+            hit_ids
+        );
     }
 
     // ----- Intent anchors end-to-end -----