`69345bd`

feat: add LSP client infrastructure

Add Language Server Protocol client implementation supporting:
- Process management for spawning language servers
- JSON-RPC message parsing and serialization
- Request/response callback handling
- Multi-server management per language
- Document synchronization (didOpen, didChange, didClose)
- Hover, completion, definition, references, rename requests
- Diagnostics handling via publishDiagnostics notifications

Note: workspaceFolders capability is disabled to ensure pyright
sends diagnostics immediately after didOpen.

Authored by

espadonne 5 months ago

SHA: 69345bd1789bd6c75b752f75415f5a2ab4a3a53b
Parents: be98840
Tree: aeb12de

7 changed files

Status	File	+
A	`src/lsp/client.rs`	512
A	`src/lsp/manager.rs`	648
A	`src/lsp/message.rs`	206
A	`src/lsp/mod.rs`	26
A	`src/lsp/process.rs`	181
A	`src/lsp/protocol.rs`	726
A	`src/lsp/types.rs`	474

src/lsp/client.rsadded

 +//! High-level LSP client API
 +//!
 +//! Provides a convenient interface for the editor to interact with language servers.
 +//!
 +//! Note: Many methods here are planned LSP features not yet wired to keybindings/UI.
 +#![allow(dead_code)]
++
 +use anyhow::Result;
 +use std::collections::HashMap;
 +use std::sync::mpsc::{self, Receiver, Sender};
 +use std::sync::{Arc, Mutex};
++
 +use super::manager::LspManager;
 +use super::protocol;
 +use super::types::{
 +    detect_language, path_to_uri, CompletionItem, Diagnostic, DocumentSymbol, HoverInfo, Location,
 +    Position, Range, TextEdit, WorkspaceEdit,
 +};
++
 +/// Document state tracked by the LSP client
 +#[derive(Debug)]
 +struct DocumentInfo {
 +    uri: String,
 +    language_id: String,
 +    version: i32,
 +}
++
 +/// High-level LSP client for the editor
 +pub struct LspClient {
 +    manager: LspManager,
 +    /// Tracked documents
 +    documents: HashMap<String, DocumentInfo>,
 +    /// Channel for receiving async responses
 +    response_rx: Receiver<LspResponse>,
 +    response_tx: Sender<LspResponse>,
 +    /// Pending diagnostics by URI
 +    diagnostics: Arc<Mutex<HashMap<String, Vec<Diagnostic>>>>,
 +}
++
 +/// Response types that can be received asynchronously
 +#[derive(Debug)]
 +pub enum LspResponse {
 +    Completions(i64, Vec<CompletionItem>),
 +    Hover(i64, Option<HoverInfo>),
 +    Definition(i64, Vec<Location>),
 +    References(i64, Vec<Location>),
 +    Symbols(i64, Vec<DocumentSymbol>),
 +    Formatting(i64, Vec<TextEdit>),
 +    Rename(i64, WorkspaceEdit),
 +    CodeActions(i64, Vec<CodeAction>),
 +    Error(i64, String),
 +}
++
 +/// Code action from the server
 +#[derive(Debug, Clone)]
 +pub struct CodeAction {
 +    pub title: String,
 +    pub kind: Option<String>,
 +    pub edit: Option<WorkspaceEdit>,
 +    pub command: Option<String>,
 +}
