feat: expand MCP tools and Codex integration

Author: Jeremy Stover

CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.9.0] - 2026-03-12
+
+### Added
+- Expanded MCP coverage with first-class `trace`, `get_module`, `dead_code_audit`, and `index_status` tools.
+- Added richer MCP index operations for stats, checks, updates, prune, and export workflows.
+- Added explicit search diagnostics for semantic index usage, fallback behavior, and index health.
+
+### Changed
+- Updated Codex MCP setup to use `config.toml` for global and project-scoped configuration instead of legacy `mcp.json`.
+- Improved dead-code auditing heuristics for NestJS-style framework-managed symbols.
+- Improved server status reporting to distinguish live in-memory layer state from on-disk cache/index state.
+
+### Fixed
+- Fixed incremental index/cache metadata inconsistencies that could leave stale stats and incomplete retained summaries.
+- Fixed trace resolution by symbol name and file path when the symbol index is stored as `symbol_index.jsonl.gz`.
+- Fixed module query resolution for normal repository paths.
+- Fixed symbol-index detection for compressed index artifacts.
+- Hardened drift tests to create valid local git repos even when commit signing is enabled globally.
+
 ## [0.8.1] - 2026-03-07
 
 ### 🧸 Teddy, Day 2 — Electric Boogaloo

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "semfora-engine"
-version = "0.8.1"
+version = "0.9.0"
 edition = "2021"
 description = "Semantic code analyzer with TOON output"
 license = "Apache-2.0"

Cargo.toml

@@ -406,7 +406,10 @@ impl CacheDir {
     }
 
     /// Read a symbol's raw content from the consolidated file, falling back to individual shards
