brainclaw 1.16.0 → 1.18.0

package/dist/core/code-map/lang/csharp/index.js

@@ -0,0 +1,224 @@
+/**
+ * Code Map langs batch 2 — CSharpProvider (provider #6).
+ *
+ * Owns `.cs` (runtime lang `csharp`). `extractDraft` delegates to the generic
+ * query-runtime; the curated `tags.scm`/`imports.scm` (this dir) drive extraction.
+ * All definition subtypes are fixed by the query (no def reclassification). C# is
+ * very Java-like, so this mirrors JavaProvider — but the import shaping is simpler:
+ * C# module specifiers are dotted names (qualified_name), NOT string literals, so
+ * there is nothing to quote-strip, and there is no wildcard using and no
+ * member-split static import. `refine()` carries ONLY what the structural query
+ * cannot express: the ALIAS binding of `using X = A.B;` (the module `A.B` is already
+ * captured; the alias `X` lives in a sibling `name_equals` node → lift it onto the
+ * module's imported names). `using static A.B.C;` needs no refine — the base query
+ * already captures the qualified type `A.B.C` as the module source.
+ *
+ * NO exports edges — C# has no export statement (visibility is modifiers;
+ * capabilities: T2 = imports). Identity is owned by the CORE finalizer — this
+ * provider mints NO ids. The grammar loads through the SHARED engine glue
+ * (`loadGrammarWasm`), never a fresh `web-tree-sitter` import (trp_8df65ab7).
+ */
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadGrammarWasm, grammarHashForWasm } from '../../wasm-loader.js';
+import { extractWithQueries } from '../query-runtime.js';
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+/** The C# grammar .wasm: dist basename + node_modules devDep fallback spec. */
+const CSHARP_WASM_BASENAME = 'tree-sitter-c_sharp.wasm';
+const CSHARP_WASM_NODE_MODULES_SPEC = 'tree-sitter-wasms/out/tree-sitter-c_sharp.wasm';
+const CSHARP_GRAMMAR_NAME = 'tree-sitter-c_sharp';
+/** Resolve a vendored `.scm` next to this module (dist) or from the source tree. */
+function readScm(basename) {
+    const local = path.join(HERE, basename);
+    if (fs.existsSync(local))
+        return fs.readFileSync(local, 'utf-8');
+    let dir = HERE;
+    for (let i = 0; i < 12; i++) {
+        if (fs.existsSync(path.join(dir, 'package.json'))) {
+            const fromSrc = path.join(dir, 'src', 'core', 'code-map', 'lang', 'csharp', basename);
+            if (fs.existsSync(fromSrc))
+                return fs.readFileSync(fromSrc, 'utf-8');
+            break;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    throw new Error(`code-map: could not locate query asset ${basename} (from ${HERE})`);
+}
+function sha256(s) {
+    return `sha256:${crypto.createHash('sha256').update(s, 'utf-8').digest('hex')}`;
+}
+const TAGS = readScm('tags.scm');
+const IMPORTS = readScm('imports.scm');
+const TAGS_HASH = sha256(TAGS);
+const IMPORTS_HASH = sha256(IMPORTS);
+const parser = {
+    grammarForLang: () => loadGrammarWasm(CSHARP_WASM_BASENAME, CSHARP_WASM_NODE_MODULES_SPEC),
+    grammarNameForLang: () => CSHARP_GRAMMAR_NAME,
+    grammarHashForLang: () => grammarHashForWasm(CSHARP_WASM_BASENAME, CSHARP_WASM_NODE_MODULES_SPEC),
+};
+const queries = {
+    tags: { name: 'tags', sourceForLang: () => TAGS, hashForLang: () => TAGS_HASH },
+    imports: { name: 'imports', sourceForLang: () => IMPORTS, hashForLang: () => IMPORTS_HASH },
+    // C# using directives are the import statement; C# has no export statement.
+    enclosingStatementNodeTypes: ['using_directive'],
+    // Every capture mirrors the hard-coded runtime convention and is validated by
+    // `assertCaptureMapConforms`. The namespaced csharp.struct/record/delegate are
+    // still definition.<subtype>.* captures (subtype = the namespaced value).
+    captureMap: [
+        { capture: 'definition.namespace.node', field: 'node', subtype: 'namespace' },
+        { capture: 'definition.namespace.name', field: 'name' },
+        { capture: 'definition.class.node', field: 'node', subtype: 'class' },
+        { capture: 'definition.class.name', field: 'name' },
+        { capture: 'definition.interface.node', field: 'node', subtype: 'interface' },
+        { capture: 'definition.interface.name', field: 'name' },
+        { capture: 'definition.csharp.struct.node', field: 'node', subtype: 'csharp.struct' },
+        { capture: 'definition.csharp.struct.name', field: 'name' },
+        { capture: 'definition.enum.node', field: 'node', subtype: 'enum' },
+        { capture: 'definition.enum.name', field: 'name' },
+        { capture: 'definition.csharp.record.node', field: 'node', subtype: 'csharp.record' },
+        { capture: 'definition.csharp.record.name', field: 'name' },
+        { capture: 'definition.csharp.delegate.node', field: 'node', subtype: 'csharp.delegate' },
+        { capture: 'definition.csharp.delegate.name', field: 'name' },
+        { capture: 'definition.method.node', field: 'node', subtype: 'method' },
+        { capture: 'definition.method.name', field: 'name' },
+        { capture: 'definition.constructor.node', field: 'node', subtype: 'constructor' },
+        { capture: 'definition.constructor.name', field: 'name' },
+        { capture: 'definition.property.node', field: 'node', subtype: 'property' },
+        { capture: 'definition.property.name', field: 'name' },
+        { capture: 'definition.constant.node', field: 'node', subtype: 'constant' },
+        { capture: 'definition.constant.name', field: 'name' },
+        { capture: 'definition.field.node', field: 'node', subtype: 'field' },
+        { capture: 'definition.field.name', field: 'name' },
+        { capture: 'import.source', field: 'source' },
+    ],
+};
+const vocabulary = {
+    nodeSubtypes: [
+        'namespace',
+        'class',
+        'interface',
+        'csharp.struct',
+        'enum',
+        'csharp.record',
+        'csharp.delegate',
+        'method',
+        'constructor',
+        'property',
+        'constant',
+        'field',
+    ],
+    edgeKinds: ['contains', 'defines', 'imports'],
+    captureMap: queries.captureMap,
+};
+const capabilities = {
+    tiers: ['T1.definitions', 'T2.imports'],
+    proven: {
+        'T1.definitions': true,
+        'T2.imports': true,
+        'T3.import_resolution': false,
+        'T4.tests_for': false,
+    },
+};
+/** A span key matching the runtime's `spanOf` (1-based start/end line+col). */
+function spanKey(span) {
+    return `${span.start_line}:${span.start_col}:${span.end_line}:${span.end_col}`;
+}
+function spanKeyOfNode(node) {
+    return `${node.startPosition.row + 1}:${node.startPosition.column + 1}:${node.endPosition.row + 1}:${node.endPosition.column + 1}`;
+}
+/** Iterative named-node DFS collecting nodes whose type is in `types`. */
+function collectByType(root, types) {
+    const found = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const n = stack.pop();
+        if (types.has(n.type))
+            found.push(n);
+        for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (c)
+                stack.push(c);
+        }
+    }
+    return found;
+}
+const USING_DIRECTIVE = new Set(['using_directive']);
+/**
+ * Map each `using X = A.B;` directive's statement span → its alias binding name.
+ * The alias lives in a `name_equals` child (`(name_equals (identifier))`); plain
+ * and `using static` directives have none and are absent from the map.
+ */
+function aliasBySpan(tree) {
+    const out = new Map();
+    for (const dir of collectByType(tree.rootNode, USING_DIRECTIVE)) {
+        for (let i = 0; i < dir.namedChildCount; i++) {
+            const c = dir.namedChild(i);
+            if (c && c.type === 'name_equals') {
+                const alias = c.namedChild(0);
+                if (alias)
+                    out.set(spanKeyOfNode(dir), alias.text);
+                break;
+            }
+        }
+    }
+    return out;
+}
+export class CSharpProvider {
+    id = 'csharp';
+    displayName = 'C#';
+    languages = ['csharp'];
+    extensions = ['.cs'];
+    priority = 0;
+    version = '0.1.0';
+    parser = parser;
+    queries = queries;
+    vocabulary = vocabulary;
+    capabilities = capabilities;
+    /** `.cs` → `csharp`. */
+    langForPath(_p) {
+        return 'csharp';
+    }
+    async extractDraft(input, _services) {
+        return extractWithQueries({
+            providerId: this.id,
+            lang: input.lang,
+            source: input.source,
+            sizeBytes: input.sizeBytes,
+            maxParseFileBytes: input.maxParseFileBytes,
+            maxQueryWaitMs: input.maxQueryWaitMs,
+            path: input.path,
+            grammarForLang: this.parser.grammarForLang,
+            tagsSource: TAGS,
+            tagsHash: TAGS_HASH,
+            importsSource: IMPORTS,
+            importsHash: IMPORTS_HASH,
+            enclosingStatementNodeTypes: queries.enclosingStatementNodeTypes,
+        });
+    }
+    /**
+     * Drafts-only refinement: lift each `using X = A.B;` alias binding (`X`) onto the
+     * corresponding module node's imported names. The module source `A.B` is already
+     * captured structurally; plain and `using static` directives are unchanged.
+     */
+    refine(draft, _ctx) {
+        const tree = draft.attributes?.__tree;
+        if (!tree || draft.imports.length === 0)
+            return draft;
+        const aliases = aliasBySpan(tree);
+        if (aliases.size === 0)
+            return draft;
+        const imports = draft.imports.map((im) => {
+            const alias = aliases.get(spanKey(im.span));
+            return alias ? { ...im, importedNames: [alias] } : im;
+        });
+        return { ...draft, imports };
+    }
+}
+/** Singleton instance for registry wiring. */
+export const csharpProvider = new CSharpProvider();
+//# sourceMappingURL=index.js.map