++
 +impl LspClient {
 +    /// Create a new LSP client
 +    pub fn new(workspace_root: &str) -> Self {
 +        let (tx, rx) = mpsc::channel();
 +        let diagnostics = Arc::new(Mutex::new(HashMap::new()));
 +        let diag_clone = Arc::clone(&diagnostics);
++
 +        let mut manager = LspManager::new(workspace_root);
++
 +        // Set up diagnostics callback
 +        manager.set_diagnostics_callback(move |uri, diags| {
 +            if let Ok(mut map) = diag_clone.lock() {
 +                map.insert(uri, diags);
 +            }
 +        });
++
 +        Self {
 +            manager,
 +            documents: HashMap::new(),
 +            response_rx: rx,
 +            response_tx: tx,
 +            diagnostics,
 +        }
 +    }
++
 +    /// Open a document (notifies the language server)
 +    pub fn open_document(&mut self, path: &str, content: &str) -> Result<()> {
 +        let language_id = match detect_language(path) {
 +            Some(lang) => lang,
 +            None => return Ok(()), // No LSP support for this file type
 +        };
++
 +        let uri = path_to_uri(path);
++
 +        // Check if document is already being tracked
 +        if self.documents.contains_key(path) {
 +            // Document already tracked - don't send another didOpen
 +            // The original didOpen (possibly queued) will be sent eventually
 +            // Just update the content if needed via didChange
 +            // But only if content actually differs (to avoid unnecessary messages)
 +            return Ok(());
 +        }
++
 +        // Track the document
 +        self.documents.insert(
 +            path.to_string(),
 +            DocumentInfo {
 +                uri: uri.clone(),
 +                language_id: language_id.to_string(),
 +                version: 1,
 +            },
 +        );
++
 +        // Send didOpen notification
 +        let notification =
 +            protocol::create_did_open_notification(&uri, language_id, 1, content);
 +        self.manager.send_notification(language_id, notification)?;
++
 +        Ok(())
 +    }
++
 +    /// Notify the server of document changes
 +    pub fn document_changed(&mut self, path: &str, content: &str) -> Result<()> {
 +        let doc = match self.documents.get_mut(path) {
 +            Some(d) => d,
 +            None => return Ok(()), // Document not tracked
 +        };
++
 +        doc.version += 1;
 +        let notification =
 +            protocol::create_did_change_notification(&doc.uri, doc.version, content);
 +        self.manager
 +            .send_notification(&doc.language_id, notification)?;
++
 +        Ok(())
 +    }
++
 +    /// Notify the server that a document was saved
 +    pub fn document_saved(&mut self, path: &str, content: Option<&str>) -> Result<()> {
 +        let doc = match self.documents.get(path) {
 +            Some(d) => d,
 +            None => return Ok(()),
 +        };
++
 +        let notification = protocol::create_did_save_notification(&doc.uri, content);
 +        self.manager
 +            .send_notification(&doc.language_id, notification)?;
++
 +        Ok(())
 +    }
++
 +    /// Close a document
 +    pub fn close_document(&mut self, path: &str) -> Result<()> {
 +        let doc = match self.documents.remove(path) {
 +            Some(d) => d,
 +            None => return Ok(()),
 +        };
++
 +        let notification = protocol::create_did_close_notification(&doc.uri);
 +        self.manager
 +            .send_notification(&doc.language_id, notification)?;
++
 +        // Clear diagnostics for this file
 +        if let Ok(mut diags) = self.diagnostics.lock() {
 +            diags.remove(&doc.uri);
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Request completions at a position
 +    pub fn request_completions(&mut self, path: &str, line: u32, character: u32) -> Result<i64> {
 +        let doc = self
 +            .documents
 +            .get(path)
 +            .ok_or_else(|| anyhow::anyhow!("Document not open: {}", path))?;
++
 +        let id = protocol::next_request_id();
 +        let request = protocol::create_completion_request(
 +            id,
 +            &doc.uri,
 +            Position::new(line, character),
 +        );
++
 +        let tx = self.response_tx.clone();
 +        self.manager.send_request(
 +            &doc.language_id,
 +            request,
 +            Box::new(move |req_id, result| {
 +                let response = match result {
 +                    Ok(value) => {
 +                        LspResponse::Completions(req_id, protocol::parse_completion_items(&value))
 +                    }
 +                    Err(e) => LspResponse::Error(req_id, e.message),
 +                };
 +                let _ = tx.send(response);
 +            }),
 +        )?;
++
 +        Ok(id)
 +    }
++
 +    /// Request hover information at a position
 +    pub fn request_hover(&mut self, path: &str, line: u32, character: u32) -> Result<i64> {
 +        let doc = self
 +            .documents
 +            .get(path)
 +            .ok_or_else(|| anyhow::anyhow!("Document not open: {}", path))?;
++
 +        let id = protocol::next_request_id();
 +        let request =
 +            protocol::create_hover_request(id, &doc.uri, Position::new(line, character));
++
 +        let tx = self.response_tx.clone();
 +        self.manager.send_request(
 +            &doc.language_id,
 +            request,
 +            Box::new(move |req_id, result| {
 +                let response = match result {
 +                    Ok(value) => LspResponse::Hover(req_id, protocol::parse_hover(&value)),
 +                    Err(e) => LspResponse::Error(req_id, e.message),
 +                };
 +                let _ = tx.send(response);
 +            }),
 +        )?;
++
 +        Ok(id)
 +    }
++
 +    /// Request go-to-definition at a position
 +    pub fn request_definition(&mut self, path: &str, line: u32, character: u32) -> Result<i64> {
 +        let doc = self
 +            .documents
 +            .get(path)
 +            .ok_or_else(|| anyhow::anyhow!("Document not open: {}", path))?;
++
 +        let id = protocol::next_request_id();
 +        let request =
 +            protocol::create_definition_request(id, &doc.uri, Position::new(line, character));
++
 +        let tx = self.response_tx.clone();
 +        self.manager.send_request(
 +            &doc.language_id,
 +            request,
 +            Box::new(move |req_id, result| {
 +                let response = match result {
 +                    Ok(value) => LspResponse::Definition(req_id, protocol::parse_locations(&value)),
 +                    Err(e) => LspResponse::Error(req_id, e.message),
 +                };
 +                let _ = tx.send(response);
 +            }),
 +        )?;
++
 +        Ok(id)
 +    }
++
 +    /// Request find-references at a position
 +    pub fn request_references(
 +        &mut self,
 +        path: &str,
 +        line: u32,
 +        character: u32,
 +        include_declaration: bool,
 +    ) -> Result<i64> {
 +        let doc = self
 +            .documents
 +            .get(path)
 +            .ok_or_else(|| anyhow::anyhow!("Document not open: {}", path))?;
++
 +        let id = protocol::next_request_id();
 +        let request = protocol::create_references_request(
 +            id,
 +            &doc.uri,
 +            Position::new(line, character),
 +            include_declaration,
 +        );
++
 +        let tx = self.response_tx.clone();
 +        self.manager.send_request(
 +            &doc.language_id,
 +            request,
 +            Box::new(move |req_id, result| {
 +                let response = match result {
 +                    Ok(value) => LspResponse::References(req_id, protocol::parse_locations(&value)),
 +                    Err(e) => LspResponse::Error(req_id, e.message),
 +                };
 +                let _ = tx.send(response);
 +            }),
 +        )?;
++
 +        Ok(id)
 +    }
++
 +    /// Request document symbols
 +    pub fn request_document_symbols(&mut self, path: &str) -> Result<i64> {
 +        let doc = self
 +            .documents
 +            .get(path)
 +            .ok_or_else(|| anyhow::anyhow!("Document not open: {}", path))?;
++
 +        let id = protocol::next_request_id();
 +        let request = protocol::create_document_symbols_request(id, &doc.uri);
++
 +        let tx = self.response_tx.clone();
 +        self.manager.send_request(
 +            &doc.language_id,
 +            request,
 +            Box::new(move |req_id, result| {
 +                let response = match result {
 +                    Ok(value) => {
 +                        LspResponse::Symbols(req_id, protocol::parse_document_symbols(&value))
 +                    }
 +                    Err(e) => LspResponse::Error(req_id, e.message),
 +                };
 +                let _ = tx.send(response);
 +            }),
 +        )?;
++
 +        Ok(id)
 +    }
++
 +    /// Request document formatting
 +    pub fn request_formatting(&mut self, path: &str, tab_size: u32, use_spaces: bool) -> Result<i64> {
 +        let doc = self
 +            .documents
 +            .get(path)
 +            .ok_or_else(|| anyhow::anyhow!("Document not open: {}", path))?;
++
 +        let id = protocol::next_request_id();
 +        let request = protocol::create_formatting_request(id, &doc.uri, tab_size, use_spaces);
++
 +        let tx = self.response_tx.clone();
 +        self.manager.send_request(
 +            &doc.language_id,
 +            request,
 +            Box::new(move |req_id, result| {
 +                let response = match result {
 +                    Ok(value) => {
 +                        LspResponse::Formatting(req_id, protocol::parse_text_edits(&value))
 +                    }
 +                    Err(e) => LspResponse::Error(req_id, e.message),
 +                };
 +                let _ = tx.send(response);
 +            }),
 +        )?;
++
 +        Ok(id)
 +    }
++
 +    /// Request rename refactoring
 +    pub fn request_rename(
 +        &mut self,
 +        path: &str,
 +        line: u32,
 +        character: u32,
 +        new_name: &str,
 +    ) -> Result<i64> {
 +        let doc = self
 +            .documents
 +            .get(path)
 +            .ok_or_else(|| anyhow::anyhow!("Document not open: {}", path))?;
++
 +        let id = protocol::next_request_id();
 +        let request = protocol::create_rename_request(
 +            id,
 +            &doc.uri,
 +            Position::new(line, character),
 +            new_name,
 +        );
++
 +        let tx = self.response_tx.clone();
 +        self.manager.send_request(
 +            &doc.language_id,
 +            request,
 +            Box::new(move |req_id, result| {
 +                let response = match result {
 +                    Ok(value) => {
 +                        LspResponse::Rename(req_id, protocol::parse_workspace_edit(&value))
 +                    }
 +                    Err(e) => LspResponse::Error(req_id, e.message),
 +                };
 +                let _ = tx.send(response);
 +            }),
 +        )?;
++
 +        Ok(id)
 +    }
++
 +    /// Request code actions for a range
 +    pub fn request_code_actions(
 +        &mut self,
 +        path: &str,
 +        start_line: u32,
 +        start_char: u32,
 +        end_line: u32,
 +        end_char: u32,
 +    ) -> Result<i64> {
 +        let doc = self
 +            .documents
 +            .get(path)
 +            .ok_or_else(|| anyhow::anyhow!("Document not open: {}", path))?;
++
 +        let id = protocol::next_request_id();
 +        let range = Range::new(
 +            Position::new(start_line, start_char),
 +            Position::new(end_line, end_char),
 +        );
 +        let request = protocol::create_code_action_request(id, &doc.uri, range);
++
 +        let tx = self.response_tx.clone();
 +        self.manager.send_request(
 +            &doc.language_id,
 +            request,
 +            Box::new(move |req_id, result| {
 +                let response = match result {
 +                    Ok(value) => {
 +                        let actions = parse_code_actions(&value);
 +                        LspResponse::CodeActions(req_id, actions)
 +                    }
 +                    Err(e) => LspResponse::Error(req_id, e.message),
 +                };
 +                let _ = tx.send(response);
 +            }),
 +        )?;
++
 +        Ok(id)
 +    }
++
 +    /// Poll for responses (non-blocking)
 +    pub fn poll_response(&self) -> Option<LspResponse> {
 +        self.response_rx.try_recv().ok()
 +    }
++
 +    /// Get diagnostics for a file
 +    pub fn get_diagnostics(&self, path: &str) -> Vec<Diagnostic> {
 +        let uri = path_to_uri(path);
 +        self.diagnostics
 +            .lock()
 +            .ok()
 +            .and_then(|map| map.get(&uri).cloned())
 +            .unwrap_or_default()
 +    }
++
 +    /// Get all diagnostics
 +    pub fn get_all_diagnostics(&self) -> HashMap<String, Vec<Diagnostic>> {
 +        self.diagnostics
 +            .lock()
 +            .ok()
 +            .map(|map| map.clone())
 +            .unwrap_or_default()
 +    }
++
 +    /// Process pending server messages (call this regularly)
 +    pub fn process_messages(&mut self) {
 +        self.manager.process_messages();
 +    }
++
 +    /// Check if LSP is available for a language
 +    pub fn has_server(&self, language: &str) -> bool {
 +        self.manager.has_server(language)
 +    }
++
 +    /// Check if LSP is available for a file
 +    pub fn has_server_for_file(&self, path: &str) -> bool {
 +        detect_language(path)
 +            .map(|lang| self.manager.has_server(lang))
 +            .unwrap_or(false)
 +    }
++
 +    /// Shutdown all servers
 +    pub fn shutdown(&mut self) {
 +        self.manager.stop_all();
 +    }
 +}
++
 +/// Parse code actions from response
 +fn parse_code_actions(value: &serde_json::Value) -> Vec<CodeAction> {
 +    value
 +        .as_array()
 +        .map(|arr| {
 +            arr.iter()
 +                .filter_map(|action| {
 +                    let title = action.get("title")?.as_str()?.to_string();
 +                    let kind = action.get("kind").and_then(|v| v.as_str()).map(String::from);
 +                    let edit = action
 +                        .get("edit")
 +                        .map(|e| protocol::parse_workspace_edit(e));
 +                    let command = action
 +                        .get("command")
 +                        .and_then(|c| c.get("command"))
 +                        .and_then(|v| v.as_str())
 +                        .map(String::from);
++
 +                    Some(CodeAction {
 +                        title,
 +                        kind,
 +                        edit,
 +                        command,
 +                    })
 +                })
 +                .collect()
 +        })
 +        .unwrap_or_default()
 +}
++
 +impl Drop for LspClient {
 +    fn drop(&mut self) {
 +        self.shutdown();
 +    }
 +}

src/lsp/manager.rsadded

 +//! LSP server manager
 +//!
 +//! Manages multiple language server instances, handles initialization,
 +//! and routes requests to appropriate servers.
 +//!
 +//! Note: Some methods are planned features not yet wired to the UI.
 +#![allow(dead_code)]
++
 +use anyhow::{anyhow, Result};
 +use serde_json::Value;
 +use std::collections::HashMap;
 +use std::sync::{Arc, Mutex};
++
 +use super::message::{DiagnosticsCallback, MessageHandler, ResponseCallback};
 +use super::process::ServerProcess;
 +use super::protocol::{self, LspMessage};
 +use super::types::{Capabilities, ServerConfig};
++
 +/// State of a language server
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum ServerState {
 +    Starting,
 +    Initializing,
 +    Ready,
 +    ShuttingDown,
 +    Stopped,
 +}
++
 +/// A managed language server instance
 +pub struct ManagedServer {
 +    pub config: ServerConfig,
 +    pub process: ServerProcess,
 +    pub state: ServerState,
 +    pub capabilities: Capabilities,
 +    pub handler: MessageHandler,
 +    /// Queued didOpen notifications (for files opened before initialization)
 +    pending_opens: Vec<LspMessage>,
 +}
++
 +impl ManagedServer {
 +    fn new(config: ServerConfig, process: ServerProcess) -> Self {
 +        Self {
 +            config,
 +            process,
 +            state: ServerState::Starting,
 +            capabilities: Capabilities::default(),
 +            handler: MessageHandler::new(),
 +            pending_opens: Vec::new(),
 +        }
 +    }
 +}
++
 +/// Manager for multiple language servers
 +pub struct LspManager {
 +    /// Workspace root path
 +    workspace_root: String,
 +    /// Server configurations by language
 +    configs: HashMap<String, Vec<ServerConfig>>,
 +    /// Active servers by language
 +    servers: HashMap<String, Vec<ManagedServer>>,
 +    /// Global diagnostics callback
 +    diagnostics_callback: Option<Arc<Mutex<DiagnosticsCallback>>>,
 +}
++
 +impl LspManager {
 +    /// Create a new LSP manager
 +    pub fn new(workspace_root: &str) -> Self {
 +        let mut manager = Self {
 +            workspace_root: workspace_root.to_string(),
 +            configs: HashMap::new(),
 +            servers: HashMap::new(),
 +            diagnostics_callback: None,
 +        };
 +        manager.register_default_configs();
 +        manager
 +    }
++
 +    /// Set the global diagnostics callback
 +    pub fn set_diagnostics_callback<F>(&mut self, callback: F)
 +    where
 +        F: Fn(String, Vec<super::types::Diagnostic>) + Send + 'static,
 +    {
 +        self.diagnostics_callback = Some(Arc::new(Mutex::new(Box::new(callback))));
 +    }
++
 +    /// Register default server configurations
 +    fn register_default_configs(&mut self) {
 +        // Rust - rust-analyzer
 +        self.register_config(ServerConfig::new("rust-analyzer", "rust", vec!["rust-analyzer"]));
++
 +        // Python - pyright and ruff
 +        self.register_config(ServerConfig::new(
 +            "pyright",
 +            "python",
 +            vec!["pyright-langserver", "--stdio"],
 +        ));
 +        self.register_config(
 +            ServerConfig::new("ruff", "python", vec!["ruff", "server"]).with_capabilities(
 +                Capabilities {
 +                    completion: false,
 +                    hover: false,
 +                    definition: false,
 +                    references: false,
 +                    rename: false,
 +                    code_actions: true,
 +                    formatting: true,
 +                    diagnostics: true,
 +                    document_symbols: false,
 +                    workspace_symbols: false,
 +                    signature_help: false,
 +                },
 +            ),
 +        );
++
 +        // TypeScript/JavaScript - typescript-language-server
 +        self.register_config(ServerConfig::new(
 +            "typescript-language-server",
 +            "typescript",
 +            vec!["typescript-language-server", "--stdio"],
 +        ));
 +        self.register_config(ServerConfig::new(
 +            "typescript-language-server",
 +            "typescriptreact",
 +            vec!["typescript-language-server", "--stdio"],
 +        ));
 +        self.register_config(ServerConfig::new(
 +            "typescript-language-server",
 +            "javascript",
 +            vec!["typescript-language-server", "--stdio"],
 +        ));
 +        self.register_config(ServerConfig::new(
 +            "typescript-language-server",
 +            "javascriptreact",
 +            vec!["typescript-language-server", "--stdio"],
 +        ));
++
 +        // Go - gopls
 +        self.register_config(ServerConfig::new("gopls", "go", vec!["gopls"]));
++
 +        // C/C++ - clangd
 +        self.register_config(ServerConfig::new("clangd", "c", vec!["clangd"]));
 +        self.register_config(ServerConfig::new("clangd", "cpp", vec!["clangd"]));
++
 +        // Java - jdtls (Eclipse JDT Language Server)
 +        self.register_config(ServerConfig::new("jdtls", "java", vec!["jdtls"]));
++
 +        // Kotlin - kotlin-language-server
 +        self.register_config(ServerConfig::new(
 +            "kotlin-language-server",
 +            "kotlin",
 +            vec!["kotlin-language-server"],
 +        ));
++
 +        // Ruby - solargraph
 +        self.register_config(ServerConfig::new(
 +            "solargraph",
 +            "ruby",
 +            vec!["solargraph", "stdio"],
 +        ));
++
 +        // PHP - intelephense
 +        self.register_config(ServerConfig::new(
 +            "intelephense",
 +            "php",
 +            vec!["intelephense", "--stdio"],
 +        ));
++
 +        // C# - omnisharp
 +        self.register_config(ServerConfig::new(
 +            "omnisharp",
 +            "csharp",
 +            vec!["omnisharp", "--languageserver"],
 +        ));
++
 +        // Lua - lua-language-server
 +        self.register_config(ServerConfig::new("lua-ls", "lua", vec!["lua-language-server"]));
++
 +        // Zig - zls
 +        self.register_config(ServerConfig::new("zls", "zig", vec!["zls"]));
++
 +        // Haskell - haskell-language-server
 +        self.register_config(ServerConfig::new(
 +            "hls",
 +            "haskell",
 +            vec!["haskell-language-server-wrapper", "--lsp"],
 +        ));
++
 +        // OCaml - ocamllsp
 +        self.register_config(ServerConfig::new("ocamllsp", "ocaml", vec!["ocamllsp"]));
++
 +        // Elixir - elixir-ls
 +        self.register_config(ServerConfig::new("elixir-ls", "elixir", vec!["elixir-ls"]));
++
 +        // Erlang - erlang_ls
 +        self.register_config(ServerConfig::new("erlang_ls", "erlang", vec!["erlang_ls"]));
++
 +        // Julia - julia-ls
 +        self.register_config(ServerConfig::new("julia-ls", "julia", vec!["julia", "--project=@.", "-e", "using LanguageServer; runserver()"]));
++
 +        // Bash - bash-language-server
 +        self.register_config(ServerConfig::new(
 +            "bash-ls",
 +            "shellscript",
 +            vec!["bash-language-server", "start"],
 +        ));
++
 +        // HTML - vscode-html-language-server
 +        self.register_config(ServerConfig::new(
 +            "html-ls",
 +            "html",
 +            vec!["vscode-html-language-server", "--stdio"],
 +        ));
++
 +        // CSS - vscode-css-language-server
 +        self.register_config(ServerConfig::new(
 +            "css-ls",
 +            "css",
 +            vec!["vscode-css-language-server", "--stdio"],
 +        ));
++
 +        // JSON - vscode-json-language-server
 +        self.register_config(ServerConfig::new(
 +            "json-ls",
 +            "json",
 +            vec!["vscode-json-language-server", "--stdio"],
 +        ));
++
 +        // YAML - yaml-language-server
 +        self.register_config(ServerConfig::new(
 +            "yaml-ls",
 +            "yaml",
 +            vec!["yaml-language-server", "--stdio"],
 +        ));
++
 +        // TOML - taplo
 +        self.register_config(ServerConfig::new("taplo", "toml", vec!["taplo", "lsp", "stdio"]));
++
 +        // Markdown - marksman
 +        self.register_config(ServerConfig::new("marksman", "markdown", vec!["marksman", "server"]));
++
 +        // Docker - dockerfile-language-server
 +        self.register_config(ServerConfig::new(
 +            "docker-ls",
 +            "dockerfile",
 +            vec!["docker-langserver", "--stdio"],
 +        ));
++
 +        // Terraform - terraform-ls
 +        self.register_config(ServerConfig::new(
 +            "terraform-ls",
 +            "terraform",
 +            vec!["terraform-ls", "serve"],
 +        ));
++
 +        // Nix - nil
 +        self.register_config(ServerConfig::new("nil", "nix", vec!["nil"]));
++
 +        // SQL - sqls
 +        self.register_config(ServerConfig::new("sqls", "sql", vec!["sqls"]));
++
 +        // Vue - volar
 +        self.register_config(ServerConfig::new(
 +            "vue-ls",
 +            "vue",
 +            vec!["vue-language-server", "--stdio"],
 +        ));
++
 +        // Svelte - svelte-language-server
 +        self.register_config(ServerConfig::new(
 +            "svelte-ls",
 +            "svelte",
 +            vec!["svelteserver", "--stdio"],
 +        ));
++
 +        // Elm - elm-language-server
 +        self.register_config(ServerConfig::new("elm-ls", "elm", vec!["elm-language-server"]));
++
 +        // Scala - metals
 +        self.register_config(ServerConfig::new("metals", "scala", vec!["metals"]));
++
 +        // Dart - dart analysis server
 +        self.register_config(ServerConfig::new(
 +            "dart-ls",
 +            "dart",
 +            vec!["dart", "language-server", "--protocol=lsp"],
 +        ));
++
 +        // Clojure - clojure-lsp
 +        self.register_config(ServerConfig::new("clojure-lsp", "clojure", vec!["clojure-lsp"]));
++
 +        // Fortran - fortls
 +        self.register_config(ServerConfig::new("fortls", "fortran", vec!["fortls"]));
++
 +        // D - serve-d
 +        self.register_config(ServerConfig::new("serve-d", "d", vec!["serve-d"]));
++
 +        // Nim - nimlsp
 +        self.register_config(ServerConfig::new("nimlsp", "nim", vec!["nimlsp"]));
++
 +        // V - vls
 +        self.register_config(ServerConfig::new("vls", "v", vec!["vls"]));
++
 +        // Perl - perlnavigator
 +        self.register_config(ServerConfig::new(
 +            "perlnavigator",
 +            "perl",
 +            vec!["perlnavigator"],
 +        ));
++
 +        // R - languageserver
 +        self.register_config(ServerConfig::new(
 +            "r-ls",
 +            "r",
 +            vec!["R", "--slave", "-e", "languageserver::run()"],
 +        ));
++
 +        // GraphQL - graphql-lsp
 +        self.register_config(ServerConfig::new(
 +            "graphql-lsp",
 +            "graphql",
 +            vec!["graphql-lsp", "server", "-m", "stream"],
 +        ));
++
 +        // CMake - cmake-language-server
 +        self.register_config(ServerConfig::new(
 +            "cmake-ls",
 +            "cmake",
 +            vec!["cmake-language-server"],
 +        ));
++
 +        // Groovy - groovy-language-server
 +        self.register_config(ServerConfig::new(
 +            "groovy-ls",
 +            "groovy",
 +            vec!["groovy-language-server"],
 +        ));
++
 +        // Swift - sourcekit-lsp
 +        self.register_config(ServerConfig::new(
 +            "sourcekit-lsp",
 +            "swift",
 +            vec!["sourcekit-lsp"],
 +        ));
++
 +        // F# - fsautocomplete
 +        self.register_config(ServerConfig::new(
 +            "fsautocomplete",
 +            "fsharp",
 +            vec!["fsautocomplete", "--adaptive-lsp-server-enabled"],
 +        ));
++
 +        // PowerShell - PowerShellEditorServices
 +        self.register_config(ServerConfig::new(
 +            "pwsh-ls",
 +            "powershell",
 +            vec![
 +                "pwsh",
 +                "-NoLogo",
 +                "-NoProfile",
 +                "-Command",
 +                "Import-Module PowerShellEditorServices; Start-EditorServices -HostName 'fackr' -HostProfileId 'fackr' -HostVersion '1.0.0' -Stdio",
 +            ],
 +        ));
++
 +        // Protocol Buffers - buf
 +        self.register_config(ServerConfig::new("buf-ls", "proto", vec!["buf", "lsp"]));
++
 +        // Assembly - asm-lsp
 +        self.register_config(ServerConfig::new("asm-lsp", "asm", vec!["asm-lsp"]));
++
 +        // Odin - ols
 +        self.register_config(ServerConfig::new("ols", "odin", vec!["ols"]));
 +    }
++
 +    /// Register a server configuration
 +    pub fn register_config(&mut self, config: ServerConfig) {
 +        self.configs
 +            .entry(config.language.clone())
 +            .or_default()
 +            .push(config);
 +    }
++
 +    /// Start a server for a language
 +    pub fn start_server(&mut self, language: &str) -> Result<()> {
 +        let configs = self
 +            .configs
 +            .get(language)
 +            .ok_or_else(|| anyhow!("No LSP server configured for language: {}", language))?
 +            .clone();
++
 +        // Start the first available server for the language
 +        for config in configs {
 +            match self.start_server_with_config(&config) {
 +                Ok(()) => return Ok(()),
 +                Err(_) => {
 +                    // Server not available, try next one
 +                    continue;
 +                }
 +            }
 +        }
++
 +        Err(anyhow!(
 +            "Failed to start any LSP server for language: {}",
 +            language
 +        ))
 +    }
++
 +    /// Start all configured servers for a language
 +    pub fn start_all_servers(&mut self, language: &str) -> Result<()> {
 +        let configs = self
 +            .configs
 +            .get(language)
 +            .ok_or_else(|| anyhow!("No LSP server configured for language: {}", language))?
 +            .clone();
++
 +        let mut started = 0;
 +        for config in configs {
 +            match self.start_server_with_config(&config) {
 +                Ok(()) => started += 1,
 +                Err(_) => {
 +                    // Server not available, continue
 +                }
 +            }
 +        }
++
 +        if started > 0 {
 +            Ok(())
 +        } else {
 +            Err(anyhow!(
 +                "Failed to start any LSP server for language: {}",
 +                language
 +            ))
 +        }
 +    }
++
 +    /// Start a server with a specific config
 +    fn start_server_with_config(&mut self, config: &ServerConfig) -> Result<()> {
 +        // Check if server is already running
 +        if let Some(servers) = self.servers.get(&config.language) {
 +            if servers.iter().any(|s| s.config.name == config.name) {
 +                return Ok(()); // Already running
 +            }
 +        }
++
 +        // Spawn the server process
 +        let process = ServerProcess::spawn(&config.command)?;
++
 +        // Create managed server
 +        let mut server = ManagedServer::new(config.clone(), process);
++
 +        // Set up diagnostics callback if configured
 +        if let Some(ref callback) = self.diagnostics_callback {
 +            let cb = Arc::clone(callback);
 +            server.handler.set_diagnostics_callback(Box::new(
 +                move |uri, diags| {
 +                    if let Ok(cb) = cb.lock() {
 +                        cb(uri, diags);
 +                    }
 +                },
 +            ));
 +        }
++
 +        // Send initialize request
 +        let id = protocol::next_request_id();
 +        let init_msg = protocol::create_initialize_request(id, &self.workspace_root, "fackr");
++
 +        server.process.send(&init_msg.to_string())?;
 +        server.state = ServerState::Initializing;
++
 +        // Store the server
 +        self.servers
 +            .entry(config.language.clone())
 +            .or_default()
 +            .push(server);
++
 +        Ok(())
 +    }
++
 +    /// Get a server for a language (start if needed)
 +    pub fn get_or_start_server(&mut self, language: &str) -> Result<&mut ManagedServer> {
 +        if !self.servers.contains_key(language) || self.servers.get(language).map_or(true, |s| s.is_empty()) {
 +            self.start_server(language)?;
 +        }
++
 +        self.servers
 +            .get_mut(language)
 +            .and_then(|servers| servers.first_mut())
 +            .ok_or_else(|| anyhow!("No server available for language: {}", language))
 +    }
++
 +    /// Get a server with a specific capability
 +    pub fn get_server_with_capability(
 +        &mut self,
 +        language: &str,
 +        check: impl Fn(&Capabilities) -> bool,
 +    ) -> Option<&mut ManagedServer> {
 +        self.servers
 +            .get_mut(language)?
 +            .iter_mut()
 +            .find(|s| s.state == ServerState::Ready && check(&s.capabilities))
 +    }
++
 +    /// Process messages from all servers (call this regularly)
 +    pub fn process_messages(&mut self) {
 +        for (_lang, servers) in self.servers.iter_mut() {
 +            for server in servers.iter_mut() {
 +                Self::process_server_messages(server, &self.workspace_root);
 +            }
 +        }
 +    }
++
 +    /// Process messages for a single server
 +    fn process_server_messages(server: &mut ManagedServer, _workspace_root: &str) {
 +        while let Some(json_str) = server.process.try_recv() {
 +            if let Ok(value) = serde_json::from_str::<Value>(&json_str) {
 +                if let Some(msg) = LspMessage::from_json(value.clone()) {
 +                    // Handle initialization response specially
 +                    if let LspMessage::Response { ref result, .. } = msg {
 +                        if server.state == ServerState::Initializing {
 +                            if let Some(result) = result {
 +                                // Parse capabilities
 +                                server.capabilities = protocol::parse_capabilities(result);
 +                                server.state = ServerState::Ready;
++
 +                                // Send initialized notification
 +                                let init_notif = protocol::create_initialized_notification();
 +                                let _ = server.process.send(&init_notif.to_string());
++
 +                                // Send any pending didOpen notifications
 +                                for pending in server.pending_opens.drain(..) {
 +                                    let _ = server.process.send(&pending.to_string());
 +                                }
 +                            }
 +                        }
 +                    }
++
 +                    // Let the handler process the message
 +                    if let Some(response) = server.handler.handle_message(msg) {
 +                        // Send response back to server
 +                        let _ = server.process.send(&response.to_string());
 +                    }
 +                }
 +            }
 +        }
 +    }
++
 +    /// Send a request to a server and register callback
 +    pub fn send_request(
 +        &mut self,
 +        language: &str,
 +        message: LspMessage,
 +        callback: ResponseCallback,
 +    ) -> Result<()> {
 +        // Clone workspace_root to avoid borrow conflict
 +        let workspace_root = self.workspace_root.clone();
 +        let server = self.get_or_start_server(language)?;
++
 +        // Wait for server to be ready
 +        if server.state != ServerState::Ready {
 +            // Process messages until ready or timeout
 +            for _ in 0..50 {
 +                Self::process_server_messages(server, &workspace_root);
 +                if server.state == ServerState::Ready {
 +                    break;
 +                }
 +                std::thread::sleep(std::time::Duration::from_millis(100));
 +            }
 +        }
++
 +        if let LspMessage::Request { id, .. } = &message {
 +            server.handler.register_callback(*id, callback);
 +        }
++
 +        server.process.send(&message.to_string())?;
 +        Ok(())
 +    }
++
 +    /// Send a notification to a server
 +    pub fn send_notification(&mut self, language: &str, message: LspMessage) -> Result<()> {
 +        let server = self.get_or_start_server(language)?;
++
 +        // Queue didOpen if server not ready
 +        if server.state != ServerState::Ready {
 +            if let LspMessage::Notification { ref method, .. } = message {
 +                if method == "textDocument/didOpen" {
 +                    server.pending_opens.push(message);
 +                    return Ok(());
 +                }
 +            }
 +        }
++
 +        server.process.send(&message.to_string())?;
 +        Ok(())
 +    }
++
 +    /// Stop a server for a language
 +    pub fn stop_server(&mut self, language: &str) -> Result<()> {
 +        if let Some(servers) = self.servers.get_mut(language) {
 +            for server in servers.iter_mut() {
 +                server.state = ServerState::ShuttingDown;
++
 +                // Send shutdown request
 +                let id = protocol::next_request_id();
 +                let shutdown = protocol::create_shutdown_request(id);
 +                let _ = server.process.send(&shutdown.to_string());
++
 +                // Wait briefly for shutdown acknowledgment
 +                std::thread::sleep(std::time::Duration::from_millis(100));
++
 +                // Send exit notification
 +                let exit = protocol::create_exit_notification();
 +                let _ = server.process.send(&exit.to_string());
++
 +                // Kill the process
 +                let _ = server.process.kill();
 +                server.state = ServerState::Stopped;
 +            }
 +            servers.clear();
 +        }
 +        Ok(())
 +    }
++
 +    /// Stop all servers
 +    pub fn stop_all(&mut self) {
 +        let languages: Vec<String> = self.servers.keys().cloned().collect();
 +        for lang in languages {
 +            let _ = self.stop_server(&lang);
 +        }
 +    }
++
 +    /// Check if a server is running for a language
 +    pub fn has_server(&self, language: &str) -> bool {
 +        self.servers
 +            .get(language)
 +            .map_or(false, |s| !s.is_empty() && s.iter().any(|s| s.state == ServerState::Ready))
 +    }
++
 +    /// Get the workspace root
 +    pub fn workspace_root(&self) -> &str {
 +        &self.workspace_root
 +    }
 +}
++
 +impl Drop for LspManager {
 +    fn drop(&mut self) {
 +        self.stop_all();
 +    }
 +}

src/lsp/message.rsadded

 +//! LSP message handling and callback management
 +//!
 +//! Handles routing of LSP responses to appropriate callbacks.
 +//!
 +//! Note: ParsedResponse helpers are for planned features.
 +#![allow(dead_code)]
++
 +use serde_json::Value;
 +use std::collections::HashMap;
++
 +use super::protocol::{LspMessage, ResponseError};
 +use super::types::{
 +    CompletionItem, Diagnostic, DocumentSymbol, HoverInfo, Location, TextEdit, WorkspaceEdit,
 +};
++
 +/// Result type for LSP responses
 +pub type LspResult<T> = Result<T, ResponseError>;
++
 +/// Callback for LSP responses
 +pub type ResponseCallback = Box<dyn FnOnce(i64, LspResult<Value>) + Send>;
++
 +/// Callback for diagnostics notifications
 +pub type DiagnosticsCallback = Box<dyn Fn(String, Vec<Diagnostic>) + Send>;
++
 +/// Tracks pending requests and their callbacks
 +pub struct MessageHandler {
 +    /// Pending request callbacks indexed by request ID
 +    pending: HashMap<i64, ResponseCallback>,
 +    /// Callback for diagnostics notifications
 +    diagnostics_callback: Option<DiagnosticsCallback>,
 +}
++
 +impl MessageHandler {
 +    pub fn new() -> Self {
 +        Self {
 +            pending: HashMap::new(),
 +            diagnostics_callback: None,
 +        }
 +    }
++
 +    /// Register a callback for a request
 +    pub fn register_callback(&mut self, id: i64, callback: ResponseCallback) {
 +        self.pending.insert(id, callback);
 +    }
++
 +    /// Set the diagnostics callback
 +    pub fn set_diagnostics_callback(&mut self, callback: DiagnosticsCallback) {
 +        self.diagnostics_callback = Some(callback);
 +    }
++
 +    /// Handle an incoming message
 +    pub fn handle_message(&mut self, message: LspMessage) -> Option<LspMessage> {
 +        match message {
 +            LspMessage::Response { id, result, error } => {
 +                self.handle_response(id, result, error);
 +                None
 +            }
 +            LspMessage::Notification { method, params } => {
 +                self.handle_notification(&method, params);
 +                None
 +            }
 +            LspMessage::Request { id, method, params } => {
 +                // Handle server-to-client requests
 +                self.handle_server_request(id, &method, params)
 +            }
 +        }
 +    }
++
 +    /// Handle a response message
 +    fn handle_response(&mut self, id: i64, result: Option<Value>, error: Option<ResponseError>) {
 +        if let Some(callback) = self.pending.remove(&id) {
 +            let response = if let Some(err) = error {
 +                Err(err)
 +            } else {
 +                Ok(result.unwrap_or(Value::Null))
 +            };
 +            callback(id, response);
 +        }
 +    }
++
 +    /// Handle a notification message
 +    fn handle_notification(&mut self, method: &str, params: Option<Value>) {
 +        match method {
 +            "textDocument/publishDiagnostics" => {
 +                if let (Some(params), Some(callback)) = (params, &self.diagnostics_callback) {
 +                    let (uri, diagnostics) = super::protocol::parse_diagnostics(&params);
 +                    callback(uri, diagnostics);
 +                }
 +            }
 +            "window/logMessage" | "window/showMessage" => {
 +                // Silently ignore server log messages
 +                // These could be surfaced to the status bar via a callback if needed
 +                let _ = params;
 +            }
 +            _ => {
 +                // Ignore other notifications
 +            }
 +        }
 +    }
++
 +    /// Handle a server-to-client request (return a response if needed)
 +    fn handle_server_request(
 +        &mut self,
 +        id: i64,
 +        method: &str,
 +        _params: Option<Value>,
 +    ) -> Option<LspMessage> {
 +        match method {
 +            "workspace/configuration" => {
 +                // Return empty configuration
 +                Some(LspMessage::Response {
 +                    id,
 +                    result: Some(Value::Array(vec![])),
 +                    error: None,
 +                })
 +            }
 +            "client/registerCapability" | "client/unregisterCapability" => {
 +                // Acknowledge capability registration
 +                Some(LspMessage::Response {
 +                    id,
 +                    result: Some(Value::Null),
 +                    error: None,
 +                })
 +            }
 +            "window/workDoneProgress/create" => {
 +                // Acknowledge progress creation
 +                Some(LspMessage::Response {
 +                    id,
 +                    result: Some(Value::Null),
 +                    error: None,
 +                })
 +            }
 +            _ => {
 +                // Unknown request - return method not found error
 +                Some(LspMessage::Response {
 +                    id,
 +                    result: None,
 +                    error: Some(ResponseError {
 +                        code: -32601, // Method not found
 +                        message: format!("Method not found: {}", method),
 +                        data: None,
 +                    }),
 +                })
 +            }
 +        }
 +    }
++
 +    /// Check if there are pending requests
 +    pub fn has_pending(&self) -> bool {
 +        !self.pending.is_empty()
 +    }
++
 +    /// Get number of pending requests
 +    pub fn pending_count(&self) -> usize {
 +        self.pending.len()
 +    }
 +}
++
 +impl Default for MessageHandler {
 +    fn default() -> Self {
 +        Self::new()
 +    }
 +}
++
 +/// Parsed LSP response types for convenience
 +pub enum ParsedResponse {
 +    Completions(Vec<CompletionItem>),
 +    Hover(Option<HoverInfo>),
 +    Locations(Vec<Location>),
 +    Symbols(Vec<DocumentSymbol>),
 +    TextEdits(Vec<TextEdit>),
 +    WorkspaceEdit(WorkspaceEdit),
 +    Empty,
 +}
++
 +impl ParsedResponse {
 +    /// Parse a completion response
 +    pub fn parse_completions(result: &Value) -> Self {
 +        ParsedResponse::Completions(super::protocol::parse_completion_items(result))
 +    }
++
 +    /// Parse a hover response
 +    pub fn parse_hover(result: &Value) -> Self {
 +        ParsedResponse::Hover(super::protocol::parse_hover(result))
 +    }
++
 +    /// Parse a definition/references response
 +    pub fn parse_locations(result: &Value) -> Self {
 +        ParsedResponse::Locations(super::protocol::parse_locations(result))
 +    }
++
 +    /// Parse a document symbols response
 +    pub fn parse_symbols(result: &Value) -> Self {
 +        ParsedResponse::Symbols(super::protocol::parse_document_symbols(result))
 +    }
++
 +    /// Parse a formatting response
 +    pub fn parse_text_edits(result: &Value) -> Self {
 +        ParsedResponse::TextEdits(super::protocol::parse_text_edits(result))
 +    }
++
 +    /// Parse a rename response
 +    pub fn parse_workspace_edit(result: &Value) -> Self {
 +        ParsedResponse::WorkspaceEdit(super::protocol::parse_workspace_edit(result))
 +    }
 +}

src/lsp/mod.rsadded

 +//! LSP (Language Server Protocol) client module
 +//!
 +//! Provides LSP support for fackr, enabling:
 +//! - Code completion
 +//! - Hover information
 +//! - Go to definition
 +//! - Find references
 +//! - Diagnostics
 +//! - Code actions
 +//! - Document symbols
 +//! - Rename refactoring
 +//! - Document formatting
++
 +mod client;
 +mod manager;
 +mod message;
 +mod process;
 +mod protocol;
 +pub mod server_manager;
 +mod types;
++
 +pub use client::{LspClient, LspResponse};
 +pub use server_manager::ServerManagerPanel;
 +pub use types::{
 +    CompletionItem, Diagnostic, DiagnosticSeverity, HoverInfo, Location, TextEdit, uri_to_path,
 +};

src/lsp/process.rsadded

 +//! LSP server process management
 +//!
 +//! Handles spawning and communicating with language server processes.
 +//!
 +//! Note: Some process methods are for planned features.
 +#![allow(dead_code)]
++
 +use anyhow::{anyhow, Result};
 +use std::io::{Read, Write};
 +use std::process::{Child, ChildStdin, ChildStdout, Command, Stdio};
 +use std::sync::mpsc::{self, Receiver, Sender, TryRecvError};
 +use std::thread;
++
 +/// A running language server process
 +pub struct ServerProcess {
 +    child: Child,
 +    stdin: ChildStdin,
 +    message_rx: Receiver<String>,
 +    /// Buffer for incomplete messages
 +    read_buffer: String,
 +}
++
 +impl ServerProcess {
 +    /// Spawn a new language server process
 +    pub fn spawn(command: &[String]) -> Result<Self> {
 +        if command.is_empty() {
 +            return Err(anyhow!("Empty command"));
 +        }
++
 +        let mut cmd = Command::new(&command[0]);
 +        if command.len() > 1 {
 +            cmd.args(&command[1..]);
 +        }
++
 +        let mut child = cmd
 +            .stdin(Stdio::piped())
 +            .stdout(Stdio::piped())
 +            .stderr(Stdio::piped())
 +            .spawn()
 +            .map_err(|e| anyhow!("Failed to spawn LSP server '{}': {}", command[0], e))?;
++
 +        let stdin = child.stdin.take().ok_or_else(|| anyhow!("No stdin"))?;
 +        let stdout = child.stdout.take().ok_or_else(|| anyhow!("No stdout"))?;
++
 +        // Spawn a thread to read from stdout asynchronously
 +        let (tx, rx) = mpsc::channel();
 +        spawn_reader_thread(stdout, tx);
++
 +        Ok(Self {
 +            child,
 +            stdin,
 +            message_rx: rx,
 +            read_buffer: String::new(),
 +        })
 +    }
++
 +    /// Send a message to the server
 +    pub fn send(&mut self, message: &str) -> Result<()> {
 +        self.stdin.write_all(message.as_bytes())?;
 +        self.stdin.flush()?;
 +        Ok(())
 +    }
++
 +    /// Try to receive a complete message from the server (non-blocking)
 +    pub fn try_recv(&mut self) -> Option<String> {
 +        // Drain all available data from the channel into our buffer
 +        loop {
 +            match self.message_rx.try_recv() {
 +                Ok(data) => self.read_buffer.push_str(&data),
 +                Err(TryRecvError::Empty) => break,
 +                Err(TryRecvError::Disconnected) => break,
 +            }
 +        }
++
 +        // Try to parse a complete message from the buffer
 +        self.parse_message()
 +    }
++
 +    /// Block until a message is received (with timeout in ms)
 +    pub fn recv_timeout(&mut self, timeout_ms: u64) -> Option<String> {
 +        use std::time::{Duration, Instant};
 +        let deadline = Instant::now() + Duration::from_millis(timeout_ms);
++
 +        loop {
 +            // First check if we have a complete message buffered
 +            if let Some(msg) = self.parse_message() {
 +                return Some(msg);
 +            }
++
 +            // Wait for more data
 +            let remaining = deadline.saturating_duration_since(Instant::now());
 +            if remaining.is_zero() {
 +                return None;
 +            }
++
 +            match self.message_rx.recv_timeout(remaining) {
 +                Ok(data) => self.read_buffer.push_str(&data),
 +                Err(_) => return None,
 +            }
 +        }
 +    }
++
 +    /// Parse a complete LSP message from the buffer
 +    fn parse_message(&mut self) -> Option<String> {
 +        // Look for Content-Length header
 +        let header_end = self.read_buffer.find("\r\n\r\n")?;
 +        let header = &self.read_buffer[..header_end];
++
 +        // Parse Content-Length
 +        let content_length: usize = header
 +            .lines()
 +            .find(|line| line.to_lowercase().starts_with("content-length:"))
 +            .and_then(|line| line.split(':').nth(1))
 +            .and_then(|len| len.trim().parse().ok())?;
++
 +        // Check if we have the full message
 +        let message_start = header_end + 4;
 +        let message_end = message_start + content_length;
++
 +        if self.read_buffer.len() < message_end {
 +            return None;
 +        }
++
 +        // Extract the message
 +        let message = self.read_buffer[message_start..message_end].to_string();
++
 +        // Remove from buffer
 +        self.read_buffer = self.read_buffer[message_end..].to_string();
++
 +        Some(message)
 +    }
++
 +    /// Check if the process is still running
 +    pub fn is_running(&mut self) -> bool {
 +        match self.child.try_wait() {
 +            Ok(Some(_)) => false, // Process has exited
 +            Ok(None) => true,     // Still running
 +            Err(_) => false,      // Error checking status
 +        }
 +    }
++
 +    /// Kill the server process
 +    pub fn kill(&mut self) -> Result<()> {
 +        let _ = self.child.kill();
 +        Ok(())
 +    }
++
 +    /// Get the process ID
 +    pub fn pid(&self) -> u32 {
 +        self.child.id()
 +    }
 +}
++
 +impl Drop for ServerProcess {
 +    fn drop(&mut self) {
 +        let _ = self.kill();
 +    }
 +}
++
 +/// Spawn a thread to read from the server's stdout
 +fn spawn_reader_thread(mut stdout: ChildStdout, tx: Sender<String>) {
 +    use std::io::ErrorKind;
++
 +    thread::spawn(move || {
 +        let mut buffer = [0u8; 8192];
 +        loop {
 +            match stdout.read(&mut buffer) {
 +                Ok(0) => break,
 +                Ok(n) => {
 +                    if let Ok(s) = std::str::from_utf8(&buffer[..n]) {
 +                        if tx.send(s.to_string()).is_err() {
 +                            break;
 +                        }
 +                    }
 +                }
 +                Err(e) if e.kind() == ErrorKind::Interrupted => continue,
 +                Err(_) => break,
 +            }
 +        }
 +    });
 +}

src/lsp/protocol.rsadded

 +//! LSP JSON-RPC protocol implementation
 +//!
 +//! Handles message creation, serialization, and parsing for the Language Server Protocol.
 +//!
 +//! Note: Some request builders and parsers are for planned features.
 +#![allow(dead_code)]
++
 +use serde::{Deserialize, Serialize};
 +use serde_json::{json, Value};
 +use std::sync::atomic::{AtomicI64, Ordering};
++
 +use super::types::{Capabilities, Position, Range};
++
 +/// Global request ID counter
 +static NEXT_REQUEST_ID: AtomicI64 = AtomicI64::new(1);
++
 +/// Get the next unique request ID
 +pub fn next_request_id() -> i64 {
 +    NEXT_REQUEST_ID.fetch_add(1, Ordering::SeqCst)
 +}
++
 +/// LSP message types
 +#[derive(Debug, Clone)]
 +pub enum LspMessage {
 +    Request {
 +        id: i64,
 +        method: String,
 +        params: Option<Value>,
 +    },
 +    Response {
 +        id: i64,
 +        result: Option<Value>,
 +        error: Option<ResponseError>,
 +    },
 +    Notification {
 +        method: String,
 +        params: Option<Value>,
 +    },
 +}
++
 +/// LSP response error
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct ResponseError {
 +    pub code: i32,
 +    pub message: String,
 +    pub data: Option<Value>,
 +}
++
 +impl LspMessage {
 +    /// Serialize message to JSON-RPC format with Content-Length header
 +    pub fn to_string(&self) -> String {
 +        let json = match self {
 +            LspMessage::Request { id, method, params } => {
 +                let mut obj = json!({
 +                    "jsonrpc": "2.0",
 +                    "id": id,
 +                    "method": method,
 +                });
 +                if let Some(p) = params {
 +                    obj["params"] = p.clone();
 +                }
 +                obj
 +            }
 +            LspMessage::Response { id, result, error } => {
 +                let mut obj = json!({
 +                    "jsonrpc": "2.0",
 +                    "id": id,
 +                });
 +                if let Some(r) = result {
 +                    obj["result"] = r.clone();
 +                }
 +                if let Some(e) = error {
 +                    obj["error"] = serde_json::to_value(e).unwrap_or(Value::Null);
 +                }
 +                obj
 +            }
 +            LspMessage::Notification { method, params } => {
 +                let mut obj = json!({
 +                    "jsonrpc": "2.0",
 +                    "method": method,
 +                });
 +                if let Some(p) = params {
 +                    obj["params"] = p.clone();
 +                }
 +                obj
 +            }
 +        };
++
 +        let content = serde_json::to_string(&json).unwrap_or_default();
 +        format!("Content-Length: {}\r\n\r\n{}", content.len(), content)
 +    }
++
 +    /// Parse a JSON-RPC message from JSON value
 +    pub fn from_json(value: Value) -> Option<Self> {
 +        let obj = value.as_object()?;
++
 +        // Check for response (has id and result/error)
 +        if let Some(id) = obj.get("id").and_then(|v| v.as_i64()) {
 +            if obj.contains_key("method") {
 +                // Request
 +                let method = obj.get("method")?.as_str()?.to_string();
 +                let params = obj.get("params").cloned();
 +                Some(LspMessage::Request { id, method, params })
 +            } else {
 +                // Response
 +                let result = obj.get("result").cloned();
 +                let error = obj
 +                    .get("error")
 +                    .and_then(|e| serde_json::from_value(e.clone()).ok());
 +                Some(LspMessage::Response { id, result, error })
 +            }
 +        } else if let Some(method) = obj.get("method").and_then(|v| v.as_str()) {
 +            // Notification (no id)
 +            let params = obj.get("params").cloned();
 +            Some(LspMessage::Notification {
 +                method: method.to_string(),
 +                params,
 +            })
 +        } else {
 +            None
 +        }
 +    }
 +}
++
 +// ============================================================================
 +// Request Builders
 +// ============================================================================
++
 +/// Create initialize request
 +pub fn create_initialize_request(
 +    id: i64,
 +    workspace_root: &str,
 +    client_name: &str,
 +) -> LspMessage {
 +    let capabilities = json!({
 +        "textDocument": {
 +            "completion": {
 +                "completionItem": {
 +                    "snippetSupport": false,
 +                    "documentationFormat": ["plaintext", "markdown"],
 +                    "deprecatedSupport": true,
 +                    "labelDetailsSupport": true
 +                },
 +                "contextSupport": true
 +            },
 +            "hover": {
 +                "contentFormat": ["plaintext", "markdown"]
 +            },
 +            "definition": {
 +                "linkSupport": true
 +            },
 +            "references": {},
 +            "documentSymbol": {
 +                "hierarchicalDocumentSymbolSupport": true
 +            },
 +            "codeAction": {
 +                "codeActionLiteralSupport": {
 +                    "codeActionKind": {
 +                        "valueSet": [
 +                            "quickfix",
 +                            "refactor",
 +                            "refactor.extract",
 +                            "refactor.inline",
 +                            "refactor.rewrite",
 +                            "source",
 +                            "source.organizeImports"
 +                        ]
 +                    }
 +                }
 +            },
 +            "rename": {
 +                "prepareSupport": true
 +            },
 +            "publishDiagnostics": {
 +                "relatedInformation": true,
 +                "tagSupport": {
 +                    "valueSet": [1, 2]
 +                }
 +            },
 +            "signatureHelp": {
 +                "signatureInformation": {
 +                    "documentationFormat": ["plaintext", "markdown"],
 +                    "parameterInformation": {
 +                        "labelOffsetSupport": true
 +                    }
 +                }
 +            },
 +            "formatting": {},
 +            "synchronization": {
 +                "didSave": true,
 +                "willSave": false,
 +                "willSaveWaitUntil": false
 +            }
 +        },
 +        "workspace": {
 +            // Note: workspaceFolders must be false for pyright to send diagnostics
 +            // after didOpen. With true, pyright waits for workspace folder change events.
 +            "workspaceFolders": false,
 +            "symbol": {
 +                "symbolKind": {
 +                    "valueSet": (1..=26).collect::<Vec<i32>>()
 +                }
 +            },
 +            "applyEdit": true,
 +            "workspaceEdit": {
 +                "documentChanges": true
 +            }
 +        }
 +    });
++
 +    let params = json!({
 +        "processId": std::process::id(),
 +        "clientInfo": {
 +            "name": client_name,
 +            "version": env!("CARGO_PKG_VERSION")
 +        },
 +        "rootUri": format!("file://{}", workspace_root),
 +        "rootPath": workspace_root,
 +        "capabilities": capabilities,
 +        "workspaceFolders": [{
 +            "uri": format!("file://{}", workspace_root),
 +            "name": workspace_root.rsplit('/').next().unwrap_or(workspace_root)
 +        }]
 +    });
++
 +    LspMessage::Request {
 +        id,
 +        method: "initialize".to_string(),
 +        params: Some(params),
 +    }
 +}
++
 +/// Create initialized notification (sent after initialize response)
 +pub fn create_initialized_notification() -> LspMessage {
 +    LspMessage::Notification {
 +        method: "initialized".to_string(),
 +        params: Some(json!({})),
 +    }
 +}
++
 +/// Create shutdown request
 +pub fn create_shutdown_request(id: i64) -> LspMessage {
 +    LspMessage::Request {
 +        id,
 +        method: "shutdown".to_string(),
 +        params: None,
 +    }
 +}
++
 +/// Create exit notification
 +pub fn create_exit_notification() -> LspMessage {
 +    LspMessage::Notification {
 +        method: "exit".to_string(),
 +        params: None,
 +    }
 +}
++
 +// ============================================================================
 +// Document Synchronization
 +// ============================================================================
++
 +/// Create textDocument/didOpen notification
 +pub fn create_did_open_notification(uri: &str, language_id: &str, version: i32, text: &str) -> LspMessage {
 +    LspMessage::Notification {
 +        method: "textDocument/didOpen".to_string(),
 +        params: Some(json!({
 +            "textDocument": {
 +                "uri": uri,
 +                "languageId": language_id,
 +                "version": version,
 +                "text": text
 +            }
 +        })),
 +    }
 +}
++
 +/// Create textDocument/didChange notification (full sync)
 +pub fn create_did_change_notification(uri: &str, version: i32, text: &str) -> LspMessage {
 +    LspMessage::Notification {
 +        method: "textDocument/didChange".to_string(),
 +        params: Some(json!({
 +            "textDocument": {
 +                "uri": uri,
 +                "version": version
 +            },
 +            "contentChanges": [{
 +                "text": text
 +            }]
 +        })),
 +    }
 +}
++
 +/// Create textDocument/didSave notification
 +pub fn create_did_save_notification(uri: &str, text: Option<&str>) -> LspMessage {
 +    let mut params = json!({
 +        "textDocument": {
 +            "uri": uri
 +        }
 +    });
 +    if let Some(t) = text {
 +        params["text"] = json!(t);
 +    }
 +    LspMessage::Notification {
 +        method: "textDocument/didSave".to_string(),
 +        params: Some(params),
 +    }
 +}
++
 +/// Create textDocument/didClose notification
 +pub fn create_did_close_notification(uri: &str) -> LspMessage {
 +    LspMessage::Notification {
 +        method: "textDocument/didClose".to_string(),
 +        params: Some(json!({
 +            "textDocument": {
 +                "uri": uri
 +            }
 +        })),
 +    }
 +}
++
 +// ============================================================================
 +// Language Features
 +// ============================================================================
++
 +fn position_params(uri: &str, pos: Position) -> Value {
 +    json!({
 +        "textDocument": { "uri": uri },
 +        "position": { "line": pos.line, "character": pos.character }
 +    })
 +}
++
 +/// Create textDocument/completion request
 +pub fn create_completion_request(id: i64, uri: &str, pos: Position) -> LspMessage {
 +    let mut params = position_params(uri, pos);
 +    params["context"] = json!({ "triggerKind": 1 }); // Invoked
 +    LspMessage::Request {
 +        id,
 +        method: "textDocument/completion".to_string(),
 +        params: Some(params),
 +    }
 +}
++
 +/// Create textDocument/hover request
 +pub fn create_hover_request(id: i64, uri: &str, pos: Position) -> LspMessage {
 +    LspMessage::Request {
 +        id,
 +        method: "textDocument/hover".to_string(),
 +        params: Some(position_params(uri, pos)),
 +    }
 +}
++
 +/// Create textDocument/definition request
 +pub fn create_definition_request(id: i64, uri: &str, pos: Position) -> LspMessage {
 +    LspMessage::Request {
 +        id,
 +        method: "textDocument/definition".to_string(),
 +        params: Some(position_params(uri, pos)),
 +    }
 +}
++
 +/// Create textDocument/references request
 +pub fn create_references_request(
 +    id: i64,
 +    uri: &str,
 +    pos: Position,
 +    include_declaration: bool,
 +) -> LspMessage {
 +    let mut params = position_params(uri, pos);
 +    params["context"] = json!({ "includeDeclaration": include_declaration });
 +    LspMessage::Request {
 +        id,
 +        method: "textDocument/references".to_string(),
 +        params: Some(params),
 +    }
 +}
++
 +/// Create textDocument/rename request
 +pub fn create_rename_request(id: i64, uri: &str, pos: Position, new_name: &str) -> LspMessage {
 +    let mut params = position_params(uri, pos);
 +    params["newName"] = json!(new_name);
 +    LspMessage::Request {
 +        id,
 +        method: "textDocument/rename".to_string(),
 +        params: Some(params),
 +    }
 +}
++
 +/// Create textDocument/codeAction request
 +pub fn create_code_action_request(id: i64, uri: &str, range: Range) -> LspMessage {
 +    LspMessage::Request {
 +        id,
 +        method: "textDocument/codeAction".to_string(),
 +        params: Some(json!({
 +            "textDocument": { "uri": uri },
 +            "range": {
 +                "start": { "line": range.start.line, "character": range.start.character },
 +                "end": { "line": range.end.line, "character": range.end.character }
 +            },
 +            "context": {
 +                "diagnostics": []
 +            }
 +        })),
 +    }
 +}
++
 +/// Create textDocument/documentSymbol request
 +pub fn create_document_symbols_request(id: i64, uri: &str) -> LspMessage {
 +    LspMessage::Request {
 +        id,
 +        method: "textDocument/documentSymbol".to_string(),
 +        params: Some(json!({
 +            "textDocument": { "uri": uri }
 +        })),
 +    }
 +}
++
 +/// Create workspace/symbol request
 +pub fn create_workspace_symbols_request(id: i64, query: &str) -> LspMessage {
 +    LspMessage::Request {
 +        id,
 +        method: "workspace/symbol".to_string(),
 +        params: Some(json!({ "query": query })),
 +    }
 +}
++
 +/// Create textDocument/signatureHelp request
 +pub fn create_signature_help_request(id: i64, uri: &str, pos: Position) -> LspMessage {
 +    LspMessage::Request {
 +        id,
 +        method: "textDocument/signatureHelp".to_string(),
 +        params: Some(position_params(uri, pos)),
 +    }
 +}
++
 +/// Create textDocument/formatting request
 +pub fn create_formatting_request(id: i64, uri: &str, tab_size: u32, use_spaces: bool) -> LspMessage {
 +    LspMessage::Request {
 +        id,
 +        method: "textDocument/formatting".to_string(),
 +        params: Some(json!({
 +            "textDocument": { "uri": uri },
 +            "options": {
 +                "tabSize": tab_size,
 +                "insertSpaces": use_spaces,
 +                "trimTrailingWhitespace": true,
 +                "insertFinalNewline": true
 +            }
 +        })),
 +    }
 +}
++
 +// ============================================================================
 +// Response Parsing
 +// ============================================================================
++
 +/// Parse server capabilities from initialize response
 +pub fn parse_capabilities(result: &Value) -> Capabilities {
 +    let caps = result.get("capabilities").unwrap_or(result);
++
 +    Capabilities {
 +        completion: caps.get("completionProvider").is_some(),
 +        hover: caps.get("hoverProvider").map_or(false, |v| !v.is_null()),
 +        definition: caps.get("definitionProvider").map_or(false, |v| !v.is_null()),
 +        references: caps.get("referencesProvider").map_or(false, |v| !v.is_null()),
 +        rename: caps.get("renameProvider").map_or(false, |v| !v.is_null()),
 +        code_actions: caps.get("codeActionProvider").map_or(false, |v| !v.is_null()),
 +        formatting: caps.get("documentFormattingProvider").map_or(false, |v| !v.is_null()),
 +        diagnostics: true, // Always assume diagnostics are supported
 +        document_symbols: caps.get("documentSymbolProvider").map_or(false, |v| !v.is_null()),
 +        workspace_symbols: caps.get("workspaceSymbolProvider").map_or(false, |v| !v.is_null()),
 +        signature_help: caps.get("signatureHelpProvider").is_some(),
 +    }
 +}
++
 +/// Parse Position from JSON
 +pub fn parse_position(value: &Value) -> Option<super::types::Position> {
 +    Some(super::types::Position {
 +        line: value.get("line")?.as_u64()? as u32,
 +        character: value.get("character")?.as_u64()? as u32,
 +    })
 +}
++
 +/// Parse Range from JSON
 +pub fn parse_range(value: &Value) -> Option<super::types::Range> {
 +    Some(super::types::Range {
 +        start: parse_position(value.get("start")?)?,
 +        end: parse_position(value.get("end")?)?,
 +    })
 +}
++
 +/// Parse Location from JSON
 +pub fn parse_location(value: &Value) -> Option<super::types::Location> {
 +    Some(super::types::Location {
 +        uri: value.get("uri")?.as_str()?.to_string(),
 +        range: parse_range(value.get("range")?)?,
 +    })
 +}
++
 +/// Parse completion items from response
 +pub fn parse_completion_items(result: &Value) -> Vec<super::types::CompletionItem> {
 +    let items = if let Some(arr) = result.as_array() {
 +        arr
 +    } else if let Some(arr) = result.get("items").and_then(|v| v.as_array()) {
 +        arr
 +    } else {
 +        return Vec::new();
 +    };
++
 +    items
 +        .iter()
 +        .filter_map(|item| {
 +            let label = item.get("label")?.as_str()?.to_string();
 +            Some(super::types::CompletionItem {
 +                label,
 +                kind: item
 +                    .get("kind")
 +                    .and_then(|v| v.as_u64())
 +                    .and_then(|k| super::types::CompletionItemKind::from_u32(k as u32)),
 +                detail: item.get("detail").and_then(|v| v.as_str()).map(String::from),
 +                documentation: item
 +                    .get("documentation")
 +                    .and_then(|v| {
 +                        if let Some(s) = v.as_str() {
 +                            Some(s.to_string())
 +                        } else {
 +                            v.get("value").and_then(|v| v.as_str()).map(String::from)
 +                        }
 +                    }),
 +                insert_text: item.get("insertText").and_then(|v| v.as_str()).map(String::from),
 +                text_edit: item.get("textEdit").and_then(|te| {
 +                    Some(super::types::TextEdit {
 +                        range: parse_range(te.get("range")?)?,
 +                        new_text: te.get("newText")?.as_str()?.to_string(),
 +                    })
 +                }),
 +                sort_text: item.get("sortText").and_then(|v| v.as_str()).map(String::from),
 +                filter_text: item.get("filterText").and_then(|v| v.as_str()).map(String::from),
 +            })
 +        })
 +        .collect()
 +}
++
 +/// Parse hover info from response
 +pub fn parse_hover(result: &Value) -> Option<super::types::HoverInfo> {
 +    let contents = result.get("contents")?;
 +    let text = if let Some(s) = contents.as_str() {
 +        s.to_string()
 +    } else if let Some(arr) = contents.as_array() {
 +        arr.iter()
 +            .filter_map(|v| {
 +                if let Some(s) = v.as_str() {
 +                    Some(s.to_string())
 +                } else {
 +                    v.get("value").and_then(|v| v.as_str()).map(String::from)
 +                }
 +            })
 +            .collect::<Vec<_>>()
 +            .join("\n\n")
 +    } else if let Some(value) = contents.get("value") {
 +        value.as_str()?.to_string()
 +    } else {
 +        return None;
 +    };
++
 +    Some(super::types::HoverInfo {
 +        contents: text,
 +        range: result.get("range").and_then(parse_range),
 +    })
 +}
++
 +/// Parse locations from definition/references response
 +pub fn parse_locations(result: &Value) -> Vec<super::types::Location> {
 +    if let Some(loc) = parse_location(result) {
 +        vec![loc]
 +    } else if let Some(arr) = result.as_array() {
 +        arr.iter().filter_map(parse_location).collect()
 +    } else {
 +        Vec::new()
 +    }
 +}
++
 +/// Parse document symbols from response
 +pub fn parse_document_symbols(result: &Value) -> Vec<super::types::DocumentSymbol> {
 +    fn parse_symbol(value: &Value) -> Option<super::types::DocumentSymbol> {
 +        let name = value.get("name")?.as_str()?.to_string();
 +        let kind = value.get("kind")?.as_u64()?;
++
 +        // Handle both DocumentSymbol and SymbolInformation formats
 +        let (range, selection_range) = if let Some(r) = value.get("range") {
 +            let range = parse_range(r)?;
 +            let sel = value.get("selectionRange").and_then(parse_range).unwrap_or(range);
 +            (range, sel)
 +        } else if let Some(loc) = value.get("location") {
 +            let range = parse_range(loc.get("range")?)?;
 +            (range, range)
 +        } else {
 +            return None;
 +        };
++
 +        let children = value
 +            .get("children")
 +            .and_then(|c| c.as_array())
 +            .map(|arr| arr.iter().filter_map(parse_symbol).collect())
 +            .unwrap_or_default();
++
 +        Some(super::types::DocumentSymbol {
 +            name,
 +            kind: super::types::SymbolKind::from_u32(kind as u32)?,
 +            range,
 +            selection_range,
 +            children,
 +        })
 +    }
++
 +    result
 +        .as_array()
 +        .map(|arr| arr.iter().filter_map(parse_symbol).collect())
 +        .unwrap_or_default()
 +}
++
 +/// Parse diagnostics from publishDiagnostics notification
 +pub fn parse_diagnostics(params: &Value) -> (String, Vec<super::types::Diagnostic>) {
 +    let uri = params
 +        .get("uri")
 +        .and_then(|v| v.as_str())
 +        .unwrap_or("")
 +        .to_string();
++
 +    let diagnostics = params
 +        .get("diagnostics")
 +        .and_then(|v| v.as_array())
 +        .map(|arr| {
 +            arr.iter()
 +                .filter_map(|d| {
 +                    Some(super::types::Diagnostic {
 +                        range: parse_range(d.get("range")?)?,
 +                        severity: d
 +                            .get("severity")
 +                            .and_then(|v| v.as_u64())
 +                            .and_then(|s| super::types::DiagnosticSeverity::from_u32(s as u32)),
 +                        code: d.get("code").and_then(|v| {
 +                            if let Some(s) = v.as_str() {
 +                                Some(s.to_string())
 +                            } else if let Some(n) = v.as_i64() {
 +                                Some(n.to_string())
 +                            } else {
 +                                None
 +                            }
 +                        }),
 +                        source: d.get("source").and_then(|v| v.as_str()).map(String::from),
 +                        message: d.get("message")?.as_str()?.to_string(),
 +                    })
 +                })
 +                .collect()
 +        })
 +        .unwrap_or_default();
++
 +    (uri, diagnostics)
 +}
++
 +/// Parse text edits from formatting response
 +pub fn parse_text_edits(result: &Value) -> Vec<super::types::TextEdit> {
 +    result
 +        .as_array()
 +        .map(|arr| {
 +            arr.iter()
 +                .filter_map(|edit| {
 +                    Some(super::types::TextEdit {
 +                        range: parse_range(edit.get("range")?)?,
 +                        new_text: edit.get("newText")?.as_str()?.to_string(),
 +                    })
 +                })
 +                .collect()
 +        })
 +        .unwrap_or_default()
 +}
++
 +/// Parse workspace edit from rename response
 +pub fn parse_workspace_edit(result: &Value) -> super::types::WorkspaceEdit {
 +    let mut edit = super::types::WorkspaceEdit::default();
++
 +    if let Some(changes) = result.get("changes").and_then(|v| v.as_object()) {
 +        for (uri, edits) in changes {
 +            let text_edits = edits
 +                .as_array()
 +                .map(|arr| {
 +                    arr.iter()
 +                        .filter_map(|e| {
 +                            Some(super::types::TextEdit {
 +                                range: parse_range(e.get("range")?)?,
 +                                new_text: e.get("newText")?.as_str()?.to_string(),
 +                            })
 +                        })
 +                        .collect()
 +                })
 +                .unwrap_or_default();
 +            edit.changes.insert(uri.clone(), text_edits);
 +        }
 +    }
++
 +    // Handle documentChanges format
 +    if let Some(doc_changes) = result.get("documentChanges").and_then(|v| v.as_array()) {
 +        for change in doc_changes {
 +            if let Some(text_doc) = change.get("textDocument") {
 +                let uri = text_doc.get("uri").and_then(|v| v.as_str()).unwrap_or("");
 +                let text_edits = change
 +                    .get("edits")
 +                    .and_then(|v| v.as_array())
 +                    .map(|arr| {
 +                        arr.iter()
 +                            .filter_map(|e| {
 +                                Some(super::types::TextEdit {
 +                                    range: parse_range(e.get("range")?)?,
 +                                    new_text: e.get("newText")?.as_str()?.to_string(),
 +                                })
 +                            })
 +                            .collect()
 +                    })
 +                    .unwrap_or_default();
 +                edit.changes.insert(uri.to_string(), text_edits);
 +            }
 +        }
 +    }
++
 +    edit
 +}

src/lsp/types.rsadded

 +//! LSP type definitions
 +//!
 +//! Core types used throughout the LSP client implementation.
 +//!
 +//! Note: Some types and methods are for planned features.
 +#![allow(dead_code)]
++
 +use std::collections::HashMap;
 +use std::path::PathBuf;
++
 +/// Position in a document (0-based line and character)
 +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 +pub struct Position {
 +    pub line: u32,
 +    pub character: u32,
 +}
++
 +impl Position {
 +    pub fn new(line: u32, character: u32) -> Self {
 +        Self { line, character }
 +    }
 +}
++
 +/// Range in a document
 +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 +pub struct Range {
 +    pub start: Position,
 +    pub end: Position,
 +}
++
 +impl Range {
 +    pub fn new(start: Position, end: Position) -> Self {
 +        Self { start, end }
 +    }
++
 +    pub fn point(pos: Position) -> Self {
 +        Self {
 +            start: pos,
 +            end: pos,
 +        }
 +    }
 +}
++
 +/// Location in a document
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct Location {
 +    pub uri: String,
 +    pub range: Range,
 +}
++
 +impl Location {
 +    /// Convert URI to file path
 +    pub fn to_path(&self) -> Option<PathBuf> {
 +        if self.uri.starts_with("file://") {
 +            Some(PathBuf::from(&self.uri[7..]))
 +        } else {
 +            None
 +        }
 +    }
 +}
++
 +/// Text edit operation
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct TextEdit {
 +    pub range: Range,
 +    pub new_text: String,
 +}
++
 +/// Workspace edit (multiple file edits)
 +#[derive(Debug, Clone, Default)]
 +pub struct WorkspaceEdit {
 +    pub changes: HashMap<String, Vec<TextEdit>>,
 +}
++
 +/// Diagnostic severity levels
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum DiagnosticSeverity {
 +    Error = 1,
 +    Warning = 2,
 +    Information = 3,
 +    Hint = 4,
 +}
++
 +impl DiagnosticSeverity {
 +    pub fn from_u32(value: u32) -> Option<Self> {
 +        match value {
 +            1 => Some(Self::Error),
 +            2 => Some(Self::Warning),
 +            3 => Some(Self::Information),
 +            4 => Some(Self::Hint),
 +            _ => None,
 +        }
 +    }
 +}
++
 +/// A diagnostic message from the language server
 +#[derive(Debug, Clone)]
 +pub struct Diagnostic {
 +    pub range: Range,
 +    pub severity: Option<DiagnosticSeverity>,
 +    pub code: Option<String>,
 +    pub source: Option<String>,
 +    pub message: String,
 +}
++
 +/// Completion item kind
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum CompletionItemKind {
 +    Text = 1,
 +    Method = 2,
 +    Function = 3,
 +    Constructor = 4,
 +    Field = 5,
 +    Variable = 6,
 +    Class = 7,
 +    Interface = 8,
 +    Module = 9,
 +    Property = 10,
 +    Unit = 11,
 +    Value = 12,
 +    Enum = 13,
 +    Keyword = 14,
 +    Snippet = 15,
 +    Color = 16,
 +    File = 17,
 +    Reference = 18,
 +    Folder = 19,
 +    EnumMember = 20,
 +    Constant = 21,
 +    Struct = 22,
 +    Event = 23,
 +    Operator = 24,
 +    TypeParameter = 25,
 +}
++
 +impl CompletionItemKind {
 +    pub fn from_u32(value: u32) -> Option<Self> {
 +        match value {
 +            1 => Some(Self::Text),
 +            2 => Some(Self::Method),
 +            3 => Some(Self::Function),
 +            4 => Some(Self::Constructor),
 +            5 => Some(Self::Field),
 +            6 => Some(Self::Variable),
 +            7 => Some(Self::Class),
 +            8 => Some(Self::Interface),
 +            9 => Some(Self::Module),
 +            10 => Some(Self::Property),
 +            11 => Some(Self::Unit),
 +            12 => Some(Self::Value),
 +            13 => Some(Self::Enum),
 +            14 => Some(Self::Keyword),
 +            15 => Some(Self::Snippet),
 +            16 => Some(Self::Color),
 +            17 => Some(Self::File),
 +            18 => Some(Self::Reference),
 +            19 => Some(Self::Folder),
 +            20 => Some(Self::EnumMember),
 +            21 => Some(Self::Constant),
 +            22 => Some(Self::Struct),
 +            23 => Some(Self::Event),
 +            24 => Some(Self::Operator),
 +            25 => Some(Self::TypeParameter),
 +            _ => None,
 +        }
 +    }
++
 +    pub fn icon(&self) -> &'static str {
 +        match self {
 +            Self::Text => "t",
 +            Self::Method => "m",
 +            Self::Function => "f",
 +            Self::Constructor => "C",
 +            Self::Field => "F",
 +            Self::Variable => "v",
 +            Self::Class => "c",
 +            Self::Interface => "i",
 +            Self::Module => "M",
 +            Self::Property => "p",
 +            Self::Unit => "u",
 +            Self::Value => "V",
 +            Self::Enum => "E",
 +            Self::Keyword => "k",
 +            Self::Snippet => "s",
 +            Self::Color => "#",
 +            Self::File => "f",
 +            Self::Reference => "r",
 +            Self::Folder => "D",
 +            Self::EnumMember => "e",
 +            Self::Constant => "K",
 +            Self::Struct => "S",
 +            Self::Event => "!",
 +            Self::Operator => "o",
 +            Self::TypeParameter => "T",
 +        }
 +    }
 +}
++
 +/// A completion item
 +#[derive(Debug, Clone)]
 +pub struct CompletionItem {
 +    pub label: String,
 +    pub kind: Option<CompletionItemKind>,
 +    pub detail: Option<String>,
 +    pub documentation: Option<String>,
 +    pub insert_text: Option<String>,
 +    pub text_edit: Option<TextEdit>,
 +    pub sort_text: Option<String>,
 +    pub filter_text: Option<String>,
 +}
++
 +/// Symbol kind (for document/workspace symbols)
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum SymbolKind {
 +    File = 1,
 +    Module = 2,
 +    Namespace = 3,
 +    Package = 4,
 +    Class = 5,
 +    Method = 6,
 +    Property = 7,
 +    Field = 8,
 +    Constructor = 9,
 +    Enum = 10,
 +    Interface = 11,
 +    Function = 12,
 +    Variable = 13,
 +    Constant = 14,
 +    String = 15,
 +    Number = 16,
 +    Boolean = 17,
 +    Array = 18,
 +    Object = 19,
 +    Key = 20,
 +    Null = 21,
 +    EnumMember = 22,
 +    Struct = 23,
 +    Event = 24,
 +    Operator = 25,
 +    TypeParameter = 26,
 +}
++
 +impl SymbolKind {
 +    pub fn from_u32(value: u32) -> Option<Self> {
 +        match value {
 +            1 => Some(Self::File),
 +            2 => Some(Self::Module),
 +            3 => Some(Self::Namespace),
 +            4 => Some(Self::Package),
 +            5 => Some(Self::Class),
 +            6 => Some(Self::Method),
 +            7 => Some(Self::Property),
 +            8 => Some(Self::Field),
 +            9 => Some(Self::Constructor),
 +            10 => Some(Self::Enum),
 +            11 => Some(Self::Interface),
 +            12 => Some(Self::Function),
 +            13 => Some(Self::Variable),
 +            14 => Some(Self::Constant),
 +            15 => Some(Self::String),
 +            16 => Some(Self::Number),
 +            17 => Some(Self::Boolean),
 +            18 => Some(Self::Array),
 +            19 => Some(Self::Object),
 +            20 => Some(Self::Key),
 +            21 => Some(Self::Null),
 +            22 => Some(Self::EnumMember),
 +            23 => Some(Self::Struct),
 +            24 => Some(Self::Event),
 +            25 => Some(Self::Operator),
 +            26 => Some(Self::TypeParameter),
 +            _ => None,
 +        }
 +    }
++
 +    pub fn icon(&self) -> &'static str {
 +        match self {
 +            Self::File => "󰈔",
 +            Self::Module => "󰆧",
 +            Self::Namespace => "󰅩",
 +            Self::Package => "󰏗",
 +            Self::Class => "󰠱",
 +            Self::Method => "󰆧",
 +            Self::Property => "󰜢",
 +            Self::Field => "󰜢",
 +            Self::Constructor => "󰆧",
 +            Self::Enum => "󰒻",
 +            Self::Interface => "󰜰",
 +            Self::Function => "󰊕",
 +            Self::Variable => "󰀫",
 +            Self::Constant => "󰏿",
 +            Self::String => "󰀬",
 +            Self::Number => "󰎠",
 +            Self::Boolean => "󰨙",
 +            Self::Array => "󰅪",
 +            Self::Object => "󰅩",
 +            Self::Key => "󰌋",
 +            Self::Null => "󰟢",
 +            Self::EnumMember => "󰒻",
 +            Self::Struct => "󰙅",
 +            Self::Event => "󰉁",
 +            Self::Operator => "󰆕",
 +            Self::TypeParameter => "󰊄",
 +        }
 +    }
 +}
