Refactor ONNX provider and related modules for improved readability and maintainability

- Reformatted code in `onnx_provider.rs` for consistent style and clarity.
- Updated import statements and organized them for better structure.
- Enhanced error handling and logging in embedding generation methods.
- Improved input preparation and normalization processes.
- Refined search functionality in `search.rs` by removing redundant imports.
- Adjusted memory mapping and serialization in `zerocopy` crate for better performance.
- Updated HTTP server configuration in `http_server.rs` for cleaner code.
- Enhanced RAG tools in `rag_tools.rs` for better readability and maintainability.
- Updated MCP protocol version in documentation and test files to reflect the latest standards.
- Added automated tests for MCP tools in `test_mcp_tools.py` to ensure functionality.

Author: jruokola

crates/codegraph-ai/src/lib.rs

@@ -1,8 +1,8 @@
 pub mod ml;
 pub mod optimization;
+pub mod qwen_simple;
 pub mod rag;
 pub mod semantic;
-pub mod qwen_simple;
 
+pub use qwen_simple::{CodeIntelligenceProvider, QwenClient, QwenConfig, QwenResult};
 pub use semantic::search::*;
-pub use qwen_simple::{QwenClient, QwenConfig, QwenResult, CodeIntelligenceProvider};

crates/codegraph-ai/src/optimization/models.rs

@@ -310,7 +310,8 @@ impl<I: Send + 'static, O: Send + 'static> DynamicBatcher<I, O> {
             .send(req)
             .await
             .map_err(|_| anyhow::anyhow!("dynamic batch queue full or closed"))?;
-        rx.await.map_err(|_| anyhow::anyhow!("inference canceled"))?
+        rx.await
+            .map_err(|_| anyhow::anyhow!("inference canceled"))?
     }
 }
 

crates/codegraph-ai/src/qwen_simple.rs

@@ -78,7 +78,11 @@ impl QwenClient {
     }
 
     /// Generate analysis using Qwen2.5-Coder with comprehensive context
-    pub async fn generate_analysis(&self, prompt: &str, system_prompt: Option<&str>) -> Result<QwenResult> {
+    pub async fn generate_analysis(
+        &self,
+        prompt: &str,
+        system_prompt: Option<&str>,
+    ) -> Result<QwenResult> {
         let start_time = Instant::now();
 
         // Build full prompt with system context if provided
@@ -99,22 +103,36 @@ impl QwenClient {
             },
         };
 
-        debug!("Sending request to Qwen2.5-Coder: {} context window", self.config.context_window);
+        debug!(
+            "Sending request to Qwen2.5-Coder: {} context window",
+            self.config.context_window
+        );
 
         let response = timeout(
             self.config.timeout,
             self.client
                 .post(&format!("{}/api/generate", self.config.base_url))
                 .json(&request)
-                .send()
+                .send(),
         )
         .await
-        .map_err(|_| CodeGraphError::Timeout(format!("Qwen request timeout after {:?}", self.config.timeout)))?
+        .map_err(|_| {
+            CodeGraphError::Timeout(format!(
+                "Qwen request timeout after {:?}",
+                self.config.timeout
+            ))
+        })?
         .map_err(|e| CodeGraphError::Network(format!("Qwen request failed: {}", e)))?;
 
         if !response.status().is_success() {
-            let error_text = response.text().await.unwrap_or_else(|_| "Unknown error".to_string());
-            return Err(CodeGraphError::External(format!("Qwen API error: {}", error_text)));
+            let error_text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "Unknown error".to_string());
+            return Err(CodeGraphError::External(format!(
+                "Qwen API error: {}",
+                error_text
+            )));
         }
 
         let response_data: SimpleResponse = response
@@ -147,11 +165,16 @@ impl QwenClient {
 
     /// Check if Qwen2.5-Coder model is available
     pub async fn check_availability(&self) -> Result<bool> {
-        debug!("Checking Qwen2.5-Coder availability at {}", self.config.base_url);
+        debug!(
+            "Checking Qwen2.5-Coder availability at {}",
+            self.config.base_url
+        );
 
         let response = timeout(
             Duration::from_secs(5),
-            self.client.get(&format!("{}/api/tags", self.config.base_url)).send()
+            self.client
+                .get(&format!("{}/api/tags", self.config.base_url))
+                .send(),
         )
         .await
         .map_err(|_| CodeGraphError::Timeout("Qwen availability check timeout".to_string()))?
@@ -201,7 +224,10 @@ impl QwenClient {
         }
 
         // Technical terminology indicates code understanding
-        if response.contains("function") || response.contains("class") || response.contains("module") {
+        if response.contains("function")
+            || response.contains("class")
+            || response.contains("module")
+        {
             confidence += 0.1;
         }
 
@@ -280,4 +306,4 @@ impl CodeIntelligenceProvider for QwenClient {
 
         Ok(result.text)
     }
-}
+}

crates/codegraph-ai/src/rag/engine.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 use std::time::Instant;
 
-use tokio::sync::{mpsc, RwLock, Mutex};
+use tokio::sync::{mpsc, Mutex, RwLock};
 use tokio::task::JoinHandle;
 use tracing::{debug, error, info, instrument, warn};
 use uuid::Uuid;

crates/codegraph-ai/src/semantic/search.rs

@@ -4,7 +4,7 @@ use std::time::{Duration, Instant};
 
 use codegraph_core::{CodeGraphError, CodeNode, GraphStore, Language, NodeId, NodeType, Result};
 use codegraph_graph::CodeGraph;
-use codegraph_vector::{EmbeddingGenerator, search::SemanticSearch};
+use codegraph_vector::{search::SemanticSearch, EmbeddingGenerator};
 use futures::future::try_join_all;
 use tokio::sync::RwLock;
 

crates/codegraph-core/src/integration/parser_graph.rs

@@ -178,7 +178,7 @@ where
         &self,
         dir: &str,
         max_concurrent: usize,
-        exclude_generated: bool
+        exclude_generated: bool,
     ) -> Result<DirSummary> {
         let start = std::time::Instant::now();
 
@@ -259,7 +259,10 @@ where
         let mut processed = 0usize;
         let mut skipped = 0usize;
 
-        info!("Processing {} files for edge derivation (all languages supported)", total);
+        info!(
+            "Processing {} files for edge derivation (all languages supported)",
+            total
+        );
 
         // Two-phase approach for better linking: first ingest nodes, then edges.
         // Phase 1: parse + add nodes for all files (incremental aware) with progress tracking
@@ -273,9 +276,12 @@ where
                             processed += 1;
                             // Simple progress logging every 10 files
                             if processed % 10 == 0 {
-                                info!("Edge analysis progress: {}/{} files processed", processed, total);
+                                info!(
+                                    "Edge analysis progress: {}/{} files processed",
+                                    processed, total
+                                );
                             }
-                        },
+                        }
                         ProcessStatus::Skipped => skipped += 1,
                     },
                     Err(e) => warn!("process_file error: {}", e),

