git.iko.soy/crush
on main help sign in
add sourcegraph tool
eb9877eKujtim Hoxha
internal/llm/tools/sourcegraph.gonew file+401
compare with main
unifiedsplit
@@ -0,0 +1,401 @@
1+package tools
2+
3+import (
4+ "bytes"
5+ "context"
6+ "encoding/json"
7+ "fmt"
8+ "io"
9+ "net/http"
10+ "strings"
11+ "time"
12+)
13+
14+const (
15+ SourcegraphToolName = "sourcegraph"
16+ sourcegraphToolDescription = `Search code across public repositories using Sourcegraph's GraphQL API.
17+
18+WHEN TO USE THIS TOOL:
19+- Use when you need to find code examples or implementations across public repositories
20+- Helpful for researching how others have solved similar problems
21+- Useful for discovering patterns and best practices in open source code
22+
23+HOW TO USE:
24+- Provide a search query using Sourcegraph's query syntax
25+- Optionally specify the number of results to return (default: 10)
26+- Optionally set a timeout for the request
27+
28+QUERY SYNTAX:
29+- Basic search: "fmt.Println" searches for exact matches
30+- File filters: "file:.go fmt.Println" limits to Go files
31+- Repository filters: "repo:^github\.com/golang/go$ fmt.Println" limits to specific repos
32+- Language filters: "lang:go fmt.Println" limits to Go code
33+- Boolean operators: "fmt.Println AND log.Fatal" for combined terms
34+- Regular expressions: "fmt\.(Print|Printf|Println)" for pattern matching
35+- Quoted strings: "\"exact phrase\"" for exact phrase matching
36+- Exclude filters: "-file:test" or "-repo:forks" to exclude matches
37+
38+ADVANCED FILTERS:
39+- Repository filters:
40+ * "repo:name" - Match repositories with name containing "name"
41+ * "repo:^github\.com/org/repo$" - Exact repository match
42+ * "repo:org/repo@branch" - Search specific branch
43+ * "repo:org/repo rev:branch" - Alternative branch syntax
44+ * "-repo:name" - Exclude repositories
45+ * "fork:yes" or "fork:only" - Include or only show forks
46+ * "archived:yes" or "archived:only" - Include or only show archived repos
47+ * "visibility:public" or "visibility:private" - Filter by visibility
48+
49+- File filters:
50+ * "file:\.js$" - Files with .js extension
51+ * "file:internal/" - Files in internal directory
52+ * "-file:test" - Exclude test files
53+ * "file:has.content(Copyright)" - Files containing "Copyright"
54+ * "file:has.contributor([email protected])" - Files with specific contributor
55+
56+- Content filters:
57+ * "content:\"exact string\"" - Search for exact string
58+ * "-content:\"unwanted\"" - Exclude files with unwanted content
59+ * "case:yes" - Case-sensitive search
60+
61+- Type filters:
62+ * "type:symbol" - Search for symbols (functions, classes, etc.)
63+ * "type:file" - Search file content only
64+ * "type:path" - Search filenames only
65+ * "type:diff" - Search code changes
66+ * "type:commit" - Search commit messages
67+
68+- Commit/diff search:
69+ * "after:\"1 month ago\"" - Commits after date
70+ * "before:\"2023-01-01\"" - Commits before date
71+ * "author:name" - Commits by author
72+ * "message:\"fix bug\"" - Commits with message
73+
74+- Result selection:
75+ * "select:repo" - Show only repository names
76+ * "select:file" - Show only file paths
77+ * "select:content" - Show only matching content
78+ * "select:symbol" - Show only matching symbols
79+
80+- Result control:
81+ * "count:100" - Return up to 100 results
82+ * "count:all" - Return all results
83+ * "timeout:30s" - Set search timeout
84+
85+EXAMPLES:
86+- "file:.go context.WithTimeout" - Find Go code using context.WithTimeout
87+- "lang:typescript useState type:symbol" - Find TypeScript React useState hooks
88+- "repo:^github\.com/kubernetes/kubernetes$ pod list type:file" - Find Kubernetes files related to pod listing
89+- "repo:sourcegraph/sourcegraph$ after:\"3 months ago\" type:diff database" - Recent changes to database code
90+- "file:Dockerfile (alpine OR ubuntu) -content:alpine:latest" - Dockerfiles with specific base images
91+- "repo:has.path(\.py) file:requirements.txt tensorflow" - Python projects using TensorFlow
92+
93+BOOLEAN OPERATORS:
94+- "term1 AND term2" - Results containing both terms
95+- "term1 OR term2" - Results containing either term
96+- "term1 NOT term2" - Results with term1 but not term2
97+- "term1 and (term2 or term3)" - Grouping with parentheses
98+
99+LIMITATIONS:
100+- Only searches public repositories
101+- Rate limits may apply
102+- Complex queries may take longer to execute
103+- Maximum of 20 results per query
104+
105+TIPS:
106+- Use specific file extensions to narrow results
107+- Add repo: filters for more targeted searches
108+- Use type:symbol to find function/method definitions
109+- Use type:file to find relevant files
110+- For more details on query syntax, visit: https://docs.sourcegraph.com/code_search/queries`
111+)
112+
113+type SourcegraphParams struct {
114+ Query string `json:"query"`
115+ Count int `json:"count,omitempty"`
116+ Timeout int `json:"timeout,omitempty"`
117+}
118+
119+type SourcegraphPermissionsParams struct {
120+ Query string `json:"query"`
121+ Count int `json:"count,omitempty"`
122+ Timeout int `json:"timeout,omitempty"`
123+}
124+
125+type sourcegraphTool struct {
126+ client *http.Client
127+}
128+
129+func NewSourcegraphTool() BaseTool {
130+ return &sourcegraphTool{
131+ client: &http.Client{
132+ Timeout: 30 * time.Second,
133+ },
134+ }
135+}
136+
137+func (t *sourcegraphTool) Info() ToolInfo {
138+ return ToolInfo{
139+ Name: SourcegraphToolName,
140+ Description: sourcegraphToolDescription,
141+ Parameters: map[string]any{
142+ "query": map[string]any{
143+ "type": "string",
144+ "description": "The Sourcegraph search query",
145+ },
146+ "count": map[string]any{
147+ "type": "number",
148+ "description": "Optional number of results to return (default: 10, max: 20)",
149+ },
150+ "timeout": map[string]any{
151+ "type": "number",
152+ "description": "Optional timeout in seconds (max 120)",
153+ },
154+ },
155+ Required: []string{"query"},
156+ }
157+}
158+
159+func (t *sourcegraphTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error) {
160+ var params SourcegraphParams
161+ if err := json.Unmarshal([]byte(call.Input), &params); err != nil {
162+ return NewTextErrorResponse("Failed to parse sourcegraph parameters: " + err.Error()), nil
163+ }
164+
165+ if params.Query == "" {
166+ return NewTextErrorResponse("Query parameter is required"), nil
167+ }
168+
169+ // Set default count if not specified
170+ if params.Count <= 0 {
171+ params.Count = 10
172+ } else if params.Count > 20 {
173+ params.Count = 20 // Limit to 20 results
174+ }
175+
176+ client := t.client
177+ if params.Timeout > 0 {
178+ maxTimeout := 120 // 2 minutes
179+ if params.Timeout > maxTimeout {
180+ params.Timeout = maxTimeout
181+ }
182+ client = &http.Client{
183+ Timeout: time.Duration(params.Timeout) * time.Second,
184+ }
185+ }
186+
187+ // GraphQL query for Sourcegraph search
188+ // Create a properly escaped JSON structure
189+ type graphqlRequest struct {
190+ Query string `json:"query"`
191+ Variables struct {
192+ Query string `json:"query"`
193+ } `json:"variables"`
194+ }
195+
196+ request := graphqlRequest{
197+ Query: "query Search($query: String!) { search(query: $query, version: V2, patternType: standard ) { results { matchCount, limitHit, resultCount, approximateResultCount, missing { name }, timedout { name }, indexUnavailable, results { __typename, ... on FileMatch { repository { name }, file { path, url, content }, lineMatches { preview, lineNumber, offsetAndLengths } } } } } }",
198+ }
199+ request.Variables.Query = params.Query
200+
201+ // Marshal to JSON to ensure proper escaping
202+ graphqlQueryBytes, err := json.Marshal(request)
203+ if err != nil {
204+ return NewTextErrorResponse("Failed to create GraphQL request: " + err.Error()), nil
205+ }
206+ graphqlQuery := string(graphqlQueryBytes)
207+
208+ // Create request to Sourcegraph API
209+ req, err := http.NewRequestWithContext(
210+ ctx,
211+ "POST",
212+ "https://sourcegraph.com/.api/graphql",
213+ bytes.NewBuffer([]byte(graphqlQuery)),
214+ )
215+ if err != nil {
216+ return NewTextErrorResponse("Failed to create request: " + err.Error()), nil
217+ }
218+
219+ req.Header.Set("Content-Type", "application/json")
220+ req.Header.Set("User-Agent", "termai/1.0")
221+
222+ resp, err := client.Do(req)
223+ if err != nil {
224+ return NewTextErrorResponse("Failed to execute request: " + err.Error()), nil
225+ }
226+ defer resp.Body.Close()
227+
228+ if resp.StatusCode != http.StatusOK {
229+ // log the error response
230+ body, _ := io.ReadAll(resp.Body)
231+ if len(body) > 0 {
232+ return NewTextErrorResponse(fmt.Sprintf("Request failed with status code: %d, response: %s", resp.StatusCode, string(body))), nil
233+ }
234+
235+ return NewTextErrorResponse(fmt.Sprintf("Request failed with status code: %d", resp.StatusCode)), nil
236+ }
237+ body, err := io.ReadAll(resp.Body)
238+ if err != nil {
239+ return NewTextErrorResponse("Failed to read response body: " + err.Error()), nil
240+ }
241+
242+ // Parse the GraphQL response
243+ var result map[string]any
244+ if err = json.Unmarshal(body, &result); err != nil {
245+ return NewTextErrorResponse("Failed to parse response: " + err.Error()), nil
246+ }
247+
248+ // Format the results in a readable way
249+ formattedResults, err := formatSourcegraphResults(result)
250+ if err != nil {
251+ return NewTextErrorResponse("Failed to format results: " + err.Error()), nil
252+ }
253+
254+ return NewTextResponse(formattedResults), nil
255+}
256+
257+func formatSourcegraphResults(result map[string]any) (string, error) {
258+ var buffer strings.Builder
259+
260+ // Check for errors in the GraphQL response
261+ if errors, ok := result["errors"].([]any); ok && len(errors) > 0 {
262+ buffer.WriteString("## Sourcegraph API Error\n\n")
263+ for _, err := range errors {
264+ if errMap, ok := err.(map[string]any); ok {
265+ if message, ok := errMap["message"].(string); ok {
266+ buffer.WriteString(fmt.Sprintf("- %s\n", message))
267+ }
268+ }
269+ }
270+ return buffer.String(), nil
271+ }
272+
273+ // Extract data from the response
274+ data, ok := result["data"].(map[string]any)
275+ if !ok {
276+ return "", fmt.Errorf("invalid response format: missing data field")
277+ }
278+
279+ search, ok := data["search"].(map[string]any)
280+ if !ok {
281+ return "", fmt.Errorf("invalid response format: missing search field")
282+ }
283+
284+ searchResults, ok := search["results"].(map[string]any)
285+ if !ok {
286+ return "", fmt.Errorf("invalid response format: missing results field")
287+ }
288+
289+ // Write search metadata
290+ matchCount, _ := searchResults["matchCount"].(float64)
291+ resultCount, _ := searchResults["resultCount"].(float64)
292+ limitHit, _ := searchResults["limitHit"].(bool)
293+
294+ buffer.WriteString("# Sourcegraph Search Results\n\n")
295+ buffer.WriteString(fmt.Sprintf("Found %d matches across %d results\n", int(matchCount), int(resultCount)))
296+
297+ if limitHit {
298+ buffer.WriteString("(Result limit reached, try a more specific query)\n")
299+ }
300+
301+ buffer.WriteString("\n")
302+
303+ // Process results
304+ results, ok := searchResults["results"].([]any)
305+ if !ok || len(results) == 0 {
306+ buffer.WriteString("No results found. Try a different query.\n")
307+ return buffer.String(), nil
308+ }
309+
310+ // Limit to 10 results
311+ maxResults := 10
312+ if len(results) > maxResults {
313+ results = results[:maxResults]
314+ }
315+
316+ // Process each result
317+ for i, res := range results {
318+ fileMatch, ok := res.(map[string]any)
319+ if !ok {
320+ continue
321+ }
322+
323+ // Skip non-FileMatch results
324+ typeName, _ := fileMatch["__typename"].(string)
325+ if typeName != "FileMatch" {
326+ continue
327+ }
328+
329+ // Extract repository and file information
330+ repo, _ := fileMatch["repository"].(map[string]any)
331+ file, _ := fileMatch["file"].(map[string]any)
332+ lineMatches, _ := fileMatch["lineMatches"].([]any)
333+
334+ if repo == nil || file == nil {
335+ continue
336+ }
337+
338+ repoName, _ := repo["name"].(string)
339+ filePath, _ := file["path"].(string)
340+ fileURL, _ := file["url"].(string)
341+ fileContent, _ := file["content"].(string)
342+
343+ buffer.WriteString(fmt.Sprintf("## Result %d: %s/%s\n\n", i+1, repoName, filePath))
344+
345+ if fileURL != "" {
346+ buffer.WriteString(fmt.Sprintf("URL: %s\n\n", fileURL))
347+ }
348+
349+ // Show line matches with context
350+ if len(lineMatches) > 0 {
351+ for _, lm := range lineMatches {
352+ lineMatch, ok := lm.(map[string]any)
353+ if !ok {
354+ continue
355+ }
356+
357+ lineNumber, _ := lineMatch["lineNumber"].(float64)
358+ preview, _ := lineMatch["preview"].(string)
359+
360+ // Extract context from file content if available
361+ if fileContent != "" {
362+ lines := strings.Split(fileContent, "\n")
363+
364+ buffer.WriteString("```\n")
365+
366+ // Display context before the match (up to 10 lines)
367+ contextBefore := 10
368+ startLine := max(1, int(lineNumber)-contextBefore)
369+
370+ for j := startLine - 1; j < int(lineNumber)-1 && j < len(lines); j++ {
371+ if j >= 0 {
372+ buffer.WriteString(fmt.Sprintf("%d| %s\n", j+1, lines[j]))
373+ }
374+ }
375+
376+ // Display the matching line (highlighted)
377+ buffer.WriteString(fmt.Sprintf("%d| %s\n", int(lineNumber), preview))
378+
379+ // Display context after the match (up to 10 lines)
380+ contextAfter := 10
381+ endLine := int(lineNumber) + contextAfter
382+
383+ for j := int(lineNumber); j < endLine && j < len(lines); j++ {
384+ if j < len(lines) {
385+ buffer.WriteString(fmt.Sprintf("%d| %s\n", j+1, lines[j]))
386+ }
387+ }
388+
389+ buffer.WriteString("```\n\n")
390+ } else {
391+ // If file content is not available, just show the preview
392+ buffer.WriteString("```\n")
393+ buffer.WriteString(fmt.Sprintf("%d| %s\n", int(lineNumber), preview))
394+ buffer.WriteString("```\n\n")
395+ }
396+ }
397+ }
398+ }
399+
400+ return buffer.String(), nil
401+}
internal/llm/tools/sourcegraph_test.gonew file+115
@@ -0,0 +1,115 @@
1+package tools
2+
3+import (
4+ "context"
5+ "encoding/json"
6+ "testing"
7+
8+ "github.com/kujtimiihoxha/termai/internal/permission"
9+ "github.com/stretchr/testify/assert"
10+ "github.com/stretchr/testify/require"
11+)
12+
13+func TestSourcegraphTool_Info(t *testing.T) {
14+ tool := NewSourcegraphTool()
15+ info := tool.Info()
16+
17+ assert.Equal(t, SourcegraphToolName, info.Name)
18+ assert.NotEmpty(t, info.Description)
19+ assert.Contains(t, info.Parameters, "query")
20+ assert.Contains(t, info.Parameters, "count")
21+ assert.Contains(t, info.Parameters, "timeout")
22+ assert.Contains(t, info.Required, "query")
23+}
24+
25+func TestSourcegraphTool_Run(t *testing.T) {
26+ // Setup a mock permission handler that always allows
27+ origPermission := permission.Default
28+ defer func() {
29+ permission.Default = origPermission
30+ }()
31+ permission.Default = newMockPermissionService(true)
32+
33+ t.Run("handles missing query parameter", func(t *testing.T) {
34+ tool := NewSourcegraphTool()
35+ params := SourcegraphParams{
36+ Query: "",
37+ }
38+
39+ paramsJSON, err := json.Marshal(params)
40+ require.NoError(t, err)
41+
42+ call := ToolCall{
43+ Name: SourcegraphToolName,
44+ Input: string(paramsJSON),
45+ }
46+
47+ response, err := tool.Run(context.Background(), call)
48+ require.NoError(t, err)
49+ assert.Contains(t, response.Content, "Query parameter is required")
50+ })
51+
52+ t.Run("handles invalid parameters", func(t *testing.T) {
53+ tool := NewSourcegraphTool()
54+ call := ToolCall{
55+ Name: SourcegraphToolName,
56+ Input: "invalid json",
57+ }
58+
59+ response, err := tool.Run(context.Background(), call)
60+ require.NoError(t, err)
61+ assert.Contains(t, response.Content, "Failed to parse sourcegraph parameters")
62+ })
63+
64+ t.Run("handles permission denied", func(t *testing.T) {
65+ permission.Default = newMockPermissionService(false)
66+
67+ tool := NewSourcegraphTool()
68+ params := SourcegraphParams{
69+ Query: "test query",
70+ }
71+
72+ paramsJSON, err := json.Marshal(params)
73+ require.NoError(t, err)
74+
75+ call := ToolCall{
76+ Name: SourcegraphToolName,
77+ Input: string(paramsJSON),
78+ }
79+
80+ response, err := tool.Run(context.Background(), call)
81+ require.NoError(t, err)
82+ assert.Contains(t, response.Content, "Permission denied")
83+ })
84+
85+ t.Run("normalizes count parameter", func(t *testing.T) {
86+ // Test cases for count normalization
87+ testCases := []struct {
88+ name string
89+ inputCount int
90+ expectedCount int
91+ }{
92+ {"negative count", -5, 10}, // Should use default (10)
93+ {"zero count", 0, 10}, // Should use default (10)
94+ {"valid count", 50, 50}, // Should keep as is
95+ {"excessive count", 150, 100}, // Should cap at 100
96+ }
97+
98+ for _, tc := range testCases {
99+ t.Run(tc.name, func(t *testing.T) {
100+ // Verify count normalization logic directly
101+ assert.NotPanics(t, func() {
102+ // Apply the same normalization logic as in the tool
103+ normalizedCount := tc.inputCount
104+ if normalizedCount <= 0 {
105+ normalizedCount = 10
106+ } else if normalizedCount > 100 {
107+ normalizedCount = 100
108+ }
109+
110+ assert.Equal(t, tc.expectedCount, normalizedCount)
111+ })
112+ })
113+ }
114+ })
115+}