Function get_lsp_diagnostics_impl

crates/opencode-tool/src/write.rs:242–362

(
    path: &Path,
    lsp_registry: Arc<opencode_lsp::LspClientRegistry>,
)

#[cfg(feature = "lsp")]
async fn get_lsp_diagnostics_impl(
    path: &Path,
    lsp_registry: Arc<opencode_lsp::LspClientRegistry>,
) -> String {
    use opencode_lsp::detect_language;
    use std::collections::HashMap;

    let language = detect_language(path);
    let clients = lsp_registry.list().await;

    let client = clients
        .iter()
        .find(|(id, _)| id.contains(language))
        .map(|(_, c)| c.clone());

    let Some(client) = client else {
        return String::new();
    };

    // Open/refresh the written file so the LSP re-publishes diagnostics
    if let Ok(content) = tokio::fs::read_to_string(path).await {
        let _ = client.open_document(path, &content, language).await;
    }

    tokio::time::sleep(std::time::Duration::from_millis(100)).await;

    // Collect all diagnostics from all files the LSP knows about
    let all_diagnostics = client.get_all_diagnostics().await;

    let normalized_path = path.canonicalize().unwrap_or_else(|_| path.to_path_buf());
    let mut output = String::new();
    let mut project_diagnostics_count = 0;

    // First pass: the written file itself
    for (file, diagnostics) in &all_diagnostics {
        let file_canonical = file.canonicalize().unwrap_or_else(|_| file.clone());
        if file_canonical != normalized_path {
            continue;
        }

        let errors: Vec<_> = diagnostics
            .iter()
            .filter(|d| d.severity == Some(lsp_types::DiagnosticSeverity::ERROR))
            .collect();

        if errors.is_empty() {
            continue;
        }

        let total = errors.len();
        let limited: Vec<_> = errors.into_iter().take(MAX_DIAGNOSTICS_PER_FILE).collect();
        let suffix = if limited.len() < total {
            format!("\n... and {} more", total - limited.len())
        } else {
            String::new()
        };

        let lines: Vec<String> = limited