roteiro 1.11.0

Roteiro: a provenance-tagged knowledge graph for your codebase — structure, intent, and context in one queryable store
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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255

//! End-to-end tests for `roteiro model` and `infer --model` that need no
//! network: the registry listing, and that a non-interactive `pull` declines
//! rather than downloading (offline-by-default). The `model` subcommand only
//! needs the `models` feature (no llama.cpp engine), so the list/pull tests
//! build under it; the `infer --model` test is gated on
//! `inference-local-models` since that command only exists with the engine.
#![cfg(feature = "models")]

use std::path::Path;
use std::process::{Command, Stdio};

const BIN: &str = env!("CARGO_BIN_EXE_roteiro");

/// Run roteiro with an isolated model store (`ROTEIRO_HOME`) and piped (non-tty)
/// stdin, so `pull` sees a non-interactive session.
fn roteiro(home: &Path, args: &[&str]) -> std::process::Output {
    Command::new(BIN)
        .args(args)
        .env("ROTEIRO_HOME", home)
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .and_then(std::process::Child::wait_with_output)
        .expect("run roteiro")
}

fn fresh_home(name: &str) -> std::path::PathBuf {
    let dir = std::env::temp_dir().join(format!("roteiro-model-{}-{name}", std::process::id()));
    std::fs::remove_dir_all(&dir).ok();
    std::fs::create_dir_all(&dir).expect("mkdir");
    dir
}

#[test]
fn model_list_shows_registry() {
    let home = fresh_home("list");
    let out = roteiro(&home, &["model", "list"]);
    assert!(out.status.success(), "model list failed: {out:?}");
    let text = String::from_utf8_lossy(&out.stdout);
    assert!(
        text.contains("bge-base-en-v1.5"),
        "registry model listed: {text}"
    );
    assert!(
        text.contains("hashing embedder"),
        "notes the always-available default"
    );
    assert!(
        text.contains("available"),
        "uninstalled model marked available"
    );
    // The status marker is the ASCII-safe, fixed-width form so columns align
    // (no wide/ambiguous glyph); a fresh host has nothing installed.
    assert!(
        text.contains("[available]"),
        "uninstalled model uses the ASCII marker: {text}"
    );
    // The new High-tier coder pick is listed.
    assert!(
        text.contains("qwen3-coder-30b-a3b"),
        "new coder entry listed: {text}"
    );
    std::fs::remove_dir_all(&home).ok();
}

#[test]
fn pull_is_declined_non_interactively_and_downloads_nothing() {
    let home = fresh_home("pull");
    let out = roteiro(&home, &["model", "pull", "bge-base-en-v1.5"]);
    // Non-interactive with no `--yes`: must refuse and exit non-zero.
    assert!(!out.status.success(), "pull must decline non-interactively");
    let err = String::from_utf8_lossy(&out.stderr);
    assert!(err.contains("non-interactive"), "explains why: {err}");
    assert!(err.contains("--yes"), "points at the override: {err}");
    // Nothing was written to the store.
    let model_dir = home.join("models/bge-base-en-v1.5");
    assert!(
        !model_dir.join("model.safetensors").exists(),
        "no weights should be downloaded",
    );
    std::fs::remove_dir_all(&home).ok();
}

#[test]
fn pull_rejects_unknown_model() {
    let home = fresh_home("unknown");
    let out = roteiro(&home, &["model", "pull", "no-such-model", "--yes"]);
    assert!(!out.status.success(), "unknown model must fail");
    let err = String::from_utf8_lossy(&out.stderr);
    assert!(err.contains("unknown model"), "clear error: {err}");
    std::fs::remove_dir_all(&home).ok();
}

#[test]
fn rm_refuses_politely_when_not_installed() {
    let home = fresh_home("rm-absent");
    let out = roteiro(&home, &["model", "rm", "qwen3-8b", "--yes"]);
    // Non-zero and explanatory — never a panic, and never a cheerful zero-byte
    // "success" for a model that was never there.
    assert!(!out.status.success(), "must exit non-zero: {out:?}");
    let err = String::from_utf8_lossy(&out.stderr);
    assert!(err.contains("not installed"), "says what is wrong: {err}");
    assert!(
        err.contains("model pull qwen3-8b"),
        "points at the fix: {err}"
    );
    assert!(!err.contains("panicked"), "no panic: {err}");
    std::fs::remove_dir_all(&home).ok();
}

#[test]
fn rm_rejects_unknown_model() {
    let home = fresh_home("rm-unknown");
    let out = roteiro(&home, &["model", "rm", "no-such-model", "--yes"]);
    assert!(!out.status.success(), "unknown model must fail");
    let err = String::from_utf8_lossy(&out.stderr);
    // An unknown name and an uninstalled model are different mistakes.
    assert!(err.contains("unknown model"), "clear error: {err}");
    std::fs::remove_dir_all(&home).ok();
}