package/dist/core/code-map/lang/csharp/tags.scm

@@ -0,0 +1,63 @@
+; Code Map — C# definitions (tags.scm). Provider #6 (langs batch 2).
+;
+; Capture-name convention (query-runtime.ts is the contract):
+;   @definition.<subtype>.node = identity-span anchor (the whole declaration)
+;   @definition.<subtype>.name = the symbol name node
+; Subtypes: namespace/class/interface/enum/method/constructor/property/field/
+; constant are universal. C#-distinct kinds are namespaced (Codex/Java R1 precedent
+; for record/annotation): a struct is a VALUE type first-class-distinct from a class
+; (reference type) — devs choose between them deliberately — so struct →
+; csharp.struct (NOT class like Go, where struct is the only aggregate); records →
+; csharp.record; delegates (named function-type declarations) → csharp.delegate.
+; enum members → constant. Constructors are a distinct grammar node
+; (constructor_declaration → constructor, not method). Nested/inner types + their
+; members are emitted by the same patterns; the finalizer emits only file-level
+; contains/defines (no fabricated nesting edges).
+
+; namespace Acme.Widgets { … }  — name is a qualified_name or a bare identifier.
+(namespace_declaration
+  name: [(qualified_name) (identifier)] @definition.namespace.name) @definition.namespace.node
+
+; File-scoped namespace (C# 10): `namespace Acme.App;` — its own grammar node.
+(file_scoped_namespace_declaration
+  name: [(qualified_name) (identifier)] @definition.namespace.name) @definition.namespace.node
+
+(class_declaration
+  name: (identifier) @definition.class.name) @definition.class.node
+
+(interface_declaration
+  name: (identifier) @definition.interface.name) @definition.interface.node
+
+(struct_declaration
+  name: (identifier) @definition.csharp.struct.name) @definition.csharp.struct.node
+
+(enum_declaration
+  name: (identifier) @definition.enum.name) @definition.enum.node
+
+; `record`, `record class`, and `record struct` all parse as record_declaration.
+(record_declaration
+  name: (identifier) @definition.csharp.record.name) @definition.csharp.record.node
+
+; `delegate int Transformer(int x);` — a named function-type declaration.
+(delegate_declaration
+  name: (identifier) @definition.csharp.delegate.name) @definition.csharp.delegate.node
+
+(method_declaration
+  name: (identifier) @definition.method.name) @definition.method.node
+
+(constructor_declaration
+  name: (identifier) @definition.constructor.name) @definition.constructor.node
+
+(property_declaration
+  name: (identifier) @definition.property.name) @definition.property.node
+
+; enum members map to constant: `enum Color { Red, Green }` → one per member.
+(enum_member_declaration
+  name: (identifier) @definition.constant.name) @definition.constant.node
+
+; `public int a, b;` yields one match per variable_declarator (all sharing the
+; field_declaration identity span) — mirrors the Java field multi-declarator rule.
+; The declarator's name is its first (unlabelled) identifier child.
+(field_declaration
+  (variable_declaration
+    (variable_declarator (identifier) @definition.field.name))) @definition.field.node

package/dist/core/code-map/lang/go/imports.scm

@@ -0,0 +1,13 @@
+; Code Map — Go imports (imports.scm). Provider #5 (langs batch 2).
+;
+; enclosingStatementNodeTypes = [import_declaration] (the import span/ordinal
+; anchor). Go import paths are double-quoted string literals, so the captured
+; @import.source text includes the surrounding quotes — the provider's refine()
+; strips them to the bare module path. An import alias (`import f "fmt"`) is NOT
+; lifted in v1: the module is still `fmt`, and the alias `f` is dropped (aliases
+; are cosmetic; the real package path is what a resolver needs). One import_spec
+; per imported package (Go groups them in an import_declaration but each path is
+; its own spec → its own module node).
+
+(import_spec
+  path: (interpreted_string_literal) @import.source)

package/dist/core/code-map/lang/go/index.js

@@ -0,0 +1,139 @@
+/**
+ * Code Map langs batch 2 — GoProvider (provider #5).
+ *
+ * Owns `.go` (runtime lang `go`). `extractDraft` delegates to the generic
+ * query-runtime; the curated `tags.scm`/`imports.scm` (this dir) drive extraction.
+ * Definition subtypes are fixed by the query (struct→class, interface→interface,
+ * function/method/constant/variable/package universal). `refine()` carries only
+ * what the import query cannot express structurally: Go import paths are quoted
+ * string literals, so the captured @import.source is `"pkg/path"` — strip the
+ * surrounding quotes to the bare module path.
+ *
+ * NO exports edges — Go has no export statement (visibility is capitalization;
+ * capabilities: T2 = imports). Identity is owned by the CORE finalizer — this
+ * provider mints NO ids. The grammar loads through the SHARED engine glue
+ * (`loadGrammarWasm`), never a fresh `web-tree-sitter` import (trp_8df65ab7).
+ */
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadGrammarWasm, grammarHashForWasm } from '../../wasm-loader.js';
+import { extractWithQueries } from '../query-runtime.js';
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const GO_WASM_BASENAME = 'tree-sitter-go.wasm';
+const GO_WASM_NODE_MODULES_SPEC = 'tree-sitter-wasms/out/tree-sitter-go.wasm';
+const GO_GRAMMAR_NAME = 'tree-sitter-go';
+/** Resolve a vendored `.scm` next to this module (dist) or from the source tree. */
+function readScm(basename) {
+    const local = path.join(HERE, basename);
+    if (fs.existsSync(local))
+        return fs.readFileSync(local, 'utf-8');
+    let dir = HERE;
+    for (let i = 0; i < 12; i++) {
+        if (fs.existsSync(path.join(dir, 'package.json'))) {
+            const fromSrc = path.join(dir, 'src', 'core', 'code-map', 'lang', 'go', basename);
+            if (fs.existsSync(fromSrc))
+                return fs.readFileSync(fromSrc, 'utf-8');
+            break;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    throw new Error(`code-map: could not locate query asset ${basename} (from ${HERE})`);
+}
+function sha256(s) {
+    return `sha256:${crypto.createHash('sha256').update(s, 'utf-8').digest('hex')}`;
+}
+const TAGS = readScm('tags.scm');
+const IMPORTS = readScm('imports.scm');
+const TAGS_HASH = sha256(TAGS);
+const IMPORTS_HASH = sha256(IMPORTS);
+const parser = {
+    grammarForLang: () => loadGrammarWasm(GO_WASM_BASENAME, GO_WASM_NODE_MODULES_SPEC),
+    grammarNameForLang: () => GO_GRAMMAR_NAME,
+    grammarHashForLang: () => grammarHashForWasm(GO_WASM_BASENAME, GO_WASM_NODE_MODULES_SPEC),
+};
+const queries = {
+    tags: { name: 'tags', sourceForLang: () => TAGS, hashForLang: () => TAGS_HASH },
+    imports: { name: 'imports', sourceForLang: () => IMPORTS, hashForLang: () => IMPORTS_HASH },
+    enclosingStatementNodeTypes: ['import_declaration'],
+    captureMap: [
+        { capture: 'definition.package.node', field: 'node', subtype: 'package' },
+        { capture: 'definition.package.name', field: 'name' },
+        { capture: 'definition.function.node', field: 'node', subtype: 'function' },
+        { capture: 'definition.function.name', field: 'name' },
+        { capture: 'definition.method.node', field: 'node', subtype: 'method' },
+        { capture: 'definition.method.name', field: 'name' },
+        { capture: 'definition.class.node', field: 'node', subtype: 'class' },
+        { capture: 'definition.class.name', field: 'name' },
+        { capture: 'definition.interface.node', field: 'node', subtype: 'interface' },
+        { capture: 'definition.interface.name', field: 'name' },
+        { capture: 'definition.constant.node', field: 'node', subtype: 'constant' },
+        { capture: 'definition.constant.name', field: 'name' },
+        { capture: 'definition.variable.node', field: 'node', subtype: 'variable' },
+        { capture: 'definition.variable.name', field: 'name' },
+        { capture: 'import.source', field: 'source' },
+    ],
+};
+const vocabulary = {
+    nodeSubtypes: ['package', 'function', 'method', 'class', 'interface', 'constant', 'variable'],
+    edgeKinds: ['contains', 'defines', 'imports'],
+    captureMap: queries.captureMap,
+};
+const capabilities = {
+    tiers: ['T1.definitions', 'T2.imports'],
+    proven: {
+        'T1.definitions': true,
+        'T2.imports': true,
+        'T3.import_resolution': false,
+        'T4.tests_for': false,
+    },
+};
+/** Strip the surrounding quotes/backticks from a Go string-literal import path. */
+function stripQuotes(s) {
+    return s.replace(/^[`"]/, '').replace(/[`"]$/, '');
+}
+export class GoProvider {
+    id = 'go';
+    displayName = 'Go';
+    languages = ['go'];
+    extensions = ['.go'];
+    priority = 0;
+    version = '0.1.0';
+    parser = parser;
+    queries = queries;
+    vocabulary = vocabulary;
+    capabilities = capabilities;
+    langForPath(_p) {
+        return 'go';
+    }
+    async extractDraft(input, _services) {
+        return extractWithQueries({
+            providerId: this.id,
+            lang: input.lang,
+            source: input.source,
+            sizeBytes: input.sizeBytes,
+            maxParseFileBytes: input.maxParseFileBytes,
+            maxQueryWaitMs: input.maxQueryWaitMs,
+            path: input.path,
+            grammarForLang: this.parser.grammarForLang,
+            tagsSource: TAGS,
+            tagsHash: TAGS_HASH,
+            importsSource: IMPORTS,
+            importsHash: IMPORTS_HASH,
+            enclosingStatementNodeTypes: queries.enclosingStatementNodeTypes,
+        });
+    }
+    /** Drafts-only: strip the quotes from each import path (`"fmt"` → `fmt`). */
+    refine(draft, _ctx) {
+        if (draft.imports.length === 0)
+            return draft;
+        const imports = draft.imports.map((im) => ({ ...im, source: stripQuotes(im.source) }));
+        return { ...draft, imports };
+    }
+}
+export const goProvider = new GoProvider();
+//# sourceMappingURL=index.js.map

package/dist/core/code-map/lang/go/tags.scm

@@ -0,0 +1,36 @@
+; Code Map — Go definitions (tags.scm). Provider #5 (langs batch 2).
+;
+; Capture-name convention (query-runtime.ts is the contract):
+;   @definition.<subtype>.node = identity-span anchor (the declaration)
+;   @definition.<subtype>.name = the symbol name node
+; Subtypes: function/method/interface/constant/variable/package are universal;
+; a Go struct maps to `class` (the named aggregate devs search for like a class).
+; Patterns are mutually exclusive by the `type:` child so a type_spec is captured
+; once (struct→class, interface→interface); bare type aliases are intentionally
+; not captured in v1 (low value, and a general type_spec pattern would double-match
+; struct/interface with a different subtype → duplicate symbol).
+
+(package_clause
+  (package_identifier) @definition.package.name) @definition.package.node
+
+(function_declaration
+  name: (identifier) @definition.function.name) @definition.function.node
+
+(method_declaration
+  name: (field_identifier) @definition.method.name) @definition.method.node
+
+(type_spec
+  name: (type_identifier) @definition.class.name
+  type: (struct_type)) @definition.class.node
+
+(type_spec
+  name: (type_identifier) @definition.interface.name
+  type: (interface_type)) @definition.interface.node
+
+; `const ( A = 1; B = 2 )` and `const C = 3` both yield const_spec per name.
+(const_spec
+  name: (identifier) @definition.constant.name) @definition.constant.node
+
+; Package-level `var x = …` → variable (one per var_spec name).
+(var_spec
+  name: (identifier) @definition.variable.name) @definition.variable.node

package/dist/core/code-map/lang/providers.js

@@ -16,9 +16,20 @@ import { typeScriptProvider } from './typescript/index.js';
 import { pythonProvider } from './python/index.js';
 import { phpProvider } from './php/index.js';
 import { javaProvider } from './java/index.js';
+import { goProvider } from './go/index.js';
+import { rustProvider } from './rust/index.js';
+import { csharpProvider } from './csharp/index.js';
+import { rubyProvider } from './ruby/index.js';
+import { cppProvider } from './cpp/index.js';
+import { cProvider } from './c/index.js';
 /**
  * The default registry, pre-loaded with the bundled providers. Add a new
  * provider's singleton to this `createRegistry(...)` call to register it.
+ *
+ * Registration ORDER is the collision tiebreak (earliest wins, after `priority`).
+ * `cpp` is registered BEFORE `c` so the C++ provider (a superset that parses C
+ * fine) wins the shared `.h` extension — a C header parses correctly as C++, but
+ * a C++ header would not parse as C.
  */
-export const defaultRegistry = createRegistry(typeScriptProvider, pythonProvider, phpProvider, javaProvider);
+export const defaultRegistry = createRegistry(typeScriptProvider, pythonProvider, phpProvider, javaProvider, goProvider, rustProvider, csharpProvider, rubyProvider, cppProvider, cProvider);
 //# sourceMappingURL=providers.js.map

package/dist/core/code-map/lang/ruby/imports.scm

@@ -0,0 +1,24 @@
+; Code Map — Ruby imports (imports.scm). Provider #6 (langs batch 2).
+;
+; Ruby has NO static import statement — `require` / `require_relative` are METHOD
+; CALLS. So the "import" is a (call) whose `method:` is the identifier `require` or
+; `require_relative` and whose single string argument is the required module/path.
+;
+; enclosingStatementNodeTypes = ['call'] (the require call is the import span/ordinal
+; anchor). The captured @import.source is the STRING literal node; its text includes
+; the surrounding quotes (`'sinatra'` / `"json"`), which the query-runtime strips
+; automatically (stripQuotes) — and the provider's refine() strips again defensively
+; (idempotent), matching the Go provider's documented pattern. Best-effort T2: the
+; module node `name` is the required string verbatim (`sinatra`, `json`, `./helpers`);
+; there is no path resolution (T3 = none).
+;
+; The `#any-of?` predicate restricts the match to require-family calls (verified:
+; web-tree-sitter 0.25.x applies text predicates inside `matches()`, so ordinary
+; calls like `puts "x"` / `foo.bar('y')` are filtered out and never emit a module
+; node). @_req is a predicate-only capture — the runtime ignores it (only
+; @import.source drives an ImportDraft).
+
+(call
+  method: (identifier) @_req
+  arguments: (argument_list (string) @import.source)
+  (#any-of? @_req "require" "require_relative"))