gitnexus 1.3.10 → 1.4.0

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

@@ -0,0 +1,363 @@
+import { SupportedLanguages } from '../../config/supported-languages.js';
+/**
+ * Walk a named-binding re-export chain through NamedImportMap.
+ *
+ * When file A imports { User } from B, and B re-exports { User } from C,
+ * the NamedImportMap for A points to B, but B has no User definition.
+ * This function follows the chain: A→B→C until a definition is found.
+ *
+ * Returns the definitions found at the end of the chain, or null if the
+ * chain breaks (missing binding, circular reference, or depth exceeded).
+ * Max depth 5 to prevent infinite loops.
+ *
+ * @param allDefs Pre-computed `symbolTable.lookupFuzzy(name)` result — must be the
+ *               complete unfiltered result. Passing a file-filtered subset will cause
+ *               silent misses at depth=0 for non-aliased bindings.
+ */
+export function walkBindingChain(name, currentFilePath, symbolTable, namedImportMap, allDefs) {
+    let lookupFile = currentFilePath;
+    let lookupName = name;
+    const visited = new Set();
+    for (let depth = 0; depth < 5; depth++) {
+        const bindings = namedImportMap.get(lookupFile);
+        if (!bindings)
+            return null;
+        const binding = bindings.get(lookupName);
+        if (!binding)
+            return null;
+        const key = `${binding.sourcePath}:${binding.exportedName}`;
+        if (visited.has(key))
+            return null; // circular
+        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);
+        if (resolvedDefs.length > 0)
+            return resolvedDefs;
+        // No definition in source file → follow re-export chain
+        lookupFile = binding.sourcePath;
+        lookupName = targetName;
+    }
+    return null;
+}
+/**
+ * Extract named bindings from an import AST node.
+ * Returns undefined if the import is not a named import (e.g., import * or default).
+ *
+ * TS: import { User, Repo as R } from './models'
+ *   → [{local:'User', exported:'User'}, {local:'R', exported:'Repo'}]
+ *
+ * Python: from models import User, Repo as R
+ *   → [{local:'User', exported:'User'}, {local:'R', exported:'Repo'}]
+ */
+export function extractNamedBindings(importNode, language) {
+    if (language === SupportedLanguages.TypeScript || language === SupportedLanguages.JavaScript) {
+        return extractTsNamedBindings(importNode);
+    }
+    if (language === SupportedLanguages.Python) {
+        return extractPythonNamedBindings(importNode);
+    }
+    if (language === SupportedLanguages.Kotlin) {
+        return extractKotlinNamedBindings(importNode);
+    }
+    if (language === SupportedLanguages.Rust) {
+        return extractRustNamedBindings(importNode);
+    }
+    if (language === SupportedLanguages.PHP) {
+        return extractPhpNamedBindings(importNode);
+    }
+    if (language === SupportedLanguages.CSharp) {
+        return extractCsharpNamedBindings(importNode);
+    }
+    if (language === SupportedLanguages.Java) {
+        return extractJavaNamedBindings(importNode);
+    }
+    return undefined;
+}
+export function extractTsNamedBindings(importNode) {
+    // import_statement > import_clause > named_imports > import_specifier*
+    const importClause = findChild(importNode, 'import_clause');
+    if (importClause) {
+        const namedImports = findChild(importClause, 'named_imports');
+        if (!namedImports)
+            return undefined; // default import, namespace import, or side-effect
+        const bindings = [];
+        for (let i = 0; i < namedImports.namedChildCount; i++) {
+            const specifier = namedImports.namedChild(i);
+            if (specifier?.type !== 'import_specifier')
+                continue;
+            const identifiers = [];
+            for (let j = 0; j < specifier.namedChildCount; j++) {
+                const child = specifier.namedChild(j);
+                if (child?.type === 'identifier')
+                    identifiers.push(child.text);
+            }
+            if (identifiers.length === 1) {
+                bindings.push({ local: identifiers[0], exported: identifiers[0] });
+            }
+            else if (identifiers.length === 2) {
+                // import { Foo as Bar } → exported='Foo', local='Bar'
+                bindings.push({ local: identifiers[1], exported: identifiers[0] });
+            }
+        }
+        return bindings.length > 0 ? bindings : undefined;
+    }
+    // Re-export: export { X } from './y' → export_statement > export_clause > export_specifier
+    const exportClause = findChild(importNode, 'export_clause');
+    if (exportClause) {
+        const bindings = [];
+        for (let i = 0; i < exportClause.namedChildCount; i++) {
+            const specifier = exportClause.namedChild(i);
+            if (specifier?.type !== 'export_specifier')
+                continue;
+            const identifiers = [];
+            for (let j = 0; j < specifier.namedChildCount; j++) {
+                const child = specifier.namedChild(j);
+                if (child?.type === 'identifier')
+                    identifiers.push(child.text);
+            }
+            if (identifiers.length === 1) {
+                // export { User } from './base' → re-exports User as User
+                bindings.push({ local: identifiers[0], exported: identifiers[0] });
+            }
+            else if (identifiers.length === 2) {
+                // export { Repo as Repository } from './models' → name=Repo, alias=Repository
+                // For re-exports, the first id is the source name, second is what's exported
+                // When another file imports { Repository }, they get Repo from the source
+                bindings.push({ local: identifiers[1], exported: identifiers[0] });
+            }
+        }
+        return bindings.length > 0 ? bindings : undefined;
+    }
+    return undefined;
+}
+export function extractPythonNamedBindings(importNode) {
+    // Only from import_from_statement, not plain import_statement
+    if (importNode.type !== 'import_from_statement')
+        return undefined;
+    const bindings = [];
+    for (let i = 0; i < importNode.namedChildCount; i++) {
+        const child = importNode.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'dotted_name') {
+            // Skip the module_name (first dotted_name is the source module)
+            const fieldName = importNode.childForFieldName?.('module_name');
+            if (fieldName && child.startIndex === fieldName.startIndex)
+                continue;
+            // This is an imported name: from x import User
+            const name = child.text;
+            if (name)
+                bindings.push({ local: name, exported: name });
+        }
+        if (child.type === 'aliased_import') {
+            // from x import Repo as R
+            const dottedName = findChild(child, 'dotted_name');
+            const aliasIdent = findChild(child, 'identifier');
+            if (dottedName && aliasIdent) {
+                bindings.push({ local: aliasIdent.text, exported: dottedName.text });
+            }
+        }
+    }
+    return bindings.length > 0 ? bindings : undefined;
+}
+export function extractKotlinNamedBindings(importNode) {
+    // import_header > identifier + import_alias > simple_identifier
+    if (importNode.type !== 'import_header')
+        return undefined;
+    const fullIdent = findChild(importNode, 'identifier');
+    if (!fullIdent)
+        return undefined;
+    const fullText = fullIdent.text;
+    const exportedName = fullText.includes('.') ? fullText.split('.').pop() : fullText;
+    const importAlias = findChild(importNode, 'import_alias');
+    if (importAlias) {
+        // Aliased: import com.example.User as U
+        const aliasIdent = findChild(importAlias, 'simple_identifier');
+        if (!aliasIdent)
+            return undefined;
+        return [{ local: aliasIdent.text, exported: exportedName }];
+    }
+    // Non-aliased: import com.example.User → local="User", exported="User"
+    // Skip wildcard imports (ending in *)
+    if (fullText.endsWith('.*') || fullText.endsWith('*'))
+        return undefined;
+    // Skip lowercase last segments — those are member/function imports (e.g.,
+    // import util.OneArg.writeAudit), not class imports. Multiple member imports
+    // with the same function name would collide in NamedImportMap, breaking
+    // arity-based disambiguation.
+    if (exportedName[0] && exportedName[0] === exportedName[0].toLowerCase())
+        return undefined;
+    return [{ local: exportedName, exported: exportedName }];
+}
+export function extractRustNamedBindings(importNode) {
+    // use_declaration may contain use_as_clause at any depth
+    if (importNode.type !== 'use_declaration')
+        return undefined;
+    const bindings = [];
+    collectRustBindings(importNode, bindings);
+    return bindings.length > 0 ? bindings : undefined;
+}
+function collectRustBindings(node, bindings) {
+    if (node.type === 'use_as_clause') {
+        // First identifier = exported name, second identifier = local alias
+        const idents = [];
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'identifier')
+                idents.push(child.text);
+            // For scoped_identifier, extract the last segment
+            if (child?.type === 'scoped_identifier') {
+                const nameNode = child.childForFieldName?.('name');
+                if (nameNode)
+                    idents.push(nameNode.text);
+            }
+        }
+        if (idents.length === 2) {
+            bindings.push({ local: idents[1], exported: idents[0] });
+        }
+        return;
+    }
+    // Terminal identifier in a use_list: use crate::models::{User, Repo}
+    if (node.type === 'identifier' && node.parent?.type === 'use_list') {
+        bindings.push({ local: node.text, exported: node.text });
+        return;
+    }
+    // Skip scoped_identifier that serves as path prefix in scoped_use_list
+    // e.g. use crate::models::{User, Repo} — the path node "crate::models" is not an importable symbol
+    if (node.type === 'scoped_identifier' && node.parent?.type === 'scoped_use_list') {
+        return; // path prefix — the use_list sibling handles the actual symbols
+    }
+    // Terminal scoped_identifier: use crate::models::User;
+    // Only extract if this is a leaf (no deeper use_list/use_as_clause/scoped_use_list)
+    if (node.type === 'scoped_identifier') {
+        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') {
+                hasDeeper = true;
+                break;
+            }
+        }
+        if (!hasDeeper) {
+            const nameNode = node.childForFieldName?.('name');
+            if (nameNode) {
+                bindings.push({ local: nameNode.text, exported: nameNode.text });
+            }
+            return;
+        }
+    }
+    // Recurse into children
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child)
+            collectRustBindings(child, bindings);
+    }
+}
+export function extractPhpNamedBindings(importNode) {
+    // namespace_use_declaration > namespace_use_clause* (flat)
+    // namespace_use_declaration > namespace_use_group > namespace_use_clause* (grouped)
+    if (importNode.type !== 'namespace_use_declaration')
+        return undefined;
+    const bindings = [];
+    // Collect all clauses — from direct children AND from namespace_use_group
+    const clauses = [];
+    for (let i = 0; i < importNode.namedChildCount; i++) {
+        const child = importNode.namedChild(i);
+        if (child?.type === 'namespace_use_clause') {
+            clauses.push(child);
+        }
+        else if (child?.type === 'namespace_use_group') {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const groupChild = child.namedChild(j);
+                if (groupChild?.type === 'namespace_use_clause')
+                    clauses.push(groupChild);
+            }
+        }
+    }
+    for (const clause of clauses) {
+        // Flat imports: qualified_name + name (alias)
+        let qualifiedName = null;
+        const names = [];
+        for (let j = 0; j < clause.namedChildCount; j++) {
+            const child = clause.namedChild(j);
+            if (child?.type === 'qualified_name')
+                qualifiedName = child;
+            else if (child?.type === 'name')
+                names.push(child);
+        }
+        if (qualifiedName && names.length > 0) {
+            // Flat aliased import: use App\Models\Repo as R;
+            const fullText = qualifiedName.text;
+            const exportedName = fullText.includes('\\') ? fullText.split('\\').pop() : fullText;
+            bindings.push({ local: names[0].text, exported: exportedName });
+        }
+        else if (qualifiedName && names.length === 0) {
+            // Flat non-aliased import: use App\Models\User;
+            const fullText = qualifiedName.text;
+            const lastSegment = fullText.includes('\\') ? fullText.split('\\').pop() : fullText;
+            bindings.push({ local: lastSegment, exported: lastSegment });
+        }
+        else if (!qualifiedName && names.length >= 2) {
+            // Grouped aliased import: {Repo as R} — first name = exported, second = alias
+            bindings.push({ local: names[1].text, exported: names[0].text });
+        }
+        else if (!qualifiedName && names.length === 1) {
+            // Grouped non-aliased import: {User} in use App\Models\{User, Repo as R}
+            bindings.push({ local: names[0].text, exported: names[0].text });
+        }
+    }
+    return bindings.length > 0 ? bindings : undefined;
+}
+export function extractCsharpNamedBindings(importNode) {
+    // using_directive with identifier (alias) + qualified_name (target)
+    if (importNode.type !== 'using_directive')
+        return undefined;
+    let aliasIdent = null;
+    let qualifiedName = null;
+    for (let i = 0; i < importNode.namedChildCount; i++) {
+        const child = importNode.namedChild(i);
+        if (child?.type === 'identifier' && !aliasIdent)
+            aliasIdent = child;
+        else if (child?.type === 'qualified_name')
+            qualifiedName = child;
+    }
+    if (!aliasIdent || !qualifiedName)
+        return undefined;
+    const fullText = qualifiedName.text;
+    const exportedName = fullText.includes('.') ? fullText.split('.').pop() : fullText;
+    return [{ local: aliasIdent.text, exported: exportedName }];
+}
+export function extractJavaNamedBindings(importNode) {
+    // import_declaration > scoped_identifier "com.example.models.User"
+    // Wildcard imports (.*) don't produce named bindings
+    if (importNode.type !== 'import_declaration')
+        return undefined;
+    // Check for asterisk (wildcard import) — skip those
+    for (let i = 0; i < importNode.childCount; i++) {
+        const child = importNode.child(i);
+        if (child?.type === 'asterisk')
+            return undefined;
+    }
+    const scopedId = findChild(importNode, 'scoped_identifier');
+    if (!scopedId)
+        return undefined;
+    const fullText = scopedId.text;
+    const lastDot = fullText.lastIndexOf('.');
+    if (lastDot === -1)
+        return undefined;
+    const className = fullText.slice(lastDot + 1);
+    // Skip lowercase names — those are package imports, not class imports
+    if (className[0] && className[0] === className[0].toLowerCase())
+        return undefined;
+    return [{ local: className, exported: className }];
+}
+function findChild(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === type)
+            return child;
+    }
+    return null;
+}

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

