gitnexus 1.6.3-rc.37 → 1.6.3-rc.39

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

@@ -5,6 +5,7 @@ import { generateId } from '../../lib/utils.js';
 import { getLanguageFromFilename, SupportedLanguages } from '../../_shared/index.js';
 import { extractVueScript, isVueSetupTopLevel } from './vue-sfc-extractor.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
+import { isVerboseIngestionEnabled } from './utils/verbose.js';
 import { getDefinitionNodeFromCaptures, findEnclosingClassInfo, getLabelFromCaptures, CLASS_CONTAINER_TYPES, } from './utils/ast-helpers.js';
 import { detectFrameworkFromAST } from './framework-detection.js';
 import { buildTypeEnv } from './type-env.js';
@@ -223,7 +224,8 @@ function seqGetFieldInfo(classNode, provider, context) {
 const processParsingSequential = async (graph, files, symbolTable, astCache, scopeTreeCache, onFileProgress) => {
     const parser = await loadParser();
     const total = files.length;
-    const skippedLanguages = new Map();
+    const logSkipped = isVerboseIngestionEnabled();
+    const skippedByLang = logSkipped ? new Map() : null;
     for (let i = 0; i < files.length; i++) {
         const file = files[i];
         // Reset memoization before each new file (node refs are per-tree)
@@ -238,9 +240,10 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
         const language = getLanguageFromFilename(file.path);
         if (!language)
             continue;
-        // Skip unsupported languages (e.g. Swift when tree-sitter-swift not installed)
         if (!isLanguageAvailable(language)) {
-            skippedLanguages.set(language, (skippedLanguages.get(language) || 0) + 1);
+            if (skippedByLang) {
+                skippedByLang.set(language, (skippedByLang.get(language) ?? 0) + 1);
+            }
             continue;
         }
         // Skip files larger than the max tree-sitter buffer (32 MB)
@@ -534,11 +537,10 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
             }
         });
     }
-    if (skippedLanguages.size > 0) {
-        const summary = Array.from(skippedLanguages.entries())
-            .map(([lang, count]) => `${lang}: ${count}`)
-            .join(', ');
-        console.warn(`  Skipped unsupported languages: ${summary}`);
+    if (skippedByLang && skippedByLang.size > 0) {
+        for (const [lang, count] of skippedByLang.entries()) {
+            console.warn(`[ingestion] Skipped ${count} ${lang} file(s) in parsing processing — ${lang} parser not available.`);
+        }
     }
 };
 // ============================================================================

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

@@ -287,31 +287,47 @@ const findEnclosingFunctionId = (node, filePath, provider) => {
                 }
                 // Qualify with enclosing class to match definition-phase node IDs
                 const classInfo = cachedFindEnclosingClassInfo(current, filePath, provider.resolveEnclosingOwner);
-                const qualifiedName = classInfo ? `${classInfo.className}.${funcName}` : funcName;
+                const encLang = getLanguageFromFilename(filePath);
+                const standaloneMethodInfo = (finalLabel === 'Method' || finalLabel === 'Constructor') &&
+                    encLang === SupportedLanguages.Go &&
+                    provider.methodExtractor?.extractFromNode
+                    ? provider.methodExtractor.extractFromNode(current, {
+                        filePath,
+                        language: encLang,
+                    })
+                    : null;
+                const ownerName = classInfo?.className ?? standaloneMethodInfo?.receiverType ?? undefined;
+                const qualifiedName = ownerName ? `${ownerName}.${funcName}` : funcName;
                 // Include #<arity> suffix to match definition-phase Method/Constructor IDs.
                 // Use the same MethodExtractor (getMethodInfo) as the definition phase.
                 // When same-arity collisions exist, also append ~type1,type2.
                 let arity;
                 let encTypeTag = '';
                 if (finalLabel === 'Method' || finalLabel === 'Constructor') {
-                    const encLang = getLanguageFromFilename(filePath);
-                    const classNode = findEnclosingClassNode(current) ?? findClassNodeByQualifiedName(current);
-                    if (classNode && encLang) {
-                        const methodMap = getMethodInfo(classNode, provider, {
-                            filePath,
-                            language: encLang,
-                        });
-                        const defLine = current.startPosition.row + 1;
-                        const info = methodMap?.get(`${funcName}:${defLine}`);
-                        if (info) {
-                            arity = info.parameters.some((p) => p.isVariadic)
-                                ? undefined
-                                : info.parameters.length;
-                            if (methodMap && arity !== undefined) {
-                                const g = buildCollisionGroups(methodMap);
-                                encTypeTag =
-                                    typeTagForId(methodMap, funcName, arity, info, encLang, g) +
-                                        constTagForId(methodMap, funcName, arity, info, g);
+                    if (standaloneMethodInfo) {
+                        arity = standaloneMethodInfo.parameters.some((p) => p.isVariadic)
+                            ? undefined
+                            : standaloneMethodInfo.parameters.length;
+                    }
+                    else {
+                        const classNode = findEnclosingClassNode(current) ?? findClassNodeByQualifiedName(current);
+                        if (classNode && encLang) {
+                            const methodMap = getMethodInfo(classNode, provider, {
+                                filePath,
+                                language: encLang,
+                            });
+                            const defLine = current.startPosition.row + 1;
+                            const info = methodMap?.get(`${funcName}:${defLine}`);
+                            if (info) {
+                                arity = info.parameters.some((p) => p.isVariadic)
+                                    ? undefined
+                                    : info.parameters.length;
+                                if (methodMap && arity !== undefined) {
+                                    const g = buildCollisionGroups(methodMap);
+                                    encTypeTag =
+                                        typeTagForId(methodMap, funcName, arity, info, encLang, g) +
+                                            constTagForId(methodMap, funcName, arity, info, g);
+                                }
                             }
                         }
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.3-rc.37",
+  "version": "1.6.3-rc.39",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",