gitnexus 1.0.0

package/dist/core/ingestion/process-processor.js

@@ -0,0 +1,278 @@
+/**
+ * Process Detection Processor
+ *
+ * Detects execution flows (Processes) in the code graph by:
+ * 1. Finding entry points (functions with no internal callers)
+ * 2. Tracing forward via CALLS edges (BFS)
+ * 3. Grouping and deduplicating similar paths
+ * 4. Labeling with heuristic names
+ *
+ * Processes help agents understand how features work through the codebase.
+ */
+import { calculateEntryPointScore, isTestFile } from './entry-point-scoring.js';
+const isDev = process.env.NODE_ENV !== 'production';
+const DEFAULT_CONFIG = {
+    maxTraceDepth: 10,
+    maxBranching: 4,
+    maxProcesses: 75,
+    minSteps: 2,
+};
+// ============================================================================
+// MAIN PROCESSOR
+// ============================================================================
+/**
+ * Detect processes (execution flows) in the knowledge graph
+ *
+ * This runs AFTER community detection, using CALLS edges to trace flows.
+ */
+export const processProcesses = async (knowledgeGraph, memberships, onProgress, config = {}) => {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    onProgress?.('Finding entry points...', 0);
+    // Build lookup maps
+    const membershipMap = new Map();
+    memberships.forEach(m => membershipMap.set(m.nodeId, m.communityId));
+    const callsEdges = buildCallsGraph(knowledgeGraph);
+    const reverseCallsEdges = buildReverseCallsGraph(knowledgeGraph);
+    const nodeMap = new Map();
+    knowledgeGraph.nodes.forEach(n => nodeMap.set(n.id, n));
+    // Step 1: Find entry points (functions that call others but have few callers)
+    const entryPoints = findEntryPoints(knowledgeGraph, reverseCallsEdges, callsEdges);
+    onProgress?.(`Found ${entryPoints.length} entry points, tracing flows...`, 20);
+    onProgress?.(`Found ${entryPoints.length} entry points, tracing flows...`, 20);
+    // Step 2: Trace processes from each entry point
+    const allTraces = [];
+    for (let i = 0; i < entryPoints.length && allTraces.length < cfg.maxProcesses * 2; i++) {
+        const entryId = entryPoints[i];
+        const traces = traceFromEntryPoint(entryId, callsEdges, cfg);
+        // Filter out traces that are too short
+        traces.filter(t => t.length >= cfg.minSteps).forEach(t => allTraces.push(t));
+        if (i % 10 === 0) {
+            onProgress?.(`Tracing entry point ${i + 1}/${entryPoints.length}...`, 20 + (i / entryPoints.length) * 40);
+        }
+    }
+    onProgress?.(`Found ${allTraces.length} traces, deduplicating...`, 60);
+    // Step 3: Deduplicate similar traces
+    const uniqueTraces = deduplicateTraces(allTraces);
+    // Step 4: Limit to max processes (prioritize longer traces)
+    const limitedTraces = uniqueTraces
+        .sort((a, b) => b.length - a.length)
+        .slice(0, cfg.maxProcesses);
+    onProgress?.(`Creating ${limitedTraces.length} process nodes...`, 80);
+    // Step 5: Create process nodes
+    const processes = [];
+    const steps = [];
+    limitedTraces.forEach((trace, idx) => {
+        const entryPointId = trace[0];
+        const terminalId = trace[trace.length - 1];
+        // Get communities touched
+        const communitiesSet = new Set();
+        trace.forEach(nodeId => {
+            const comm = membershipMap.get(nodeId);
+            if (comm)
+                communitiesSet.add(comm);
+        });
+        const communities = Array.from(communitiesSet);
+        // Determine process type
+        const processType = communities.length > 1 ? 'cross_community' : 'intra_community';
+        // Generate label
+        const entryNode = nodeMap.get(entryPointId);
+        const terminalNode = nodeMap.get(terminalId);
+        const entryName = entryNode?.properties.name || 'Unknown';
+        const terminalName = terminalNode?.properties.name || 'Unknown';
+        const heuristicLabel = `${capitalize(entryName)} → ${capitalize(terminalName)}`;
+        const processId = `proc_${idx}_${sanitizeId(entryName)}`;
+        processes.push({
+            id: processId,
+            label: heuristicLabel,
+            heuristicLabel,
+            processType,
+            stepCount: trace.length,
+            communities,
+            entryPointId,
+            terminalId,
+            trace,
+        });
+        // Create step relationships
+        trace.forEach((nodeId, stepIdx) => {
+            steps.push({
+                nodeId,
+                processId,
+                step: stepIdx + 1, // 1-indexed
+            });
+        });
+    });
+    onProgress?.('Process detection complete!', 100);
+    // Calculate stats
+    const crossCommunityCount = processes.filter(p => p.processType === 'cross_community').length;
+    const avgStepCount = processes.length > 0
+        ? processes.reduce((sum, p) => sum + p.stepCount, 0) / processes.length
+        : 0;
+    return {
+        processes,
+        steps,
+        stats: {
+            totalProcesses: processes.length,
+            crossCommunityCount,
+            avgStepCount: Math.round(avgStepCount * 10) / 10,
+            entryPointsFound: entryPoints.length,
+        },
+    };
+};
+const buildCallsGraph = (graph) => {
+    const adj = new Map();
+    graph.relationships.forEach(rel => {
+        if (rel.type === 'CALLS') {
+            if (!adj.has(rel.sourceId)) {
+                adj.set(rel.sourceId, []);
+            }
+            adj.get(rel.sourceId).push(rel.targetId);
+        }
+    });
+    return adj;
+};
+const buildReverseCallsGraph = (graph) => {
+    const adj = new Map();
+    graph.relationships.forEach(rel => {
+        if (rel.type === 'CALLS') {
+            if (!adj.has(rel.targetId)) {
+                adj.set(rel.targetId, []);
+            }
+            adj.get(rel.targetId).push(rel.sourceId);
+        }
+    });
+    return adj;
+};
+/**
+ * Find functions/methods that are good entry points for tracing.
+ *
+ * Entry points are scored based on:
+ * 1. Call ratio (calls many, called by few)
+ * 2. Export status (exported/public functions rank higher)
+ * 3. Name patterns (handle*, on*, *Controller, etc.)
+ *
+ * Test files are excluded entirely.
+ */
+const findEntryPoints = (graph, reverseCallsEdges, callsEdges) => {
+    const symbolTypes = new Set(['Function', 'Method']);
+    const entryPointCandidates = [];
+    graph.nodes.forEach(node => {
+        if (!symbolTypes.has(node.label))
+            return;
+        const filePath = node.properties.filePath || '';
+        // Skip test files entirely
+        if (isTestFile(filePath))
+            return;
+        const callers = reverseCallsEdges.get(node.id) || [];
+        const callees = callsEdges.get(node.id) || [];
+        // Must have at least 1 outgoing call to trace forward
+        if (callees.length === 0)
+            return;
+        // Calculate entry point score using new scoring system
+        const { score, reasons } = calculateEntryPointScore(node.properties.name, node.properties.language || 'javascript', node.properties.isExported ?? false, callers.length, callees.length, filePath // Pass filePath for framework detection
+        );
+        if (score > 0) {
+            entryPointCandidates.push({ id: node.id, score, reasons });
+        }
+    });
+    // Sort by score descending and return top candidates
+    const sorted = entryPointCandidates.sort((a, b) => b.score - a.score);
+    // DEBUG: Log top candidates with new scoring details
+    if (sorted.length > 0 && isDev) {
+        console.log(`[Process] Top 10 entry point candidates (new scoring):`);
+        sorted.slice(0, 10).forEach((c, i) => {
+            const node = graph.nodes.find(n => n.id === c.id);
+            const exported = node?.properties.isExported ? '✓' : '✗';
+            const shortPath = node?.properties.filePath?.split('/').slice(-2).join('/') || '';
+            console.log(`  ${i + 1}. ${node?.properties.name} [exported:${exported}] (${shortPath})`);
+            console.log(`     score: ${c.score.toFixed(2)} = [${c.reasons.join(' × ')}]`);
+        });
+    }
+    return sorted
+        .slice(0, 200) // Limit to prevent explosion
+        .map(c => c.id);
+};
+// ============================================================================
+// HELPER: Trace from entry point (BFS)
+// ============================================================================
+/**
+ * Trace forward from an entry point using BFS.
+ * Returns all distinct paths up to maxDepth.
+ */
+const traceFromEntryPoint = (entryId, callsEdges, config) => {
+    const traces = [];
+    // BFS with path tracking
+    // Each queue item: [currentNodeId, pathSoFar]
+    const queue = [[entryId, [entryId]]];
+    const visited = new Set();
+    while (queue.length > 0 && traces.length < config.maxBranching * 3) {
+        const [currentId, path] = queue.shift();
+        // Get outgoing calls
+        const callees = callsEdges.get(currentId) || [];
+        if (callees.length === 0) {
+            // Terminal node - this is a complete trace
+            if (path.length >= config.minSteps) {
+                traces.push([...path]);
+            }
+        }
+        else if (path.length >= config.maxTraceDepth) {
+            // Max depth reached - save what we have
+            if (path.length >= config.minSteps) {
+                traces.push([...path]);
+            }
+        }
+        else {
+            // Continue tracing - limit branching
+            const limitedCallees = callees.slice(0, config.maxBranching);
+            let addedBranch = false;
+            for (const calleeId of limitedCallees) {
+                // Avoid cycles
+                if (!path.includes(calleeId)) {
+                    queue.push([calleeId, [...path, calleeId]]);
+                    addedBranch = true;
+                }
+            }
+            // If all branches were cycles, save current path as terminal
+            if (!addedBranch && path.length >= config.minSteps) {
+                traces.push([...path]);
+            }
+        }
+    }
+    return traces;
+};
+// ============================================================================
+// HELPER: Deduplicate traces
+// ============================================================================
+/**
+ * Merge traces that are subsets of other traces.
+ * Keep longer traces, remove redundant shorter ones.
+ */
+const deduplicateTraces = (traces) => {
+    if (traces.length === 0)
+        return [];
+    // Sort by length descending
+    const sorted = [...traces].sort((a, b) => b.length - a.length);
+    const unique = [];
+    for (const trace of sorted) {
+        // Check if this trace is a subset of any already-added trace
+        const traceKey = trace.join('->');
+        const isSubset = unique.some(existing => {
+            const existingKey = existing.join('->');
+            return existingKey.includes(traceKey);
+        });
+        if (!isSubset) {
+            unique.push(trace);
+        }
+    }
+    return unique;
+};
+// ============================================================================
+// HELPER: String utilities
+// ============================================================================
+const capitalize = (s) => {
+    if (!s)
+        return s;
+    return s.charAt(0).toUpperCase() + s.slice(1);
+};
+const sanitizeId = (s) => {
+    return s.replace(/[^a-zA-Z0-9]/g, '_').substring(0, 20).toLowerCase();
+};

