krait-cli 0.1.2

Code intelligence CLI for AI agents
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use std::collections::HashSet;

use crate::commands::find::{ReferenceMatch, SymbolMatch};

/// Merge symbol results from multiple LSP servers, sorted by path:line.
#[must_use]
pub fn merge_symbol_results(results: Vec<Vec<SymbolMatch>>) -> Vec<SymbolMatch> {
    let mut merged: Vec<SymbolMatch> = results.into_iter().flatten().collect();
    merged.sort_by(|a, b| a.path.cmp(&b.path).then(a.line.cmp(&b.line)));

    // Deduplicate by (path, line)
    let mut seen = HashSet::new();
    merged.retain(|m| seen.insert((m.path.clone(), m.line)));
    merged
}

/// Merge reference results from multiple LSP servers, deduplicate by path:line.
#[must_use]
pub fn merge_reference_results(results: Vec<Vec<ReferenceMatch>>) -> Vec<ReferenceMatch> {
    let mut merged: Vec<ReferenceMatch> = results.into_iter().flatten().collect();

    // Deduplicate by (path, line)
    let mut seen = HashSet::new();
    merged.retain(|m| seen.insert((m.path.clone(), m.line)));

    // Sort: definition first, then by file:line
    merged.sort_by(|a, b| {
        b.is_definition
            .cmp(&a.is_definition)
            .then(a.path.cmp(&b.path))
            .then(a.line.cmp(&b.line))
    });
    merged
}

#[cfg(test)]
mod tests {
    use super::*;

    fn sym(path: &str, line: u32, kind: &str) -> SymbolMatch {
        SymbolMatch {
            path: path.to_string(),
            line,
            kind: kind.to_string(),
            preview: String::new(),
            body: None,
        }
    }

    fn refm(path: &str, line: u32, is_def: bool) -> ReferenceMatch {
        ReferenceMatch {
            path: path.to_string(),
            line,
            preview: String::new(),
            is_definition: is_def,
            containing_symbol: None,
        }
    }

    #[test]
    fn merge_symbols_deduplicates() {
        let r1 = vec![sym("src/a.rs", 10, "function")];
        let r2 = vec![sym("src/a.rs", 10, "function"), sym("src/b.ts", 5, "class")];

        let merged = merge_symbol_results(vec![r1, r2]);
        assert_eq!(merged.len(), 2);
        assert_eq!(merged[0].path, "src/a.rs");
        assert_eq!(merged[1].path, "src/b.ts");
    }

    #[test]
    fn merge_symbols_sorted_by_path_line() {
        let r1 = vec![sym("src/z.rs", 1, "function")];
        let r2 = vec![sym("src/a.rs", 1, "function")];

        let merged = merge_symbol_results(vec![r1, r2]);
        assert_eq!(merged[0].path, "src/a.rs");
        assert_eq!(merged[1].path, "src/z.rs");
    }

    #[test]
    fn merge_refs_deduplicates() {
        let r1 = vec![refm("src/a.rs", 10, true)];
        let r2 = vec![refm("src/a.rs", 10, true), refm("src/b.rs", 20, false)];

        let merged = merge_reference_results(vec![r1, r2]);
        assert_eq!(merged.len(), 2);
    }

    #[test]
    fn merge_refs_definition_first() {
        let r1 = vec![refm("src/b.rs", 20, false)];
        let r2 = vec![refm("src/a.rs", 10, true)];

        let merged = merge_reference_results(vec![r1, r2]);
        assert!(merged[0].is_definition);
        assert_eq!(merged[0].path, "src/a.rs");
    }

    #[test]
    fn merge_empty_inputs() {
        assert!(merge_symbol_results(vec![]).is_empty());
        assert!(merge_reference_results(vec![]).is_empty());
    }
}