#[test]
fn rm_clears_an_empty_directory_left_by_an_abandoned_pull() {
    let home = fresh_home("rm-empty");
    // Exactly what a pull that died before writing its first byte leaves behind:
    // the directory exists but holds nothing. Removal must still clear it —
    // "installed" is about the directory being there, not about it having bytes,
    // and this is the debris the command exists to clean up.
    let dir = home.join("models/qwen3-0.6b");
    std::fs::create_dir_all(&dir).expect("mkdir");

    let out = roteiro(&home, &["model", "rm", "qwen3-0.6b", "--yes", "--json"]);
    assert!(out.status.success(), "empty dir must be removable: {out:?}");
    let report: serde_json::Value =
        serde_json::from_slice(&out.stdout).expect("json report on stdout");
    assert_eq!(report["freed_bytes"], 0, "nothing to free, but it is gone");
    assert_eq!(report["freed"], "0 B");
    assert!(
        report["files"].as_array().expect("files").is_empty(),
        "no files to list: {report}"
    );
    assert!(!dir.exists(), "the empty directory is gone");
    std::fs::remove_dir_all(&home).ok();
}

#[test]
fn rm_frees_the_files_and_reports_what_it_reclaimed() {
    let home = fresh_home("rm-frees");
    let dir = home.join("models/qwen3-0.6b");
    std::fs::create_dir_all(&dir).expect("mkdir");
    std::fs::write(dir.join("model.gguf"), vec![0u8; 3 * 1024 * 1024]).expect("weights");
    // An orphaned partial from an abandoned pull must go with the model.
    std::fs::write(dir.join("model.partial"), vec![0u8; 512 * 1024]).expect("partial");
    std::fs::write(dir.join("model.partial.json"), b"{}").expect("sidecar");

    // `model list` shows what removal would reclaim.
    let listed = roteiro(&home, &["model", "list"]);
    let text = String::from_utf8_lossy(&listed.stdout);
    assert!(
        text.contains("on disk"),
        "list reports installed size: {text}"
    );

    let out = roteiro(&home, &["model", "rm", "qwen3-0.6b", "--yes", "--json"]);
    assert!(out.status.success(), "rm failed: {out:?}");
    let report: serde_json::Value =
        serde_json::from_slice(&out.stdout).expect("json report on stdout");
    assert_eq!(report["model"], "qwen3-0.6b");
    assert_eq!(report["freed_bytes"], 3 * 1024 * 1024 + 512 * 1024 + 2);
    assert_eq!(report["freed"], "3.5 MiB", "human-readable figure too");
    let files: Vec<String> = serde_json::from_value(report["files"].clone()).expect("files listed");
    assert_eq!(
        files,
        vec!["model.gguf", "model.partial", "model.partial.json"],
        "the orphaned partial is cleaned up with the model"
    );
    assert!(!dir.exists(), "the model directory is gone");
    std::fs::remove_dir_all(&home).ok();
}

#[test]
fn rm_declines_non_interactively_without_yes() {
    let home = fresh_home("rm-consent");
    let dir = home.join("models/qwen3-0.6b");
    std::fs::create_dir_all(&dir).expect("mkdir");
    std::fs::write(dir.join("model.gguf"), vec![0u8; 4096]).expect("weights");

    let out = roteiro(&home, &["model", "rm", "qwen3-0.6b"]);
    assert!(!out.status.success(), "must not remove without consent");
    let err = String::from_utf8_lossy(&out.stderr);
    assert!(err.contains("--yes"), "points at the override: {err}");
    assert!(
        dir.join("model.gguf").exists(),
        "the model must still be there"
    );
    std::fs::remove_dir_all(&home).ok();
}

#[test]
fn rm_help_is_honest_about_not_detecting_a_running_serve() {
    let home = fresh_home("rm-help");
    let out = roteiro(&home, &["model", "rm", "--help"]);
    assert!(out.status.success());
    let text = String::from_utf8_lossy(&out.stdout);
    // Roteiro keeps no lock or pid file over the model store, so it genuinely
    // cannot tell. The help must say so rather than imply a check happens.
    assert!(
        text.contains("cannot tell whether a running"),
        "help states the limitation: {text}"
    );
    std::fs::remove_dir_all(&home).ok();
}

#[cfg(feature = "inference-local-models")]
#[test]
fn infer_with_uninstalled_model_errors() {
    // A git repo so `infer` can build a graph, but the model isn't pulled.
    let dir = fresh_home("infer");
    std::fs::write(dir.join("a.rs"), "fn a() {}\n").expect("write");
    for args in [
        &["-c", "user.name=t", "-c", "user.email=t@e", "init", "-q"][..],
        &["-c", "user.name=t", "-c", "user.email=t@e", "add", "."][..],
        &[
            "-c",
            "user.name=t",
            "-c",
            "user.email=t@e",
            "-c",
            "commit.gpgsign=false",
            "commit",
            "-qm",
            "x",
        ][..],
    ] {
        assert!(
            Command::new("git")
                .args(args)
                .current_dir(&dir)
                .status()
                .expect("git")
                .success()
        );
    }
    let out = Command::new(BIN)
        .args(["infer", "--model", "bge-base-en-v1.5"])
        .current_dir(&dir)
        .env("ROTEIRO_HOME", &dir)
        .output()
        .expect("run");
    assert!(!out.status.success(), "uninstalled model must error");
    let err = String::from_utf8_lossy(&out.stderr);
    assert!(err.contains("not installed"), "points at model pull: {err}");
    std::fs::remove_dir_all(&dir).ok();
}