++
 +/// A document symbol
 +#[derive(Debug, Clone)]
 +pub struct DocumentSymbol {
 +    pub name: String,
 +    pub kind: SymbolKind,
 +    pub range: Range,
 +    pub selection_range: Range,
 +    pub children: Vec<DocumentSymbol>,
 +}
++
 +/// Hover information
 +#[derive(Debug, Clone)]
 +pub struct HoverInfo {
 +    pub contents: String,
 +    pub range: Option<Range>,
 +}
++
 +/// Server capabilities
 +#[derive(Debug, Clone, Default)]
 +pub struct Capabilities {
 +    pub completion: bool,
 +    pub hover: bool,
 +    pub definition: bool,
 +    pub references: bool,
 +    pub rename: bool,
 +    pub code_actions: bool,
 +    pub formatting: bool,
 +    pub diagnostics: bool,
 +    pub document_symbols: bool,
 +    pub workspace_symbols: bool,
 +    pub signature_help: bool,
 +}
++
 +impl Capabilities {
 +    pub fn all() -> Self {
 +        Self {
 +            completion: true,
 +            hover: true,
 +            definition: true,
 +            references: true,
 +            rename: true,
 +            code_actions: true,
 +            formatting: true,
 +            diagnostics: true,
 +            document_symbols: true,
 +            workspace_symbols: true,
 +            signature_help: true,
 +        }
 +    }
 +}
