gitnexus 1.6.2-rc.2 → 1.6.2-rc.21

package/dist/core/ingestion/workers/parse-worker.js

@@ -36,8 +36,7 @@ try {
 catch { }
 import { getLanguageFromFilename } from '../../../_shared/index.js';
 import { FUNCTION_NODE_TYPES, getDefinitionNodeFromCaptures, findEnclosingClassInfo, getLabelFromCaptures, findDescendant, extractStringContent, genericFuncName, inferFunctionLabel, CLASS_CONTAINER_TYPES, } from '../utils/ast-helpers.js';
-import { countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, extractMixedChain, extractCallArgTypes, } from '../utils/call-analysis.js';
-import { extractParsedCallSite } from '../call-sites/extract-language-call-site.js';
+import { extractCallArgTypes } from '../utils/call-analysis.js';
 import { buildTypeEnv } from '../type-env.js';
 import { detectFrameworkFromAST } from '../framework-detection.js';
 import { generateId } from '../../../lib/utils.js';
@@ -1081,6 +1080,10 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
         }
         // Per-file map: decorator end-line → decorator info, for associating with definitions
         const fileDecorators = new Map();
+        // Track start indices of definition nodes already processed by higher-priority captures
+        // (e.g. @definition.function) to avoid duplicate nodes when @definition.const/@definition.variable
+        // patterns overlap with the same source range.
+        const processedDefinitionNodes = new Set();
         for (const match of matches) {
             const captureMap = {};
             for (const c of match.captures) {
@@ -1248,98 +1251,125 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             }
             // Extract call sites
             if (captureMap['call']) {
-                const callNode0 = captureMap['call'];
-                const languageSeed = extractParsedCallSite(language, callNode0);
-                if (languageSeed) {
-                    if (!provider.isBuiltInName(languageSeed.calledName)) {
-                        const sourceId = findEnclosingFunctionId(callNode0, file.path, provider) ||
-                            generateId('File', file.path);
-                        const receiverName = languageSeed.callForm === 'member' ? languageSeed.receiverName : undefined;
-                        let receiverTypeName = receiverName
-                            ? typeEnv.lookup(receiverName, callNode0)
-                            : undefined;
-                        // Type-as-receiver (e.g. Java `User::getName`): no TypeEnv binding for the class name
-                        if (receiverName !== undefined &&
-                            receiverTypeName === undefined &&
-                            languageSeed.callForm === 'member' &&
-                            (language === SupportedLanguages.Java ||
-                                language === SupportedLanguages.CSharp ||
-                                language === SupportedLanguages.Kotlin)) {
-                            const c0 = receiverName.charCodeAt(0);
-                            if (c0 >= 65 && c0 <= 90)
-                                receiverTypeName = receiverName;
-                        }
-                        result.calls.push({
-                            filePath: file.path,
-                            calledName: languageSeed.calledName,
-                            sourceId,
-                            callForm: languageSeed.callForm,
-                            ...(receiverName !== undefined ? { receiverName } : {}),
-                            ...(receiverTypeName !== undefined ? { receiverTypeName } : {}),
-                        });
-                    }
-                    continue;
-                }
+                const callNode = captureMap['call'];
                 const callNameNode = captureMap['call.name'];
-                if (callNameNode) {
-                    const calledName = callNameNode.text;
-                    // Dispatch: route language-specific calls (heritage, properties, imports)
-                    const routed = callRouter?.(calledName, captureMap['call']);
-                    if (routed) {
-                        if (routed.kind === 'skip')
-                            continue;
-                        if (routed.kind === 'import') {
-                            result.imports.push({
+                const callExtractor = provider.callExtractor;
+                if (callExtractor) {
+                    // ── Path 1: Language-specific call site (bypasses routing) ────
+                    // Try language-specific extraction (e.g. Java `::` method references)
+                    // without callNameNode.  If successful, skip routing and the generic
+                    // path entirely.
+                    const langCallSite = callExtractor.extract(callNode, undefined);
+                    if (langCallSite) {
+                        if (!provider.isBuiltInName(langCallSite.calledName)) {
+                            const sourceId = findEnclosingFunctionId(callNode, file.path, provider) ||
+                                generateId('File', file.path);
+                            const receiverName = langCallSite.callForm === 'member' ? langCallSite.receiverName : undefined;
+                            let receiverTypeName = receiverName
+                                ? typeEnv.lookup(receiverName, callNode)
+                                : undefined;
+                            // Type-as-receiver heuristic (e.g. Java `User::getName`)
+                            if (langCallSite.typeAsReceiverHeuristic &&
+                                receiverName !== undefined &&
+                                receiverTypeName === undefined &&
+                                langCallSite.callForm === 'member') {
+                                const c0 = receiverName.charCodeAt(0);
+                                if (c0 >= 65 && c0 <= 90)
+                                    receiverTypeName = receiverName;
+                            }
+                            result.calls.push({
                                 filePath: file.path,
-                                rawImportPath: routed.importPath,
-                                language,
+                                calledName: langCallSite.calledName,
+                                sourceId,
+                                callForm: langCallSite.callForm,
+                                ...(receiverName !== undefined ? { receiverName } : {}),
+                                ...(receiverTypeName !== undefined ? { receiverTypeName } : {}),
                             });
-                            continue;
                         }
-                        if (routed.kind === 'heritage') {
-                            for (const item of routed.items) {
-                                result.heritage.push({
+                        continue;
+                    }
+                    // ── Path 2: Generic extraction via @call.name ────────────────
+                    if (callNameNode) {
+                        const calledName = callNameNode.text;
+                        // Dispatch: route language-specific calls (heritage, properties, imports)
+                        const routed = callRouter?.(calledName, captureMap['call']);
+                        if (routed) {
+                            if (routed.kind === 'skip')
+                                continue;
+                            if (routed.kind === 'import') {
+                                result.imports.push({
                                     filePath: file.path,
-                                    className: item.enclosingClass,
-                                    parentName: item.mixinName,
-                                    kind: item.heritageKind,
+                                    rawImportPath: routed.importPath,
+                                    language,
                                 });
+                                continue;
                             }
-                            continue;
-                        }
-                        if (routed.kind === 'properties') {
-                            const propEnclosingInfo = cachedFindEnclosingClassInfo(captureMap['call'], file.path, provider.resolveEnclosingOwner);
-                            const propEnclosingClassId = propEnclosingInfo?.classId ?? null;
-                            // Enrich routed properties with FieldExtractor metadata
-                            let routedFieldMap;
-                            if (provider.fieldExtractor && typeEnv) {
-                                const classNode = findEnclosingClassNode(captureMap['call']);
-                                if (classNode) {
-                                    routedFieldMap = getFieldInfo(classNode, provider, {
-                                        typeEnv,
-                                        symbolTable: NOOP_SYMBOL_TABLE,
+                            if (routed.kind === 'heritage') {
+                                for (const item of routed.items) {
+                                    result.heritage.push({
                                         filePath: file.path,
-                                        language,
+                                        className: item.enclosingClass,
+                                        parentName: item.mixinName,
+                                        kind: item.heritageKind,
                                     });
                                 }
+                                continue;
                             }
-                            for (const item of routed.items) {
-                                const routedFieldInfo = routedFieldMap?.get(item.propName);
-                                const propQualifiedName = propEnclosingInfo
-                                    ? `${propEnclosingInfo.className}.${item.propName}`
-                                    : item.propName;
-                                const nodeId = generateId('Property', `${file.path}:${propQualifiedName}`);
-                                result.nodes.push({
-                                    id: nodeId,
-                                    label: 'Property',
-                                    properties: {
-                                        name: item.propName,
+                            if (routed.kind === 'properties') {
+                                const propEnclosingInfo = cachedFindEnclosingClassInfo(captureMap['call'], file.path, provider.resolveEnclosingOwner);
+                                const propEnclosingClassId = propEnclosingInfo?.classId ?? null;
+                                // Enrich routed properties with FieldExtractor metadata
+                                let routedFieldMap;
+                                if (provider.fieldExtractor && typeEnv) {
+                                    const classNode = findEnclosingClassNode(captureMap['call']);
+                                    if (classNode) {
+                                        routedFieldMap = getFieldInfo(classNode, provider, {
+                                            typeEnv,
+                                            symbolTable: NOOP_SYMBOL_TABLE,
+                                            filePath: file.path,
+                                            language,
+                                        });
+                                    }
+                                }
+                                for (const item of routed.items) {
+                                    const routedFieldInfo = routedFieldMap?.get(item.propName);
+                                    const propQualifiedName = propEnclosingInfo
+                                        ? `${propEnclosingInfo.className}.${item.propName}`
+                                        : item.propName;
+                                    const nodeId = generateId('Property', `${file.path}:${propQualifiedName}`);
+                                    result.nodes.push({
+                                        id: nodeId,
+                                        label: 'Property',
+                                        properties: {
+                                            name: item.propName,
+                                            filePath: file.path,
+                                            startLine: item.startLine,
+                                            endLine: item.endLine,
+                                            language,
+                                            isExported: true,
+                                            description: item.accessorType,
+                                            ...(item.declaredType
+                                                ? { declaredType: item.declaredType }
+                                                : routedFieldInfo?.type
+                                                    ? { declaredType: routedFieldInfo.type }
+                                                    : {}),
+                                            ...(routedFieldInfo?.visibility !== undefined
+                                                ? { visibility: routedFieldInfo.visibility }
+                                                : {}),
+                                            ...(routedFieldInfo?.isStatic !== undefined
+                                                ? { isStatic: routedFieldInfo.isStatic }
+                                                : {}),
+                                            ...(routedFieldInfo?.isReadonly !== undefined
+                                                ? { isReadonly: routedFieldInfo.isReadonly }
+                                                : {}),
+                                        },
+                                    });
+                                    result.symbols.push({
                                         filePath: file.path,
-                                        startLine: item.startLine,
-                                        endLine: item.endLine,
-                                        language,
-                                        isExported: true,
-                                        description: item.accessorType,
+                                        name: item.propName,
+                                        nodeId,
+                                        type: 'Property',
+                                        ...(propEnclosingClassId ? { ownerId: propEnclosingClassId } : {}),
                                         ...(item.declaredType
                                             ? { declaredType: item.declaredType }
                                             : routedFieldInfo?.type
@@ -1354,101 +1384,71 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                                         ...(routedFieldInfo?.isReadonly !== undefined
                                             ? { isReadonly: routedFieldInfo.isReadonly }
                                             : {}),
-                                    },
-                                });
-                                result.symbols.push({
-                                    filePath: file.path,
-                                    name: item.propName,
-                                    nodeId,
-                                    type: 'Property',
-                                    ...(propEnclosingClassId ? { ownerId: propEnclosingClassId } : {}),
-                                    ...(item.declaredType
-                                        ? { declaredType: item.declaredType }
-                                        : routedFieldInfo?.type
-                                            ? { declaredType: routedFieldInfo.type }
-                                            : {}),
-                                    ...(routedFieldInfo?.visibility !== undefined
-                                        ? { visibility: routedFieldInfo.visibility }
-                                        : {}),
-                                    ...(routedFieldInfo?.isStatic !== undefined
-                                        ? { isStatic: routedFieldInfo.isStatic }
-                                        : {}),
-                                    ...(routedFieldInfo?.isReadonly !== undefined
-                                        ? { isReadonly: routedFieldInfo.isReadonly }
-                                        : {}),
-                                });
-                                const fileId = generateId('File', file.path);
-                                const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
-                                result.relationships.push({
-                                    id: relId,
-                                    sourceId: fileId,
-                                    targetId: nodeId,
-                                    type: 'DEFINES',
-                                    confidence: 1.0,
-                                    reason: '',
-                                });
-                                if (propEnclosingClassId) {
+                                    });
+                                    const fileId = generateId('File', file.path);
+                                    const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
                                     result.relationships.push({
-                                        id: generateId('HAS_PROPERTY', `${propEnclosingClassId}->${nodeId}`),
-                                        sourceId: propEnclosingClassId,
+                                        id: relId,
+                                        sourceId: fileId,
                                         targetId: nodeId,
-                                        type: 'HAS_PROPERTY',
+                                        type: 'DEFINES',
                                         confidence: 1.0,
                                         reason: '',
                                     });
+                                    if (propEnclosingClassId) {
+                                        result.relationships.push({
+                                            id: generateId('HAS_PROPERTY', `${propEnclosingClassId}->${nodeId}`),
+                                            sourceId: propEnclosingClassId,
+                                            targetId: nodeId,
+                                            type: 'HAS_PROPERTY',
+                                            confidence: 1.0,
+                                            reason: '',
+                                        });
+                                    }
                                 }
+                                continue;
                             }
-                            continue;
+                            // kind === 'call' — fall through to normal call processing below
                         }
-                        // kind === 'call' — fall through to normal call processing below
-                    }
-                    if (!provider.isBuiltInName(calledName)) {
-                        const callNode = captureMap['call'];
-                        const sourceId = findEnclosingFunctionId(callNode, file.path, provider) ||
-                            generateId('File', file.path);
-                        const callForm = inferCallForm(callNode, callNameNode);
-                        let receiverName = callForm === 'member' ? extractReceiverName(callNameNode) : undefined;
-                        let receiverTypeName = receiverName
-                            ? typeEnv.lookup(receiverName, callNode)
-                            : undefined;
-                        let receiverMixedChain;
-                        // When the receiver is a complex expression (call chain, field chain, or mixed),
-                        // extractReceiverName returns undefined. Walk the receiver node to build a unified
-                        // mixed chain for deferred resolution in processCallsFromExtracted.
-                        if (callForm === 'member' && receiverName === undefined && !receiverTypeName) {
-                            const receiverNode = extractReceiverNode(callNameNode);
-                            if (receiverNode) {
-                                const extracted = extractMixedChain(receiverNode);
-                                if (extracted && extracted.chain.length > 0) {
-                                    receiverMixedChain = extracted.chain;
-                                    receiverName = extracted.baseReceiverName;
-                                    // Try the type environment immediately for the base receiver
-                                    // (covers explicitly-typed locals and annotated parameters).
-                                    if (receiverName) {
-                                        receiverTypeName = typeEnv.lookup(receiverName, callNode);
-                                    }
+                        if (!provider.isBuiltInName(calledName)) {
+                            const callSite = callExtractor.extract(callNode, callNameNode);
+                            if (callSite) {
+                                const sourceId = findEnclosingFunctionId(callNode, file.path, provider) ||
+                                    generateId('File', file.path);
+                                let receiverTypeName = callSite.receiverName
+                                    ? typeEnv.lookup(callSite.receiverName, callNode)
+                                    : undefined;
+                                // Type-as-receiver heuristic
+                                if (callSite.typeAsReceiverHeuristic &&
+                                    callSite.receiverName !== undefined &&
+                                    receiverTypeName === undefined &&
+                                    callSite.callForm === 'member') {
+                                    const c0 = callSite.receiverName.charCodeAt(0);
+                                    if (c0 >= 65 && c0 <= 90)
+                                        receiverTypeName = callSite.receiverName;
                                 }
+                                const inferLiteralType = provider.typeConfig?.inferLiteralType;
+                                // Skip when no arg list / zero args: nothing to infer for overload typing
+                                const argTypes = inferLiteralType && callSite.argCount !== undefined && callSite.argCount > 0
+                                    ? extractCallArgTypes(callNode, inferLiteralType, (varName, cn) => typeEnv.lookup(varName, cn))
+                                    : undefined;
+                                result.calls.push({
+                                    filePath: file.path,
+                                    calledName: callSite.calledName,
+                                    sourceId,
+                                    ...(callSite.argCount !== undefined ? { argCount: callSite.argCount } : {}),
+                                    ...(callSite.callForm !== undefined ? { callForm: callSite.callForm } : {}),
+                                    ...(callSite.receiverName !== undefined
+                                        ? { receiverName: callSite.receiverName }
+                                        : {}),
+                                    ...(receiverTypeName !== undefined ? { receiverTypeName } : {}),
+                                    ...(callSite.receiverMixedChain !== undefined
+                                        ? { receiverMixedChain: callSite.receiverMixedChain }
+                                        : {}),
+                                    ...(argTypes !== undefined ? { argTypes } : {}),
+                                });
                             }
                         }
-                        const inferLiteralType = provider.typeConfig?.inferLiteralType;
-                        const argCountForOverloadHints = countCallArguments(callNode);
-                        // Skip when no arg list / zero args: nothing to infer for overload typing; saves AST walks + payload size.
-                        const argTypes = inferLiteralType &&
-                            argCountForOverloadHints !== undefined &&
-                            argCountForOverloadHints > 0
-                            ? extractCallArgTypes(callNode, inferLiteralType, (varName, cn) => typeEnv.lookup(varName, cn))
-                            : undefined;
-                        result.calls.push({
-                            filePath: file.path,
-                            calledName,
-                            sourceId,
-                            argCount: countCallArguments(callNode),
-                            ...(callForm !== undefined ? { callForm } : {}),
-                            ...(receiverName !== undefined ? { receiverName } : {}),
-                            ...(receiverTypeName !== undefined ? { receiverTypeName } : {}),
-                            ...(receiverMixedChain !== undefined ? { receiverMixedChain } : {}),
-                            ...(argTypes !== undefined ? { argTypes } : {}),
-                        });
                     }
                 }
                 continue;
@@ -1505,6 +1505,17 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 })
                 : null;
             const nodeLabel = extractedClassSymbol?.type ?? defaultNodeLabel;
+            // Dedup: variable captures (Const/Static/Variable) may overlap with higher-priority
+            // captures (e.g. `const fn = () => {}` matches both @definition.function and @definition.const).
+            // Skip variable captures whose definition node was already processed.
+            if ((nodeLabel === 'Const' || nodeLabel === 'Static' || nodeLabel === 'Variable') &&
+                definitionNode &&
+                processedDefinitionNodes.has(definitionNode.startIndex)) {
+                continue;
+            }
+            if (definitionNode) {
+                processedDefinitionNodes.add(definitionNode.startIndex);
+            }
             // Synthesize name for constructors without explicit @name capture (e.g. Swift init)
             if (!nameNode && nodeLabel !== 'Constructor' && !extractedClassSymbol)
                 continue;
@@ -1657,6 +1668,25 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     }
                 }
             }
+            // Variable/Const/Static metadata extraction via VariableExtractor
+            if ((nodeLabel === 'Const' || nodeLabel === 'Static' || nodeLabel === 'Variable') &&
+                definitionNode &&
+                provider.variableExtractor) {
+                const varCtx = {
+                    filePath: file.path,
+                    language,
+                };
+                const varInfo = provider.variableExtractor.extract(definitionNode, varCtx);
+                if (varInfo) {
+                    if (varInfo.type)
+                        declaredType = varInfo.type;
+                    methodProps.visibility = varInfo.visibility;
+                    methodProps.isStatic = varInfo.isStatic;
+                    methodProps.isConst = varInfo.isConst;
+                    methodProps.isMutable = varInfo.isMutable;
+                    methodProps.scope = varInfo.scope;
+                }
+            }
             result.nodes.push({
                 id: nodeId,
                 label: nodeLabel,

package/dist/core/ingestion/workers/worker-pool.js

@@ -79,6 +79,9 @@ export const createWorkerPool = (workerUrl, poolSize) => {
                             onProgress(total);
                         }
                     }
+                    else if (msg.type === 'warning') {
+                        console.warn(msg.message);
+                    }
                     else if (msg.type === 'sub-batch-done') {
                         sendNextSubBatch();
                     }

package/dist/core/lbug/csv-generator.js

@@ -228,6 +228,7 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
         'TypeAlias',
         'Const',
         'Static',
+        'Variable',
         'Property',
         'Record',
         'Delegate',

package/dist/core/lbug/lbug-adapter.d.ts

@@ -1,5 +1,6 @@
 import lbug from '@ladybugdb/core';
 import { KnowledgeGraph } from '../graph/types.js';
+import type { CachedEmbedding } from '../embeddings/types.js';
 /** Factory for creating WriteStreams — injectable for testing. */
 export type WriteStreamFactory = (filePath: string) => import('fs').WriteStream;
 /** Result of splitting the relationship CSV into per-label-pair files. */
@@ -92,14 +93,22 @@ export declare const getLbugStats: () => Promise<{
  * Load cached embeddings from LadybugDB before a rebuild.
  * Returns all embedding vectors so they can be re-inserted after the graph is reloaded,
  * avoiding expensive re-embedding of unchanged nodes.
+ *
+ * Detects old schema (no chunkIndex column) and returns empty cache to trigger rebuild.
  */
 export declare const loadCachedEmbeddings: () => Promise<{
     embeddingNodeIds: Set<string>;
-    embeddings: Array<{
-        nodeId: string;
-        embedding: number[];
-    }>;
+    embeddings: CachedEmbedding[];
 }>;
+/**
+ * Fetch existing embedding hashes from CodeEmbedding table for incremental embedding.
+ * Returns a Map<nodeId, contentHash> suitable for passing to `runEmbeddingPipeline`.
+ * Handles legacy DBs without the `contentHash` column (all rows treated as stale with empty hash).
+ * Returns undefined if the CodeEmbedding table does not exist.
+ *
+ * @param execQuery - Cypher query executor (typically pool-adapter's `executeQuery`)
+ */
+export declare const fetchExistingEmbeddingHashes: (execQuery: (cypher: string) => Promise<any[]>) => Promise<Map<string, string> | undefined>;
 export declare const closeLbug: () => Promise<void>;
 export declare const isLbugReady: () => boolean;
 /**