@@ -10,16 +10,7 @@ export interface WorkerExtractedData {
     heritage: ExtractedHeritage[];
     routes: ExtractedRoute[];
 }
-/**
- * Check if a symbol (function, class, etc.) is exported/public
- * Handles all 9 supported languages with explicit logic
- *
- * @param node - The AST node for the symbol name
- * @param name - The symbol name
- * @param language - The programming language
- * @returns true if the symbol is exported/public
- */
-export declare const isNodeExported: (node: any, name: string, language: string) => boolean;
+export { isNodeExported } from './export-detection.js';
 export declare const processParsing: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;

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

@@ -2,178 +2,13 @@ import Parser from 'tree-sitter';
 import { loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
-import { findSiblingChild, getLanguageFromFilename, yieldToEventLoop } from './utils.js';
+import { getLanguageFromFilename, yieldToEventLoop, getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature } from './utils.js';
+import { isNodeExported } from './export-detection.js';
 import { detectFrameworkFromAST } from './framework-detection.js';
-const DEFINITION_CAPTURE_KEYS = [
-    'definition.function',
-    'definition.class',
-    'definition.interface',
-    'definition.method',
-    'definition.struct',
-    'definition.enum',
-    'definition.namespace',
-    'definition.module',
-    'definition.trait',
-    'definition.impl',
-    'definition.type',
-    'definition.const',
-    'definition.static',
-    'definition.typedef',
-    'definition.macro',
-    'definition.union',
-    'definition.property',
-    'definition.record',
-    'definition.delegate',
-    'definition.annotation',
-    'definition.constructor',
-    'definition.template',
-];
-const getDefinitionNodeFromCaptures = (captureMap) => {
-    for (const key of DEFINITION_CAPTURE_KEYS) {
-        if (captureMap[key])
-            return captureMap[key];
-    }
-    return null;
-};
-// ============================================================================
-// EXPORT DETECTION - Language-specific visibility detection
-// ============================================================================
-/**
- * Check if a symbol (function, class, etc.) is exported/public
- * Handles all 9 supported languages with explicit logic
- *
- * @param node - The AST node for the symbol name
- * @param name - The symbol name
- * @param language - The programming language
- * @returns true if the symbol is exported/public
- */
-export const isNodeExported = (node, name, language) => {
-    let current = node;
-    switch (language) {
-        // JavaScript/TypeScript: Check for export keyword in ancestors
-        case 'javascript':
-        case 'typescript':
-            while (current) {
-                const type = current.type;
-                if (type === 'export_statement' ||
-                    type === 'export_specifier' ||
-                    type === 'lexical_declaration' && current.parent?.type === 'export_statement') {
-                    return true;
-                }
-                // Also check if text starts with 'export '
-                if (current.text?.startsWith('export ')) {
-                    return true;
-                }
-                current = current.parent;
-            }
-            return false;
-        // Python: Public if no leading underscore (convention)
-        case 'python':
-            return !name.startsWith('_');
-        // Java: Check for 'public' modifier
-        // In tree-sitter Java, modifiers are siblings of the name node, not parents
-        case 'java':
-            while (current) {
-                // Check if this node or any sibling is a 'modifiers' node containing 'public'
-                if (current.parent) {
-                    const parent = current.parent;
-                    // Check all children of the parent for modifiers
-                    for (let i = 0; i < parent.childCount; i++) {
-                        const child = parent.child(i);
-                        if (child?.type === 'modifiers' && child.text?.includes('public')) {
-                            return true;
-                        }
-                    }
-                    // Also check if the parent's text starts with 'public' (fallback)
-                    if (parent.type === 'method_declaration' || parent.type === 'constructor_declaration') {
-                        if (parent.text?.trimStart().startsWith('public')) {
-                            return true;
-                        }
-                    }
-                }
-                current = current.parent;
-            }
-            return false;
-        // C#: Check for 'public' modifier in ancestors
-        case 'csharp':
-            while (current) {
-                if (current.type === 'modifier' || current.type === 'modifiers') {
-                    if (current.text?.includes('public'))
-                        return true;
-                }
-                current = current.parent;
-            }
-            return false;
-        // Go: Uppercase first letter = exported
-        case 'go':
-            if (name.length === 0)
-                return false;
-            const first = name[0];
-            // Must be uppercase letter (not a number or symbol)
-            return first === first.toUpperCase() && first !== first.toLowerCase();
-        // Rust: Check for 'pub' visibility modifier
-        case 'rust':
-            while (current) {
-                if (current.type === 'visibility_modifier') {
-                    if (current.text?.includes('pub'))
-                        return true;
-                }
-                current = current.parent;
-            }
-            return false;
-        // Kotlin: Default visibility is public (unlike Java)
-        // visibility_modifier is inside modifiers, a sibling of the name node within the declaration
-        case 'kotlin':
-            while (current) {
-                if (current.parent) {
-                    const visMod = findSiblingChild(current.parent, 'modifiers', 'visibility_modifier');
-                    if (visMod) {
-                        const text = visMod.text;
-                        if (text === 'private' || text === 'internal' || text === 'protected')
-                            return false;
-                        if (text === 'public')
-                            return true;
-                    }
-                }
-                current = current.parent;
-            }
-            // No visibility modifier = public (Kotlin default)
-            return true;
-        // C/C++: No native export concept at language level
-        // Entry points will be detected via name patterns (main, etc.)
-        case 'c':
-        case 'cpp':
-            return false;
-        // Swift: Check for 'public' or 'open' access modifiers
-        case 'swift':
-            while (current) {
-                if (current.type === 'modifiers' || current.type === 'visibility_modifier') {
-                    const text = current.text || '';
-                    if (text.includes('public') || text.includes('open'))
-                        return true;
-                }
-                current = current.parent;
-            }
-            return false;
-        // PHP: Check for visibility modifier or top-level scope
-        case 'php':
-            while (current) {
-                if (current.type === 'class_declaration' ||
-                    current.type === 'interface_declaration' ||
-                    current.type === 'trait_declaration' ||
-                    current.type === 'enum_declaration') {
-                    return true;
-                }
-                if (current.type === 'visibility_modifier') {
-                    return current.text === 'public';
-                }
-                current = current.parent;
-            }
-            return true; // Top-level functions are globally accessible
-        default:
-            return false;
-    }
-};
+import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from './constants.js';
+// isNodeExported imported from ./export-detection.js (shared module)
+// Re-export for backward compatibility with any external consumers
+export { isNodeExported } from './export-detection.js';
 // ============================================================================
 // Worker-based parallel parsing
 // ============================================================================
@@ -209,7 +44,10 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
             graph.addRelationship(rel);
         }
         for (const sym of result.symbols) {
-            symbolTable.add(sym.filePath, sym.name, sym.nodeId, sym.type);
+            symbolTable.add(sym.filePath, sym.name, sym.nodeId, sym.type, {
+                parameterCount: sym.parameterCount,
+                ownerId: sym.ownerId,
+            });
         }
         allImports.push(...result.imports);
         allCalls.push(...result.calls);
