gitnexus 1.4.10 → 1.5.0

package/dist/core/ingestion/method-extractors/generic.js

@@ -0,0 +1,137 @@
+// gitnexus/src/core/ingestion/method-extractors/generic.ts
+/** Owner node types where member functions are effectively static (JVM semantics). */
+const STATIC_OWNER_TYPES = new Set(['companion_object', 'object_declaration']);
+/**
+ * Create a MethodExtractor from a declarative config.
+ */
+export function createMethodExtractor(config) {
+    const typeDeclarationSet = new Set(config.typeDeclarationNodes);
+    const methodNodeSet = new Set(config.methodNodeTypes);
+    const bodyNodeSet = new Set(config.bodyNodeTypes);
+    return {
+        language: config.language,
+        isTypeDeclaration(node) {
+            return typeDeclarationSet.has(node.type);
+        },
+        extract(node, context) {
+            if (!typeDeclarationSet.has(node.type))
+                return null;
+            // Resolve owner name: field-based → type_identifier → simple_identifier → "Companion"
+            let ownerName;
+            const nameField = node.childForFieldName('name');
+            if (nameField) {
+                ownerName = nameField.text;
+            }
+            else {
+                for (let i = 0; i < node.namedChildCount; i++) {
+                    const child = node.namedChild(i);
+                    if (child && (child.type === 'type_identifier' || child.type === 'simple_identifier')) {
+                        ownerName = child.text;
+                        break;
+                    }
+                }
+            }
+            // Unnamed companion objects use "Companion" (Kotlin convention)
+            if (!ownerName && node.type === 'companion_object') {
+                ownerName = 'Companion';
+            }
+            if (!ownerName)
+                return null;
+            const methods = [];
+            const bodies = findBodies(node, bodyNodeSet);
+            for (const body of bodies) {
+                extractMethodsFromBody(body, node, context, config, methodNodeSet, methods);
+            }
+            // Extract primary constructor from the owner node itself (e.g. C# 12)
+            if (config.extractPrimaryConstructor) {
+                const primaryCtor = config.extractPrimaryConstructor(node, context);
+                if (primaryCtor)
+                    methods.push(primaryCtor);
+            }
+            return { ownerName, methods };
+        },
+    };
+}
+function findBodies(node, bodyNodeSet) {
+    const result = [];
+    const bodyField = node.childForFieldName('body');
+    if (bodyField && bodyNodeSet.has(bodyField.type)) {
+        result.push(bodyField);
+        addNestedBodies(bodyField, bodyNodeSet, result);
+        return result;
+    }
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && bodyNodeSet.has(child.type)) {
+            result.push(child);
+        }
+    }
+    if (result.length === 0 && bodyField) {
+        // Fallback: body field exists but its type is not in bodyNodeTypes.
+        // This may indicate a config typo — log for debugging if NODE_ENV is development.
+        if (process.env.NODE_ENV === 'development') {
+            console.warn(`[MethodExtractor] body field type '${bodyField.type}' not in bodyNodeTypes for node '${node.type}'`);
+        }
+        result.push(bodyField);
+        addNestedBodies(bodyField, bodyNodeSet, result);
+    }
+    return result;
+}
+function addNestedBodies(parent, bodyNodeSet, out) {
+    for (let i = 0; i < parent.namedChildCount; i++) {
+        const child = parent.namedChild(i);
+        if (child && bodyNodeSet.has(child.type) && !out.includes(child)) {
+            out.push(child);
+        }
+    }
+}
+function extractMethodsFromBody(body, ownerNode, context, config, methodNodeSet, out) {
+    for (let i = 0; i < body.namedChildCount; i++) {
+        const child = body.namedChild(i);
+        if (!child)
+            continue;
+        if (methodNodeSet.has(child.type)) {
+            const method = buildMethod(child, ownerNode, context, config);
+            if (method)
+                out.push(method);
+        }
+        // Recurse into enum constant anonymous class bodies
+        if (child.type === 'enum_constant') {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const innerBody = child.namedChild(j);
+                if (innerBody && innerBody.type === 'class_body') {
+                    extractMethodsFromBody(innerBody, ownerNode, context, config, methodNodeSet, out);
+                }
+            }
+        }
+    }
+}
+function buildMethod(node, ownerNode, context, config) {
+    const name = config.extractName(node);
+    if (!name)
+        return null;
+    const isAbstract = config.isAbstract(node, ownerNode);
+    let isFinal = config.isFinal(node);
+    // Domain invariant: abstract methods cannot be final
+    if (isAbstract)
+        isFinal = false;
+    // companion_object / object_declaration members are effectively static on JVM
+    const isStatic = STATIC_OWNER_TYPES.has(ownerNode.type) || config.isStatic(node);
+    return {
+        name,
+        receiverType: config.extractReceiverType?.(node) ?? null,
+        returnType: config.extractReturnType(node) ?? null,
+        parameters: config.extractParameters(node),
+        visibility: config.extractVisibility(node),
+        isStatic,
+        isAbstract,
+        isFinal,
+        ...(config.isVirtual?.(node) ? { isVirtual: true } : {}),
+        ...(config.isOverride?.(node) ? { isOverride: true } : {}),
+        ...(config.isAsync?.(node) ? { isAsync: true } : {}),
+        ...(config.isPartial?.(node) ? { isPartial: true } : {}),
+        annotations: config.extractAnnotations?.(node) ?? [],
+        sourceFile: context.filePath,
+        line: node.startPosition.row + 1,
+    };
+}

