tenant.openagents/omega

1(internal_module
2  "namespace" @context
3  name: (_) @name) @item
4
5(enum_declaration
6  "enum" @context
7  name: (_) @name) @item
8
9(type_alias_declaration
10  "type" @context
11  name: (_) @name) @item
12
13(function_declaration
14  "async"? @context
15  "function" @context
16  name: (_) @name
17  parameters: (formal_parameters
18    "(" @context
19    ")" @context)) @item
20
21(generator_function_declaration
22  "async"? @context
23  "function" @context
24  "*" @context
25  name: (_) @name
26  parameters: (formal_parameters
27    "(" @context
28    ")" @context)) @item
29
30(interface_declaration
31  "interface" @context
32  name: (_) @name) @item
33
34(export_statement
35  (lexical_declaration
36    [
37      "let"
38      "const"
39    ] @context
40    (variable_declarator
41      name: (identifier) @name) @item))
42
43; Exported array destructuring
44(export_statement
45  (lexical_declaration
46    [
47      "let"
48      "const"
49    ] @context
50    (variable_declarator
51      name: (array_pattern
52        [
53          (identifier) @name @item
54          (assignment_pattern
55            left: (identifier) @name @item)
56          (rest_pattern
57            (identifier) @name @item)
58        ]))))
59
60; Exported object destructuring
61(export_statement
62  (lexical_declaration
63    [
64      "let"
65      "const"
66    ] @context
67    (variable_declarator
68      name: (object_pattern
69        [
70          (shorthand_property_identifier_pattern) @name @item
71          (pair_pattern
72            value: (identifier) @name @item)
73          (pair_pattern
74            value: (assignment_pattern
75              left: (identifier) @name @item))
76          (rest_pattern
77            (identifier) @name @item)
78        ]))))
79
80(program
81  (lexical_declaration
82    [
83      "let"
84      "const"
85    ] @context
86    (variable_declarator
87      name: (identifier) @name) @item))
88
89; Top-level array destructuring
90(program
91  (lexical_declaration
92    [
93      "let"
94      "const"
95    ] @context
96    (variable_declarator
97      name: (array_pattern
98        [
99          (identifier) @name @item
100          (assignment_pattern
101            left: (identifier) @name @item)
102          (rest_pattern
103            (identifier) @name @item)
104        ]))))
105
106; Top-level object destructuring
107(program
108  (lexical_declaration
109    [
110      "let"
111      "const"
112    ] @context
113    (variable_declarator
114      name: (object_pattern
115        [
116          (shorthand_property_identifier_pattern) @name @item
117          (pair_pattern
118            value: (identifier) @name @item)
119          (pair_pattern
120            value: (assignment_pattern
121              left: (identifier) @name @item))
122          (rest_pattern
123            (identifier) @name @item)
124        ]))))
125
126(class_declaration
127  "class" @context
128  name: (_) @name) @item
129
130(abstract_class_declaration
131  "abstract" @context
132  "class" @context
133  name: (_) @name) @item
134
135; Method definitions in classes (not in object literals)
136(class_body
137  (method_definition
138    [
139      "get"
140      "set"
141      "async"
142      "*"
143      "readonly"
144      "static"
145      (override_modifier)
146      (accessibility_modifier)
147    ]* @context
148    name: (_) @name
149    parameters: (formal_parameters
150      "(" @context
151      ")" @context)) @item)
152
153; Object literal methods (including nested objects)
154(object
155  (method_definition
156    [
157      "get"
158      "set"
159      "async"
160      "*"
161    ]* @context
162    name: (_) @name
163    parameters: (formal_parameters
164      "(" @context
165      ")" @context)) @item)
166
167(public_field_definition
168  [
169    "declare"
170    "readonly"
171    "abstract"
172    "static"
173    (accessibility_modifier)
174  ]* @context
175  name: (_) @name) @item
176
177; Add support for (node:test, bun:test and Jest) runnable
178; Also matches direct modifiers: .skip, .todo, .only, .failing (Jest, Bun, Vitest)
179((call_expression
180  function: [
181    (identifier) @_name
182    (member_expression
183      object: [
184        (identifier) @_name
185        (member_expression
186          object: (identifier) @_name)
187      ])
188  ] @context
189  (#any-of? @_name "it" "test" "describe" "context" "suite")
190  arguments: (arguments
191    .
192    [
193      (string
194        (string_fragment) @name)
195      (identifier) @name
196    ]))) @item
197
198; Parameterized and conditional tests. Docs per runner:
199;   Jest:   https://jestjs.io/docs/api#testeachtablename-fn-timeout
200;   Vitest: https://vitest.dev/api/
201;   Bun:    https://bun.sh/docs/test/writing-tests#test-modifiers
202((call_expression
203  function: (call_expression
204    function: (member_expression
205      object: [
206        (identifier) @_name
207        (member_expression
208          object: (identifier) @_name)
209      ]
210      property: (property_identifier) @_property)
211    (#any-of? @_name "it" "test" "describe" "context" "suite")
212    (#any-of? @_property
213      ; Jest, Bun, Vitest
214      "each"
215      ; Vitest
216      "skipIf" "runIf"
217      ; Bun
218      "if" "todoIf"))
219  arguments: (arguments
220    .
221    [
222      (string
223        (string_fragment) @name)
224      (identifier) @name
225    ]))) @item
226
227; Object properties
228(pair
229  key: [
230    (property_identifier) @name
231    (string
232      (string_fragment) @name)
233    (number) @name
234    (computed_property_name) @name
235  ]) @item
236
237; Nested variables in function bodies
238(statement_block
239  (lexical_declaration
240    [
241      "let"
242      "const"
243    ] @context
244    (variable_declarator
245      name: (identifier) @name) @item))
246
247; Nested array destructuring in functions
248(statement_block
249  (lexical_declaration
250    [
251      "let"
252      "const"
253    ] @context
254    (variable_declarator
255      name: (array_pattern
256        [
257          (identifier) @name @item
258          (assignment_pattern
259            left: (identifier) @name @item)
260          (rest_pattern
261            (identifier) @name @item)
262        ]))))
263
264; Nested object destructuring in functions
265(statement_block
266  (lexical_declaration
267    [
268      "let"
269      "const"
270    ] @context
271    (variable_declarator
272      name: (object_pattern
273        [
274          (shorthand_property_identifier_pattern) @name @item
275          (pair_pattern
276            value: (identifier) @name @item)
277          (pair_pattern
278            value: (assignment_pattern
279              left: (identifier) @name @item))
280          (rest_pattern
281            (identifier) @name @item)
282        ]))))
283
284(comment) @annotation
285