package/dist/core/ingestion/structure-processor.d.ts

@@ -0,0 +1,2 @@
+import { KnowledgeGraph } from "../graph/types.js";
+export declare const processStructure: (graph: KnowledgeGraph, paths: string[]) => void;

package/dist/core/ingestion/structure-processor.js

@@ -0,0 +1,36 @@
+import { generateId } from "../../lib/utils.js";
+export const processStructure = (graph, paths) => {
+    paths.forEach(path => {
+        const parts = path.split('/');
+        let currentPath = '';
+        let parentId = '';
+        parts.forEach((part, index) => {
+            const isFile = index === parts.length - 1;
+            const label = isFile ? 'File' : 'Folder';
+            currentPath = currentPath ? `${currentPath}/${part}` : part;
+            const nodeId = generateId(label, currentPath);
+            const node = {
+                id: nodeId,
+                label: label,
+                properties: {
+                    name: part,
+                    filePath: currentPath
+                }
+            };
+            graph.addNode(node);
+            if (parentId) {
+                const relId = generateId('CONTAINS', `${parentId}->${nodeId}`);
+                const relationship = {
+                    id: relId,
+                    type: 'CONTAINS',
+                    sourceId: parentId,
+                    targetId: nodeId,
+                    confidence: 1.0,
+                    reason: '',
+                };
+                graph.addRelationship(relationship);
+            }
+            parentId = nodeId;
+        });
+    });
+};

