cosh-tools 0.1.1

Tools crate for cosh - coding agent for the terminal
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

//! `lsp_diagnostics` engine: ensure servers, settle, snapshot and render.

use std::time::Duration;

use super::{support::Deps, types::DiagnosticsInput, types::DiagnosticsOutput};
use cosh_sdk::lsp::SeverityFilter;

/// Resolve the severity filter from the model-facing string.
fn parse_severity(input: &DiagnosticsInput) -> Result<SeverityFilter, String> {
    match input.severity.as_deref() {
        None | Some("all") => Ok(SeverityFilter::All),
        Some("errors") => Ok(SeverityFilter::ErrorsOnly),
        Some("warnings") => Ok(SeverityFilter::WarningAndUp),
        Some(other) => Err(format!(
            "invalid severity `{other}`: expected \"errors\", \"warnings\" or \"all\""
        )),
    }
}

/// Ensure the file's servers are up, wait for diagnostics to settle, then
/// render. With `file_path` omitted this reports a workspace-wide snapshot of
/// current state — nothing is opened or waited on.
pub async fn run_diagnostics(
    deps: &Deps<'_>,
    input: &DiagnosticsInput,
) -> Result<DiagnosticsOutput, String> {
    let filter = parse_severity(input)?;
    let max_items = usize::try_from(input.max_items.unwrap_or(50).max(1)).unwrap_or(50);
    let cap = Duration::from_millis(u64::from(input.settle_ms.unwrap_or(5_000)));

    let diags = match &input.file_path {
        Some(file_path) => {
            let path = deps.manager.root().join(file_path);
            super::support::prepare(deps, &path).await?;
            let settled = deps.diagnostics.wait_for_settle(cap).await;
            return Ok(finish(deps.diagnostics, &path, filter, max_items, settled));
        }
        None => deps
            .diagnostics
            .snapshot_all(Some(deps.manager.root()))
            .into_iter()
            .flat_map(|(_, per_file)| per_file)
            .collect::<Vec<_>>(),
    };

    // Workspace-wide: report current knowledge; no churn was triggered, so
    // the snapshot is as fresh as the push stream allows.
    let formatted = cosh_sdk::lsp::format_for_model(&diags, filter, max_items);
    Ok(DiagnosticsOutput {
        count: formatted.lines().count(),
        formatted,
        settled: true,
    })
}

fn finish(
    engine: &crate::lsp::DiagnosticsEngine,
    path: &std::path::Path,
    filter: SeverityFilter,
    max_items: usize,
    settled: bool,
) -> DiagnosticsOutput {
    let snapshot = engine.snapshot_for(path);
    let formatted = cosh_sdk::lsp::format_for_model(&snapshot, filter, max_items);
    DiagnosticsOutput {
        count: formatted.lines().count(),
        formatted,
        settled,
    }
}