grepapp_haystack 1.16.34

Grep.app integration for searching code across GitHub repositories
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

use serde::{Deserialize, Serialize};

/// Response from grep.app search API
#[derive(Debug, Deserialize, Serialize)]
pub struct SearchResponse {
    /// Aggregated statistics for the search results
    pub facets: Option<Facets>,
    /// Array of search result hits
    pub hits: Hits,
}

/// Search result hits container
#[derive(Debug, Deserialize, Serialize)]
pub struct Hits {
    /// Array of individual search results
    #[serde(default)]
    pub hits: Vec<Hit>,
}

/// Aggregated statistics
#[derive(Debug, Deserialize, Serialize)]
pub struct Facets {
    /// Language breakdown
    pub lang: Option<FacetBucket>,
    /// Repository breakdown
    pub repo: Option<FacetBucket>,
}

/// Facet bucket containing counts
#[derive(Debug, Deserialize, Serialize)]
pub struct FacetBucket {
    /// Array of buckets with counts
    pub buckets: Vec<Bucket>,
}

/// Individual bucket with key and count
#[derive(Debug, Deserialize, Serialize)]
pub struct Bucket {
    /// Bucket key (e.g., language name or repo name)
    pub key: String,
    /// Number of results in this bucket
    #[serde(rename = "doc_count")]
    pub doc_count: u64,
}

/// Individual search result hit
#[derive(Debug, Deserialize, Serialize)]
pub struct Hit {
    /// Source data containing the actual result details
    #[serde(rename = "_source")]
    pub source: HitSource,
}

/// Source data for a search hit
#[derive(Debug, Deserialize, Serialize)]
pub struct HitSource {
    /// Repository information
    pub repo: RepoField,
    /// File path information
    pub path: PathField,
    /// Branch information
    pub branch: BranchField,
    /// Content snippet with matches
    pub content: ContentField,
}

/// Repository field
#[derive(Debug, Deserialize, Serialize)]
pub struct RepoField {
    /// Raw repository name (e.g., "owner/repo")
    pub raw: String,
}

/// Path field
#[derive(Debug, Deserialize, Serialize)]
pub struct PathField {
    /// Raw file path
    pub raw: String,
}

/// Branch field
#[derive(Debug, Deserialize, Serialize)]
pub struct BranchField {
    /// Raw branch name
    pub raw: String,
}

/// Content field with snippet
#[derive(Debug, Deserialize, Serialize)]
pub struct ContentField {
    /// HTML-formatted code snippet with highlighted matches
    pub snippet: String,
}

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

    #[test]
    fn test_deserialize_search_response() {
        let json = r#"{
            "facets": {
                "lang": {
                    "buckets": [
                        {"key": "Rust", "doc_count": 42}
                    ]
                },
                "repo": {
                    "buckets": [
                        {"key": "terraphim/terraphim-ai", "doc_count": 10}
                    ]
                }
            },
            "hits": {
                "hits": [
                    {
                        "_source": {
                            "repo": {"raw": "terraphim/terraphim-ai"},
                            "path": {"raw": "src/main.rs"},
                            "branch": {"raw": "main"},
                            "content": {"snippet": "async fn <mark>search</mark>()"}
                        }
                    }
                ]
            }
        }"#;

        let response: SearchResponse = serde_json::from_str(json).unwrap();
        assert_eq!(response.hits.hits.len(), 1);
        assert_eq!(
            response.hits.hits[0].source.repo.raw,
            "terraphim/terraphim-ai"
        );

        let facets = response.facets.unwrap();
        assert!(facets.lang.is_some());
        assert_eq!(facets.lang.unwrap().buckets[0].key, "Rust");
    }
}