gitnexus 1.4.10 → 1.5.1

package/dist/core/ingestion/call-routing.js

@@ -61,15 +61,21 @@ export function routeRubyCall(calledName, callNode) {
             return SKIP_RESULT;
         const items = [];
         const argList = callNode.childForFieldName?.('arguments');
-        for (const arg of (argList?.children ?? [])) {
+        for (const arg of argList?.children ?? []) {
             if (arg.type === 'constant' || arg.type === 'scope_resolution') {
-                items.push({ enclosingClass, mixinName: arg.text, heritageKind: calledName });
+                items.push({
+                    enclosingClass,
+                    mixinName: arg.text,
+                    heritageKind: calledName,
+                });
             }
         }
         return items.length > 0 ? { kind: 'heritage', items } : SKIP_RESULT;
     }
     // ── attr_accessor / attr_reader / attr_writer → property definitions ───
-    if (calledName === 'attr_accessor' || calledName === 'attr_reader' || calledName === 'attr_writer') {
+    if (calledName === 'attr_accessor' ||
+        calledName === 'attr_reader' ||
+        calledName === 'attr_writer') {
         // Extract YARD @return [Type] from preceding comment (e.g. `# @return [Address]`)
         let yardType;
         let sibling = callNode.previousSibling;
@@ -92,7 +98,7 @@ export function routeRubyCall(calledName, callNode) {
         }
         const items = [];
         const argList = callNode.childForFieldName?.('arguments');
-        for (const arg of (argList?.children ?? [])) {
+        for (const arg of argList?.children ?? []) {
             if (arg.type === 'simple_symbol') {
                 items.push({
                     propName: arg.text.startsWith(':') ? arg.text.slice(1) : arg.text,

package/dist/core/ingestion/call-sites/extract-language-call-site.d.ts

@@ -0,0 +1,10 @@
+/** Non-generic @call shapes → { calledName, callForm, receiverName? } (used from call-processor / parse-worker). */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import type { SyntaxNode } from '../utils/ast-helpers.js';
+export type ParsedCallSite = {
+    calledName: string;
+    callForm: 'free' | 'member' | 'constructor';
+    receiverName?: string;
+};
+/** Non-null → seed replaces @call.name; null → use @call.name + inferCallForm / extractReceiverName. */
+export declare function extractParsedCallSite(language: SupportedLanguages, callNode: SyntaxNode): ParsedCallSite | null;

package/dist/core/ingestion/call-sites/extract-language-call-site.js

@@ -0,0 +1,22 @@
+/** Non-generic @call shapes → { calledName, callForm, receiverName? } (used from call-processor / parse-worker). */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { parseJavaMethodReference } from './java.js';
+/** Non-null → seed replaces @call.name; null → use @call.name + inferCallForm / extractReceiverName. */
+export function extractParsedCallSite(language, callNode) {
+    switch (language) {
+        case SupportedLanguages.Java:
+            if (callNode.type === 'method_reference') {
+                const parsed = parseJavaMethodReference(callNode);
+                if (!parsed)
+                    return null;
+                return {
+                    calledName: parsed.calledName,
+                    callForm: parsed.callForm,
+                    ...(parsed.receiverName !== undefined ? { receiverName: parsed.receiverName } : {}),
+                };
+            }
+            return null;
+        default:
+            return null;
+    }
+}

package/dist/core/ingestion/call-sites/java.d.ts

@@ -0,0 +1,9 @@
+/** Java `method_reference` (`::`) nodes (tree-sitter-java). `super::` still lacks TypeEnv receiver typing. */
+import type { SyntaxNode } from '../utils/ast-helpers.js';
+export type ParsedJavaMethodReference = {
+    calledName: string;
+    callForm: 'member' | 'constructor';
+    receiverName?: string;
+};
+/** Parse `expr::method`, `Type::new`, `this::m`, `super::m`. */
+export declare const parseJavaMethodReference: (callNode: SyntaxNode) => ParsedJavaMethodReference | null;

package/dist/core/ingestion/call-sites/java.js

@@ -0,0 +1,30 @@
+/** Java `method_reference` (`::`) nodes (tree-sitter-java). `super::` still lacks TypeEnv receiver typing. */
+/** Parse `expr::method`, `Type::new`, `this::m`, `super::m`. */
+export const parseJavaMethodReference = (callNode) => {
+    if (callNode.type !== 'method_reference')
+        return null;
+    const recv = callNode.namedChild(0);
+    if (!recv)
+        return null;
+    for (const c of callNode.children) {
+        if (c.type === 'new') {
+            if (recv.type !== 'identifier')
+                return null;
+            return { calledName: recv.text, callForm: 'constructor' };
+        }
+    }
+    const rhs = callNode.child(callNode.childCount - 1);
+    if (!rhs || rhs.type !== 'identifier')
+        return null;
+    const methodName = rhs.text;
+    if (recv.type === 'identifier') {
+        return { calledName: methodName, callForm: 'member', receiverName: recv.text };
+    }
+    if (recv.type === 'this') {
+        return { calledName: methodName, callForm: 'member', receiverName: 'this' };
+    }
+    if (recv.type === 'super') {
+        return { calledName: methodName, callForm: 'member', receiverName: 'super' };
+    }
+    return null;
+};

package/dist/core/ingestion/cluster-enricher.js

@@ -10,9 +10,7 @@
 const buildEnrichmentPrompt = (members, heuristicLabel) => {
     // Limit to first 20 members to control token usage
     const limitedMembers = members.slice(0, 20);
-    const memberList = limitedMembers
-        .map(m => `${m.name} (${m.type})`)
-        .join(', ');
+    const memberList = limitedMembers.map((m) => `${m.name} (${m.type})`).join(', ');
     return `Analyze this code cluster and provide a semantic name and short description.
 
 Heuristic: "${heuristicLabel}"
@@ -109,16 +107,16 @@ export const enrichClustersBatch = async (communities, memberMap, llmClient, bat
         // Report progress
         onProgress?.(Math.min(i + batchSize, communities.length), communities.length);
         const batch = communities.slice(i, i + batchSize);
-        const batchPrompt = batch.map((community, idx) => {
+        const batchPrompt = batch
+            .map((community, idx) => {
             const members = memberMap.get(community.id) || [];
             const limitedMembers = members.slice(0, 15);
-            const memberList = limitedMembers
-                .map(m => `${m.name} (${m.type})`)
-                .join(', ');
+            const memberList = limitedMembers.map((m) => `${m.name} (${m.type})`).join(', ');
             return `Cluster ${idx + 1} (id: ${community.id}):
 Heuristic: "${community.heuristicLabel}"
 Members: ${memberList}`;
-        }).join('\n\n');
+        })
+            .join('\n\n');
         const prompt = `Analyze these code clusters and generate semantic names, keywords, and descriptions.
 
 ${batchPrompt}

package/dist/core/ingestion/cobol/cobol-copy-expander.js

@@ -151,7 +151,12 @@ export function parseReplacingClause(text) {
             break;
         const toToken = tokens[i];
         i++;
-        replacings.push({ type, from: fromToken.value, to: toToken.value, isPseudotext: fromToken.isPseudotext || undefined });
+        replacings.push({
+            type,
+            from: fromToken.value,
+            to: toToken.value,
+            isPseudotext: fromToken.isPseudotext || undefined,
+        });
     }
     return replacings;
 }
@@ -246,14 +251,16 @@ function applyReplacing(content, replacings) {
     // characters (pseudotext). These cannot be handled by identifier-level matching.
     let result = content;
     for (const r of replacings) {
-        if (r.type === 'EXACT' && (r.isPseudotext || r.from.includes(' ') || !/^[A-Z][A-Z0-9-]*$/i.test(r.from))) {
+        if (r.type === 'EXACT' &&
+            (r.isPseudotext || r.from.includes(' ') || !/^[A-Z][A-Z0-9-]*$/i.test(r.from))) {
             const escaped = r.from.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
             const re = new RegExp(escaped, 'gi');
             result = result.replace(re, r.to);
         }
     }
     // Second pass: identifier-level replacements (LEADING, TRAILING, single-word EXACT)
-    const identifierReplacings = replacings.filter(r => !(r.type === 'EXACT' && (r.isPseudotext || r.from.includes(' ') || !/^[A-Z][A-Z0-9-]*$/i.test(r.from))));
+    const identifierReplacings = replacings.filter((r) => !(r.type === 'EXACT' &&
+        (r.isPseudotext || r.from.includes(' ') || !/^[A-Z][A-Z0-9-]*$/i.test(r.from))));
     if (identifierReplacings.length === 0)
         return result;
     return result.replace(RE_COBOL_IDENTIFIER, (match) => {