chore: Fixes LSP configu to be workspace specific.

kennvene-aws · kennvene-aws · commit 38880f1dff02 · 2025-11-06T16:26:49.000-08:00
diff --git a/crates/chat-cli/src/cli/chat/tools/code.rs b/crates/chat-cli/src/cli/chat/tools/code.rs
@@ -309,11 +309,18 @@ impl Code {
                     
                     match client.goto_definition(request).await {
                         Ok(Some(definition)) => {
-                            // Always show location with context in single line
+                            // Show location with context (max 3 lines, then show count of remaining)
                             let context = if let Some(source) = &definition.source_line {
-                                let trimmed = source.trim();
-                                if !trimmed.is_empty() {
-                                    format!(": {}", trimmed)
+                                let lines: Vec<&str> = source.lines().collect();
+                                if !lines.is_empty() {
+                                    let display_lines: Vec<String> = lines.iter().take(3).map(|line| line.trim().to_string()).collect();
+                                    let remaining = lines.len().saturating_sub(3);
+                                    
+                                    let mut context_str = format!(": {}", display_lines.join(" | "));
+                                    if remaining > 0 {
+                                        context_str.push_str(&format!(" ... ({} more lines)", remaining));
+                                    }
+                                    context_str
                                 } else {
                                     String::new()
                                 }
diff --git a/crates/code-agent-sdk/src/config/config_manager.rs b/crates/code-agent-sdk/src/config/config_manager.rs
@@ -1,90 +1,142 @@
 use super::json_config::LanguagesConfig;
 use crate::model::types::LanguageServerConfig;
-use std::sync::OnceLock;
+use std::path::PathBuf;
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
 
-static LANGUAGES_CONFIG: OnceLock<LanguagesConfig> = OnceLock::new();
+const CONFIG_TTL: Duration = Duration::from_secs(60); // 1 minute TTL
 
-pub struct ConfigManager;
+#[derive(Debug)]
+struct CachedConfig {
+    config: LanguagesConfig,
+    loaded_at: Instant,
+}
+
+#[derive(Debug)]
+pub struct ConfigManager {
+    config_root: PathBuf,
+    cached_config: Arc<Mutex<Option<CachedConfig>>>,
+}
 
 impl ConfigManager {
-    /// Get the global languages configuration
-    fn get_languages_config() -> &'static LanguagesConfig {
-        LANGUAGES_CONFIG.get_or_init(|| {
-            LanguagesConfig::load().unwrap_or_else(|e| {
-                eprintln!("Failed to load languages config: {}, using defaults", e);
-                LanguagesConfig::default_config()
-            })
-        })
+    /// Create a new ConfigManager with the specified config root
+    pub fn new(config_root: PathBuf) -> Self {
+        Self {
+            config_root,
+            cached_config: Arc::new(Mutex::new(None)),
+        }
+    }
+
+    /// Get the languages configuration (with TTL caching)
+    pub fn get_config(&self) -> anyhow::Result<LanguagesConfig> {
+        let mut cache = self.cached_config.lock().unwrap();
+        
+        // Check if we need to reload
+        let needs_reload = cache.as_ref()
+            .map(|c| c.loaded_at.elapsed() > CONFIG_TTL)
+            .unwrap_or(true);
+
+        if needs_reload {
+            let config = LanguagesConfig::get_or_create(&self.config_root)?;
+            *cache = Some(CachedConfig {
+                config: config.clone(),
+                loaded_at: Instant::now(),
+            });
+            Ok(config)
+        } else {
+            Ok(cache.as_ref().unwrap().config.clone())
+        }
     }
 
     /// Get project patterns for a specific language
-    pub fn get_project_patterns_for_language(language: &str) -> Vec<String> {
-        Self::get_languages_config().get_project_patterns_for_language(language)
+    pub fn get_project_patterns_for_language(&self, language: &str) -> Vec<String> {
+        self.get_config()
+            .map(|c| c.get_project_patterns_for_language(language))
+            .unwrap_or_default()
     }
 
     /// Get language for file extension
-    pub fn get_language_for_extension(extension: &str) -> Option<String> {
-        Self::get_languages_config().get_language_for_extension(extension)
+    pub fn get_language_for_extension(&self, extension: &str) -> Option<String> {
+        self.get_config()
+            .ok()
+            .and_then(|c| c.get_language_for_extension(extension))
     }
 
     /// Get all language server configurations
-    pub fn all_configs() -> Vec<LanguageServerConfig> {
-        Self::get_languages_config().all_configs()
+    pub fn all_configs(&self) -> Vec<LanguageServerConfig> {
+        self.get_config()
+            .map(|c| c.all_configs())
+            .unwrap_or_default()
     }
 
-    /// Get language server config by language name
-    pub fn get_config_by_language(language: &str) -> Result<LanguageServerConfig, String> {
-        Self::get_languages_config().get_config_by_language(language)
+    /// Get configuration for a specific language
+    pub fn get_config_by_language(&self, language: &str) -> Result<LanguageServerConfig, String> {
+        self.get_config()
+            .map_err(|e| e.to_string())
+            .and_then(|c| c.get_config_by_language(language))
     }
 
-    /// Get server name for language (for workspace manager mapping)
-    pub fn get_server_name_for_language(language: &str) -> Option<String> {
-        Self::get_languages_config().get_server_name_for_language(language)
+    /// Get server name for a language
+    pub fn get_server_name_for_language(&self, language: &str) -> Option<String> {
+        self.get_config()
+            .ok()
+            .and_then(|c| c.get_server_name_for_language(language))
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_config_manager_new() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_manager = ConfigManager::new(temp_dir.path().to_path_buf());
+        assert_eq!(config_manager.config_root, temp_dir.path());
+    }
 
     #[test]
     fn test_get_project_patterns_for_language() {
-        let patterns = ConfigManager::get_project_patterns_for_language("typescript");
-        assert!(!patterns.is_empty());
+        let temp_dir = TempDir::new().unwrap();
+        let config_manager = ConfigManager::new(temp_dir.path().to_path_buf());
+        let patterns = config_manager.get_project_patterns_for_language("typescript");
+        assert!(patterns.contains(&"package.json".to_string()));
     }
 
     #[test]
     fn test_get_language_for_extension() {
-        assert_eq!(ConfigManager::get_language_for_extension("ts"), Some("typescript".to_string()));
-        assert_eq!(ConfigManager::get_language_for_extension("rs"), Some("rust".to_string()));
-        assert_eq!(ConfigManager::get_language_for_extension("unknown"), None);
+        let temp_dir = TempDir::new().unwrap();
+        let config_manager = ConfigManager::new(temp_dir.path().to_path_buf());
+        assert_eq!(config_manager.get_language_for_extension("ts"), Some("typescript".to_string()));
+        assert_eq!(config_manager.get_language_for_extension("rs"), Some("rust".to_string()));
+        assert_eq!(config_manager.get_language_for_extension("unknown"), None);
     }
 
     #[test]
     fn test_all_configs() {
-        let configs = ConfigManager::all_configs();
-        assert!(!configs.is_empty());
+        let temp_dir = TempDir::new().unwrap();
+        let config_manager = ConfigManager::new(temp_dir.path().to_path_buf());
+        let configs = config_manager.all_configs();
+        assert_eq!(configs.len(), 3); // typescript, rust, python
     }
 
     #[test]
     fn test_get_config_by_language() {
-        let config = ConfigManager::get_config_by_language("typescript");
+        let temp_dir = TempDir::new().unwrap();
+        let config_manager = ConfigManager::new(temp_dir.path().to_path_buf());
+        let config = config_manager.get_config_by_language("typescript");
         assert!(config.is_ok());
         
-        let invalid = ConfigManager::get_config_by_language("nonexistent");
+        let invalid = config_manager.get_config_by_language("nonexistent");
         assert!(invalid.is_err());
     }
 
     #[test]
     fn test_get_server_name_for_language() {
-        assert!(ConfigManager::get_server_name_for_language("typescript").is_some());
-        assert_eq!(ConfigManager::get_server_name_for_language("unknown"), None);
-    }
-
-    #[test]
-    fn test_config_fallback_on_error() {
-        // Verify default config works (covers error fallback path)
-        let default_config = crate::config::json_config::LanguagesConfig::default_config();
-        assert!(!default_config.languages.is_empty());
+        let temp_dir = TempDir::new().unwrap();
+        let config_manager = ConfigManager::new(temp_dir.path().to_path_buf());
+        assert!(config_manager.get_server_name_for_language("typescript").is_some());
+        assert_eq!(config_manager.get_server_name_for_language("unknown"), None);
     }
 }
diff --git a/crates/code-agent-sdk/src/config/json_config.rs b/crates/code-agent-sdk/src/config/json_config.rs
@@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::collections::HashMap;
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct LanguageConfig {
     pub name: String,
     pub command: String,
@@ -15,13 +15,33 @@ pub struct LanguageConfig {
     pub initialization_options: Option<Value>,
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct LanguagesConfig {
-    pub project_patterns: Vec<String>,
     pub languages: HashMap<String, LanguageConfig>,
 }
 
 impl LanguagesConfig {
+    /// Get or create configuration in config root folder
+    pub fn get_or_create(config_root: &std::path::Path) -> Result<Self> {
+        let config_path = config_root.join("languages.json");
+
+        // Create config directory if it doesn't exist
+        if !config_root.exists() {
+            std::fs::create_dir_all(config_root)?;
+        }
+
+        // If config file exists, load it, otherwise create default
+        if config_path.exists() {
+            let content = std::fs::read_to_string(&config_path)?;
+            Ok(serde_json::from_str(&content)?)
+        } else {
+            let default_config = Self::default_config();
+            let config_json = serde_json::to_string_pretty(&default_config)?;
+            std::fs::write(&config_path, config_json)?;
+            Ok(default_config)
+        }
+    }
+
     /// Load configuration from JSON file
     pub fn load() -> Result<Self> {
         let config_path = std::path::Path::new("config/languages.json");
@@ -97,13 +117,6 @@ impl LanguagesConfig {
     /// Default embedded configuration
     pub fn default_config() -> Self {
         let json = r#"{
-            "project_patterns": [
-                "Cargo.toml",
-                "package.json",
-                "tsconfig.json",
-                "pyproject.toml",
-                "setup.py"
-            ],
             "languages": {
                 "typescript": {
                     "name": "typescript-language-server",
diff --git a/crates/code-agent-sdk/src/mcp/server.rs b/crates/code-agent-sdk/src/mcp/server.rs
@@ -444,7 +444,7 @@ impl CodeIntelligenceServer {
         let mut client_guard = self.client.lock().await;
         let client = client_guard.as_mut().unwrap();
 
-        let symbols = client.find_symbols(request).await.map_err(|e| {
+        let symbols = client.find_symbols(request.clone()).await.map_err(|e| {
             ErrorData::new(
                 ErrorCode::INTERNAL_ERROR,
                 format!("Find symbols failed: {}", e),
@@ -462,7 +462,17 @@ impl CodeIntelligenceServer {
                 "end_row": s.end_row,
                 "end_column": s.end_column,
                 "detail": s.detail
-            })).collect::<Vec<_>>()
+            })).collect::<Vec<_>>(),
+            "search_context": {
+                "symbol_name": request.symbol_name,
+                "total_found": symbols.len(),
+                "limit_applied": request.limit,
+                "scope": if request.file_path.is_some() { 
+                    format!("file: {}", request.file_path.as_ref().unwrap().display()) 
+                } else { 
+                    "workspace".to_string() 
+                }
+            }
         });
 
         Ok(CallToolResult::success(vec![Content::text(
diff --git a/crates/code-agent-sdk/src/sdk/client.rs b/crates/code-agent-sdk/src/sdk/client.rs
@@ -50,7 +50,7 @@ pub struct CodeIntelligence {
     symbol_service: Box<dyn SymbolService>,
     coding_service: Box<dyn CodingService>,
     workspace_service: Box<dyn WorkspaceService>,
-    workspace_manager: WorkspaceManager,
+    pub workspace_manager: WorkspaceManager,
 }
 
 impl std::fmt::Debug for CodeIntelligence {
diff --git a/crates/code-agent-sdk/src/sdk/mod.rs b/crates/code-agent-sdk/src/sdk/mod.rs
@@ -9,7 +9,6 @@ pub mod file_watcher;
 pub mod services;
 pub mod workspace_manager;
 
-use crate::config::ConfigManager;
 use crate::sdk::client::CodeIntelligence;
 use std::path::PathBuf;
 pub use workspace_manager::WorkspaceManager;
@@ -88,13 +87,13 @@ impl CodeIntelligenceBuilder {
                 .map_err(|e| format!("Failed to detect workspace: {}", e))?;
 
             for language in workspace_info.detected_languages {
-                if let Ok(config) = ConfigManager::get_config_by_language(&language) {
+                if let Ok(config) = client.workspace_manager.config_manager.get_config_by_language(&language) {
                     client.add_language_server(config);
                 }
             }
         } else {
             for language in self.languages {
-                let config = ConfigManager::get_config_by_language(&language)?;
+                let config = client.workspace_manager.config_manager.get_config_by_language(&language)?;
                 client.add_language_server(config);
             }
         }
diff --git a/crates/code-agent-sdk/src/sdk/services/symbol_service.rs b/crates/code-agent-sdk/src/sdk/services/symbol_service.rs
@@ -170,8 +170,8 @@ impl LspSymbolService {
         }
 
         // Apply limit
-        if request.limit.is_some() {
-            all_symbols.truncate(request.limit.unwrap() as usize);
+        if let Some(limit) = request.limit {
+            all_symbols.truncate(limit as usize);
         }
         Ok(all_symbols)
     }
diff --git a/crates/code-agent-sdk/src/sdk/services/workspace_service.rs b/crates/code-agent-sdk/src/sdk/services/workspace_service.rs
@@ -1,4 +1,3 @@
-use crate::config::ConfigManager;
 use crate::sdk::workspace_manager::WorkspaceManager;
 use anyhow::Result;
 use lsp_types::*;
@@ -50,6 +49,14 @@ impl WorkspaceService for LspWorkspaceService {
             return Ok(()); // File already opened, no need to wait
         }
 
+        // Determine language ID from file extension using ConfigManager
+        let language_id = if let Some(ext) = file_path.extension().and_then(|ext| ext.to_str()) {
+            workspace_manager.config_manager.get_language_for_extension(ext)
+                .unwrap_or_else(|| "plaintext".to_string())
+        } else {
+            "plaintext".to_string()
+        };
+
         let client = workspace_manager
             .get_client_for_file(file_path)
             .await?
@@ -58,14 +65,6 @@ impl WorkspaceService for LspWorkspaceService {
         let uri =
             Url::from_file_path(file_path).map_err(|_| anyhow::anyhow!("Invalid file path"))?;
 
-        // Determine language ID from file extension using ConfigManager
-        let language_id = if let Some(ext) = file_path.extension().and_then(|ext| ext.to_str()) {
-            ConfigManager::get_language_for_extension(ext)
-                .unwrap_or_else(|| "plaintext".to_string())
-        } else {
-            "plaintext".to_string()
-        };
-
         let params = DidOpenTextDocumentParams {
             text_document: TextDocumentItem {
                 uri,
diff --git a/crates/code-agent-sdk/src/sdk/workspace_manager.rs b/crates/code-agent-sdk/src/sdk/workspace_manager.rs

Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ pub struct CodeIntelligence {`
`50`	`50`	`symbol_service: Box<dyn SymbolService>,`
`51`	`51`	`coding_service: Box<dyn CodingService>,`
`52`	`52`	`workspace_service: Box<dyn WorkspaceService>,`
`53`		`- workspace_manager: WorkspaceManager,`
	`53`	`+ pub workspace_manager: WorkspaceManager,`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`impl std::fmt::Debug for CodeIntelligence {`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,6 @@ pub mod file_watcher;`
`9`	`9`	`pub mod services;`
`10`	`10`	`pub mod workspace_manager;`
`11`	`11`
`12`		`-use crate::config::ConfigManager;`
`13`	`12`	`use crate::sdk::client::CodeIntelligence;`
`14`	`13`	`use std::path::PathBuf;`
`15`	`14`	`pub use workspace_manager::WorkspaceManager;`
`@@ -88,13 +87,13 @@ impl CodeIntelligenceBuilder {`
`88`	`87`	`.map_err(\|e\| format!("Failed to detect workspace: {}", e))?;`
`89`	`88`
`90`	`89`	`for language in workspace_info.detected_languages {`
`91`		`- if let Ok(config) = ConfigManager::get_config_by_language(&language) {`
	`90`	`+ if let Ok(config) = client.workspace_manager.config_manager.get_config_by_language(&language) {`
`92`	`91`	`client.add_language_server(config);`
`93`	`92`	`}`
`94`	`93`	`}`
`95`	`94`	`} else {`
`96`	`95`	`for language in self.languages {`
`97`		`- let config = ConfigManager::get_config_by_language(&language)?;`
	`96`	`+ let config = client.workspace_manager.config_manager.get_config_by_language(&language)?;`
`98`	`97`	`client.add_language_server(config);`
`99`	`98`	`}`
`100`	`99`	`}`
Original file line number	Diff line number	Diff line change
`@@ -170,8 +170,8 @@ impl LspSymbolService {`
`170`	`170`	`}`
`171`	`171`
`172`	`172`	`// Apply limit`
`173`		`- if request.limit.is_some() {`
`174`		`- all_symbols.truncate(request.limit.unwrap() as usize);`
	`173`	`+ if let Some(limit) = request.limit {`
	`174`	`+ all_symbols.truncate(limit as usize);`
`175`	`175`	`}`
`176`	`176`	`Ok(all_symbols)`
`177`	`177`	`}`