@pugi/cli 0.1.0-beta.10 → 0.1.0-beta.101

package/dist/core/codegraph/parser.js

@@ -0,0 +1,598 @@
+/**
+ * Pugi local symbol index - tree-sitter parser (PR L1).
+ *
+ * Reads one source file, parses it with the appropriate tree-sitter
+ * grammar, runs the language's symbol + edge query
+ * (`./queries/<lang>.scm`), and emits a `ParseResult`:
+ *
+ *   - `symbols`: complete `Symbol[]` ready for `db.ts:insertSymbols`.
+ *   - `pendingEdges`: name-keyed edges. `db.Edge` requires assigned
+ *     SQLite row ids on both endpoints, which the parser cannot
+ *     supply - the orchestrator (in `runtime/commands/index-cmd.ts`)
+ *     inserts symbols first, builds a name map per file, and then
+ *     resolves pending edges before calling `insertEdges`. Cross-file
+ *     edges land when the target symbol exists in the index at flush
+ *     time.
+ *
+ * Design decisions:
+ *
+ *  - The contract types in `./types.ts` are FROZEN. We extend the
+ *    `ParseResult` shape locally (add `pendingEdges`) rather than
+ *    changing `Edge` to carry names. `db.ts` stays single-purpose.
+ *  - Tree-sitter has built-in error recovery via `SyntaxNode.hasError`.
+ *    Broken sources still produce a partial tree; we walk it as-is
+ *    and surface the partial symbol set rather than throwing. This
+ *    mirrors Aider / Cody / Sourcegraph - all production indexers
+ *    swallow parse errors and trust the user to notice via downstream
+ *    symptoms.
+ *  - The performance budget (200 ms per 5K LOC file) is enforced by
+ *    `setTimeoutMicros` on the parser and a wall-clock check after
+ *    the query pass. Over-budget files emit to stderr (unless
+ *    silenced) rather than throwing.
+ *  - Query files (`.scm`) are loaded once per process and the
+ *    compiled `Parser.Query` instances are cached on the grammar.
+ *    The query constructor is the expensive step (~30-50 ms for a
+ *    20-pattern query) - the cache keeps reindex throughput high.
+ *
+ * Native dependency caveat: `tree-sitter` + the per-language grammar
+ * packages are native modules. The `node-gyp-build` runtime they ship
+ * resolves prebuilt binaries for darwin-{arm64,x64},
+ * linux-{arm64,x64}, win32-arm64 - the set the @pugi/cli customer
+ * matrix actually covers. On an unsupported platform `require()`
+ * throws at the top-level import; we lazy-load the grammar (and the
+ * runtime itself, via dynamic import) so a missing prebuild degrades
+ * to "unsupported file type" rather than crashing the CLI on startup.
+ * See `loadBindings`.
+ */
+import { promises as fs, readFileSync } from 'node:fs';
+import { extname, dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { performance } from 'node:perf_hooks';
+/** Wall-clock perf budget in milliseconds for a single file. */
+const PERF_BUDGET_MS = 200;
+/**
+ * tree-sitter accepts a microseconds timeout on the parser itself.
+ * We cap parsing at 2x the wall-clock budget to give the query
+ * phase headroom while still bounding pathological cases.
+ */
+const PARSER_TIMEOUT_MICROS = PERF_BUDGET_MS * 1000 * 2;
+/**
+ * Extensions the parser handles. Mirror of the docs in `db.ts` /
+ * `types.ts:IndexedLanguage`. Anything not in this map returns an
+ * empty ParseResult without touching tree-sitter at all.
+ */
+const EXT_TO_LANG = Object.freeze({
+    '.ts': 'typescript',
+    '.tsx': 'tsx',
+    '.js': 'javascript',
+    '.jsx': 'javascript',
+    '.mjs': 'javascript',
+    '.cjs': 'javascript',
+    '.py': 'python',
+    '.go': 'go',
+    '.rs': 'rust',
+});
+/**
+ * Stable list of file extensions the v1 parser supports. Exported
+ * so the watcher (PR L2) and the CLI command (`pugi index`) can
+ * pre-filter the file walk without instantiating a parser. The set
+ * mirrors `INDEXED_LANGUAGES` in `./types.ts`.
+ */
+export const PARSEABLE_EXTENSIONS = Object.freeze([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.py',
+    '.go',
+    '.rs',
+]);
+/** Tag for the typescript-with-jsx variant of the tree-sitter grammar. */
+const TSX_TAG = 'tsx';
+let bindingsCache = null;
+let bindingsError = null;
+let bindingsErrorReported = false;
+/**
+ * Lazy-load tree-sitter runtime + grammar bindings. Bundled here so
+ * that a missing prebuild on the host platform produces a "no
+ * parser" branch rather than a startup-time `require()` throw that
+ * crashes `pugi` before the operator sees a prompt.
+ *
+ * Returns null when the native module is unavailable. Callers
+ * downgrade to "unsupported file type" - the CLI logs the underlying
+ * error to stderr once per process for transparency.
+ */
+async function loadBindings(quiet) {
+    if (bindingsCache)
+        return bindingsCache;
+    if (bindingsError) {
+        if (!quiet && !bindingsErrorReported) {
+            bindingsErrorReported = true;
+            process.stderr.write(`pugi index: tree-sitter unavailable on this platform - ${bindingsError.message}\n`);
+        }
+        return null;
+    }
+    try {
+        // Dynamic import so a missing prebuild surfaces as a normal
+        // Error and the rest of the CLI keeps working. `tree-sitter`
+        // itself ships a CJS entry; the ESM dynamic import wraps it
+        // transparently.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const tsModule = await import('tree-sitter');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const ParserCtor = tsModule.default ?? tsModule;
+        const QueryCtor = ParserCtor.Query;
+        if (typeof QueryCtor !== 'function') {
+            throw new Error('tree-sitter module loaded but Parser.Query is missing - rebuild the native binding');
+        }
+        const langs = new Map();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const pickLang = async (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        importer, 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        pick) => {
+            const mod = await importer();
+            const language = pick(mod);
+            if (!language) {
+                throw new Error('grammar load produced no Language object');
+            }
+            return language;
+        };
+        const typescript = await pickLang(() => import('tree-sitter-typescript'), (m) => m.typescript ?? m.default?.typescript);
+        const tsx = await pickLang(() => import('tree-sitter-typescript'), (m) => m.tsx ?? m.default?.tsx);
+        const javascript = await pickLang(() => import('tree-sitter-javascript'), (m) => m.default ?? m);
+        const python = await pickLang(() => import('tree-sitter-python'), (m) => m.default ?? m);
+        const go = await pickLang(() => import('tree-sitter-go'), (m) => m.default ?? m);
+        const rust = await pickLang(() => import('tree-sitter-rust'), (m) => m.default ?? m);
+        const tsQuerySrc = readQuerySource('typescript');
+        const jsQuerySrc = readQuerySource('javascript');
+        const pyQuerySrc = readQuerySource('python');
+        const goQuerySrc = readQuerySource('go');
+        const rsQuerySrc = readQuerySource('rust');
+        langs.set('typescript', {
+            language: typescript,
+            query: new QueryCtor(typescript, tsQuerySrc),
+        });
+        langs.set(TSX_TAG, {
+            language: tsx,
+            query: new QueryCtor(tsx, tsQuerySrc),
+        });
+        langs.set('javascript', {
+            language: javascript,
+            query: new QueryCtor(javascript, jsQuerySrc),
+        });
+        langs.set('python', {
+            language: python,
+            query: new QueryCtor(python, pyQuerySrc),
+        });
+        langs.set('go', {
+            language: go,
+            query: new QueryCtor(go, goQuerySrc),
+        });
+        langs.set('rust', {
+            language: rust,
+            query: new QueryCtor(rust, rsQuerySrc),
+        });
+        bindingsCache = { ParserCtor, langs };
+        return bindingsCache;
+    }
+    catch (err) {
+        bindingsError = err instanceof Error ? err : new Error(String(err));
+        if (!quiet && !bindingsErrorReported) {
+            bindingsErrorReported = true;
+            process.stderr.write(`pugi index: tree-sitter unavailable on this platform - ${bindingsError.message}\n`);
+        }
+        return null;
+    }
+}
+/**
+ * Reset the bindings cache. Exposed for tests so a forced reload
+ * exercises the cold path. Not part of the public API.
+ */
+export function __resetBindingsCacheForTests() {
+    bindingsCache = null;
+    bindingsError = null;
+    bindingsErrorReported = false;
+}
+/**
+ * Resolve `<here>/queries/<lang>.scm`. tsc copies the `.scm` files
+ * to `dist/core/codegraph/queries/` via `scripts/copy-queries.mjs`;
+ * at runtime (both via `tsx` against `src/` and via `node` against
+ * `dist/`) `import.meta.url` already points to the right tree.
+ */
+function readQuerySource(lang) {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const path = resolve(here, 'queries', `${lang}.scm`);
+    return readFileSync(path, 'utf8');
+}
+/**
+ * Resolve the language tag for a given file path. Returns null when
+ * the extension is not in the v1 set. Exported for the watcher and
+ * tests; the CLI does the same check via PARSEABLE_EXTENSIONS first.
+ */
+export function detectLanguage(path) {
+    const ext = extname(path).toLowerCase();
+    return EXT_TO_LANG[ext] ?? null;
+}
+/**
+ * Parse one source file. The signature is the stable contract that
+ * db.ts, the watcher (PR L2), and the MCP tools (PR L3) consume.
+ *
+ * Behavior summary:
+ *
+ *  - Unsupported extension - `{symbols: [], pendingEdges: [],
+ *    language: null}` without reading the file.
+ *  - tree-sitter unavailable (no prebuild) - same shape, plus a
+ *    one-time stderr message.
+ *  - Source bytes large or syntactically broken - partial result;
+ *    `SyntaxNode.hasError` does not abort the walk.
+ *  - Perf budget exceeded - result is returned anyway; a one-line
+ *    warning to stderr (unless `opts.quiet`) so reindex throughput
+ *    issues surface without aborting the run.
+ *
+ * Throws only on un-recoverable IO errors (file disappeared
+ * mid-read on the supplied workspace). Callers wrap in try/catch
+ * when they want to tolerate that as well.
+ */
+export async function parseFile(path, opts = {}) {
+    const language = detectLanguage(path);
+    if (!language) {
+        return { symbols: [], pendingEdges: [], language: null, parseMs: 0 };
+    }
+    const bindings = await loadBindings(opts.quiet === true);
+    if (!bindings) {
+        return { symbols: [], pendingEdges: [], language: null, parseMs: 0 };
+    }
+    const langEntry = bindings.langs.get(language);
+    if (!langEntry) {
+        return { symbols: [], pendingEdges: [], language: null, parseMs: 0 };
+    }
+    const source = opts.sourceOverride !== undefined
+        ? opts.sourceOverride
+        : await fs.readFile(path, 'utf8');
+    const relPath = opts.relPath ?? path;
+    const start = performance.now();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const parser = new bindings.ParserCtor();
+    parser.setLanguage(langEntry.language);
+    // node-tree-sitter's `setTimeoutMicros` is a hard cap that returns
+    // null from `parse()` when exceeded. We catch null and emit an
+    // empty result so the rest of the index walk keeps making progress.
+    if (typeof parser.setTimeoutMicros === 'function') {
+        parser.setTimeoutMicros(PARSER_TIMEOUT_MICROS);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let tree = null;
+    try {
+        tree = parser.parse(source);
+    }
+    catch (err) {
+        if (!opts.quiet) {
+            process.stderr.write(`pugi index: parse error in ${relPath}: ${err instanceof Error ? err.message : String(err)}\n`);
+        }
+        return {
+            symbols: [],
+            pendingEdges: [],
+            language: tagForResult(language),
+            parseMs: performance.now() - start,
+        };
+    }
+    if (!tree || !tree.rootNode) {
+        return {
+            symbols: [],
+            pendingEdges: [],
+            language: tagForResult(language),
+            parseMs: performance.now() - start,
+        };
+    }
+    const { symbols, pendingEdges } = extract(tree.rootNode, langEntry.query, relPath, language);
+    const parseMs = performance.now() - start;
+    if (parseMs > PERF_BUDGET_MS && !opts.quiet) {
+        const loc = countLines(source);
+        process.stderr.write(`pugi index: ${relPath} parsed in ${parseMs.toFixed(1)} ms (${loc} LOC) - over ${PERF_BUDGET_MS} ms budget\n`);
+    }
+    return {
+        symbols,
+        pendingEdges,
+        language: tagForResult(language),
+        parseMs,
+    };
+}
+/**
+ * Map the tree-sitter grammar tag back to the customer-facing
+ * language label used by `Symbol` / `IndexedLanguage`. We collapse
+ * the tsx grammar back to `typescript` so the FTS5 + db layer sees
+ * one tag per extension family.
+ */
+function tagForResult(grammarTag) {
+    if (grammarTag === TSX_TAG)
+        return 'typescript';
+    return grammarTag;
+}
+/**
+ * Walk every capture produced by the language query and split it
+ * into `Symbol` rows and `PendingEdge` entries. The capture-name
+ * convention is documented in each `.scm` file head; here we
+ * centralize the parsing of `@symbol.<kind>.def` /
+ * `@symbol.<kind>.name` / `@edge.<kind>.target` /
+ * `@edge.<kind>.from`.
+ *
+ * Scope is computed by walking up the syntax tree from the
+ * definition node and collecting the names of enclosing class /
+ * function / module declarations. The dotted form matches the
+ * convention in `types.ts:Symbol.scope`. Cost is bounded by tree
+ * depth, which is bounded by source nesting; on a 5K LOC file
+ * scope resolution is dominated by the query pass itself.
+ */
+function extract(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+rootNode, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+query, file, grammarTag) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const matches = query.matches(rootNode);
+    const symbols = [];
+    /**
+     * Map from def-node identity to the index in `symbols`. The same
+     * def may appear in multiple matches (a class with both an extends
+     * and implements clause); we dedupe to keep one Symbol row per
+     * declaration site.
+     */
+    const symbolByDefId = new Map();
+    /**
+     * Map from caller-side definition node id to the canonical name +
+     * scope pair. Used when a later @edge.calls.target capture lands
+     * inside that definition and we need to know who originated the
+     * edge.
+     */
+    const defContextByNodeId = new Map();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const collectSymbol = (defNode, nameNode, kind) => {
+        if (symbolByDefId.has(defNode.id))
+            return;
+        const scope = computeScope(defNode, grammarTag);
+        const symbol = {
+            name: nameNode.text,
+            kind,
+            file,
+            line: defNode.startPosition.row + 1,
+            column: defNode.startPosition.column,
+            scope,
+        };
+        const sig = trimSignature(defNode);
+        if (sig)
+            symbol.signature = sig;
+        symbolByDefId.set(defNode.id, symbols.length);
+        symbols.push(symbol);
+        defContextByNodeId.set(defNode.id, {
+            name: symbol.name,
+            scope: symbol.scope,
+            kind: symbol.kind,
+        });
+    };
+    for (const m of matches) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const defs = {};
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const names = {};
+        for (const cap of m.captures) {
+            const parts = cap.name.split('.');
+            if (parts[0] !== 'symbol' || parts.length < 3)
+                continue;
+            const kind = parts[1];
+            const role = parts[2];
+            if (role === 'def')
+                defs[kind] = cap.node;
+            else if (role === 'name')
+                names[kind] = cap.node;
+        }
+        for (const kind of Object.keys(defs)) {
+            const def = defs[kind];
+            const nm = names[kind];
+            if (!def || !nm)
+                continue;
+            if (!isSymbolKind(kind))
+                continue;
+            collectSymbol(def, nm, kind);
+        }
+    }
+    const pendingEdges = [];
+    for (const m of matches) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const fromCaps = {};
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const targetCaps = {};
+        for (const cap of m.captures) {
+            const parts = cap.name.split('.');
+            if (parts[0] !== 'edge' || parts.length < 3)
+                continue;
+            const kind = parts[1];
+            const role = parts[2];
+            if (role === 'from')
+                fromCaps[kind] = cap.node;
+            else if (role === 'target')
+                targetCaps[kind] = cap.node;
+        }
+        for (const kind of Object.keys(targetCaps)) {
+            const tgt = targetCaps[kind];
+            if (!tgt)
+                continue;
+            if (!isEdgeKind(kind))
+                continue;
+            const fromNode = fromCaps[kind];
+            let fromName;
+            let fromScope;
+            if (fromNode) {
+                fromName = fromNode.text;
+                fromScope = computeScope(fromNode, grammarTag);
+            }
+            else {
+                const ctx = findEnclosingDef(tgt, defContextByNodeId);
+                if (!ctx) {
+                    // No tracked caller in this file - skip; the orchestrator
+                    // can't store an orphan with no fromSymbolId. We could in
+                    // theory emit a "file-level" edge, but the db schema does
+                    // not model that today and PR L4 PageRank does not need it.
+                    continue;
+                }
+                fromName = ctx.name;
+                fromScope = ctx.scope;
+            }
+            pendingEdges.push({
+                fromName,
+                fromScope,
+                toName: tgt.text,
+                kind,
+                line: tgt.startPosition.row + 1,
+            });
+        }
+    }
+    return { symbols, pendingEdges };
+}
+/**
+ * Walk parents until we hit a node that owns a tracked symbol. The
+ * map is keyed by `SyntaxNode.id`, which is stable within a tree.
+ */
+function findEnclosingDef(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+startNode, byId) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let n = startNode.parent;
+    while (n) {
+        const ctx = byId.get(n.id);
+        if (ctx)
+            return ctx;
+        n = n.parent;
+    }
+    return null;
+}
+/**
+ * Walk parents to build a dotted scope path. We collect ancestor
+ * names for class / interface / function / method / module
+ * declarations. Cross-language node-type names diverge - the picker
+ * uses a small grammar-tagged switch to match the right node types.
+ */
+function computeScope(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+defNode, grammarTag) {
+    const names = [];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let n = defNode.parent;
+    while (n) {
+        const tag = scopeNameFor(n, grammarTag);
+        if (tag)
+            names.unshift(tag);
+        n = n.parent;
+    }
+    return names.join(grammarTag === 'rust' ? '::' : '.');
+}
+/**
+ * Per-grammar lookup: given a syntax node, return the
+ * operator-facing name to contribute to scope, or null if this node
+ * is not a scope. Centralized here so adding a new grammar means
+ * appending one branch.
+ */
+function scopeNameFor(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+node, grammarTag) {
+    const type = node.type;
+    switch (grammarTag) {
+        case 'typescript':
+        case 'tsx':
+        case 'javascript':
+            if (type === 'class_declaration' ||
+                type === 'abstract_class_declaration' ||
+                type === 'interface_declaration' ||
+                type === 'function_declaration' ||
+                type === 'method_definition') {
+                return nodeFieldText(node, 'name');
+            }
+            return null;
+        case 'python':
+            if (type === 'class_definition' || type === 'function_definition') {
+                return nodeFieldText(node, 'name');
+            }
+            return null;
+        case 'go':
+            if (type === 'function_declaration' ||
+                type === 'method_declaration' ||
+                type === 'type_declaration') {
+                return nodeFieldText(node, 'name');
+            }
+            return null;
+        case 'rust':
+            if (type === 'mod_item' ||
+                type === 'function_item' ||
+                type === 'struct_item' ||
+                type === 'enum_item' ||
+                type === 'trait_item') {
+                return nodeFieldText(node, 'name');
+            }
+            return null;
+        default:
+            return null;
+    }
+}
+/**
+ * Extract `node.childForFieldName(field)?.text` defensively.
+ * Returns null if either the field is absent OR the child has no
+ * text. We do NOT throw; absent field names in tree-sitter happen
+ * frequently on partial trees and broken syntax.
+ */
+function nodeFieldText(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+node, field) {
+    if (typeof node.childForFieldName !== 'function')
+        return null;
+    const child = node.childForFieldName(field);
+    if (!child)
+        return null;
+    const txt = child.text;
+    return typeof txt === 'string' && txt.length > 0 ? txt : null;
+}
+/**
+ * Cap signature snippets to the first line, trimmed to 120 chars.
+ * The FTS5 column does not need full bodies; readers ask for the
+ * file and line instead. Keeps storage flat.
+ */
+function trimSignature(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+defNode) {
+    const text = defNode.text;
+    if (typeof text !== 'string' || text.length === 0)
+        return null;
+    const firstLine = text.split(/\r?\n/, 1)[0]?.trim() ?? '';
+    if (firstLine.length === 0)
+        return null;
+    if (firstLine.length <= 120)
+        return firstLine;
+    return `${firstLine.slice(0, 117)}...`;
+}
+function countLines(s) {
+    let n = 1;
+    for (let i = 0; i < s.length; i += 1) {
+        if (s.charCodeAt(i) === 10)
+            n += 1;
+    }
+    return n;
+}
+function isSymbolKind(s) {
+    return (s === 'function' ||
+        s === 'class' ||
+        s === 'method' ||
+        s === 'interface' ||
+        s === 'type' ||
+        s === 'variable' ||
+        s === 'import');
+}
+function isEdgeKind(s) {
+    return (s === 'calls' ||
+        s === 'extends' ||
+        s === 'implements' ||
+        s === 'imports' ||
+        s === 'references');
+}
+//# sourceMappingURL=parser.js.map

