@mnemonik/shared 6.50.0 → 6.51.0

package/src/codeScanner.ts

@@ -6,9 +6,11 @@ import { readdir, readFile, stat, lstat, realpath } from 'fs/promises';
 import { join, relative, extname, sep } from 'path';
 import { createHash } from 'crypto';
 import ignore, { type Ignore } from 'ignore';
-import { debug as logDebug, warn as logWarn } from './logger.js';
+import { debug as logDebug, info as logInfo, warn as logWarn } from './logger.js';
 import { withTimeout } from './asyncUtils.js';
 import { scrubSecrets } from './secretPatterns.js';
+import { MAX_AST_PARSE_BYTES, chunkWithAst, type AstChunk } from './ast/astChunker.js';
+import { astArtifactReport, resolveAstLanguage } from './ast/grammars.js';
 
 /**
  * File operation timeout (5 seconds) to prevent hanging on slow/unresponsive filesystems
@@ -51,6 +53,11 @@ export interface CodeChunk {
     size: number;
     signature?: string; // Function/class signature (e.g. "function foo(bar: string): number")
     symbolName?: string; // Symbol name (e.g. "foo")
+    // The AST chunker's finer classification, verbatim from the tag capture
+    // ('method', 'interface', 'struct', ...). `chunkType` above is the coarse
+    // wire enum and cannot express it; only the AST path sets this, so its
+    // absence is exactly the signal "this chunk came from the heuristic path".
+    symbolKind?: string;
   };
 }
 
@@ -59,6 +66,13 @@ export interface ScanOptions {
   minChunkSize?: number;
   ignorePatterns?: string[];
   includeExtensions?: string[];
+  /**
+   * Byte ceiling above which a file is chunked heuristically instead of parsed.
+   * Defaults to `MAX_AST_PARSE_BYTES`; exposed so a caller (and the routing
+   * test) can drive the degradation path through production code rather than a
+   * mock.
+   */
+  maxAstParseBytes?: number;
 }
 
 /**
@@ -501,6 +515,7 @@ const DEFAULT_OPTIONS: Required<ScanOptions> = {
   minChunkSize: 100,
   ignorePatterns: [...BUILT_IN_IGNORE_DIRS, ...BUILT_IN_IGNORE_FILE_PATTERNS],
   includeExtensions: [...DEFAULT_INCLUDE_EXTENSIONS],
+  maxAstParseBytes: MAX_AST_PARSE_BYTES,
 };
 
 /**
@@ -613,6 +628,65 @@ interface IgnoreLayer {
 }
 type IgnoreStack = IgnoreLayer[];
 
+/**
+ * Latch for `logAstCapabilityOnce`. A promise, not a boolean: two concurrent
+ * callers must both wait on the same report rather than the second returning
+ * before the first has logged.
+ */
+let astCapabilityLog: Promise<void> | null = null;
+
+/**
+ * `reason:grammar` pairs already warned about, for the reasons that are
+ * process-global rather than file-specific.
+ *
+ * Only `grammar_unavailable` qualifies: `loadGrammar` caches its failure, so the
+ * answer is identical for every file of that language and warning per file
+ * printed 1,037 lines in one scan of this repo. `file_too_large` and
+ * `parse_failed` are properties of one file and stay per file.
+ */
+const reportedGrammarFallbacks = new Set<string>();
+
+/**
+ * Log which grammars this install ships — ONCE per process, at daemon start,
+ * never per file.
+ *
+ * A missing grammar silently degrades every file of that language to the
+ * heuristic chunker. Per-file warnings would say so 30,000 times and drown the
+ * log; saying nothing is how a half-broken install looks healthy. One startup
+ * line naming the vendored grammars, and a WARNING when an artifact is missing,
+ * is the whole contract.
+ *
+ * Deliberately a `statSync` of the artifacts (`astArtifactReport`) and not a
+ * load of them (`astCapabilityReport`). Loading all 18 to print this line costs
+ * ~690 ms and ~75 MB of RSS that is never returned — web-tree-sitter exposes no
+ * `Language.delete` — which is a permanent tax on a daemon watching a pure
+ * TypeScript repo, paid to pre-answer a question about seventeen languages it
+ * will never see. Grammars load lazily instead, on the first file of a language,
+ * and the two failure modes only a load can detect (`wasm_load_failed`,
+ * `query_compile_failed`) are warned there, once per language, by the
+ * `grammar_unavailable` branch in `chunkFile`.
+ *
+ * Cheap to call repeatedly: this latches, and the report instantiates nothing.
+ */
+export function logAstCapabilityOnce(): Promise<void> {
+  astCapabilityLog ??= (async () => {
+    const report = astArtifactReport();
+    const detail = {
+      grammars: report.vendored.length,
+      languages: report.vendored.join(' '),
+    };
+    if (report.missing.length > 0) {
+      logWarn('AST chunking: some vendored grammar artifacts are missing', {
+        ...detail,
+        missing: report.missing.map((m) => `${m.id}(${m.reason}: ${m.detail})`).join('; '),
+      });
+    } else {
+      logInfo('AST chunking ready (grammars load lazily, per language)', detail);
+    }
+  })();
+  return astCapabilityLog;
+}
+
 export class CodeScanner {
   private options: Required<ScanOptions>;
 
@@ -1144,14 +1218,131 @@ export class CodeScanner {
         return this.chunkMarkdown(content, relativePath, stats.size);
       }
 
-      const structuredChunks = this.extractStructuredChunks(content, language);
-
       const fileMetadata = {
         fileName: filePath.split('/').pop() || '',
         extension: extname(filePath),
         size: stats.size,
       };
 
+      // AST first for the languages with a vendored grammar. `null` means "no
+      // grammar for this" — the honest majority of the allowlist — and the
+      // heuristic path below takes over with no log, because that is not a
+      // degradation.
+      const astLanguage = resolveAstLanguage(fileMetadata.extension, language);
+      if (astLanguage) {
+        const ast = await chunkWithAst(content, astLanguage, {
+          maxParseBytes: this.options.maxAstParseBytes,
+        });
+        if ('chunks' in ast) {
+          // A definition the chunker could not place reaches no chunk, so its
+          // name reaches no index and a citation to it resolves as
+          // `unresolved_symbol`. It cannot be emitted (two chunks over one line
+          // range collide on the `filePath:startLine-endLine` staleness key), but
+          // a scan that quietly loses symbols must not look like a healthy one.
+          if (ast.droppedDefinitions > 0) {
+            logWarn('AST chunker dropped definitions that share a line range', {
+              filePath: relativePath,
+              grammar: astLanguage,
+              droppedDefinitions: ast.droppedDefinitions,
+            });
+          }
+          // `errorNodes` is handed back precisely so this degradation is not
+          // silent, and discarding it made it silent. One ERROR node can swallow
+          // the rest of a file — `typeof import(...)` in a type argument does
+          // exactly that to tree-sitter-typescript — after which no definition is
+          // captured and the file arrives as one unnamed whole-file chunk. Naming
+          // the file, the error count and how many definitions survived is what
+          // makes that visible in a scan log.
+          //
+          // Deliberately NOT a fallback to the heuristic path: measured on the
+          // real construct (tests/AgentInjectionDeliveryWiring.test.ts), the
+          // heuristic path names nothing either (its name pattern needs a
+          // leading `function`/`class`/`const`) AND covers less — it emitted 3
+          // chunks starting at line 18 and dropped lines 1-17, because the
+          // uncovered-region supplement only fires above 50 lines. Trading
+          // total coverage for no gain is worse than one honest blob, so the
+          // AST result stands and the log says so.
+          if (ast.errorNodes > 0) {
+            logWarn('AST parse errors; extents and symbol names degraded for this file', {
+              filePath: relativePath,
+              grammar: astLanguage,
+              errorNodes: ast.errorNodes,
+              definitions: ast.chunks.filter((chunk) => chunk.symbolKind).length,
+              chunks: ast.chunks.length,
+            });
+          }
+          // The wire cap (`scanChunkSchema` allows 500,000 chars) and the
+          // embedding cap (8191 tokens per input) are both downstream of
+          // `maxChunkSize`, and the AST chunker only bounds its uncovered spans:
+          // a definition chunk is whatever the definition is. `boundAstChunks`
+          // makes the cap unreachable by construction, or answers null when the
+          // file cannot be bounded on line boundaries at all.
+          const bounded = this.boundAstChunks(ast.chunks);
+          if (bounded) {
+            // Zero chunks here means the file has no non-whitespace line — the AST
+            // chunker covers every other line by construction — so returning
+            // nothing is the correct answer, not a lost file.
+            return bounded.map(({ symbolName, symbolKind, signature, ...chunk }) => ({
+              ...chunk,
+              filePath: relativePath,
+              language,
+              contentHash: this.hash(chunk.content),
+              metadata: {
+                ...fileMetadata,
+                ...(signature ? { signature } : {}),
+                ...(symbolName ? { symbolName } : {}),
+                ...(symbolKind ? { symbolKind } : {}),
+              },
+            }));
+          }
+          // One line longer than `maxChunkSize` — a generated `*_pb2.py` carries
+          // the whole serialized descriptor on one. Splitting it would have to
+          // cut mid-line, and two chunks over one line range collide on the
+          // `filePath:startLine-endLine` staleness key, so the whole file goes to
+          // the heuristic chunker, which force-splits long lines by character
+          // count. Loud, because a file that loses its symbol names must not look
+          // like a healthy one.
+          logWarn('AST chunk exceeds maxChunkSize on a single line; heuristic chunking instead', {
+            filePath: relativePath,
+            grammar: astLanguage,
+            maxChunkSize: this.options.maxChunkSize,
+            longestLine: content
+              .split('\n')
+              .reduce((longest, line) => Math.max(longest, line.length), 0),
+          });
+        } else if (ast.unsupported === 'grammar_unavailable') {
+          // Process-global, not per file: `loadGrammar` caches its failures, so
+          // every file of this language degrades for the same reason. Warned per
+          // file, this printed 1,037 identical lines in one scan of this repo —
+          // the log flood `logAstCapabilityOnce` exists to avoid. Once per
+          // (reason, grammar); the file-specific reasons below stay per file.
+          const key = `${ast.unsupported}:${astLanguage}`;
+          if (!reportedGrammarFallbacks.has(key)) {
+            reportedGrammarFallbacks.add(key);
+            logWarn('AST chunking unavailable for a whole language; heuristic chunking instead', {
+              grammar: astLanguage,
+              reason: ast.unsupported,
+              detail: ast.detail,
+              firstFile: relativePath,
+              note: 'logged once per grammar per process; every file of this language degrades',
+            });
+          }
+        } else {
+          // Not a silent no-op: name the file AND the reason, then degrade to the
+          // heuristic path. A degraded scan indistinguishable from a healthy one
+          // is the defect class this routing exists to avoid — and degrading to
+          // zero chunks would delete the file from the index instead.
+          logWarn('AST chunking unavailable; falling back to heuristic chunking', {
+            filePath: relativePath,
+            grammar: astLanguage,
+            reason: ast.unsupported,
+            detail: ast.detail,
+          });
+        }
+      }
+
+      const structuredChunks = this.extractStructuredChunks(content, language);
+
       if (structuredChunks.length > 0) {
         const mapped = structuredChunks.map(({ signature, symbolName, ...chunk }) => ({
           ...chunk,
@@ -1201,6 +1392,85 @@ export class CodeScanner {
     }
   }
 
+  /**
+   * Hold every AST chunk at or under `maxChunkSize`, or answer `null` when this
+   * file cannot be held there on line boundaries.
+   *
+   * The AST chunker bounds only the spans it invents (`MAX_RAW_SPAN_CHARS`); a
+   * chunk that came from a definition is exactly as big as the definition, and a
+   * span that is one enormous line is left whole on purpose. Both used to reach
+   * the wire verbatim, where `scanChunkSchema` caps content at 500,000 chars and
+   * rejects the WHOLE push if any chunk is over — so one generated file stopped
+   * all scanning for that push — and where anything past 8191 tokens is only
+   * partially embedded.
+   *
+   * The invariants, all of which the split preserves:
+   * - content stays verbatim contiguous source: `lines[startLine-1..endLine-1]`
+   *   joined by '\n', never a join of disjoint regions and never an elision;
+   * - total coverage is unchanged: the pieces tile the original range, in order,
+   *   with no gap and no overlap;
+   * - the definition's identity rides on the piece that carries its signature —
+   *   the first one — and the continuations are plain `raw` spans, because a
+   *   continuation is not the definition and must not claim its name.
+   *
+   * `null` (the caller degrades the whole file to the heuristic chunker) is
+   * reserved for the one shape a line-boundary split cannot fix: a single line
+   * longer than the cap, as every generated `*_pb2.py` has. Cutting mid-line
+   * would give two chunks the same `filePath:startLine-endLine` staleness key,
+   * which is the collision the chunker refuses everywhere else.
+   */
+  private boundAstChunks(chunks: readonly AstChunk[]): AstChunk[] | null {
+    const max = this.options.maxChunkSize;
+    if (chunks.every((chunk) => chunk.content.length <= max)) return [...chunks];
+
+    const bounded: AstChunk[] = [];
+    for (const chunk of chunks) {
+      if (chunk.content.length <= max) {
+        bounded.push(chunk);
+        continue;
+      }
+      // `content` is exactly `startLine..endLine` joined by '\n', so this split
+      // recovers the file's own lines for that range.
+      const lines = chunk.content.split('\n');
+      if (lines.some((line) => line.length > max)) return null;
+
+      /** `from`/`to` are 0-based offsets into `lines`, inclusive. */
+      const emit = (from: number, to: number): void => {
+        const content = lines.slice(from, to + 1).join('\n');
+        // A piece of nothing but blank lines is owed no chunk (the chunker's own
+        // rule) and `scanChunkSchema` requires content.min(1) anyway.
+        if (content.trim() === '') return;
+        const isFirst = from === 0;
+        bounded.push({
+          content,
+          startLine: chunk.startLine + from,
+          endLine: chunk.startLine + to,
+          chunkType: isFirst ? chunk.chunkType : 'raw',
+          ...(isFirst && chunk.symbolName ? { symbolName: chunk.symbolName } : {}),
+          ...(isFirst && chunk.symbolKind ? { symbolKind: chunk.symbolKind } : {}),
+          ...(isFirst && chunk.signature ? { signature: chunk.signature } : {}),
+        });
+      };
+
+      let pieceStart = 0;
+      let pieceLength = 0;
+      for (let i = 0; i < lines.length; i++) {
+        const lineLength = (lines[i] ?? '').length;
+        // The '\n' the join will put back is part of what has to fit.
+        const withLine = i === pieceStart ? lineLength : pieceLength + 1 + lineLength;
+        if (i > pieceStart && withLine > max) {
+          emit(pieceStart, i - 1);
+          pieceStart = i;
+          pieceLength = lineLength;
+        } else {
+          pieceLength = withLine;
+        }
+      }
+      emit(pieceStart, lines.length - 1);
+    }
+    return bounded;
+  }
+
   /**
    * Detect language from file extension
    */

package/src/index.ts

@@ -20,9 +20,31 @@ export {
   isFixturePath,
   isSecretFile,
   isAuthorityOnlyPath,
+  logAstCapabilityOnce,
   type CodeChunk,
   type ScanOptions,
 } from './codeScanner.js';
+export {
+  AST_LANGUAGE_IDS,
+  QUERY_CHAIN,
+  VENDORED_ARTIFACT_DIR,
+  astArtifactReport,
+  astCapabilityReport,
+  grammarArtifactBasename,
+  loadGrammar,
+  loadedGrammarIds,
+  resolveAstLanguage,
+  type AstLanguageId,
+  type GrammarBinding,
+  type GrammarLoad,
+  type GrammarUnavailableReason,
+} from './ast/grammars.js';
+export {
+  MAX_AST_PARSE_BYTES,
+  chunkWithAst,
+  type AstChunk,
+  type AstChunkResult,
+} from './ast/astChunker.js';
 export {
   SECRET_PATTERNS,
   SECRET_REDACTION_PLACEHOLDER,

package/wasm/bash.tags.scm

@@ -0,0 +1,7 @@
+; Hand-written: tree-sitter-bash ships no queries/tags.scm.
+;
+; Node names verified by parsing a sample with the vendored bash.wasm rather than
+; taken from documentation — `function_definition` carries its name in a `name`
+; field typed `word`, covering both `foo() { }` and `function foo { }`.
+(function_definition
+  name: (word) @name) @definition.function

package/wasm/c-sharp.tags.scm

@@ -0,0 +1,23 @@
+(class_declaration name: (identifier) @name) @definition.class
+
+(class_declaration (base_list (_) @name)) @reference.class
+
+(interface_declaration name: (identifier) @name) @definition.interface
+
+(interface_declaration (base_list (_) @name)) @reference.interface
+
+(method_declaration name: (identifier) @name) @definition.method
+
+(object_creation_expression type: (identifier) @name) @reference.class
+
+(type_parameter_constraints_clause (identifier) @name) @reference.class
+
+(type_parameter_constraint (type type: (identifier) @name)) @reference.class
+
+(variable_declaration type: (identifier) @name) @reference.class
+
+(invocation_expression function: (member_access_expression name: (identifier) @name)) @reference.send
+
+(namespace_declaration name: (identifier) @name) @definition.module
+
+(namespace_declaration name: (identifier) @name) @module

package/wasm/c.tags.scm

@@ -0,0 +1,9 @@
+(struct_specifier name: (type_identifier) @name body:(_)) @definition.class
+
+(declaration type: (union_specifier name: (type_identifier) @name)) @definition.class
+
+(function_declarator declarator: (identifier) @name) @definition.function
+
+(type_definition declarator: (type_identifier) @name) @definition.type
+
+(enum_specifier name: (type_identifier) @name) @definition.type

package/wasm/cpp.tags.scm

@@ -0,0 +1,15 @@
+(struct_specifier name: (type_identifier) @name body:(_)) @definition.class
+
+(declaration type: (union_specifier name: (type_identifier) @name)) @definition.class
+
+(function_declarator declarator: (identifier) @name) @definition.function
+
+(function_declarator declarator: (field_identifier) @name) @definition.function
+
+(function_declarator declarator: (qualified_identifier scope: (namespace_identifier) @local.scope name: (identifier) @name)) @definition.method
+
+(type_definition declarator: (type_identifier) @name) @definition.type
+
+(enum_specifier name: (type_identifier) @name) @definition.type
+
+(class_specifier name: (type_identifier) @name) @definition.class

package/wasm/elixir.tags.scm

@@ -0,0 +1,54 @@
+; Definitions
+
+; * modules and protocols
+(call
+  target: (identifier) @ignore
+  (arguments (alias) @name)
+  (#any-of? @ignore "defmodule" "defprotocol")) @definition.module
+
+; * functions/macros
+(call
+  target: (identifier) @ignore
+  (arguments
+    [
+      ; zero-arity functions with no parentheses
+      (identifier) @name
+      ; regular function clause
+      (call target: (identifier) @name)
+      ; function clause with a guard clause
+      (binary_operator
+        left: (call target: (identifier) @name)
+        operator: "when")
+    ])
+  (#any-of? @ignore "def" "defp" "defdelegate" "defguard" "defguardp" "defmacro" "defmacrop" "defn" "defnp")) @definition.function
+
+; References
+
+; ignore calls to kernel/special-forms keywords
+(call
+  target: (identifier) @ignore
+  (#any-of? @ignore "def" "defp" "defdelegate" "defguard" "defguardp" "defmacro" "defmacrop" "defn" "defnp" "defmodule" "defprotocol" "defimpl" "defstruct" "defexception" "defoverridable" "alias" "case" "cond" "else" "for" "if" "import" "quote" "raise" "receive" "require" "reraise" "super" "throw" "try" "unless" "unquote" "unquote_splicing" "use" "with"))
+
+; ignore module attributes
+(unary_operator
+  operator: "@"
+  operand: (call
+    target: (identifier) @ignore))
+
+; * function call
+(call
+  target: [
+   ; local
+   (identifier) @name
+   ; remote
+   (dot
+     right: (identifier) @name)
+  ]) @reference.call
+
+; * pipe into function call
+(binary_operator
+  operator: "|>"
+  right: (identifier) @name) @reference.call
+
+; * modules
+(alias) @name @reference.module

package/wasm/go.tags.scm

@@ -0,0 +1,42 @@
+(
+  (comment)* @doc
+  .
+  (function_declaration
+    name: (identifier) @name) @definition.function
+  (#strip! @doc "^//\\s*")
+  (#set-adjacent! @doc @definition.function)
+)
+
+(
+  (comment)* @doc
+  .
+  (method_declaration
+    name: (field_identifier) @name) @definition.method
+  (#strip! @doc "^//\\s*")
+  (#set-adjacent! @doc @definition.method)
+)
+
+(call_expression
+  function: [
+    (identifier) @name
+    (parenthesized_expression (identifier) @name)
+    (selector_expression field: (field_identifier) @name)
+    (parenthesized_expression (selector_expression field: (field_identifier) @name))
+  ]) @reference.call
+
+(type_spec
+  name: (type_identifier) @name) @definition.type
+
+(type_identifier) @name @reference.type
+
+(package_clause "package" (package_identifier) @name)
+
+(type_declaration (type_spec name: (type_identifier) @name type: (interface_type)))
+
+(type_declaration (type_spec name: (type_identifier) @name type: (struct_type)))
+
+(import_declaration (import_spec) @name)
+
+(var_declaration (var_spec name: (identifier) @name))
+
+(const_declaration (const_spec name: (identifier) @name))

package/wasm/groovy.tags.scm

@@ -0,0 +1,15 @@
+; Hand-written: tree-sitter-groovy ships no queries/tags.scm.
+;
+; Node names verified against the vendored groovy.wasm. Groovy distinguishes a
+; top-level `function_definition` from a `method_declaration` inside a
+; `class_body`, and both name via an `identifier` field — so methods get
+; definition.method and keep their own name, which is the defect this plan
+; exists to fix for every language.
+(class_declaration
+  name: (identifier) @name) @definition.class
+
+(method_declaration
+  name: (identifier) @name) @definition.method
+
+(function_definition
+  name: (identifier) @name) @definition.function

package/wasm/java.tags.scm

@@ -0,0 +1,20 @@
+(class_declaration
+  name: (identifier) @name) @definition.class
+
+(method_declaration
+  name: (identifier) @name) @definition.method
+
+(method_invocation
+  name: (identifier) @name
+  arguments: (argument_list) @reference.call)
+
+(interface_declaration
+  name: (identifier) @name) @definition.interface
+
+(type_list
+  (type_identifier) @name) @reference.implementation
+
+(object_creation_expression
+  type: (type_identifier) @name) @reference.class
+
+(superclass (type_identifier) @name) @reference.class

package/wasm/javascript.tags.scm

@@ -0,0 +1,99 @@
+(
+  (comment)* @doc
+  .
+  (method_definition
+    name: (property_identifier) @name) @definition.method
+  (#not-eq? @name "constructor")
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.method)
+)
+
+(
+  (comment)* @doc
+  .
+  [
+    (class
+      name: (_) @name)
+    (class_declaration
+      name: (_) @name)
+  ] @definition.class
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.class)
+)
+
+(
+  (comment)* @doc
+  .
+  [
+    (function_expression
+      name: (identifier) @name)
+    (function_declaration
+      name: (identifier) @name)
+    (generator_function
+      name: (identifier) @name)
+    (generator_function_declaration
+      name: (identifier) @name)
+  ] @definition.function
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.function)
+)
+
+(
+  (comment)* @doc
+  .
+  (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: [(arrow_function) (function_expression)]) @definition.function)
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.function)
+)
+
+(
+  (comment)* @doc
+  .
+  (variable_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: [(arrow_function) (function_expression)]) @definition.function)
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.function)
+)
+
+(assignment_expression
+  left: [
+    (identifier) @name
+    (member_expression
+      property: (property_identifier) @name)
+  ]
+  right: [(arrow_function) (function_expression)]
+) @definition.function
+
+(pair
+  key: (property_identifier) @name
+  value: [(arrow_function) (function_expression)]) @definition.function
+
+(
+  (call_expression
+    function: (identifier) @name) @reference.call
+  (#not-match? @name "^(require)$")
+)
+
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @name)
+  arguments: (_) @reference.call)
+
+(new_expression
+  constructor: (_) @name) @reference.class
+
+(export_statement value: (assignment_expression left: (identifier) @name right: ([
+ (number)
+ (string)
+ (identifier)
+ (undefined)
+ (null)
+ (new_expression)
+ (binary_expression)
+ (call_expression)
+]))) @definition.constant