package/dist/core/ingestion/method-types.d.ts

@@ -0,0 +1,61 @@
+import type { SupportedLanguages } from 'gitnexus-shared';
+import type { FieldVisibility } from './field-types.js';
+import type { SyntaxNode } from './utils/ast-helpers.js';
+export type MethodVisibility = FieldVisibility;
+export interface ParameterInfo {
+    name: string;
+    type: string | null;
+    isOptional: boolean;
+    isVariadic: boolean;
+}
+export interface MethodInfo {
+    name: string;
+    receiverType: string | null;
+    returnType: string | null;
+    parameters: ParameterInfo[];
+    visibility: MethodVisibility;
+    isStatic: boolean;
+    isAbstract: boolean;
+    isFinal: boolean;
+    isVirtual?: boolean;
+    isOverride?: boolean;
+    isAsync?: boolean;
+    isPartial?: boolean;
+    annotations: string[];
+    sourceFile: string;
+    line: number;
+}
+export interface MethodExtractorContext {
+    filePath: string;
+    language: SupportedLanguages;
+}
+export interface ExtractedMethods {
+    ownerName: string;
+    methods: MethodInfo[];
+}
+export interface MethodExtractor {
+    language: SupportedLanguages;
+    extract(node: SyntaxNode, context: MethodExtractorContext): ExtractedMethods | null;
+    isTypeDeclaration(node: SyntaxNode): boolean;
+}
+export interface MethodExtractionConfig {
+    language: SupportedLanguages;
+    typeDeclarationNodes: string[];
+    methodNodeTypes: string[];
+    bodyNodeTypes: string[];
+    extractName: (node: SyntaxNode) => string | undefined;
+    extractReturnType: (node: SyntaxNode) => string | undefined;
+    extractParameters: (node: SyntaxNode) => ParameterInfo[];
+    extractVisibility: (node: SyntaxNode) => MethodVisibility;
+    isStatic: (node: SyntaxNode) => boolean;
+    isAbstract: (node: SyntaxNode, ownerNode: SyntaxNode) => boolean;
+    isFinal: (node: SyntaxNode) => boolean;
+    extractAnnotations?: (node: SyntaxNode) => string[];
+    extractReceiverType?: (node: SyntaxNode) => string | undefined;
+    isVirtual?: (node: SyntaxNode) => boolean;
+    isOverride?: (node: SyntaxNode) => boolean;
+    isAsync?: (node: SyntaxNode) => boolean;
+    isPartial?: (node: SyntaxNode) => boolean;
+    /** Extract a primary constructor from the owner node itself (e.g. C# 12 class Point(int x, int y)). */
+    extractPrimaryConstructor?: (ownerNode: SyntaxNode, context: MethodExtractorContext) => MethodInfo | null;
+}

package/dist/core/ingestion/method-types.js

@@ -0,0 +1,2 @@
+// gitnexus/src/core/ingestion/method-types.ts
+export {};

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

@@ -19,7 +19,7 @@
  * Cypher: MATCH (c:Class)-[r:CodeRelation {type: 'OVERRIDES'}]->(m:Method)
  */
 import { KnowledgeGraph } from '../graph/types.js';
