@getmikk/core 2.0.12 → 2.0.14

package/src/parser/index.ts

@@ -4,6 +4,15 @@ import { OxcParser } from './oxc-parser.js'
 import { GoParser } from './go/go-parser.js'
 import { UnsupportedLanguageError } from '../utils/errors.js'
 import type { ParsedFile } from './types.js'
+import { hashContent } from '../hash/file-hasher.js'
+import { IncrementalCache } from '../cache/incremental-cache.js'
+import {
+    parserKindForExtension,
+    languageForExtension,
+    getParserExtensions,
+    isTreeSitterExtension,
+    type ParserKind,
+} from '../utils/language-registry.js'
 
 export type {
     ParsedFile,
@@ -30,42 +39,93 @@ export { JavaScriptResolver } from './javascript/js-resolver.js'
 export { BoundaryChecker } from './boundary-checker.js'
 export { TreeSitterParser } from './tree-sitter/parser.js'
 
+export type ParseDiagnosticStage = 'read' | 'parse' | 'resolve-imports'
+export type ParseDiagnosticReason =
+    | 'read-error'
+    | 'parse-error'
+    | 'resolve-error'
+    | 'unsupported-extension'
+    | 'parser-unavailable'
+
+export interface ParseDiagnostic {
+    filePath: string
+    extension: string
+    parser: ParserKind
+    stage: ParseDiagnosticStage
+    reason: ParseDiagnosticReason
+    message: string
+}
+
+export interface ParseFilesSummary {
+    requestedFiles: number
+    parsedFiles: number
+    fallbackFiles: number
+    unreadableFiles: number
+    unsupportedFiles: number
+    diagnostics: number
+}
+
+export interface ParseFilesResult {
+    files: ParsedFile[]
+    diagnostics: ParseDiagnostic[]
+    summary: ParseFilesSummary
+}
+
+const isLikelyParserUnavailable = (parser: ParserKind, message: string): boolean => {
+    if (parser !== 'tree-sitter') return false
+    const normalized = message.toLowerCase()
+    return normalized.includes('web-tree-sitter') ||
+        normalized.includes('tree-sitter') ||
+        normalized.includes('cannot find module')
+}
+
+
+const buildFallbackParsedFile = (filePath: string, content: string, ext: string): ParsedFile => ({
+    path: filePath,
+    language: languageForExtension(ext) as ParsedFile['language'],
+    functions: [],
+    classes: [],
+    generics: [],
+    imports: [],
+    exports: [],
+    routes: [],
+    variables: [],
+    calls: [],
+    hash: hashContent(content),
+    parsedAt: Date.now(),
+})
+
+const normalizeErrorMessage = (err: unknown): string => {
+    if (!err) return 'Unknown error'
+    if (err instanceof Error) return err.message
+    return String(err)
+}
+
 /** Get the appropriate parser for a file based on its extension */
 export function getParser(filePath: string): BaseParser {
     const ext = nodePath.extname(filePath).toLowerCase()
-    switch (ext) {
-        case '.ts':
-        case '.tsx':
-        case '.js':
-        case '.mjs':
-        case '.cjs':
-        case '.jsx':
+    const parserKind = parserKindForExtension(ext)
+
+    switch (parserKind) {
+        case 'oxc':
             return new OxcParser()
-        case '.go':
+        case 'go':
             return new GoParser()
-        case '.py':
-        case '.java':
-        case '.c':
-        case '.h':
-        case '.cpp':
-        case '.cc':
-        case '.hpp':
-        case '.cs':
-        case '.rs':
-        case '.php':
-        case '.rb':
-            // Tree-sitter parser - dynamically imported to handle missing web-tree-sitter
+        case 'tree-sitter':
             return createTreeSitterParser()
         default:
-            throw new UnsupportedLanguageError(ext)
+            throw new UnsupportedLanguageError(ext || '<no extension>')
     }
 }
 
-const _treeSitterParserInstance: BaseParser | null = null
+let _treeSitterParserInstance: BaseParser | null = null
 
 const createTreeSitterParser = (): BaseParser => {
-    // Return a lazy-loading wrapper that handles missing tree-sitter gracefully
-    return new LazyTreeSitterParser()
+    if (!_treeSitterParserInstance) {
+        // Return a lazy-loading wrapper that handles missing tree-sitter gracefully.
+        _treeSitterParserInstance = new LazyTreeSitterParser()
+    }
+    return _treeSitterParserInstance
 }
 
 class LazyTreeSitterParser extends BaseParser {
@@ -96,26 +156,15 @@ class LazyTreeSitterParser extends BaseParser {
     }
 
     getSupportedExtensions(): string[] {
-        return ['.py', '.java', '.c', '.h', '.cpp', '.cc', '.hpp', '.cs', '.rs', '.php', '.rb']
+        return [...getParserExtensions('tree-sitter')]
     }
 
     private buildEmptyFile(filePath: string, content: string): ParsedFile {
         const ext = nodePath.extname(filePath).toLowerCase()
-        let lang: ParsedFile['language'] = 'unknown'
-        switch (ext) {
-            case '.py': lang = 'python'; break
-            case '.java': lang = 'java'; break
-            case '.c': case '.h': lang = 'c'; break
-            case '.cpp': case '.cc': case '.hpp': lang = 'cpp'; break
-            case '.cs': lang = 'csharp'; break
-            case '.go': lang = 'go'; break
-            case '.rs': lang = 'rust'; break
-            case '.php': lang = 'php'; break
-            case '.rb': lang = 'ruby'; break
-        }
+        const lang = languageForExtension(ext)
         return {
             path: filePath,
-            language: lang,
+            language: lang as ParsedFile['language'],
             functions: [],
             classes: [],
             generics: [],
@@ -124,97 +173,304 @@ class LazyTreeSitterParser extends BaseParser {
             routes: [],
             variables: [],
             calls: [],
-            hash: '',
+            hash: hashContent(content),
             parsedAt: Date.now(),
         }
     }
 }
 
-/**
- * Parse multiple files, resolve their imports, and return ParsedFile[].
- *
- * Path contract (critical for graph correctness):
- *   - filePaths come from discoverFiles() as project-root-relative strings
- *   - We resolve them to ABSOLUTE posix paths before passing to parse()
- *   - ParsedFile.path is therefore always absolute + forward-slash
- *   - OxcResolver also returns absolute paths → import edges always consistent
- */
-export async function parseFiles(
+export interface ParseFilesOptions {
+    strictParserPreflight?: boolean
+    treeSitterRuntimeAvailable?: boolean
+}
+
+async function isTreeSitterRuntimeAvailable(): Promise<boolean> {
+    try {
+        const { TreeSitterParser } = await import('./tree-sitter/parser.js')
+        const parser = new TreeSitterParser()
+        if (typeof (parser as any).isRuntimeAvailable !== 'function') {
+            return true
+        }
+        return await (parser as any).isRuntimeAvailable()
+    } catch {
+        return false
+    }
+}
+
+export async function parseFilesWithDiagnostics(
     filePaths: string[],
     projectRoot: string,
-    readFile: (fp: string) => Promise<string>
-): Promise<ParsedFile[]> {
-    // Shared parser instances — avoid re-initialisation overhead per file
+    readFile: (fp: string) => Promise<string>,
+    options: ParseFilesOptions = {},
+): Promise<ParseFilesResult> {
+    // Shared parser instances — avoid re-initialisation overhead per file.
     const oxcParser = new OxcParser()
     const goParser = new GoParser()
 
-    // Lazily loaded to avoid mandatory dep on tree-sitter
+    // Lazily loaded to avoid mandatory dependency on tree-sitter for TS/JS-only projects.
     let treeSitterParser: BaseParser | null = null
     const getTreeSitter = async (): Promise<BaseParser> => {
         if (!treeSitterParser) {
             const { TreeSitterParser } = await import('./tree-sitter/parser.js')
             treeSitterParser = new TreeSitterParser()
         }
-        return treeSitterParser!
+        return treeSitterParser
     }
 
-    const tsExtensions = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'])
-    const goExtensions = new Set(['.go'])
-    const treeSitterExtensions = new Set(['.py', '.java', '.c', '.h', '.cpp', '.cc', '.hpp', '.cs', '.rs', '.php', '.rb'])
+    const diagnostics: ParseDiagnostic[] = []
+    const addDiagnostic = (diagnostic: ParseDiagnostic) => diagnostics.push(diagnostic)
+
+    const treeSitterNeeded = filePaths.some(fp => {
+        const ext = nodePath.extname(fp).toLowerCase()
+        return isTreeSitterExtension(ext)
+    })
+
+    let treeSitterAvailable = true
+    if (treeSitterNeeded) {
+        treeSitterAvailable =
+            typeof options.treeSitterRuntimeAvailable === 'boolean'
+                ? options.treeSitterRuntimeAvailable
+                : await isTreeSitterRuntimeAvailable()
+        if (!treeSitterAvailable) {
+            addDiagnostic({
+                filePath: '*',
+                extension: '*',
+                parser: 'tree-sitter',
+                stage: 'parse',
+                reason: 'parser-unavailable',
+                message: 'Tree-sitter runtime unavailable. Install web-tree-sitter and language grammars.',
+            })
+            if (options.strictParserPreflight) {
+                return {
+                    files: [],
+                    diagnostics,
+                    summary: {
+                        requestedFiles: filePaths.length,
+                        parsedFiles: 0,
+                        fallbackFiles: 0,
+                        unreadableFiles: 0,
+                        unsupportedFiles: 0,
+                        diagnostics: diagnostics.length,
+                    },
+                }
+            }
+        }
+    }
 
-    // Normalised project root for absolute path construction
+    // Initialize incremental cache
+    const cache = new IncrementalCache(projectRoot)
+
+    // Normalized project root for absolute path construction.
     const normalizedRoot = nodePath.resolve(projectRoot).replace(/\\/g, '/')
 
-    // Group by parser to enable batch resolveImports
+    // Group by parser to enable batch resolveImports.
     const oxcFiles: ParsedFile[] = []
     const goFiles: ParsedFile[] = []
     const treeFiles: ParsedFile[] = []
+    const fallbackFiles: ParsedFile[] = []
+
+    let parsedFilesCount = 0
+    let fallbackFilesCount = 0
+    let unreadableFiles = 0
+    let unsupportedFiles = 0
 
     // Parse sequentially to avoid races in parser implementations that keep
     // mutable per-instance state (e.g. language switching/counters).
     for (const fp of filePaths) {
         const ext = nodePath.extname(fp).toLowerCase()
+        const parserKind = parserKindForExtension(ext)
 
-        // Build absolute posix path — this is the single source of truth for all IDs
+        // Build absolute posix path — this is the single source of truth for all IDs.
         const absoluteFp = nodePath.resolve(normalizedRoot, fp).replace(/\\/g, '/')
 
         let content: string
         try {
             content = await readFile(absoluteFp)
-        } catch {
-            // File unreadable — skip silently (deleted, permission error, binary)
+        } catch (err: unknown) {
+            unreadableFiles += 1
+            addDiagnostic({
+                filePath: absoluteFp,
+                extension: ext,
+                parser: parserKind,
+                stage: 'read',
+                reason: 'read-error',
+                message: normalizeErrorMessage(err),
+            })
+            continue
+        }
+
+        if (parserKind === 'unknown') {
+            unsupportedFiles += 1
+            fallbackFilesCount += 1
+            fallbackFiles.push(buildFallbackParsedFile(absoluteFp, content, ext))
+            addDiagnostic({
+                filePath: absoluteFp,
+                extension: ext,
+                parser: parserKind,
+                stage: 'parse',
+                reason: 'unsupported-extension',
+                message: `Unsupported extension: ${ext || '<none>'}`,
+            })
             continue
         }
 
         try {
-            if (tsExtensions.has(ext)) {
+            // Compute content hash for cache lookup
+            const contentHash = hashContent(content)
+
+            // Check cache first
+            const cached = await cache.get(absoluteFp, contentHash)
+            if (cached) {
+                // Cache hit — reuse parsed result
+                if (parserKind === 'oxc') {
+                    oxcFiles.push(cached)
+                } else if (parserKind === 'go') {
+                    goFiles.push(cached)
+                } else {
+                    treeFiles.push(cached)
+                }
+                parsedFilesCount += 1
+                continue
+            }
+
+            // Cache miss — parse and store
+            if (parserKind === 'oxc') {
                 const parsed = await oxcParser.parse(absoluteFp, content)
+                await cache.set(absoluteFp, contentHash, parsed)
                 oxcFiles.push(parsed)
-            } else if (goExtensions.has(ext)) {
+                parsedFilesCount += 1
+            } else if (parserKind === 'go') {
                 const parsed = await goParser.parse(absoluteFp, content)
+                await cache.set(absoluteFp, contentHash, parsed)
                 goFiles.push(parsed)
-            } else if (treeSitterExtensions.has(ext)) {
+                parsedFilesCount += 1
+            } else {
+                if (!treeSitterAvailable) {
+                    fallbackFilesCount += 1
+                    fallbackFiles.push(buildFallbackParsedFile(absoluteFp, content, ext))
+                    addDiagnostic({
+                        filePath: absoluteFp,
+                        extension: ext,
+                        parser: 'tree-sitter',
+                        stage: 'parse',
+                        reason: 'parser-unavailable',
+                        message: 'Tree-sitter runtime unavailable. Falling back to empty parsed file.',
+                    })
+                    continue
+                }
                 const ts = await getTreeSitter()
                 const parsed = await ts.parse(absoluteFp, content)
+                await cache.set(absoluteFp, contentHash, parsed)
                 treeFiles.push(parsed)
+                parsedFilesCount += 1
             }
-        } catch {
-            // Parser error — skip this file, don't abort the whole run
+        } catch (err: unknown) {
+            fallbackFilesCount += 1
+            const message = normalizeErrorMessage(err)
+            const reason: ParseDiagnosticReason = isLikelyParserUnavailable(parserKind, message)
+                ? 'parser-unavailable'
+                : 'parse-error'
+
+            fallbackFiles.push(buildFallbackParsedFile(absoluteFp, content, ext))
+            addDiagnostic({
+                filePath: absoluteFp,
+                extension: ext,
+                parser: parserKind,
+                stage: 'parse',
+                reason,
+                message,
+            })
+        }
+    }
+
+    // Resolve imports batch-wise per parser (each has its own resolver).
+    let resolvedOxcFiles = oxcFiles
+    if (oxcFiles.length > 0) {
+        try {
+            resolvedOxcFiles = await oxcParser.resolveImports(oxcFiles, normalizedRoot)
+        } catch (err: unknown) {
+            addDiagnostic({
+                filePath: '*',
+                extension: '*',
+                parser: 'oxc',
+                stage: 'resolve-imports',
+                reason: 'resolve-error',
+                message: normalizeErrorMessage(err),
+            })
         }
     }
 
-    // Resolve imports batch-wise per parser (each has its own resolver)
-    let resolvedTreeFiles: ParsedFile[] = treeFiles
+    let resolvedGoFiles = goFiles
+    if (goFiles.length > 0) {
+        try {
+            resolvedGoFiles = await goParser.resolveImports(goFiles, normalizedRoot)
+        } catch (err: unknown) {
+            addDiagnostic({
+                filePath: '*',
+                extension: '*',
+                parser: 'go',
+                stage: 'resolve-imports',
+                reason: 'resolve-error',
+                message: normalizeErrorMessage(err),
+            })
+        }
+    }
+
+    let resolvedTreeFiles = treeFiles
     if (treeFiles.length > 0) {
-        const treeParser = treeSitterParser ?? await getTreeSitter()
-        resolvedTreeFiles = await treeParser.resolveImports(treeFiles, normalizedRoot)
+        try {
+            const treeParser = treeSitterParser ?? await getTreeSitter()
+            resolvedTreeFiles = await treeParser.resolveImports(treeFiles, normalizedRoot)
+        } catch (err: unknown) {
+            addDiagnostic({
+                filePath: '*',
+                extension: '*',
+                parser: 'tree-sitter',
+                stage: 'resolve-imports',
+                reason: 'resolve-error',
+                message: normalizeErrorMessage(err),
+            })
+        }
     }
 
     const resolved: ParsedFile[] = [
-        ...await oxcParser.resolveImports(oxcFiles, normalizedRoot),
-        ...await goParser.resolveImports(goFiles, normalizedRoot),
+        ...resolvedOxcFiles,
+        ...resolvedGoFiles,
         ...resolvedTreeFiles,
+        ...fallbackFiles,
     ]
 
-    return resolved
+    // Persist cache metadata
+    cache.flush()
+
+    return {
+        files: resolved,
+        diagnostics,
+        summary: {
+            requestedFiles: filePaths.length,
+            parsedFiles: parsedFilesCount,
+            fallbackFiles: fallbackFilesCount,
+            unreadableFiles,
+            unsupportedFiles,
+            diagnostics: diagnostics.length,
+        },
+    }
+}
+
+/**
+ * Parse multiple files, resolve their imports, and return ParsedFile[].
+ *
+ * Path contract (critical for graph correctness):
+ *   - filePaths come from discoverFiles() as project-root-relative strings
+ *   - We resolve them to ABSOLUTE posix paths before passing to parse()
+ *   - ParsedFile.path is therefore always absolute + forward-slash
+ *   - OxcResolver also returns absolute paths → import edges always consistent
+ */
+export async function parseFiles(
+    filePaths: string[],
+    projectRoot: string,
+    readFile: (fp: string) => Promise<string>
+): Promise<ParsedFile[]> {
+    const result = await parseFilesWithDiagnostics(filePaths, projectRoot, readFile)
+    return result.files
 }

package/src/parser/oxc-parser.ts

@@ -219,12 +219,13 @@ function extractCalls(node: any, lineIndex: LineIndex): CallExpression[] {
     const walk = (n: any): void => {
         if (!n || typeof n !== 'object') return;
 
-        if (n.type === 'CallExpression' && n.span) {
+        if (n.type === 'CallExpression') {
             const { name, type } = resolveCallIdentity(n.callee);
             if (name) {
+                const span = getSpan(n);
                 calls.push({
                     name,
-                    line: lineIndex.getLine(n.span.start),
+                    line: lineIndex.getLine(span.start),
                     type,
                 });
             }

package/src/parser/tree-sitter/parser.ts

@@ -36,6 +36,11 @@ function isExportedByLanguage(ext: string, name: string, nodeText: string): bool
             return !name.startsWith('_')
         case '.java':
             return /\bpublic\b/.test(nodeText)
+        case '.kt':
+        case '.kts':
+            return !/\bprivate\b/.test(nodeText) && !/\binternal\b/.test(nodeText) && !/\bprotected\b/.test(nodeText)
+        case '.swift':
+            return !/\bprivate\b/.test(nodeText) && !/\bfileprivate\b/.test(nodeText)
         case '.cs':
             return /\bpublic\b/.test(nodeText) && !/\binternal\b/.test(nodeText)
         case '.go':
@@ -181,7 +186,7 @@ export class TreeSitterParser extends BaseParser {
     private wasmLoadError = false
 
     getSupportedExtensions(): string[] {
-        return ['.py', '.java', '.c', '.cpp', '.cc', '.h', '.hpp', '.cs', '.go', '.rs', '.php', '.rb']
+        return ['.py', '.java', '.kt', '.kts', '.swift', '.c', '.cpp', '.cc', '.cxx', '.h', '.hpp', '.hxx', '.hh', '.cs', '.go', '.rs', '.php', '.rb']
     }
 
     private async init() {
@@ -193,6 +198,11 @@ export class TreeSitterParser extends BaseParser {
         }
     }
 
+    async isRuntimeAvailable(): Promise<boolean> {
+        await this.init()
+        return Boolean(this.parser)
+    }
+
     async parse(filePath: string, content: string): Promise<ParsedFile> {
         this.nameCounter.clear()
         await this.init()
@@ -509,13 +519,41 @@ export class TreeSitterParser extends BaseParser {
         try {
             const nameForFile = name.replace(/-/g, '_')
             
-            // Try multiple possible WASM locations
-            const possiblePaths = [
-                path.resolve('node_modules/tree-sitter-wasms/out', `tree-sitter-${nameForFile}.wasm`),
-                path.resolve('./node_modules/tree-sitter-wasms/out', `tree-sitter-${nameForFile}.wasm`),
-                path.resolve(process.cwd(), 'node_modules/tree-sitter-wasms/out', `tree-sitter-${nameForFile}.wasm`),
-                path.resolve(process.cwd(), 'node_modules', 'tree-sitter-wasms', 'out', `tree-sitter-${nameForFile}.wasm`),
-            ]
+            // Try multiple possible WASM locations, including parent directories and siblings for monorepos
+            const baseDirs = new Set<string>()
+            baseDirs.add(process.cwd())
+            
+            // Add parent directories (up to 4 levels) for monorepo setups
+            let current = process.cwd()
+            let parentDir = ''
+            for (let i = 0; i < 4; i++) {
+                parentDir = path.dirname(current)
+                if (parentDir === current) break
+                baseDirs.add(parentDir)
+                baseDirs.add(path.join(parentDir, 'node_modules'))
+                
+                // Also check sibling directories in the parent for monorepo setups
+                // (e.g., metis and Mesh are siblings under the same parent)
+                try {
+                    const fs = await import('node:fs')
+                    const entries = fs.readdirSync(parentDir, { withFileTypes: true })
+                    for (const entry of entries) {
+                        if (entry.isDirectory() && entry.name !== path.basename(current)) {
+                            baseDirs.add(path.join(parentDir, entry.name, 'node_modules'))
+                        }
+                    }
+                } catch { /* skip */ }
+                
+                current = parentDir
+            }
+
+            const possiblePaths: string[] = []
+            for (const baseDir of baseDirs) {
+                if (!baseDir) continue
+                possiblePaths.push(
+                    path.join(baseDir, 'node_modules/tree-sitter-wasms/out', `tree-sitter-${nameForFile}.wasm`),
+                )
+            }
             
             let wasmPath = ''
             for (const p of possiblePaths) {
@@ -553,7 +591,6 @@ export class TreeSitterParser extends BaseParser {
             
             if (!wasmPath) {
                 // WASM not found - but don't mark as permanent error, just skip this language
-                console.warn(`Tree-sitter WASM not found for ${name}`)
                 return null
             }
             
@@ -591,12 +628,19 @@ export class TreeSitterParser extends BaseParser {
                 return { lang: await this.loadLang('python'), query: Queries.PYTHON_QUERIES }
             case '.java':
                 return { lang: await this.loadLang('java'), query: Queries.JAVA_QUERIES }
+            case '.kt':
+            case '.kts':
+                return { lang: await this.loadLang('kotlin'), query: Queries.KOTLIN_QUERIES }
+            case '.swift':
+                return { lang: await this.loadLang('swift'), query: Queries.SWIFT_QUERIES }
             case '.c':
             case '.h':
                 return { lang: await this.loadLang('c'), query: Queries.C_QUERIES }
             case '.cpp':
             case '.cc':
+            case '.cxx':
             case '.hpp':
+            case '.hxx':
             case '.hh':
                 return { lang: await this.loadLang('cpp'), query: Queries.CPP_QUERIES }
             case '.cs':
@@ -619,8 +663,14 @@ function extensionToLanguage(ext: string): ParsedFile['language'] {
     switch (ext) {
         case '.py': return 'python'
         case '.java': return 'java'
+        case '.kt':
+        case '.kts':
+            return 'kotlin'
+        case '.swift':
+            return 'swift'
         case '.c': case '.h': return 'c'
         case '.cpp': case '.cc': case '.hpp': return 'cpp'
+        case '.cxx': case '.hxx': case '.hh': return 'cpp'
         case '.cs': return 'csharp'
         case '.go': return 'go'
         case '.rs': return 'rust'

package/src/parser/tree-sitter/queries.ts

@@ -65,6 +65,33 @@ export const JAVA_QUERIES = `
 (class_declaration name: (identifier) @heritage.class (super_interfaces (type_list (type_identifier) @heritage.implements))) @heritage.impl
 `;
 
+export const KOTLIN_QUERIES = `
+(class_declaration name: (type_identifier) @name) @definition.class
+(object_declaration name: (type_identifier) @name) @definition.class
+(function_declaration name: (simple_identifier) @name) @definition.function
+(property_declaration (variable_declaration (simple_identifier) @name)) @definition.property
+(type_alias (type_identifier) @name) @definition.type
+(import_header (identifier) @import.source) @import
+(call_expression (simple_identifier) @call.name) @call
+(call_expression
+  (navigation_expression
+    (navigation_suffix (simple_identifier) @call.name))) @call
+(constructor_invocation
+  (user_type (type_identifier) @call.name)) @call
+`;
+
+export const SWIFT_QUERIES = `
+(class_declaration name: (type_identifier) @name) @definition.class
+(protocol_declaration name: (type_identifier) @name) @definition.interface
+(function_declaration name: (simple_identifier) @name) @definition.function
+(property_declaration (pattern (simple_identifier) @name)) @definition.property
+(import_declaration (identifier) @import.source) @import
+(call_expression (simple_identifier) @call.name) @call
+(call_expression
+  (navigation_expression
+    (navigation_suffix (simple_identifier) @call.name))) @call
+`;
+
 export const C_QUERIES = `
 (function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function
 (declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.function