++
 +/// Configuration for an LSP server
 +#[derive(Debug, Clone)]
 +pub struct ServerConfig {
 +    pub name: String,
 +    pub language: String,
 +    pub command: Vec<String>,
 +    pub file_patterns: Vec<String>,
 +    pub capabilities: Capabilities,
 +}
++
 +impl ServerConfig {
 +    pub fn new(name: &str, language: &str, command: Vec<&str>) -> Self {
 +        Self {
 +            name: name.to_string(),
 +            language: language.to_string(),
 +            command: command.into_iter().map(String::from).collect(),
 +            file_patterns: Vec::new(),
 +            capabilities: Capabilities::all(),
 +        }
 +    }
++
 +    pub fn with_patterns(mut self, patterns: Vec<&str>) -> Self {
 +        self.file_patterns = patterns.into_iter().map(String::from).collect();
 +        self
 +    }
++
 +    pub fn with_capabilities(mut self, caps: Capabilities) -> Self {
 +        self.capabilities = caps;
 +        self
 +    }
 +}
++
 +/// Language ID detection from file extension
 +pub fn detect_language(path: &str) -> Option<&'static str> {
 +    let ext = path.rsplit('.').next()?;
 +    match ext.to_lowercase().as_str() {
 +        "rs" => Some("rust"),
 +        "py" | "pyw" => Some("python"),
 +        "js" | "mjs" | "cjs" => Some("javascript"),
 +        "ts" | "mts" | "cts" => Some("typescript"),
 +        "tsx" => Some("typescriptreact"),
 +        "jsx" => Some("javascriptreact"),
 +        "c" | "h" => Some("c"),
 +        "cpp" | "cc" | "cxx" | "hpp" | "hxx" | "hh" => Some("cpp"),
 +        "go" => Some("go"),
 +        "java" => Some("java"),
 +        "kt" | "kts" => Some("kotlin"),
 +        "swift" => Some("swift"),
 +        "rb" | "erb" => Some("ruby"),
 +        "php" => Some("php"),
 +        "cs" => Some("csharp"),
 +        "fs" | "fsi" | "fsx" => Some("fsharp"),
 +        "scala" | "sc" => Some("scala"),
 +        "hs" | "lhs" => Some("haskell"),
 +        "lua" => Some("lua"),
 +        "pl" | "pm" => Some("perl"),
 +        "r" | "R" => Some("r"),
 +        "jl" => Some("julia"),
 +        "ex" | "exs" => Some("elixir"),
 +        "erl" | "hrl" => Some("erlang"),
 +        "clj" | "cljs" | "cljc" => Some("clojure"),
 +        "f90" | "f95" | "f03" | "f08" | "for" | "ftn" => Some("fortran"),
 +        "zig" => Some("zig"),
 +        "nim" => Some("nim"),
 +        "odin" => Some("odin"),
 +        "v" => Some("v"),
 +        "d" => Some("d"),
 +        "sh" | "bash" => Some("shellscript"),
 +        "zsh" => Some("shellscript"),
 +        "fish" => Some("fish"),
 +        "ps1" | "psm1" => Some("powershell"),
 +        "sql" => Some("sql"),
 +        "html" | "htm" => Some("html"),
 +        "css" => Some("css"),
 +        "scss" => Some("scss"),
 +        "less" => Some("less"),
 +        "json" => Some("json"),
 +        "jsonc" => Some("jsonc"),
 +        "yaml" | "yml" => Some("yaml"),
 +        "toml" => Some("toml"),
 +        "xml" => Some("xml"),
 +        "md" | "markdown" => Some("markdown"),
 +        "dockerfile" => Some("dockerfile"),
 +        "tf" | "tfvars" => Some("terraform"),
 +        "nix" => Some("nix"),
 +        "ml" | "mli" => Some("ocaml"),
 +        "dart" => Some("dart"),
 +        "groovy" | "gradle" => Some("groovy"),
 +        "vue" => Some("vue"),
 +        "svelte" => Some("svelte"),
 +        "elm" => Some("elm"),
 +        "asm" | "s" => Some("asm"),
 +        "cmake" => Some("cmake"),
 +        "proto" => Some("proto"),
 +        "graphql" | "gql" => Some("graphql"),
 +        _ => None,
 +    }
 +}
++
 +/// Convert file path to LSP URI
 +pub fn path_to_uri(path: &str) -> String {
 +    if path.starts_with('/') {
 +        format!("file://{}", path)
 +    } else {
 +        format!("file:///{}", path)
 +    }
 +}
++
 +/// Convert LSP URI to file path
 +pub fn uri_to_path(uri: &str) -> Option<String> {
 +    if uri.starts_with("file://") {
 +        Some(uri[7..].to_string())
 +    } else {
 +        None
 +    }
 +}