-    pub fn read_symbol_raw(&self, symbol_hash: &str) -> std::result::Result<String, crate::error::McpDiffError> {
+    pub fn read_symbol_raw(
+        &self,
+        symbol_hash: &str,
+    ) -> std::result::Result<String, crate::error::McpDiffError> {
         // Try consolidated file first
         let idx_path = self.symbols_idx_path();
         if idx_path.exists() {
@@ -418,8 +421,10 @@ impl CacheDir {
         // Fall back to individual shard files
         let path = self.symbol_path(symbol_hash);
         if path.exists() {
-            return std::fs::read_to_string(&path).map_err(|e| crate::error::McpDiffError::GitError {
-                message: format!("Failed to read symbol file: {}", e),
+            return std::fs::read_to_string(&path).map_err(|e| {
+                crate::error::McpDiffError::GitError {
+                    message: format!("Failed to read symbol file: {}", e),
+                }
             });
         }
 
@@ -430,40 +435,49 @@ impl CacheDir {
 
     /// Load the symbols.idx into a HashMap (last entry per hash wins, deduplicating stale entries).
     /// Cached via OnceCell so the index is only parsed once per CacheDir lifetime.
-    fn load_symbol_dat_index(&self) -> std::result::Result<&std::collections::HashMap<String, (u64, usize)>, crate::error::McpDiffError> {
-        self.symbol_dat_index.get_or_try_init(|| {
-            use std::io::BufRead;
-
-            let idx_path = self.symbols_idx_path();
-            let idx_file = std::fs::File::open(&idx_path).map_err(|e| crate::error::McpDiffError::GitError {
-                message: format!("Failed to open symbols.idx: {}", e),
-            })?;
+    fn load_symbol_dat_index(
+        &self,
+    ) -> std::result::Result<
+        &std::collections::HashMap<String, (u64, usize)>,
+        crate::error::McpDiffError,
+    > {
+        self.symbol_dat_index
+            .get_or_try_init(|| {
+                use std::io::BufRead;
+
+                let idx_path = self.symbols_idx_path();
+                let idx_file = std::fs::File::open(&idx_path).map_err(|e| {
+                    crate::error::McpDiffError::GitError {
+                        message: format!("Failed to open symbols.idx: {}", e),
+                    }
+                })?;
 
-            let reader = std::io::BufReader::new(idx_file);
-            let mut map = std::collections::HashMap::new();
+                let reader = std::io::BufReader::new(idx_file);
+                let mut map = std::collections::HashMap::new();
 
-            for line in reader.lines() {
-                let line = line.map_err(|e| crate::error::McpDiffError::GitError {
-                    message: format!("Failed to read index line: {}", e),
-                })?;
-                let trimmed = line.trim();
-                if trimmed.is_empty() {
-                    continue;
-                }
-                if let Ok(entry) = serde_json::from_str::<serde_json::Value>(trimmed) {
-                    if let (Some(h), Some(o), Some(l)) = (
-                        entry.get("h").and_then(|v| v.as_str()),
-                        entry.get("o").and_then(|v| v.as_u64()),
-                        entry.get("l").and_then(|v| v.as_u64()),
-                    ) {
-                        // Last entry wins — deduplicates stale entries from incremental appends
-                        map.insert(h.to_string(), (o, l as usize));
+                for line in reader.lines() {
+                    let line = line.map_err(|e| crate::error::McpDiffError::GitError {
+                        message: format!("Failed to read index line: {}", e),
+                    })?;
+                    let trimmed = line.trim();
+                    if trimmed.is_empty() {
+                        continue;
+                    }
+                    if let Ok(entry) = serde_json::from_str::<serde_json::Value>(trimmed) {
+                        if let (Some(h), Some(o), Some(l)) = (
+                            entry.get("h").and_then(|v| v.as_str()),
+                            entry.get("o").and_then(|v| v.as_u64()),
+                            entry.get("l").and_then(|v| v.as_u64()),
+                        ) {
+                            // Last entry wins — deduplicates stale entries from incremental appends
+                            map.insert(h.to_string(), (o, l as usize));
+                        }
                     }
                 }
-            }
 
-            Ok(map)
-        }).map_err(|e: crate::error::McpDiffError| e)
+                Ok(map)
+            })
+            .map_err(|e: crate::error::McpDiffError| e)
     }
 
     /// Invalidate the cached symbol dat index (call after writing new entries)
@@ -473,35 +487,48 @@ impl CacheDir {
 
     /// Read a symbol from the consolidated .dat file using the cached HashMap index.
     /// O(1) lookup per read instead of O(n) linear scan.
-    fn read_symbol_from_dat(&self, symbol_hash: &str) -> std::result::Result<String, crate::error::McpDiffError> {
+    fn read_symbol_from_dat(
+        &self,
+        symbol_hash: &str,
+    ) -> std::result::Result<String, crate::error::McpDiffError> {
         use std::io::{Read, Seek, SeekFrom};
 
         let index = self.load_symbol_dat_index()?;
 
-        let &(offset, len) = index.get(symbol_hash).ok_or_else(|| {
-            crate::error::McpDiffError::FileNotFound {
-                path: format!("symbol:{} (not in index)", symbol_hash),
-            }
-        })?;
+        let &(offset, len) =
+            index
+                .get(symbol_hash)
+                .ok_or_else(|| crate::error::McpDiffError::FileNotFound {
+                    path: format!("symbol:{} (not in index)", symbol_hash),
+                })?;
 
         let mut dat_file = std::fs::File::open(self.symbols_dat_path()).map_err(|e| {
-            crate::error::McpDiffError::GitError { message: format!("Failed to open symbols.dat: {}", e) }
+            crate::error::McpDiffError::GitError {
+                message: format!("Failed to open symbols.dat: {}", e),
+            }
         })?;
         dat_file.seek(SeekFrom::Start(offset)).map_err(|e| {
-            crate::error::McpDiffError::GitError { message: format!("Failed to seek in symbols.dat: {}", e) }
+            crate::error::McpDiffError::GitError {
+                message: format!("Failed to seek in symbols.dat: {}", e),
+            }
         })?;
         let mut buf = vec![0u8; len];
-        dat_file.read_exact(&mut buf).map_err(|e| {
-            crate::error::McpDiffError::GitError { message: format!("Failed to read from symbols.dat: {}", e) }
-        })?;
+        dat_file
+            .read_exact(&mut buf)
+            .map_err(|e| crate::error::McpDiffError::GitError {
+                message: format!("Failed to read from symbols.dat: {}", e),
+            })?;
 
-        String::from_utf8(buf).map_err(|e| {
-            crate::error::McpDiffError::GitError { message: format!("Invalid UTF-8 in symbol: {}", e) }
+        String::from_utf8(buf).map_err(|e| crate::error::McpDiffError::GitError {
+            message: format!("Invalid UTF-8 in symbol: {}", e),
         })
     }
 
     /// Read a symbol and parse it as CachedContent, with fallback to individual shards
-    pub fn read_symbol_cached(&self, symbol_hash: &str) -> crate::error::Result<crate::commands::toon_parser::CachedContent> {
+    pub fn read_symbol_cached(
+        &self,
+        symbol_hash: &str,
+    ) -> crate::error::Result<crate::commands::toon_parser::CachedContent> {
         let raw = self.read_symbol_raw(symbol_hash)?;
         let is_json = raw.trim_start().starts_with('{');
         let json = if is_json {
@@ -1012,6 +1039,7 @@ impl CacheDir {
     /// Check if symbol index exists
     pub fn has_symbol_index(&self) -> bool {
         self.symbol_index_path().exists()
+            || self.symbol_index_path().with_extension("jsonl.gz").exists()
     }
 
     /// Path to the function signature index file (JSONL format)
@@ -1072,10 +1100,10 @@ impl CacheDir {
         file_path: &str,
         new_entries: Vec<SymbolIndexEntry>,
     ) -> Result<()> {
-        use std::io::{BufRead, Write};
         use flate2::read::GzDecoder;
         use flate2::write::GzEncoder;
         use flate2::Compression;
+        use std::io::{BufRead, Write};
 
         // Try .jsonl.gz first (compressed), fall back to .jsonl (uncompressed)
         let compressed_path = self.symbol_index_path().with_extension("jsonl.gz");
@@ -1192,8 +1220,8 @@ impl CacheDir {
         risk_filter: Option<&str>,
         limit: usize,
     ) -> Result<Vec<SymbolIndexEntry>> {
-        use std::io::BufRead;
         use flate2::read::GzDecoder;
+        use std::io::BufRead;
 
         // Try .jsonl.gz first (compressed), fall back to .jsonl (uncompressed)
         let compressed_path = self.symbol_index_path().with_extension("jsonl.gz");
@@ -1279,8 +1307,8 @@ impl CacheDir {
         risk_filter: Option<&str>,
         limit: usize,
     ) -> Result<Vec<SymbolIndexEntry>> {
-        use std::io::BufRead;
         use flate2::read::GzDecoder;
+        use std::io::BufRead;
 
         // Try .jsonl.gz first (compressed), fall back to .jsonl (uncompressed)
         let compressed_path = self.symbol_index_path().with_extension("jsonl.gz");
@@ -1344,8 +1372,8 @@ impl CacheDir {
     /// Returns all entries from the symbol index without filtering.
     /// Use this for batch analysis operations.
     pub fn load_all_symbol_entries(&self) -> Result<Vec<SymbolIndexEntry>> {
-        use std::io::BufRead;
         use flate2::read::GzDecoder;
+        use std::io::BufRead;
 
         // Try .jsonl.gz first (compressed), fall back to .jsonl (uncompressed)
         let compressed_path = self.symbol_index_path().with_extension("jsonl.gz");
@@ -1392,8 +1420,8 @@ impl CacheDir {
     where
         F: Fn(&SymbolIndexEntry) -> bool,
     {
-        use std::io::BufRead;
         use flate2::read::GzDecoder;
+        use std::io::BufRead;
 
         // Try .jsonl.gz first (compressed), fall back to .jsonl (uncompressed)
         let compressed_path = self.symbol_index_path().with_extension("jsonl.gz");
@@ -1439,8 +1467,8 @@ impl CacheDir {
     where
         F: Fn(&SymbolIndexEntry) -> bool,
     {
-        use std::io::BufRead;
         use flate2::read::GzDecoder;
+        use std::io::BufRead;
 
         // Try .jsonl.gz first (compressed), fall back to .jsonl (uncompressed)
         let compressed_path = self.symbol_index_path().with_extension("jsonl.gz");
@@ -1481,9 +1509,11 @@ impl CacheDir {
 
     /// Build a HashMap from symbol hash to (name, risk) by streaming the index.
     /// Used for call graph resolution without loading the full index.
-    pub fn build_symbol_name_map(&self) -> Result<std::collections::HashMap<String, (String, String)>> {
-        use std::io::BufRead;
+    pub fn build_symbol_name_map(
+        &self,
+    ) -> Result<std::collections::HashMap<String, (String, String)>> {
         use flate2::read::GzDecoder;
+        use std::io::BufRead;
 
         // Try .jsonl.gz first (compressed), fall back to .jsonl (uncompressed)
         let compressed_path = self.symbol_index_path().with_extension("jsonl.gz");
@@ -1512,7 +1542,10 @@ impl CacheDir {
                 Err(_) => continue,
             };
 
-            map.insert(entry.hash.clone(), (entry.symbol.clone(), entry.risk.clone()));
+            map.insert(
+                entry.hash.clone(),
+                (entry.symbol.clone(), entry.risk.clone()),
+            );
         }
 
         Ok(map)
@@ -2165,8 +2198,8 @@ impl CacheDir {
 
         // Get unique files from symbol index (streaming — only collect file paths, not full entries)
         let unique_files: HashSet<String> = {
-            use std::io::BufRead;
             use flate2::read::GzDecoder;
+            use std::io::BufRead;
 
             // Try .jsonl.gz first (compressed), fall back to .jsonl (uncompressed)
             let compressed_path = self.symbol_index_path().with_extension("jsonl.gz");
@@ -2187,7 +2220,9 @@ impl CacheDir {
             if let Some(reader) = reader {
                 for line in reader.lines() {
                     let line = line?;
-                    if line.trim().is_empty() { continue; }
+                    if line.trim().is_empty() {
+                        continue;
+                    }
                     // Quick JSON extraction of just the "f" field
                     if let Ok(entry) = serde_json::from_str::<SymbolIndexEntry>(&line) {
                         files.insert(entry.file);