package/dist/core/codegraph/queries/go.scm

@@ -0,0 +1,57 @@
+; Go symbol + edge query - used by core/codegraph/parser.ts.
+;
+; SymbolKind coverage:
+;   function   - function_declaration at file top level
+;   method     - method_declaration (receiver-attached)
+;   type       - type_declaration (struct, alias, interface base)
+;   interface  - type_declaration whose underlying type is interface_type
+;   variable   - top-level var / const single-identifier binding
+;   import     - import_spec path string OR alias identifier
+;
+; EdgeKind coverage:
+;   calls      - call_expression with identifier OR selector
+;   implements - Go has no `implements` keyword; satisfaction is
+;                structural. We do NOT emit implements edges for Go.
+
+(function_declaration
+  name: (identifier) @symbol.function.name) @symbol.function.def
+
+(method_declaration
+  name: (field_identifier) @symbol.method.name) @symbol.method.def
+
+; `type Foo struct { ... }` / `type Foo interface { ... }` / `type Foo = X`
+(type_declaration
+  (type_spec
+    name: (type_identifier) @symbol.type.name)) @symbol.type.def
+
+(type_declaration
+  (type_spec
+    name: (type_identifier) @symbol.interface.name
+    type: (interface_type))) @symbol.interface.def
+
+; Top-level var / const - single-identifier specs only to dodge noise.
+(var_declaration
+  (var_spec
+    name: (identifier) @symbol.variable.name)) @symbol.variable.def
+
+(const_declaration
+  (const_spec
+    name: (identifier) @symbol.variable.name)) @symbol.variable.def
+
+; Imports: `import "fmt"` / `import f "fmt"`. We keep both the quoted
+; path and the alias identifier as the symbol name. Reviewer note: the
+; quoted form (with double quotes) matches what Go editor tooling
+; surfaces - we keep it as-is.
+(import_spec
+  path: (interpreted_string_literal) @symbol.import.name) @symbol.import.def
+
+(import_spec
+  name: (package_identifier) @symbol.import.name) @symbol.import.def
+
+; Calls: bare and selector.
+(call_expression
+  function: (identifier) @edge.calls.target)
+
+(call_expression
+  function: (selector_expression
+    field: (field_identifier) @edge.calls.target))