@@ -0,0 +1,313 @@
1+package treesitter
2+
3+import (
4+ "context"
5+ "os"
6+ "path/filepath"
7+ "strings"
8+
9+ sitter "github.com/smacker/go-tree-sitter"
10+ "github.com/smacker/go-tree-sitter/golang"
11+)
12+
13+// langForExt returns the tree-sitter language for a file extension, or nil.
14+func langForExt(ext string) *sitter.Language {
15+ switch ext {
16+ case ".go":
17+ return golang.GetLanguage()
18+ default:
19+ return nil
20+ }
21+}
22+
23+// Supported returns true if the file extension has a tree-sitter grammar.
24+func Supported(path string) bool {
25+ return langForExt(strings.ToLower(filepath.Ext(path))) != nil
26+}
27+
28+// ParseFile reads and parses a file, returning its top-level symbols.
29+func ParseFile(path string) ([]Symbol, error) {
30+ src, err := os.ReadFile(path)
31+ if err != nil {
32+ return nil, err
33+ }
34+ return ParseSource(path, src)
35+}
36+
37+// ParseSource parses source bytes and returns top-level symbols.
38+func ParseSource(path string, src []byte) ([]Symbol, error) {
39+ lang := langForExt(strings.ToLower(filepath.Ext(path)))
40+ if lang == nil {
41+ return nil, nil
42+ }
43+
44+ parser := sitter.NewParser()
45+ defer parser.Close()
46+ parser.SetLanguage(lang)
47+
48+ tree, err := parser.ParseCtx(context.Background(), nil, src)
49+ if err != nil {
50+ return nil, err
51+ }
52+ defer tree.Close()
53+
54+ return extractGo(tree.RootNode(), src), nil
55+}
56+
57+// extractGo walks a Go AST root and extracts top-level symbols.
58+func extractGo(root *sitter.Node, src []byte) []Symbol {
59+ var syms []Symbol
60+ count := int(root.ChildCount())
61+
62+ for i := 0; i < count; i++ {
63+ child := root.Child(i)
64+ switch child.Type() {
65+ case "package_clause":
66+ // package_identifier is a named child, not a field.
67+ if nc := child.NamedChild(0); nc != nil && nc.Type() == "package_identifier" {
68+ syms = append(syms, Symbol{
69+ Name: content(nc, src),
70+ Kind: KindPackage,
71+ StartLine: line(child),
72+ EndLine: endLine(child),
73+ })
74+ }
75+
76+ case "import_declaration":
77+ syms = append(syms, extractImport(child, src))
78+
79+ case "function_declaration":
80+ syms = append(syms, extractFunc(child, src))
81+
82+ case "method_declaration":
83+ syms = append(syms, extractMethod(child, src))
84+
85+ case "type_declaration":
86+ syms = append(syms, extractTypeDecl(child, src)...)
87+
88+ case "const_declaration":
89+ syms = append(syms, extractConstVar(child, src, KindConst)...)
90+
91+ case "var_declaration":
92+ syms = append(syms, extractConstVar(child, src, KindVar)...)
93+ }
94+ }
95+ return syms
96+}
97+
98+func extractImport(node *sitter.Node, src []byte) Symbol {
99+ return Symbol{
100+ Name: strings.TrimSpace(content(node, src)),
101+ Kind: KindImport,
102+ StartLine: line(node),
103+ EndLine: endLine(node),
104+ }
105+}
106+
107+func extractFunc(node *sitter.Node, src []byte) Symbol {
108+ name := node.ChildByFieldName("name")
109+ params := node.ChildByFieldName("parameters")
110+ result := node.ChildByFieldName("result")
111+
112+ sym := Symbol{
113+ Kind: KindFunction,
114+ StartLine: line(node),
115+ EndLine: endLine(node),
116+ }
117+ if name != nil {
118+ sym.Name = content(name, src)
119+ }
120+ sym.Signature = buildFuncSig("", sym.Name, params, result, src)
121+ return sym
122+}
123+
124+func extractMethod(node *sitter.Node, src []byte) Symbol {
125+ name := node.ChildByFieldName("name")
126+ receiver := node.ChildByFieldName("receiver")
127+ params := node.ChildByFieldName("parameters")
128+ result := node.ChildByFieldName("result")
129+
130+ sym := Symbol{
131+ Kind: KindMethod,
132+ StartLine: line(node),
133+ EndLine: endLine(node),
134+ }
135+ if name != nil {
136+ sym.Name = content(name, src)
137+ }
138+
139+ var recvStr string
140+ if receiver != nil {
141+ recvStr = content(receiver, src)
142+ // Extract just the type name from receiver for Receiver field.
143+ sym.Receiver = extractReceiverType(receiver, src)
144+ }
145+ sym.Signature = buildFuncSig(recvStr, sym.Name, params, result, src)
146+ return sym
147+}
148+
149+func extractTypeDecl(node *sitter.Node, src []byte) []Symbol {
150+ var syms []Symbol
151+ count := int(node.ChildCount())
152+ for i := 0; i < count; i++ {
153+ child := node.Child(i)
154+ switch child.Type() {
155+ case "type_spec":
156+ syms = append(syms, extractTypeSpec(child, src))
157+ case "type_alias":
158+ syms = append(syms, extractTypeSpec(child, src))
159+ }
160+ }
161+ return syms
162+}
163+
164+func extractTypeSpec(node *sitter.Node, src []byte) Symbol {
165+ name := node.ChildByFieldName("name")
166+ typeNode := node.ChildByFieldName("type")
167+
168+ sym := Symbol{
169+ Kind: KindType,
170+ StartLine: line(node),
171+ EndLine: endLine(node),
172+ }
173+ if name != nil {
174+ sym.Name = content(name, src)
175+ }
176+ if typeNode != nil {
177+ switch typeNode.Type() {
178+ case "struct_type":
179+ sym.Kind = KindStruct
180+ sym.Children = extractStructFields(typeNode, src)
181+ case "interface_type":
182+ sym.Kind = KindInterface
183+ sym.Children = extractInterfaceMethods(typeNode, src)
184+ }
185+ sym.Signature = "type " + sym.Name + " " + typeNode.Type()
186+ }
187+ return sym
188+}
189+
190+func extractStructFields(node *sitter.Node, src []byte) []Symbol {
191+ var fields []Symbol
192+ body := node.ChildByFieldName("body")
193+ if body == nil {
194+ // struct_type has field_declaration_list as child
195+ for i := 0; i < int(node.ChildCount()); i++ {
196+ child := node.Child(i)
197+ if child.Type() == "field_declaration_list" {
198+ body = child
199+ break
200+ }
201+ }
202+ }
203+ if body == nil {
204+ return nil
205+ }
206+ for i := 0; i < int(body.ChildCount()); i++ {
207+ child := body.Child(i)
208+ if child.Type() == "field_declaration" {
209+ nameNode := child.ChildByFieldName("name")
210+ typeNode := child.ChildByFieldName("type")
211+ if nameNode != nil {
212+ f := Symbol{
213+ Name: content(nameNode, src),
214+ Kind: KindVar,
215+ StartLine: line(child),
216+ EndLine: endLine(child),
217+ }
218+ if typeNode != nil {
219+ f.Signature = content(nameNode, src) + " " + content(typeNode, src)
220+ }
221+ fields = append(fields, f)
222+ }
223+ }
224+ }
225+ return fields
226+}
227+
228+func extractInterfaceMethods(node *sitter.Node, src []byte) []Symbol {
229+ var methods []Symbol
230+ for i := 0; i < int(node.ChildCount()); i++ {
231+ child := node.Child(i)
232+ if child.Type() == "method_elem" || child.Type() == "method_spec" {
233+ nameNode := child.ChildByFieldName("name")
234+ if nameNode != nil {
235+ m := Symbol{
236+ Name: content(nameNode, src),
237+ Kind: KindMethod,
238+ StartLine: line(child),
239+ EndLine: endLine(child),
240+ Signature: content(child, src),
241+ }
242+ methods = append(methods, m)
243+ }
244+ }
245+ }
246+ return methods
247+}
248+
249+func extractConstVar(node *sitter.Node, src []byte, kind SymbolKind) []Symbol {
250+ var syms []Symbol
251+ count := int(node.ChildCount())
252+ for i := 0; i < count; i++ {
253+ child := node.Child(i)
254+ if child.Type() == "const_spec" || child.Type() == "var_spec" {
255+ nameNode := child.ChildByFieldName("name")
256+ if nameNode != nil {
257+ syms = append(syms, Symbol{
258+ Name: content(nameNode, src),
259+ Kind: kind,
260+ StartLine: line(child),
261+ EndLine: endLine(child),
262+ })
263+ }
264+ }
265+ }
266+ return syms
267+}
268+
269+func extractReceiverType(receiver *sitter.Node, src []byte) string {
270+ // Walk into parameter_list -> parameter_declaration -> type
271+ for i := 0; i < int(receiver.ChildCount()); i++ {
272+ child := receiver.Child(i)
273+ if child.Type() == "parameter_declaration" {
274+ typeNode := child.ChildByFieldName("type")
275+ if typeNode != nil {
276+ return content(typeNode, src)
277+ }
278+ }
279+ }
280+ return ""
281+}
282+
283+func buildFuncSig(receiver, name string, params, result *sitter.Node, src []byte) string {
284+ var b strings.Builder
285+ b.WriteString("func ")
286+ if receiver != "" {
287+ b.WriteString(receiver)
288+ b.WriteByte(' ')
289+ }
290+ b.WriteString(name)
291+ if params != nil {
292+ b.WriteString(content(params, src))
293+ }
294+ if result != nil {
295+ b.WriteByte(' ')
296+ b.WriteString(content(result, src))
297+ }
298+ return b.String()
299+}
300+
301+// helpers
302+
303+func content(node *sitter.Node, src []byte) string {
304+ return node.Content(src)
305+}
306+
307+func line(node *sitter.Node) int {
308+ return int(node.StartPoint().Row) + 1 // 1-indexed
309+}
310+
311+func endLine(node *sitter.Node) int {
312+ return int(node.EndPoint().Row) + 1
313+}