goosedump 0.4.2

Coding agent context data browser
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

// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) Jarkko Sakkinen 2026

use crate::message::{ConversationMessage, MessageKind, SearchHit, TaggedListing};
use serde_json::{Map, Value, json};

/// Render a value as pretty JSON for stdout.
#[must_use]
pub fn to_string(value: &Value) -> String {
    serde_json::to_string_pretty(value).expect("serialize json value")
}

#[must_use]
pub fn listings(contexts: &[TaggedListing]) -> Value {
    let sessions: Vec<Value> = contexts
        .iter()
        .map(|t| {
            json!({
                "provider": t.provider,
                "id": t.listing.id,
                "tag": format!("{}:{}", t.provider, t.listing.id),
                "detail": t.listing.detail,
                "path": t.listing.path.as_ref().map(|p| p.display().to_string()),
            })
        })
        .collect();
    json!({ "sessions": sessions })
}

#[must_use]
pub fn messages(msgs: &[ConversationMessage]) -> Value {
    let messages: Vec<Value> = msgs.iter().map(message).collect();
    json!({ "messages": messages })
}

fn message(msg: &ConversationMessage) -> Value {
    let mut obj = Map::new();
    obj.insert("entryId".into(), json!(msg.entry_id));
    match &msg.kind {
        MessageKind::TextContent(tc) => {
            obj.insert("kind".into(), json!("text"));
            obj.insert("role".into(), json!(tc.role));
            obj.insert("text".into(), json!(tc.text));
        }
        MessageKind::AssistantResponse(ar) => {
            let calls: Vec<Value> = ar
                .tool_calls
                .iter()
                .map(|tc| json!({ "name": tc.name, "arguments": tc.arguments }))
                .collect();
            obj.insert("kind".into(), json!("assistant"));
            obj.insert("thinking".into(), json!(ar.thinking));
            obj.insert("text".into(), json!(ar.text));
            obj.insert("toolCalls".into(), json!(calls));
        }
        MessageKind::ToolResultData(tr) => {
            obj.insert("kind".into(), json!("toolResult"));
            obj.insert("toolName".into(), json!(tr.tool_name));
            obj.insert("content".into(), json!(tr.content));
            obj.insert("isError".into(), json!(tr.is_error));
        }
        MessageKind::BashOutput(bo) => {
            obj.insert("kind".into(), json!("bash"));
            obj.insert("command".into(), json!(bo.command));
            obj.insert("output".into(), json!(bo.output));
        }
    }
    Value::Object(obj)
}

#[must_use]
pub fn hits(hits: &[SearchHit]) -> Value {
    let hits: Vec<Value> = hits
        .iter()
        .map(|h| {
            json!({
                "entryId": h.entry_id,
                "score": h.score,
                "role": h.role,
                "text": h.text,
                "files": h.files,
                "terms": h.terms,
            })
        })
        .collect();
    json!(hits)
}