Fix lsp_servers[].file_patterns

Problem

While using `mcpls` in a C++ project I noticed that it always return
the following error when calling get references from a '.h' header file:

    Error: tool call error: tool call failed for `mcpls/get_references`
    Caused by:
        tools/call failed: Mcp error: -32603: no LSP server configured for language: c

After reviewing the documentation and creating an mcpls.toml with the
following, it continued to not work

    [[lsp_servers]]
    language_id = "cpp"
    command = "clangd"
    args = ["--background-index", "--clang-tidy"]
    file_patterns = ["**/*.cpp", "**/*.cc", "**/*.cxx", "**/*.hpp", "**/*.c", "**/*.h"]

    # and/or with
    [[lsp_servers]]
    language_id = "c"
    command = "clangd"
    args = ["--background-index", "--clang-tidy"]
    file_patterns = ["**/*.c", "**/*.h"]

With the above changing resulting in the language detection for matching
file patterns to "plaintext"

    Error: tool call error: tool call failed for `mcpls/get_references`
    Caused by:
        tools/call failed: Mcp error: -32603: no LSP server configured for language: plaintext

What changed

- serve() now initializes the translator with an effective extension map
  built from both workspace mappings and LSP server file patterns:
    - crates/mcpls-core/src/lib.rs:114:114
- Added ServerConfig::build_effective_extension_map() to overlay
  extensions inferred from file_patterns:
    - crates/mcpls-core/src/config/mod.rs:287:287
- Added a small parser for simple glob extensions (e.g. **/*.h, *.c):
    - crates/mcpls-core/src/config/mod.rs:123:123

Tests added

- Pattern-derived mapping overrides default extension mapping (.c/.h -> cpp):
    - crates/mcpls-core/src/config/mod.rs:700:700
- Complex non-simple patterns are ignored safely:
    - crates/mcpls-core/src/config/mod.rs:721:721

Verification

- New tests passed.
- Full mcpls-core unit/integration tests passed.
- Existing unrelated doctest failure remains in lsp/types.rs (pre-existing visibility issue).

Fix was implemented by Codex

Author: wtfbbqhax

crates/mcpls-core/src/config/mod.rs

@@ -116,6 +116,27 @@ impl WorkspaceConfig {
     }
 }
 
+/// Extract a file extension from a glob-like file pattern.
+///
+/// Supports common patterns such as `**/*.rs` and `*.h`.
+/// Returns `None` for patterns without a simple trailing extension.
+fn extract_extension_from_pattern(pattern: &str) -> Option<String> {
+    let (_, ext) = pattern.rsplit_once('.')?;
+    if ext.is_empty() {
+        return None;
+    }
+
+    // Keep this conservative: only accept plain extension-like tokens.
+    if ext
+        .chars()
+        .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-')
+    {
+        Some(ext.to_string())
+    } else {
+        None
+    }
+}
+
 fn default_position_encodings() -> Vec<String> {
     vec!["utf-8".to_string(), "utf-16".to_string()]
 }
@@ -258,6 +279,25 @@ fn default_language_extensions() -> Vec<LanguageExtensionMapping> {
 }
 
 impl ServerConfig {
+    /// Build the effective extension map used for language detection.
+    ///
+    /// Starts with workspace mappings and overlays mappings inferred from
+    /// configured LSP server `file_patterns`.
+    #[must_use]
+    pub fn build_effective_extension_map(&self) -> HashMap<String, String> {
+        let mut map = self.workspace.build_extension_map();
+
+        for server in &self.lsp_servers {
+            for pattern in &server.file_patterns {
+                if let Some(ext) = extract_extension_from_pattern(pattern) {
+                    map.insert(ext, server.language_id.clone());
+                }
+            }
+        }
+
+        map
+    }
+
     /// Load configuration from the default path.
     ///
     /// Default paths checked in order:
@@ -656,6 +696,48 @@ mod tests {
         assert_eq!(map.get("unknown"), None);
     }
 
+    #[test]
+    fn test_build_effective_extension_map_overrides_with_file_patterns() {
+        let config = ServerConfig {
+            workspace: WorkspaceConfig::default(),
+            lsp_servers: vec![LspServerConfig {
+                language_id: "cpp".to_string(),
+                command: "clangd".to_string(),
+                args: vec![],
+                env: HashMap::new(),
+                file_patterns: vec!["**/*.c".to_string(), "**/*.h".to_string()],
+                initialization_options: None,
+                timeout_seconds: 30,
+                heuristics: None,
+            }],
+        };
+
+        let map = config.build_effective_extension_map();
+        assert_eq!(map.get("c"), Some(&"cpp".to_string()));
+        assert_eq!(map.get("h"), Some(&"cpp".to_string()));
+    }
+
+    #[test]
+    fn test_build_effective_extension_map_ignores_complex_patterns_without_extension() {
+        let config = ServerConfig {
+            workspace: WorkspaceConfig::default(),
+            lsp_servers: vec![LspServerConfig {
+                language_id: "cpp".to_string(),
+                command: "clangd".to_string(),
+                args: vec![],
+                env: HashMap::new(),
+                file_patterns: vec!["**/*".to_string(), "**/*.{h,hpp}".to_string()],
+                initialization_options: None,
+                timeout_seconds: 30,
+                heuristics: None,
+            }],
+        };
+
+        let map = config.build_effective_extension_map();
+        // Default C/C++ mappings remain unchanged when patterns cannot be parsed.
+        assert_eq!(map.get("h"), Some(&"c".to_string()));
+    }
+
     #[test]
     fn test_get_language_for_extension() {
         let workspace = WorkspaceConfig {

crates/mcpls-core/src/lib.rs

@@ -111,7 +111,7 @@ pub async fn serve(config: ServerConfig) -> Result<(), Error> {
     info!("Starting MCPLS server...");
 
     let workspace_roots = resolve_workspace_roots(&config.workspace.roots);
-    let extension_map = config.workspace.build_extension_map();
+    let extension_map = config.build_effective_extension_map();
     let max_depth = Some(config.workspace.heuristics_max_depth);
 
     let mut translator = Translator::new().with_extensions(extension_map);