-import { SupportedLanguages } from '../../config/supported-languages.js';
+import { SupportedLanguages } from 'gitnexus-shared';
 export interface MROEntry {
     classId: string;
     className: string;

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

@@ -119,14 +119,14 @@ function c3Linearize(classId, parentMap, cache, inProgress) {
     // Add the direct parents list as the final sequence
     const sequences = [...parentLinearizations, [...directParents]];
     const result = [];
-    while (sequences.some(s => s.length > 0)) {
+    while (sequences.some((s) => s.length > 0)) {
         // Find a good head: one that doesn't appear in the tail of any other sequence
         let head = null;
         for (const seq of sequences) {
             if (seq.length === 0)
                 continue;
             const candidate = seq[0];
-            const inTail = sequences.some(other => other.length > 1 && other.indexOf(candidate, 1) !== -1);
+            const inTail = sequences.some((other) => other.length > 1 && other.indexOf(candidate, 1) !== -1);
             if (!inTail) {
                 head = candidate;
                 break;
@@ -153,7 +153,7 @@ function c3Linearize(classId, parentMap, cache, inProgress) {
 /** Resolve by MRO order — first ancestor in linearized order wins. */
 function resolveByMroOrder(methodName, defs, mroOrder, reasonPrefix) {
     for (const ancestorId of mroOrder) {
-        const match = defs.find(d => d.classId === ancestorId);
+        const match = defs.find((d) => d.classId === ancestorId);
         if (match) {
             return {
                 resolvedTo: match.methodId,
@@ -162,7 +162,11 @@ function resolveByMroOrder(methodName, defs, mroOrder, reasonPrefix) {
             };
         }
     }
-    return { resolvedTo: defs[0].methodId, reason: `${reasonPrefix} fallback: first definition`, confidence: 0.7 };
+    return {
+        resolvedTo: defs[0].methodId,
+        reason: `${reasonPrefix} fallback: first definition`,
+        confidence: 0.7,
+    };
 }
 function resolveCsharpJava(methodName, defs, parentEdgeTypes) {
     const classDefs = [];
@@ -186,7 +190,7 @@ function resolveCsharpJava(methodName, defs, parentEdgeTypes) {
     if (interfaceDefs.length > 1) {
         return {
             resolvedTo: null,
-            reason: `ambiguous: ${methodName} defined in multiple interfaces: ${interfaceDefs.map(d => d.className).join(', ')}`,
+            reason: `ambiguous: ${methodName} defined in multiple interfaces: ${interfaceDefs.map((d) => d.className).join(', ')}`,
             confidence: 0.5,
         };
     }
@@ -231,7 +235,7 @@ export function computeMRO(graph) {
         }
         // Get the parent names for the MRO entry
         const mroNames = mroOrder
-            .map(id => graph.getNode(id)?.properties.name)
+            .map((id) => graph.getNode(id)?.properties.name)
             .filter((n) => n !== undefined);
         // Collect methods from all ancestors, grouped by method name
         const methodsByName = new Map();
@@ -254,7 +258,7 @@ export function computeMRO(graph) {
                     methodsByName.set(methodName, defs);
                 }
                 // Avoid duplicates (same method seen via multiple paths)
-                if (!defs.some(d => d.methodId === methodId)) {
+                if (!defs.some((d) => d.methodId === methodId)) {
                     defs.push({
                         classId: ancestorId,
                         className: ancestorNode.properties.name,
@@ -275,7 +279,7 @@ export function computeMRO(graph) {
                 continue;
             // Own method shadows inherited — no ambiguity
             const ownMethods = methodMap.get(classId) ?? [];
-            const ownDefinesIt = ownMethods.some(mid => {
+            const ownDefinesIt = ownMethods.some((mid) => {
                 const mn = graph.getNode(mid);
                 return mn?.properties.name === methodName;
             });

package/dist/core/ingestion/named-binding-processor.js

@@ -30,8 +30,8 @@ export function walkBindingChain(name, currentFilePath, symbolTable, namedImport
         visited.add(key);
         const targetName = binding.exportedName;
         const resolvedDefs = targetName !== lookupName || depth > 0
-            ? symbolTable.lookupFuzzy(targetName).filter(def => def.filePath === binding.sourcePath)
-            : allDefs.filter(def => def.filePath === binding.sourcePath);
+            ? symbolTable.lookupFuzzy(targetName).filter((def) => def.filePath === binding.sourcePath)
+            : allDefs.filter((def) => def.filePath === binding.sourcePath);
         if (resolvedDefs.length > 0)
             return resolvedDefs;
         // No definition in source file → follow re-export chain

package/dist/core/ingestion/named-bindings/rust.js

@@ -42,7 +42,9 @@ function collectRustBindings(node, bindings) {
         let hasDeeper = false;
         for (let i = 0; i < node.namedChildCount; i++) {
             const child = node.namedChild(i);
-            if (child?.type === 'use_list' || child?.type === 'use_as_clause' || child?.type === 'scoped_use_list') {
+            if (child?.type === 'use_list' ||
+                child?.type === 'use_as_clause' ||
+                child?.type === 'scoped_use_list') {
                 hasDeeper = true;
                 break;
             }

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

@@ -2,9 +2,9 @@ import Parser from 'tree-sitter';
 import { loadParser, loadLanguage, isLanguageAvailable } from '../tree-sitter/parser-loader.js';
 import { getProvider } from './languages/index.js';
 import { generateId } from '../../lib/utils.js';
-import { getLanguageFromFilename } from './utils/language-detection.js';
+import { getLanguageFromFilename } from 'gitnexus-shared';
 import { yieldToEventLoop } from './utils/event-loop.js';
-import { getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature, getLabelFromCaptures, CLASS_CONTAINER_TYPES } from './utils/ast-helpers.js';
+import { getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature, getLabelFromCaptures, CLASS_CONTAINER_TYPES, } from './utils/ast-helpers.js';
 import { detectFrameworkFromAST } from './framework-detection.js';
 import { buildTypeEnv } from './type-env.js';
 import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from './constants.js';
@@ -20,7 +20,19 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
             parseableFiles.push({ path: file.path, content: file.content });
     }
     if (parseableFiles.length === 0)
-        return { imports: [], calls: [], assignments: [], heritage: [], routes: [], fetchCalls: [], decoratorRoutes: [], toolDefs: [], ormQueries: [], constructorBindings: [], typeEnvBindings: [] };
+        return {
+            imports: [],
+            calls: [],
+            assignments: [],
+            heritage: [],
+            routes: [],
+            fetchCalls: [],
+            decoratorRoutes: [],
+            toolDefs: [],
+            ormQueries: [],
+            constructorBindings: [],
+            typeEnvBindings: [],
+        };
     const total = files.length;
     // Dispatch to worker pool — pool handles splitting into chunks and sub-batching
     const chunkResults = await workerPool.dispatch(parseableFiles, (filesProcessed) => {
@@ -87,7 +99,19 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
     }
     // Final progress
     onFileProgress?.(total, total, 'done');
-    return { imports: allImports, calls: allCalls, assignments: allAssignments, heritage: allHeritage, routes: allRoutes, fetchCalls: allFetchCalls, decoratorRoutes: allDecoratorRoutes, toolDefs: allToolDefs, ormQueries: allORMQueries, constructorBindings: allConstructorBindings, typeEnvBindings: allTypeEnvBindings };
+    return {
+        imports: allImports,
+        calls: allCalls,
+        assignments: allAssignments,
+        heritage: allHeritage,
+        routes: allRoutes,
+        fetchCalls: allFetchCalls,
+        decoratorRoutes: allDecoratorRoutes,
+        toolDefs: allToolDefs,
+        ormQueries: allORMQueries,
+        constructorBindings: allConstructorBindings,
+        typeEnvBindings: allTypeEnvBindings,
+    };
 };
 // ============================================================================
 // Sequential fallback (original implementation)
@@ -178,7 +202,9 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
         }
         let tree;
         try {
-            tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+            tree = parser.parse(file.content, undefined, {
+                bufferSize: getTreeSitterBufferSize(file.content.length),
+            });
         }
         catch (parseError) {
             console.warn(`Skipping unparseable file: ${file.path}`);
@@ -202,10 +228,12 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             continue;
         }
         // Build per-file type environment for FieldExtractor context (lightweight — skipped if no fieldExtractor)
-        const typeEnv = provider.fieldExtractor ? buildTypeEnv(tree, language, { enclosingFunctionFinder: provider.enclosingFunctionFinder }) : null;
-        matches.forEach(match => {
+        const typeEnv = provider.fieldExtractor
+            ? buildTypeEnv(tree, language, { enclosingFunctionFinder: provider.enclosingFunctionFinder })
+            : null;
+        matches.forEach((match) => {
             const captureMap = {};
-            match.captures.forEach(c => {
+            match.captures.forEach((c) => {
                 captureMap[c.name] = c.node;
             });
             const nodeLabel = getLabelFromCaptures(captureMap, provider);
@@ -217,19 +245,27 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                 return;
             const nodeName = nameNode ? nameNode.text : 'init';
             const definitionNodeForRange = getDefinitionNodeFromCaptures(captureMap);
-            const startLine = definitionNodeForRange ? definitionNodeForRange.startPosition.row : (nameNode ? nameNode.startPosition.row : 0);
+            const startLine = definitionNodeForRange
+                ? definitionNodeForRange.startPosition.row
+                : nameNode
+                    ? nameNode.startPosition.row
+                    : 0;
             const nodeId = generateId(nodeLabel, `${file.path}:${nodeName}`);
             const definitionNode = getDefinitionNodeFromCaptures(captureMap);
             const frameworkHint = definitionNode
                 ? detectFrameworkFromAST(language, (definitionNode.text || '').slice(0, 300))
                 : null;
             // Extract method signature for Method/Constructor nodes
-            const methodSig = (nodeLabel === 'Function' || nodeLabel === 'Method' || nodeLabel === 'Constructor')
+            const methodSig = nodeLabel === 'Function' || nodeLabel === 'Method' || nodeLabel === 'Constructor'
                 ? extractMethodSignature(definitionNode)
                 : undefined;
             // Language-specific return type fallback (e.g. Ruby YARD @return [Type])
             // Also upgrades uninformative AST types like PHP `array` with PHPDoc `@return User[]`
-            if (methodSig && (!methodSig.returnType || methodSig.returnType === 'array' || methodSig.returnType === 'iterable') && definitionNode) {
+            if (methodSig &&
+                (!methodSig.returnType ||
+                    methodSig.returnType === 'array' ||
+                    methodSig.returnType === 'iterable') &&
+                definitionNode) {
                 const tc = provider.typeConfig;
                 if (tc?.extractReturnType) {
                     const docReturn = tc.extractReturnType(definitionNode);
@@ -247,23 +283,34 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                     endLine: definitionNodeForRange ? definitionNodeForRange.endPosition.row : startLine,
                     language: language,
                     isExported: cachedExportCheck(provider.exportChecker, nameNode || definitionNodeForRange, nodeName),
-                    ...(frameworkHint ? {
-                        astFrameworkMultiplier: frameworkHint.entryPointMultiplier,
-                        astFrameworkReason: frameworkHint.reason,
-                    } : {}),
-                    ...(methodSig ? {
-                        parameterCount: methodSig.parameterCount,
-                        ...(methodSig.requiredParameterCount !== undefined ? { requiredParameterCount: methodSig.requiredParameterCount } : {}),
-                        ...(methodSig.parameterTypes ? { parameterTypes: methodSig.parameterTypes } : {}),
-                        returnType: methodSig.returnType,
-                    } : {}),
+                    ...(frameworkHint
+                        ? {
+                            astFrameworkMultiplier: frameworkHint.entryPointMultiplier,
+                            astFrameworkReason: frameworkHint.reason,
+                        }
+                        : {}),
+                    ...(methodSig
+                        ? {
+                            parameterCount: methodSig.parameterCount,
+                            ...(methodSig.requiredParameterCount !== undefined
+                                ? { requiredParameterCount: methodSig.requiredParameterCount }
+                                : {}),
+                            ...(methodSig.parameterTypes ? { parameterTypes: methodSig.parameterTypes } : {}),
+                            returnType: methodSig.returnType,
+                        }
+                        : {}),
                 },
             };
             graph.addNode(node);
             // Compute enclosing class for Method/Constructor/Property/Function — used for both ownerId and HAS_METHOD
             // Function is included because Kotlin/Rust/Python capture class methods as Function nodes
-            const needsOwner = nodeLabel === 'Method' || nodeLabel === 'Constructor' || nodeLabel === 'Property' || nodeLabel === 'Function';
-            const enclosingClassId = needsOwner ? cachedFindEnclosingClassId(nameNode || definitionNodeForRange, file.path) : null;
+            const needsOwner = nodeLabel === 'Method' ||
+                nodeLabel === 'Constructor' ||
+                nodeLabel === 'Property' ||
+                nodeLabel === 'Function';
+            const enclosingClassId = needsOwner
+                ? cachedFindEnclosingClassId(nameNode || definitionNodeForRange, file.path)
+                : null;
             // Extract declared type and field metadata for Property nodes
             let declaredType;
             let seqVisibility;
@@ -275,7 +322,10 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                     const classNode = seqFindEnclosingClassNode(definitionNode);
                     if (classNode) {
                         const fieldMap = seqGetFieldInfo(classNode, provider, {
-                            typeEnv, symbolTable: NOOP_SYMBOL_TABLE_SEQ, filePath: file.path, language,
+                            typeEnv,
+                            symbolTable: NOOP_SYMBOL_TABLE_SEQ,
+                            filePath: file.path,
+                            language,
                         });
                         const info = fieldMap?.get(nodeName);
                         if (info) {

package/dist/core/ingestion/pipeline.d.ts

@@ -1,4 +1,5 @@
-import { PipelineProgress, PipelineResult } from '../../types/pipeline.js';
+import { type PipelineProgress } from 'gitnexus-shared';
+import { PipelineResult } from '../../types/pipeline.js';
 /** A group of files with no mutual dependencies, safe to process in parallel. */
 type IndependentFileGroup = readonly string[];
 /** Kahn's algorithm: returns files grouped by topological level.