Run cargo fmt to fix formatting

anthonylee991 · claude · anthonylee991 · commit ebc0b38ac742 · 2026-03-06T09:45:13.000Z
Co-Authored-By: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/src/benchmark/mod.rs b/src/benchmark/mod.rs
@@ -308,7 +308,12 @@ pub fn run_benchmark(
     cases: &[TestCase],
     verbose: bool,
 ) -> Result<BenchmarkResult> {
-    run_benchmark_with("GliNER", |text| extractor.extract_triplets(text), cases, verbose)
+    run_benchmark_with(
+        "GliNER",
+        |text| extractor.extract_triplets(text),
+        cases,
+        verbose,
+    )
 }
 
 /// Print the benchmark summary
@@ -352,7 +357,10 @@ pub fn print_summary(result: &BenchmarkResult) {
 /// Print comparison between two benchmark results
 pub fn print_comparison(before: &BenchmarkResult, after: &BenchmarkResult) {
     println!("\n{}", "=".repeat(60));
-    println!("COMPARISON: {} vs {}", before.extractor_name, after.extractor_name);
+    println!(
+        "COMPARISON: {} vs {}",
+        before.extractor_name, after.extractor_name
+    );
     println!("{}", "=".repeat(60));
 
     let precision_delta = (after.precision - before.precision) * 100.0;
diff --git a/src/extractor/gliner.rs b/src/extractor/gliner.rs
@@ -5,34 +5,87 @@ use gliner::model::{input::text::TextInput, params::Parameters, pipeline::span::
 
 /// Known relation verbs for extracting predicates from text between entities.
 const RELATION_VERBS: &[&str] = &[
-    "works", "founded", "leads", "manages", "joined", "acquired", "owns",
-    "based", "located", "headquartered", "reports", "partnered", "uses",
-    "built", "developed", "created", "provides", "competes", "invested",
-    "launched", "serves", "appointed", "hired", "employs", "supervises",
-    "sold", "purchased", "ordered", "shipped", "reviewed", "paid",
-    "governs", "applies", "requires", "depends", "integrates", "runs",
-    "heads", "oversees", "established", "operates", "supports", "maintains",
-    "produces", "manufactures", "supplies", "distributes", "sponsors",
+    "works",
+    "founded",
+    "leads",
+    "manages",
+    "joined",
+    "acquired",
+    "owns",
+    "based",
+    "located",
+    "headquartered",
+    "reports",
+    "partnered",
+    "uses",
+    "built",
+    "developed",
+    "created",
+    "provides",
+    "competes",
+    "invested",
+    "launched",
+    "serves",
+    "appointed",
+    "hired",
+    "employs",
+    "supervises",
+    "sold",
+    "purchased",
+    "ordered",
+    "shipped",
+    "reviewed",
+    "paid",
+    "governs",
+    "applies",
+    "requires",
+    "depends",
+    "integrates",
+    "runs",
+    "heads",
+    "oversees",
+    "established",
+    "operates",
+    "supports",
+    "maintains",
+    "produces",
+    "manufactures",
+    "supplies",
+    "distributes",
+    "sponsors",
 ];
 
 /// Prepositions that attach to verbs to form compound predicates.
-const PREPOSITIONS: &[&str] = &[
-    "at", "in", "for", "with", "to", "by", "of", "from", "on",
-];
+const PREPOSITIONS: &[&str] = &["at", "in", "for", "with", "to", "by", "of", "from", "on"];
 
 /// Pronouns and noise words that should never be entities.
 const GARBAGE_WORDS: &[&str] = &[
-    "our", "we", "us", "they", "my", "your", "his", "her", "i", "me",
-    "it", "this", "that", "these", "those", "its", "their", "he", "she",
-    "who", "which", "what", "where", "when", "how", "why",
+    "our", "we", "us", "they", "my", "your", "his", "her", "i", "me", "it", "this", "that",
+    "these", "those", "its", "their", "he", "she", "who", "which", "what", "where", "when", "how",
+    "why",
 ];
 
 /// Section header words that GliNER sometimes picks up as entities.
 const SECTION_HEADERS: &[&str] = &[
-    "overview", "summary", "conclusion", "introduction", "background",
-    "features", "pricing", "security", "details", "description",
-    "requirements", "objectives", "scope", "methodology", "results",
-    "abstract", "appendix", "references", "contents",
+    "overview",
+    "summary",
+    "conclusion",
+    "introduction",
+    "background",
+    "features",
+    "pricing",
+    "security",
+    "details",
+    "description",
+    "requirements",
+    "objectives",
+    "scope",
+    "methodology",
+    "results",
+    "abstract",
+    "appendix",
+    "references",
+    "contents",
 ];
 
 /// Check if an entity text is garbage that should be filtered out.
@@ -65,7 +118,10 @@ fn extract_verb_predicate(between_text: &str) -> String {
 
     for (i, word) in words.iter().enumerate() {
         let lower = word.to_lowercase();
-        if RELATION_VERBS.iter().any(|v| lower == *v || lower.ends_with(v)) {
+        if RELATION_VERBS
+            .iter()
+            .any(|v| lower == *v || lower.ends_with(v))
+        {
             // Check if next word is a preposition to attach
             if i + 1 < words.len() {
                 let next_lower = words[i + 1].to_lowercase();
diff --git a/src/extractor/hybrid.rs b/src/extractor/hybrid.rs
@@ -1,4 +1,6 @@
-use crate::extractor::{gliner::GlinerExtractor, normalize_predicate, patterns::PatternMatcher, Triplet};
+use crate::extractor::{
+    gliner::GlinerExtractor, normalize_predicate, patterns::PatternMatcher, Triplet,
+};
 use anyhow::Result;
 
 /// Hybrid extractor that combines GliNER neural extraction with pattern-based rules.
@@ -32,8 +34,7 @@ impl HybridExtractor {
         for gt in gliner_triplets {
             // Check if this triplet overlaps significantly with any pattern triplet
             let dominated = pattern_triplets.iter().any(|pt| {
-                spans_overlap(pt.source_span, gt.source_span)
-                    || triplets_similar(pt, &gt)
+                spans_overlap(pt.source_span, gt.source_span) || triplets_similar(pt, &gt)
             });
 
             if !dominated {
diff --git a/src/extractor/mod.rs b/src/extractor/mod.rs
@@ -30,8 +30,8 @@ pub fn normalize_predicate(predicate: &str) -> String {
 
     match trimmed {
         "co-founded" | "established" => "founded".to_string(),
-        "heads" | "runs" | "ceo of" | "cto of" | "coo of" | "cfo of"
-        | "director of" | "president of" | "chairman of" => "leads".to_string(),
+        "heads" | "runs" | "ceo of" | "cto of" | "coo of" | "cfo of" | "director of"
+        | "president of" | "chairman of" => "leads".to_string(),
         "works for" | "employed at" | "employed by" => "works at".to_string(),
         "supervises" | "oversees" => "manages".to_string(),
         "based in" | "headquartered in" => "located in".to_string(),
diff --git a/src/extractor/patterns.rs b/src/extractor/patterns.rs
@@ -398,9 +398,9 @@ impl PatternMatcher {
             for caps in pattern.regex.captures_iter(text) {
                 if let Some(triplet) = (pattern.extractor)(&caps, text) {
                     // Avoid duplicate spans
-                    let dominated = seen_spans.iter().any(|(s, e)| {
-                        triplet.source_span.0 >= *s && triplet.source_span.1 <= *e
-                    });
+                    let dominated = seen_spans
+                        .iter()
+                        .any(|(s, e)| triplet.source_span.0 >= *s && triplet.source_span.1 <= *e);
                     if !dominated {
                         seen_spans.push(triplet.source_span);
                         triplets.push(triplet);
diff --git a/src/main.rs b/src/main.rs
@@ -152,8 +152,15 @@ async fn main() -> anyhow::Result<()> {
             }
             println!("Total: {} triplets from file", total);
         }
-        cli::Commands::Recall { query, limit, min_strength } => {
-            println!("Recalling memories for: {} (min_strength: {})", query, min_strength);
+        cli::Commands::Recall {
+            query,
+            limit,
+            min_strength,
+        } => {
+            println!(
+                "Recalling memories for: {} (min_strength: {})",
+                query, min_strength
+            );
             let retriever = HybridRetriever::new(&storage);
             let request = RecallRequest {
                 query,
@@ -165,7 +172,11 @@ async fn main() -> anyhow::Result<()> {
             for m in response.memories {
                 println!(
                     "- {} -> {} -> {} (strength: {:.2}, conf: {:.2})",
-                    m.subject_node.label, m.edge.predicate, m.object_node.label, m.relevance_score, m.edge.confidence
+                    m.subject_node.label,
+                    m.edge.predicate,
+                    m.object_node.label,
+                    m.relevance_score,
+                    m.edge.confidence
                 );
             }
         }
@@ -203,10 +214,16 @@ async fn main() -> anyhow::Result<()> {
         cli::Commands::Dedup => {
             println!("Running Node Deduplication...");
             let nodes = storage.list_nodes()?;
-            let mut normalized_map: std::collections::HashMap<String, Vec<Node>> = std::collections::HashMap::new();
+            let mut normalized_map: std::collections::HashMap<String, Vec<Node>> =
+                std::collections::HashMap::new();
 
             for node in nodes {
-                let norm = node.label.to_lowercase().chars().filter(|c| c.is_alphanumeric()).collect::<String>();
+                let norm = node
+                    .label
+                    .to_lowercase()
+                    .chars()
+                    .filter(|c| c.is_alphanumeric())
+                    .collect::<String>();
                 normalized_map.entry(norm).or_default().push(node);
             }
 
@@ -215,15 +232,22 @@ async fn main() -> anyhow::Result<()> {
                 if group.len() > 1 && !norm.is_empty() {
                     let winner = &group[0];
                     for loser in &group[1..] {
-                        println!("Merging '{}' (id: {}) -> '{}' (id: {})", loser.label, loser.id, winner.label, winner.id);
+                        println!(
+                            "Merging '{}' (id: {}) -> '{}' (id: {})",
+                            loser.label, loser.id, winner.label, winner.id
+                        );
                         storage.merge_nodes(&winner.id, &loser.id)?;
                         merged_count += 1;
                     }
                 }
             }
             println!("Deduplication complete. Merged {} nodes.", merged_count);
         }
-        cli::Commands::Benchmark { cases, verbose, mode } => {
+        cli::Commands::Benchmark {
+            cases,
+            verbose,
+            mode,
+        } => {
             println!("Loading test cases from: {}", cases.display());
             let test_cases = benchmark::load_test_cases(&cases)?;
 
diff --git a/src/mcp.rs b/src/mcp.rs
@@ -2,6 +2,9 @@
 //!
 //! Contains the MCPServer struct with all tool handlers, and the SSE transport layer.
 
+use crate::graph::{Edge, GraphStore, Node, NodeType};
+use crate::retriever::{search::HybridRetriever, RecallRequest, Retriever};
+use crate::storage::sqlite::SqliteStorage;
 use anyhow::Result;
 use axum::{
     extract::{Query, State as AxumState},
@@ -14,9 +17,6 @@ use axum::{
     Json, Router,
 };
 use futures::stream::Stream;
-use crate::graph::{Edge, GraphStore, Node, NodeType};
-use crate::retriever::{search::HybridRetriever, RecallRequest, Retriever};
-use crate::storage::sqlite::SqliteStorage;
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 use std::collections::HashMap;
@@ -666,7 +666,11 @@ pub async fn sse_handler(
     let session_id = uuid::Uuid::new_v4().to_string();
     let (tx, rx) = mpsc::unbounded_channel::<String>();
 
-    state.sessions.lock().await.insert(session_id.clone(), tx.clone());
+    state
+        .sessions
+        .lock()
+        .await
+        .insert(session_id.clone(), tx.clone());
 
     let endpoint_url = format!("/message?session_id={}", session_id);
     let _ = tx.send(format!("__endpoint__{}", endpoint_url));
@@ -808,7 +812,10 @@ pub async fn run_sse(server: MCPServer, port: u16) -> Result<()> {
 
     let addr = std::net::SocketAddr::from(([127, 0, 0, 1], port));
     eprintln!("[orunla] SSE transport listening on http://{}", addr);
-    eprintln!("[orunla] Connect your MCP client to http://localhost:{}/sse", port);
+    eprintln!(
+        "[orunla] Connect your MCP client to http://localhost:{}/sse",
+        port
+    );
 
     let listener = tokio::net::TcpListener::bind(addr).await?;
     axum::serve(listener, app.into_make_service()).await?;
diff --git a/src/retriever/search.rs b/src/retriever/search.rs
@@ -22,7 +22,7 @@ impl<'a> Retriever for HybridRetriever<'a> {
         let mut memories = Vec::new();
         for edge in edges {
             let strength = calculate_strength(&edge, now);
-            
+
             if edge.confidence >= request.min_confidence && strength >= request.min_strength {
                 let subject_node = self.store.get_node(&edge.source)?.unwrap_or_else(|| {
                     crate::graph::Node::new("Unknown".to_string(), crate::graph::NodeType::Unknown)
diff --git a/src/server/mod.rs b/src/server/mod.rs
@@ -15,7 +15,7 @@ use axum::{
 use serde::Deserialize;
 use serde_json::{json, Value};
 use std::collections::HashMap;
-use std::net::{SocketAddr, IpAddr};
+use std::net::{IpAddr, SocketAddr};
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 use tokio::sync::Mutex;
@@ -130,7 +130,11 @@ async fn auth_middleware(
     Err(StatusCode::UNAUTHORIZED)
 }
 
-pub async fn start_server(storage: SqliteStorage, port: u16, api_key: Option<String>) -> anyhow::Result<()> {
+pub async fn start_server(
+    storage: SqliteStorage,
+    port: u16,
+    api_key: Option<String>,
+) -> anyhow::Result<()> {
     println!("Initializing hybrid extractor (Patterns + GliNER)...");
     let extractor = Arc::new(HybridExtractor::new()?);
     let rate_limiter = Arc::new(RateLimiter::new(60)); // 60 requests per minute per IP
@@ -477,7 +481,9 @@ pub async fn delete_memory_handler(
     match storage.delete_edge(&id) {
         Ok(_) => {
             let orphaned = storage.cleanup_orphaned_nodes().unwrap_or(0);
-            Json(json!({ "status": "ok", "message": format!("Memory deleted. Cleaned up {} orphaned nodes.", orphaned) }))
+            Json(
+                json!({ "status": "ok", "message": format!("Memory deleted. Cleaned up {} orphaned nodes.", orphaned) }),
+            )
         }
         Err(_e) => {
             eprintln!("Delete error: {}", _e); // Log server-side only
diff --git a/src/storage/sqlite.rs b/src/storage/sqlite.rs
diff --git a/src/utils/query.rs b/src/utils/query.rs
