sniff-cli 0.1.2

An exhaustive LLM-backed slop finder for codebases
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

fn string_from_array(items: &[serde_json::Value]) -> Option<String> {
    let parts: Vec<String> = items
        .iter()
        .filter_map(string_from_value)
        .filter(|part| !part.is_empty())
        .collect();
    if parts.is_empty() {
        None
    } else {
        Some(parts.join(""))
    }
}

fn string_from_object(map: &serde_json::Map<String, serde_json::Value>) -> Option<String> {
    ["text", "content", "value", "output"]
        .iter()
        .find_map(|key| {
            map.get(*key)
                .and_then(string_from_value)
                .filter(|part| !part.is_empty())
        })
}

fn string_from_value(value: &serde_json::Value) -> Option<String> {
    match value {
        serde_json::Value::String(s) => Some(s.clone()),
        serde_json::Value::Array(items) => string_from_array(items),
        serde_json::Value::Object(map) => string_from_object(map),
        _ => None,
    }
}

pub(super) fn openai_content(data: &serde_json::Value) -> String {
    let candidates = [
        "/choices/0/message/content",
        "/choices/0/text",
        "/choices/0/message/output",
        "/output_text",
        "/content",
        "/message/content",
    ];

    for candidate in candidates {
        if let Some(value) = data.pointer(candidate)
            && let Some(text) = string_from_value(value)
            && !text.trim().is_empty()
        {
            return text;
        }
    }

    String::new()
}

pub(super) fn anthropic_content(data: &serde_json::Value) -> String {
    let candidates = ["/content", "/choices/0/message/content", "/output_text"];

    for candidate in candidates {
        if let Some(value) = data.pointer(candidate)
            && let Some(text) = string_from_value(value)
            && !text.trim().is_empty()
        {
            return text;
        }
    }

    String::new()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn openai_content_handles_string_and_array_shapes() {
        let data = serde_json::json!({
            "choices": [
                {
                    "message": {
                        "content": [
                            { "type": "text", "text": "{\"smelly\":false}" }
                        ]
                    }
                }
            ]
        });

        assert_eq!(openai_content(&data), "{\"smelly\":false}");
    }

    #[test]
    fn anthropic_content_handles_block_arrays() {
        let data = serde_json::json!({
            "content": [
                { "type": "text", "text": "{\"smelly\":false}" }
            ]
        });

        assert_eq!(anthropic_content(&data), "{\"smelly\":false}");
    }

    #[test]
    fn anthropic_content_ignores_thinking_blocks() {
        let data = serde_json::json!({
            "content": [
                {
                    "type": "thinking",
                    "thinking": "I will think out loud here."
                },
                {
                    "type": "text",
                    "text": "{\"smelly\":false,\"tier\":\"clean\",\"evidence\":\"\",\"reason\":\"clean\"}"
                }
            ]
        });

        assert_eq!(
            anthropic_content(&data),
            "{\"smelly\":false,\"tier\":\"clean\",\"evidence\":\"\",\"reason\":\"clean\"}"
        );
    }
}