codescout 0.15.0

High-performance coding agent toolkit MCP server
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

use codescout::retrieval::config::RetrievalConfig;

#[test]
fn config_from_env_uses_defaults_when_unset() {
    // Use temp_env::with_vars_unset to isolate this test's env-var assumptions
    // from concurrent tests in other binaries. #[serial_test::serial] only
    // serializes within a single test binary's parallel scheduler, so it does
    // not prevent cross-binary CODESCOUT_* writes that occur during a full
    // `cargo test` run (BUG: 2026-05-24-ci-retrieval-env-test-cross-binary-flake).
    temp_env::with_vars_unset(
        [
            "CODESCOUT_QDRANT_URL",
            "CODESCOUT_EMBEDDER_URL",
            "CODESCOUT_SPARSE_EMBEDDER_URL",
            "CODESCOUT_RERANKER_URL",
            "CODESCOUT_MODEL_DIM",
            "CODESCOUT_RETRIEVAL_PROFILE",
        ],
        || {
            let cfg = RetrievalConfig::from_env().expect("defaults");
            assert_eq!(cfg.qdrant_url, "http://127.0.0.1:6334");
            assert_eq!(cfg.embedder_url, "http://127.0.0.1:8081");
            assert_eq!(cfg.sparse_embedder_url, "http://127.0.0.1:8084");
            assert_eq!(cfg.reranker_url, "http://127.0.0.1:8083");
            assert_eq!(cfg.model_dim, 768);
            assert_eq!(cfg.profile, "cpu");
        },
    );
}

#[test]
fn config_from_env_reads_overrides() {
    // See config_from_env_uses_defaults_when_unset above for the cross-binary
    // serial_test inadequacy rationale.
    temp_env::with_vars(
        [
            ("CODESCOUT_QDRANT_URL", Some("http://qd:1")),
            ("CODESCOUT_EMBEDDER_URL", Some("http://eb:2")),
            ("CODESCOUT_SPARSE_EMBEDDER_URL", Some("http://eb-sparse:5")),
            ("CODESCOUT_RERANKER_URL", Some("http://rr:3")),
            ("CODESCOUT_MODEL_DIM", Some("4096")),
            ("CODESCOUT_RETRIEVAL_PROFILE", Some("gpu")),
        ],
        || {
            let cfg = RetrievalConfig::from_env().expect("overrides");
            assert_eq!(cfg.qdrant_url, "http://qd:1");
            assert_eq!(cfg.sparse_embedder_url, "http://eb-sparse:5");
            assert_eq!(cfg.model_dim, 4096);
            assert_eq!(cfg.profile, "gpu");
        },
    );
}

#[cfg(feature = "server-stack")]
#[test]

fn client_from_env_constructs_when_urls_present() {
    std::env::set_var("CODESCOUT_QDRANT_URL", "http://127.0.0.1:6334");
    std::env::set_var("CODESCOUT_EMBEDDER_URL", "http://127.0.0.1:8081");
    std::env::set_var("CODESCOUT_SPARSE_EMBEDDER_URL", "http://127.0.0.1:8084");
    std::env::set_var("CODESCOUT_RERANKER_URL", "http://127.0.0.1:8083");
    let cfg = codescout::retrieval::config::RetrievalConfig::from_env().unwrap();
    let _ = codescout::retrieval::client::RetrievalClient::from_config_only(cfg);
    // doesn't connect — just constructs
    for k in [
        "CODESCOUT_QDRANT_URL",
        "CODESCOUT_EMBEDDER_URL",
        "CODESCOUT_SPARSE_EMBEDDER_URL",
        "CODESCOUT_RERANKER_URL",
    ] {
        std::env::remove_var(k);
    }
}

use codescout::retrieval::drift::{diff_chunks, ChunkRef};

fn cr(id: &str, hash: &str) -> ChunkRef {
    ChunkRef {
        chunk_id: id.into(),
        content_hash: hash.into(),
    }
}

#[test]
fn diff_identical_yields_noop() {
    let server = vec![cr("a", "h1"), cr("b", "h2")];
    let local = vec![cr("a", "h1"), cr("b", "h2")];
    let d = diff_chunks(&server, &local);
    assert!(d.to_upsert.is_empty());
    assert!(d.to_delete.is_empty());
}

#[test]
fn diff_added_chunk_yields_upsert() {
    let server = vec![cr("a", "h1")];
    let local = vec![cr("a", "h1"), cr("b", "h2")];
    let d = diff_chunks(&server, &local);
    assert_eq!(d.to_upsert, vec!["b".to_string()]);
    assert!(d.to_delete.is_empty());
}

#[test]
fn diff_deleted_chunk_yields_delete() {
    let server = vec![cr("a", "h1"), cr("b", "h2")];
    let local = vec![cr("a", "h1")];
    let d = diff_chunks(&server, &local);
    assert!(d.to_upsert.is_empty());
    assert_eq!(d.to_delete, vec!["b".to_string()]);
}

#[test]
fn diff_modified_chunk_yields_upsert_for_new_id() {
    let server = vec![cr("a-old", "h1")];
    let local = vec![cr("a-new", "h2")];
    let d = diff_chunks(&server, &local);
    assert_eq!(d.to_upsert, vec!["a-new".to_string()]);
    assert_eq!(d.to_delete, vec!["a-old".to_string()]);
}

#[cfg(feature = "server-stack")]
use codescout::retrieval::payload::{map_to_payload, payload_to_map, CodePayload};

#[cfg(feature = "server-stack")]
#[test]
fn payload_roundtrip_preserves_fields() {
    let p = CodePayload {
        project_id: "codescout".into(),
        file_path: "src/lib.rs".into(),
        language: "rust".into(),
        start_line: 10,
        end_line: 42,
        ast_kind: "fn".into(),
        ast_header: "fn main()".into(),
        content: "fn main() {}".into(),
        content_hash: "h1".into(),
        last_indexed_commit: "abc".into(),
        chunk_id: "id1".into(),
    };
    let map = payload_to_map(&p);
    let back = map_to_payload(&map).expect("decode");
    assert_eq!(back.project_id, p.project_id);
    assert_eq!(back.start_line, p.start_line);
    assert_eq!(back.content_hash, p.content_hash);
    assert_eq!(back.file_path, p.file_path);
}