package/dist/core/ingestion/symbol-table.d.ts

@@ -0,0 +1,33 @@
+export interface SymbolDefinition {
+    nodeId: string;
+    filePath: string;
+    type: string;
+}
+export interface SymbolTable {
+    /**
+     * Register a new symbol definition
+     */
+    add: (filePath: string, name: string, nodeId: string, type: string) => void;
+    /**
+     * High Confidence: Look for a symbol specifically inside a file
+     * Returns the Node ID if found
+     */
+    lookupExact: (filePath: string, name: string) => string | undefined;
+    /**
+     * Low Confidence: Look for a symbol anywhere in the project
+     * Used when imports are missing or for framework magic
+     */
+    lookupFuzzy: (name: string) => SymbolDefinition[];
+    /**
+     * Debugging: See how many symbols are tracked
+     */
+    getStats: () => {
+        fileCount: number;
+        globalSymbolCount: number;
+    };
+    /**
+     * Cleanup memory
+     */
+    clear: () => void;
+}
+export declare const createSymbolTable: () => SymbolTable;

package/dist/core/ingestion/symbol-table.js

@@ -0,0 +1,38 @@
+export const createSymbolTable = () => {
+    // 1. File-Specific Index (The "Good" one)
+    // Structure: FilePath -> (SymbolName -> NodeID)
+    const fileIndex = new Map();
+    // 2. Global Reverse Index (The "Backup")
+    // Structure: SymbolName -> [List of Definitions]
+    const globalIndex = new Map();
+    const add = (filePath, name, nodeId, type) => {
+        // A. Add to File Index
+        if (!fileIndex.has(filePath)) {
+            fileIndex.set(filePath, new Map());
+        }
+        fileIndex.get(filePath).set(name, nodeId);
+        // B. Add to Global Index
+        if (!globalIndex.has(name)) {
+            globalIndex.set(name, []);
+        }
+        globalIndex.get(name).push({ nodeId, filePath, type });
+    };
+    const lookupExact = (filePath, name) => {
+        const fileSymbols = fileIndex.get(filePath);
+        if (!fileSymbols)
+            return undefined;
+        return fileSymbols.get(name);
+    };
+    const lookupFuzzy = (name) => {
+        return globalIndex.get(name) || [];
+    };
+    const getStats = () => ({
+        fileCount: fileIndex.size,
+        globalSymbolCount: globalIndex.size
+    });
+    const clear = () => {
+        fileIndex.clear();
+        globalIndex.clear();
+    };
+    return { add, lookupExact, lookupFuzzy, getStats, clear };
+};

