sqry-cli 6.0.18

CLI for sqry - semantic code search
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

mod common;

use assert_cmd::Command;
use common::sqry_bin;
use std::fs;
use tempfile::tempdir;

fn sqry_cmd() -> Command {
    let path = sqry_bin();
    let mut cmd = Command::new(path);
    cmd.env("NO_COLOR", "1");
    cmd
}

/// Build a temp workspace with a Rust file containing a function and a struct,
/// index it, and return the temp dir (kept alive by the caller).
fn build_indexed_workspace() -> tempfile::TempDir {
    let dir = tempdir().unwrap();
    let src = dir.path().join("lib.rs");
    fs::write(
        &src,
        "pub fn target_function() {}\npub struct TargetStruct {}\n",
    )
    .unwrap();

    sqry_cmd().arg("index").arg(dir.path()).assert().success();

    dir
}

/// Parse NDJSON output into a vec of serde_json::Value.
fn parse_ndjson(output: &str) -> Vec<serde_json::Value> {
    output
        .lines()
        .filter(|l| !l.is_empty())
        .map(|l| serde_json::from_str(l).expect("valid JSON line"))
        .collect()
}

fn partial_results(events: &[serde_json::Value]) -> Vec<&serde_json::Value> {
    events
        .iter()
        .filter(|e| e["event"].as_str() == Some("partial_result"))
        .collect()
}

fn final_summaries(events: &[serde_json::Value]) -> Vec<&serde_json::Value> {
    events
        .iter()
        .filter(|e| e["event"].as_str() == Some("final_summary"))
        .collect()
}

#[test]
fn json_stream_respects_kind_filter() {
    let dir = build_indexed_workspace();

    let output = sqry_cmd()
        .args([
            "--fuzzy",
            "--json-stream",
            "--kind",
            "function",
            "search",
            "target",
        ])
        .arg(dir.path())
        .output()
        .expect("command runs");

    assert!(output.status.success(), "exit code should be 0");

    let events = parse_ndjson(&String::from_utf8_lossy(&output.stdout));
    let results = partial_results(&events);
    let summaries = final_summaries(&events);

    assert!(!results.is_empty(), "should have partial results");
    assert_eq!(summaries.len(), 1, "should have exactly one summary");

    // All partial results should be functions (kind filter applied)
    for event in &results {
        let kind = event["result"]["kind"].as_str().unwrap_or("");
        assert_eq!(
            kind.to_lowercase(),
            "function",
            "all results should be functions, got: {kind}"
        );
    }

    // Scores should be real values (not 0.0 placeholder)
    for event in &results {
        let score = event["score"].as_f64().unwrap_or(0.0);
        assert!(score > 0.0, "score should be > 0.0, got: {score}");
    }
}

#[test]
fn json_stream_respects_lang_filter() {
    let dir = build_indexed_workspace();

    // Search with --lang rust should return results (workspace is Rust)
    let output = sqry_cmd()
        .args([
            "--fuzzy",
            "--json-stream",
            "--lang",
            "rust",
            "search",
            "target",
        ])
        .arg(dir.path())
        .output()
        .expect("command runs");

    assert!(output.status.success());

    let events = parse_ndjson(&String::from_utf8_lossy(&output.stdout));
    let results = partial_results(&events);

    assert!(
        !results.is_empty(),
        "should find Rust symbols with --lang rust"
    );

    // Search with --lang python should return zero partial results
    let output = sqry_cmd()
        .args([
            "--fuzzy",
            "--json-stream",
            "--lang",
            "python",
            "search",
            "target",
        ])
        .arg(dir.path())
        .output()
        .expect("command runs");

    assert!(output.status.success());

    let events = parse_ndjson(&String::from_utf8_lossy(&output.stdout));
    let results = partial_results(&events);

    assert!(
        results.is_empty(),
        "should find no Python symbols in a Rust-only workspace"
    );
}