Function execute_with_lsp

crates/opencode-tool/src/lsp_tool.rs:147–349

(
    params: &LspParams,
    path: &PathBuf,
    line: u32,
    character: u32,
    ctx: &ToolContext,
)

#[cfg(feature = "lsp")]
async fn execute_with_lsp(
    params: &LspParams,
    path: &PathBuf,
    line: u32,
    character: u32,
    ctx: &ToolContext,
) -> Result<ToolResult, ToolError> {
    use opencode_lsp::{detect_language, LspClientRegistry};
    use std::sync::Arc;

    let lsp_registry: Option<Arc<LspClientRegistry>> = ctx.lsp_registry.clone();

    let output = match &lsp_registry {
        Some(registry) => {
            // Check if any LSP client can handle this file type (mirrors TS LSP.hasClients)
            if !registry.has_clients(path).await {
                return Err(ToolError::ExecutionError(
                    "No LSP server available for this file type.".to_string(),
                ));
            }

            // Touch the file to open/refresh it in all matching LSP clients,
            // waiting for diagnostics (mirrors TS LSP.touchFile(file, true))
            registry.touch_file(path, true).await.map_err(|e| {
                ToolError::ExecutionError(format!("Failed to touch file in LSP: {}", e))
            })?;

            let language = detect_language(path);
            let clients = registry.list().await;
            let client = clients
                .iter()
                .find(|(id, _)| id.contains(language))
                .map(|(_, c)| c.clone());

            match client {
                Some(client) => match &params.operation {
                    LspOperation::GoToDefinition => {
                        match client.goto_definition(path, line, character).await {
                            Ok(Some(loc)) => format_location_result("Definition", loc),
                            Ok(None) => "No definition found.".to_string(),
                            Err(e) => format!("LSP error: {}", e),
                        }
                    }
                    LspOperation::FindReferences => {
                        match client.references(path, line, character).await {
                            Ok(locs) if !locs.is_empty() => locs
                                .iter()
                                .map(|l| format_location(l))
                                .collect::<Vec<_>>()
                                .join("\n"),
                            Ok(_) => "No references found.".to_string(),
                            Err(e) => format!("LSP error: {}", e),
                        }
                    }
                    LspOperation::Hover => match client.hover(path, line, character).await {
                        Ok(Some(hover)) => format_hover_result(hover),
                        Ok(None) => "No hover information available.".to_string(),
                        Err(e) => format!("LSP error: {}", e),