package/dist/core/ingestion/tree-sitter-queries.d.ts

@@ -0,0 +1,11 @@
+import { SupportedLanguages } from '../../config/supported-languages.js';
+export declare const TYPESCRIPT_QUERIES = "\n(class_declaration\n  name: (type_identifier) @name) @definition.class\n\n(interface_declaration\n  name: (type_identifier) @name) @definition.interface\n\n(function_declaration\n  name: (identifier) @name) @definition.function\n\n(method_definition\n  name: (property_identifier) @name) @definition.method\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (arrow_function))) @definition.function\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (function_expression))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (arrow_function)))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (function_expression)))) @definition.function\n\n(import_statement\n  source: (string) @import.source) @import\n\n(call_expression\n  function: (identifier) @call.name) @call\n\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @call.name)) @call\n\n; Heritage queries - class extends\n(class_declaration\n  name: (type_identifier) @heritage.class\n  (class_heritage\n    (extends_clause\n      value: (identifier) @heritage.extends))) @heritage\n\n; Heritage queries - class implements interface\n(class_declaration\n  name: (type_identifier) @heritage.class\n  (class_heritage\n    (implements_clause\n      (type_identifier) @heritage.implements))) @heritage.impl\n";
+export declare const JAVASCRIPT_QUERIES = "\n(class_declaration\n  name: (identifier) @name) @definition.class\n\n(function_declaration\n  name: (identifier) @name) @definition.function\n\n(method_definition\n  name: (property_identifier) @name) @definition.method\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (arrow_function))) @definition.function\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (function_expression))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (arrow_function)))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (function_expression)))) @definition.function\n\n(import_statement\n  source: (string) @import.source) @import\n\n(call_expression\n  function: (identifier) @call.name) @call\n\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @call.name)) @call\n\n; Heritage queries - class extends (JavaScript uses different AST than TypeScript)\n; In tree-sitter-javascript, class_heritage directly contains the parent identifier\n(class_declaration\n  name: (identifier) @heritage.class\n  (class_heritage\n    (identifier) @heritage.extends)) @heritage\n";
+export declare const PYTHON_QUERIES = "\n(class_definition\n  name: (identifier) @name) @definition.class\n\n(function_definition\n  name: (identifier) @name) @definition.function\n\n(import_statement\n  name: (dotted_name) @import.source) @import\n\n(import_from_statement\n  module_name: (dotted_name) @import.source) @import\n\n(call\n  function: (identifier) @call.name) @call\n\n(call\n  function: (attribute\n    attribute: (identifier) @call.name)) @call\n\n; Heritage queries - Python class inheritance\n(class_definition\n  name: (identifier) @heritage.class\n  superclasses: (argument_list\n    (identifier) @heritage.extends)) @heritage\n";
+export declare const JAVA_QUERIES = "\n; Classes, Interfaces, Enums, Annotations\n(class_declaration name: (identifier) @name) @definition.class\n(interface_declaration name: (identifier) @name) @definition.interface\n(enum_declaration name: (identifier) @name) @definition.enum\n(annotation_type_declaration name: (identifier) @name) @definition.annotation\n\n; Methods & Constructors\n(method_declaration name: (identifier) @name) @definition.method\n(constructor_declaration name: (identifier) @name) @definition.constructor\n\n; Imports - capture any import declaration child as source\n(import_declaration (_) @import.source) @import\n\n; Calls\n(method_invocation name: (identifier) @call.name) @call\n(method_invocation object: (_) name: (identifier) @call.name) @call\n\n; Heritage - extends class\n(class_declaration name: (identifier) @heritage.class\n  (superclass (type_identifier) @heritage.extends)) @heritage\n\n; Heritage - implements interfaces\n(class_declaration name: (identifier) @heritage.class\n  (super_interfaces (type_list (type_identifier) @heritage.implements))) @heritage.impl\n";
+export declare const C_QUERIES = "\n; Functions\n(function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n(declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n\n; Structs, Unions, Enums, Typedefs\n(struct_specifier name: (type_identifier) @name) @definition.struct\n(union_specifier name: (type_identifier) @name) @definition.union\n(enum_specifier name: (type_identifier) @name) @definition.enum\n(type_definition declarator: (type_identifier) @name) @definition.typedef\n\n; Macros\n(preproc_function_def name: (identifier) @name) @definition.macro\n(preproc_def name: (identifier) @name) @definition.macro\n\n; Includes\n(preproc_include path: (_) @import.source) @import\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (field_expression field: (field_identifier) @call.name)) @call\n";
+export declare const GO_QUERIES = "\n; Functions & Methods\n(function_declaration name: (identifier) @name) @definition.function\n(method_declaration name: (field_identifier) @name) @definition.method\n\n; Types\n(type_declaration (type_spec name: (type_identifier) @name type: (struct_type))) @definition.struct\n(type_declaration (type_spec name: (type_identifier) @name type: (interface_type))) @definition.interface\n(type_declaration (type_spec name: (type_identifier) @name)) @definition.type\n\n; Imports\n(import_declaration (import_spec path: (interpreted_string_literal) @import.source)) @import\n(import_declaration (import_spec_list (import_spec path: (interpreted_string_literal) @import.source))) @import\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (selector_expression field: (field_identifier) @call.name)) @call\n";
+export declare const CPP_QUERIES = "\n; Classes, Structs, Namespaces\n(class_specifier name: (type_identifier) @name) @definition.class\n(struct_specifier name: (type_identifier) @name) @definition.struct\n(namespace_definition name: (namespace_identifier) @name) @definition.namespace\n(enum_specifier name: (type_identifier) @name) @definition.enum\n\n; Functions & Methods\n(function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n(function_definition declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name))) @definition.method\n\n; Templates\n(template_declaration (class_specifier name: (type_identifier) @name)) @definition.template\n(template_declaration (function_definition declarator: (function_declarator declarator: (identifier) @name))) @definition.template\n\n; Includes\n(preproc_include path: (_) @import.source) @import\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (field_expression field: (field_identifier) @call.name)) @call\n(call_expression function: (qualified_identifier name: (identifier) @call.name)) @call\n(call_expression function: (template_function name: (identifier) @call.name)) @call\n\n; Heritage\n(class_specifier name: (type_identifier) @heritage.class\n  (base_class_clause (type_identifier) @heritage.extends)) @heritage\n(class_specifier name: (type_identifier) @heritage.class\n  (base_class_clause (access_specifier) (type_identifier) @heritage.extends)) @heritage\n";
+export declare const CSHARP_QUERIES = "\n; Types\n(class_declaration name: (identifier) @name) @definition.class\n(interface_declaration name: (identifier) @name) @definition.interface\n(struct_declaration name: (identifier) @name) @definition.struct\n(enum_declaration name: (identifier) @name) @definition.enum\n(record_declaration name: (identifier) @name) @definition.record\n(delegate_declaration name: (identifier) @name) @definition.delegate\n\n; Namespaces\n(namespace_declaration name: (identifier) @name) @definition.namespace\n(namespace_declaration name: (qualified_name) @name) @definition.namespace\n\n; Methods & Properties\n(method_declaration name: (identifier) @name) @definition.method\n(local_function_statement name: (identifier) @name) @definition.function\n(constructor_declaration name: (identifier) @name) @definition.constructor\n(property_declaration name: (identifier) @name) @definition.property\n\n; Using\n(using_directive (qualified_name) @import.source) @import\n(using_directive (identifier) @import.source) @import\n\n; Calls\n(invocation_expression function: (identifier) @call.name) @call\n(invocation_expression function: (member_access_expression name: (identifier) @call.name)) @call\n\n; Heritage\n(class_declaration name: (identifier) @heritage.class\n  (base_list (simple_base_type (identifier) @heritage.extends))) @heritage\n(class_declaration name: (identifier) @heritage.class\n  (base_list (simple_base_type (generic_name (identifier) @heritage.extends)))) @heritage\n";
+export declare const RUST_QUERIES = "\n; Functions & Items\n(function_item name: (identifier) @name) @definition.function\n(struct_item name: (type_identifier) @name) @definition.struct\n(enum_item name: (type_identifier) @name) @definition.enum\n(trait_item name: (type_identifier) @name) @definition.trait\n(impl_item type: (type_identifier) @name) @definition.impl\n(mod_item name: (identifier) @name) @definition.module\n\n; Type aliases, const, static, macros\n(type_item name: (type_identifier) @name) @definition.type\n(const_item name: (identifier) @name) @definition.const\n(static_item name: (identifier) @name) @definition.static\n(macro_definition name: (identifier) @name) @definition.macro\n\n; Use statements\n(use_declaration argument: (_) @import.source) @import\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (field_expression field: (field_identifier) @call.name)) @call\n(call_expression function: (scoped_identifier name: (identifier) @call.name)) @call\n(call_expression function: (generic_function function: (identifier) @call.name)) @call\n\n; Heritage (trait implementation)\n(impl_item trait: (type_identifier) @heritage.trait type: (type_identifier) @heritage.class) @heritage\n(impl_item trait: (generic_type type: (type_identifier) @heritage.trait) type: (type_identifier) @heritage.class) @heritage\n";
+export declare const LANGUAGE_QUERIES: Record<SupportedLanguages, string>;