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