crates/codegraph-core/src/types.rs

@@ -7,7 +7,9 @@ use uuid::Uuid;
 pub type NodeId = Uuid;
 pub type EdgeId = Uuid;
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, bincode::Encode, bincode::Decode)]
+#[derive(
+    Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, bincode::Encode, bincode::Decode,
+)]
 pub enum Language {
     Rust,
     TypeScript,
@@ -26,7 +28,9 @@ pub enum Language {
     Other(String),
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, bincode::Encode, bincode::Decode)]
+#[derive(
+    Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, bincode::Encode, bincode::Decode,
+)]
 pub enum NodeType {
     Function,
     Struct,

crates/codegraph-graph/src/file_watcher.rs

@@ -1,7 +1,11 @@
 use codegraph_core::{traits::FileWatcher, ChangeEvent, Result};
 use crossbeam_channel::Sender;
-use notify::{recommended_watcher, Event, RecommendedWatcher, RecursiveMode, Watcher};
+use notify::{
+    recommended_watcher, Config, Event, PollWatcher, RecursiveMode, Watcher,
+};
+use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::path::Path;
+use std::time::Duration;
 
 pub struct FileWatcherImpl {
     path: String,
@@ -19,10 +23,30 @@ impl FileWatcher for FileWatcherImpl {
     fn watch(&self, tx: Sender<ChangeEvent>) -> Result<()> {
         let (notify_tx, notify_rx) = std::sync::mpsc::channel::<notify::Result<Event>>();
 
-        let mut watcher: RecommendedWatcher = recommended_watcher(move |res: notify::Result<Event>| {
-            let _ = notify_tx.send(res);
-        })
-        .map_err(|e| codegraph_core::CodeGraphError::Notify(e))?;
+        let watcher_result = catch_unwind(AssertUnwindSafe(|| {
+            let tx_clone = notify_tx.clone();
+            recommended_watcher(move |res: notify::Result<Event>| {
+                let _ = tx_clone.send(res);
+            })
+        }));
+
+        let mut watcher: Box<dyn Watcher + Send> = match watcher_result {
+            Ok(Ok(watcher)) => Box::new(watcher),
+            Ok(Err(e)) => return Err(codegraph_core::CodeGraphError::Notify(e)),
+            Err(_) => {
+                eprintln!("⚠️ macOS FSEvents watcher unavailable; falling back to polling file watcher");
+                let tx_clone = notify_tx.clone();
+                let poll_config = Config::default().with_poll_interval(Duration::from_secs(2));
+                let poll_watcher = PollWatcher::new(
+                    move |res: notify::Result<Event>| {
+                        let _ = tx_clone.send(res);
+                    },
+                    poll_config,
+                )
+                .map_err(|e| codegraph_core::CodeGraphError::Notify(e))?;
+                Box::new(poll_watcher)
+            }
+        };
 
         watcher
             .watch(Path::new(&self.path), RecursiveMode::Recursive)

crates/codegraph-graph/src/graph.rs

@@ -393,7 +393,7 @@ impl CodeGraph {
         from: NodeId,
         to: NodeId,
         edge_type: EdgeType,
-        metadata: HashMap<String, String>
+        metadata: HashMap<String, String>,
     ) -> Result<()> {
         // Create CodeEdge and use existing add_edge method
         let edge = CodeEdge {

crates/codegraph-graph/src/io_batcher.rs

@@ -69,8 +69,9 @@ impl ReadCoalescer {
             .map_err(|e| CodeGraphError::Database(e.to_string()))?;
         if let Some(bytes) = data {
             // SerializableCodeNode is defined in storage.rs module; mimic fields via serde
-            let s: crate::storage::SerializableCodeNode = serde_json::from_slice::<crate::storage::SerializableCodeNode>(&bytes)
-                .map_err(|e| CodeGraphError::Database(e.to_string()))?;
+            let s: crate::storage::SerializableCodeNode =
+                serde_json::from_slice::<crate::storage::SerializableCodeNode>(&bytes)
+                    .map_err(|e| CodeGraphError::Database(e.to_string()))?;
             let node: CodeNode = s.into();
             self.cache.insert(id, Arc::new(node.clone()));
             Ok(Some(node))