sparrow-cli 0.4.0

A local-first Rust agent cockpit — route, run, replay, rewind
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

use sparrow::event::{Block, RunId};
use sparrow::tools::builder_tools::LspClient;
use sparrow::tools::{Tool, ToolCtx, known_tool_metadata};

fn ctx(root: &std::path::Path) -> ToolCtx {
    ToolCtx {
        workspace_root: root.to_path_buf(),
        run_id: RunId("lsp-test".into()),
    }
}

fn text(result: sparrow::tools::ToolResult) -> String {
    result
        .content
        .into_iter()
        .map(|block| match block {
            Block::Text(text) => text,
            other => format!("{:?}", other),
        })
        .collect::<Vec<_>>()
        .join("\n")
}

#[tokio::test]
async fn lsp_goto_definition_and_references_are_real() {
    let tmp = tempfile::tempdir().expect("tmp");
    let src = tmp.path().join("src");
    std::fs::create_dir_all(&src).expect("src");
    std::fs::write(
        src.join("lib.rs"),
        "pub fn alpha() -> i32 { 7 }\n\npub fn beta() -> i32 { alpha() }\n",
    )
    .expect("write");

    let tool = LspClient;
    let def = tool
        .call(
            serde_json::json!({
                "action": "goto_definition",
                "file": "src/lib.rs",
                "symbol": "alpha"
            }),
            &ctx(tmp.path()),
        )
        .await
        .expect("definition");
    let def = text(def);
    assert!(def.contains("src/lib.rs:1: pub fn alpha()"));

    let refs = tool
        .call(
            serde_json::json!({
                "action": "find_references",
                "file": "src/lib.rs",
                "symbol": "alpha"
            }),
            &ctx(tmp.path()),
        )
        .await
        .expect("references");
    let refs = text(refs);
    assert!(refs.contains("src/lib.rs:1: pub fn alpha()"));
    assert!(refs.contains("src/lib.rs:3: pub fn beta()"));
}

#[tokio::test]
async fn lsp_hover_returns_context_and_symbol_definition() {
    let tmp = tempfile::tempdir().expect("tmp");
    std::fs::write(
        tmp.path().join("main.py"),
        "def greet(name):\n    return f'hi {name}'\n\nprint(greet('sparrow'))\n",
    )
    .expect("write");

    let out = LspClient
        .call(
            serde_json::json!({
                "action": "hover",
                "file": "main.py",
                "line": 4,
                "column": 8
            }),
            &ctx(tmp.path()),
        )
        .await
        .expect("hover");
    let out = text(out);
    assert!(out.contains("hover main.py:4:8"));
    assert!(out.contains("symbol: greet"));
    assert!(out.contains("main.py:1: def greet(name):"));
}

#[test]
fn lsp_is_advertised_as_debug_readonly_tool() {
    let tools = known_tool_metadata(None);
    let lsp = tools
        .into_iter()
        .find(|tool| tool.name == "lsp")
        .expect("lsp metadata");
    assert_eq!(lsp.toolset, "debug");
    assert!(!lsp.exec);
    assert!(!lsp.mutates_files);
}