Add analyze tool to Developer extension

crates/goose-mcp/Cargo.toml

@@ -60,6 +60,17 @@ hyper = "1"
 serde_with = "3"
 which = "6.0"
 glob = "0.3"
+lru = "0.12"
+tree-sitter = "0.21"
+tree-sitter-python = "0.21"
+tree-sitter-rust = "0.21"
+tree-sitter-javascript = "0.21"
+tree-sitter-go = "0.21"
+tree-sitter-java = "0.21"
+tree-sitter-kotlin = "0.3.8"
+devgen-tree-sitter-swift = "0.21.0"
+streaming-iterator = "0.1"
+rayon = "1.10"
 # TODO: Fork mpatch or replace with a custom implementation using `similar` crate
 # for fuzzy patch matching. Current crate has limited maintenance (single maintainer,
 # ~1000 downloads). Pinned to exact version to prevent supply chain attacks.
@@ -70,6 +81,8 @@ mpatch = "=0.2.0"
 serial_test = "3.0.0"
 sysinfo = "0.32.1"
 temp-env = "0.3.6"
+clap = { version = "4", features = ["derive"] }
+colored = "2"
 
 [features]
 utoipa = ["dep:utoipa"]

crates/goose-mcp/src/developer/analyze/cache.rs

@@ -0,0 +1,86 @@
+use lru::LruCache;
+use std::num::NonZeroUsize;
+use std::path::PathBuf;
+use std::sync::{Arc, Mutex};
+use std::time::SystemTime;
+
+use super::lock_or_recover;
+use crate::developer::analyze::types::AnalysisResult;
+
+#[derive(Clone)]
+pub struct AnalysisCache {
+    cache: Arc<Mutex<LruCache<CacheKey, Arc<AnalysisResult>>>>,
+    #[allow(dead_code)]
+    max_size: usize,
+}
+
+#[derive(Hash, Eq, PartialEq, Debug, Clone)]
+struct CacheKey {
+    path: PathBuf,
+    modified: SystemTime,
+}
+
+impl AnalysisCache {
+    pub fn new(max_size: usize) -> Self {
+        tracing::info!("Initializing analysis cache with size {}", max_size);
+
+        let size = NonZeroUsize::new(max_size).unwrap_or_else(|| {
+            tracing::warn!("Invalid cache size {}, using default 100", max_size);
+            NonZeroUsize::new(100).unwrap()
+        });
+
+        Self {
+            cache: Arc::new(Mutex::new(LruCache::new(size))),
+            max_size,
+        }
+    }
+
+    pub fn get(&self, path: &PathBuf, modified: SystemTime) -> Option<AnalysisResult> {
+        let mut cache = lock_or_recover(&self.cache, |c| c.clear());
+        let key = CacheKey {
+            path: path.clone(),
+            modified,
+        };
+
+        if let Some(result) = cache.get(&key) {
+            tracing::trace!("Cache hit for {:?}", path);
+            Some((**result).clone())
+        } else {
+            tracing::trace!("Cache miss for {:?}", path);
+            None
+        }
+    }
+
+    pub fn put(&self, path: PathBuf, modified: SystemTime, result: AnalysisResult) {
+        let mut cache = lock_or_recover(&self.cache, |c| c.clear());
+        let key = CacheKey {
+            path: path.clone(),
+            modified,
+        };
+
+        tracing::trace!("Caching result for {:?}", path);
+        cache.put(key, Arc::new(result));
+    }
+
+    pub fn clear(&self) {
+        let mut cache = lock_or_recover(&self.cache, |c| c.clear());
+        cache.clear();
+        tracing::debug!("Cache cleared");
+    }
+
+    pub fn len(&self) -> usize {
+        let cache = lock_or_recover(&self.cache, |c| c.clear());
+        cache.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        let cache = lock_or_recover(&self.cache, |c| c.clear());
+        cache.is_empty()
+    }
+}
+
+impl Default for AnalysisCache {
+    fn default() -> Self {
+        Self::new(100)
+    }
+}