@@ -234,8 +72,8 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
         const language = getLanguageFromFilename(file.path);
         if (!language)
             continue;
-        // Skip very large files — they can crash tree-sitter or cause OOM
-        if (file.content.length > 512 * 1024)
+        // Skip files larger than the max tree-sitter buffer (32 MB)
+        if (file.content.length > TREE_SITTER_MAX_BUFFER)
             continue;
         try {
             await loadLanguage(language, file.path);
@@ -245,7 +83,7 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
         }
         let tree;
         try {
-            tree = parser.parse(file.content, undefined, { bufferSize: 1024 * 256 });
+            tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
         }
         catch (parseError) {
             console.warn(`Skipping unparseable file: ${file.path}`);
@@ -330,11 +168,15 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                 nodeLabel = 'Template';
             const definitionNodeForRange = getDefinitionNodeFromCaptures(captureMap);
             const startLine = definitionNodeForRange ? definitionNodeForRange.startPosition.row : (nameNode ? nameNode.startPosition.row : 0);
-            const nodeId = generateId(nodeLabel, `${file.path}:${nodeName}:${startLine}`);
+            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')
+                ? extractMethodSignature(definitionNode)
+                : undefined;
             const node = {
                 id: nodeId,
                 label: nodeLabel,
@@ -349,10 +191,21 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                         astFrameworkMultiplier: frameworkHint.entryPointMultiplier,
                         astFrameworkReason: frameworkHint.reason,
                     } : {}),
+                    ...(methodSig ? {
+                        parameterCount: methodSig.parameterCount,
+                        returnType: methodSig.returnType,
+                    } : {}),
                 },
             };
             graph.addNode(node);
-            symbolTable.add(file.path, nodeName, nodeId, nodeLabel);
+            // 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 ? findEnclosingClassId(nameNode || definitionNodeForRange, file.path) : null;
+            symbolTable.add(file.path, nodeName, nodeId, nodeLabel, {
+                parameterCount: methodSig?.parameterCount,
+                ownerId: enclosingClassId ?? undefined,
+            });
             const fileId = generateId('File', file.path);
             const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
             const relationship = {
@@ -364,6 +217,17 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                 reason: '',
             };
             graph.addRelationship(relationship);
+            // ── HAS_METHOD: link method/constructor/property to enclosing class ──
+            if (enclosingClassId) {
+                graph.addRelationship({
+                    id: generateId('HAS_METHOD', `${enclosingClassId}->${nodeId}`),
+                    sourceId: enclosingClassId,
+                    targetId: nodeId,
+                    type: 'HAS_METHOD',
+                    confidence: 1.0,
+                    reason: '',
+                });
+            }
         });
     }
 };