@veewo/gitnexus 1.3.11 → 1.4.6-rc

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

@@ -2,13 +2,16 @@ import { KnowledgeGraph } from '../graph/types.js';
 import { SymbolTable } from './symbol-table.js';
 import { ASTCache } from './ast-cache.js';
 import { WorkerPool } from './workers/worker-pool.js';
-import type { ExtractedImport, ExtractedCall, ExtractedHeritage } from './workers/parse-worker.js';
+import type { ExtractedImport, ExtractedCall, ExtractedHeritage, ExtractedRoute, FileConstructorBindings } from './workers/parse-worker.js';
 export type FileProgressCallback = (current: number, total: number, filePath: string) => void;
 export interface WorkerExtractedData {
     imports: ExtractedImport[];
     calls: ExtractedCall[];
     heritage: ExtractedHeritage[];
+    routes: ExtractedRoute[];
+    constructorBindings: FileConstructorBindings[];
 }
+export { isNodeExported } from './export-detection.js';
 export declare const processParsing: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;

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

@@ -1,103 +1,15 @@
 import Parser from 'tree-sitter';
-import { loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
+import { loadParser, loadLanguage, isLanguageAvailable } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
-import { getLanguageFromFilename, yieldToEventLoop } from './utils.js';
-// ============================================================================
-// 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
- */
-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;
-        // 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;
-        default:
-            return false;
-    }
-};
+import { getLanguageFromFilename, yieldToEventLoop, getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature } from './utils.js';
+import { isNodeExported } from './export-detection.js';
+import { detectFrameworkFromAST } from './framework-detection.js';
+import { typeConfigs } from './type-extractors/index.js';
+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
 // ============================================================================
@@ -110,7 +22,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
             parseableFiles.push({ path: file.path, content: file.content });
     }
     if (parseableFiles.length === 0)
-        return { imports: [], calls: [], heritage: [] };
+        return { imports: [], calls: [], heritage: [], routes: [], constructorBindings: [] };
     const total = files.length;
     // Dispatch to worker pool — pool handles splitting into chunks and sub-batching
     const chunkResults = await workerPool.dispatch(parseableFiles, (filesProcessed) => {
@@ -120,6 +32,8 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
     const allImports = [];
     const allCalls = [];
     const allHeritage = [];
+    const allRoutes = [];
+    const allConstructorBindings = [];
     for (const result of chunkResults) {
         for (const node of result.nodes) {
             graph.addNode({
@@ -132,15 +46,34 @@ 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,
+                returnType: sym.returnType,
+                ownerId: sym.ownerId,
+            });
         }
         allImports.push(...result.imports);
         allCalls.push(...result.calls);
         allHeritage.push(...result.heritage);
+        allRoutes.push(...result.routes);
+        allConstructorBindings.push(...result.constructorBindings);
+    }
+    // Merge and log skipped languages from workers
+    const skippedLanguages = new Map();
+    for (const result of chunkResults) {
+        for (const [lang, count] of Object.entries(result.skippedLanguages)) {
+            skippedLanguages.set(lang, (skippedLanguages.get(lang) || 0) + count);
+        }
+    }
+    if (skippedLanguages.size > 0) {
+        const summary = Array.from(skippedLanguages.entries())
+            .map(([lang, count]) => `${lang}: ${count}`)
+            .join(', ');
+        console.warn(`  Skipped unsupported languages: ${summary}`);
     }
     // Final progress
     onFileProgress?.(total, total, 'done');
-    return { imports: allImports, calls: allCalls, heritage: allHeritage };
+    return { imports: allImports, calls: allCalls, heritage: allHeritage, routes: allRoutes, constructorBindings: allConstructorBindings };
 };
 // ============================================================================
 // Sequential fallback (original implementation)
@@ -148,6 +81,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
 const processParsingSequential = async (graph, files, symbolTable, astCache, onFileProgress) => {
     const parser = await loadParser();
     const total = files.length;
+    const skippedLanguages = new Map();
     for (let i = 0; i < files.length; i++) {
         const file = files[i];
         onFileProgress?.(i + 1, total, file.path);
@@ -156,13 +90,23 @@ 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 unsupported languages (e.g. Swift when tree-sitter-swift not installed)
+        if (!isLanguageAvailable(language)) {
+            skippedLanguages.set(language, (skippedLanguages.get(language) || 0) + 1);
             continue;
-        await loadLanguage(language, file.path);
+        }
+        // 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);
+        }
+        catch {
+            continue; // parser unavailable — safety net
+        }
         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}`);
@@ -196,9 +140,10 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                 return;
             }
             const nameNode = captureMap['name'];
-            if (!nameNode)
+            // Synthesize name for constructors without explicit @name capture (e.g. Swift init)
+            if (!nameNode && !captureMap['definition.constructor'])
                 return;
-            const nodeName = nameNode.text;
+            const nodeName = nameNode ? nameNode.text : 'init';
             let nodeLabel = 'CodeElement';
             if (captureMap['definition.function'])
                 nodeLabel = 'Function';
@@ -244,7 +189,27 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                 nodeLabel = 'Constructor';
             else if (captureMap['definition.template'])
                 nodeLabel = 'Template';
+            const definitionNodeForRange = getDefinitionNodeFromCaptures(captureMap);
+            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')
+                ? 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) {
+                const tc = typeConfigs[language];
+                if (tc?.extractReturnType) {
+                    const docReturn = tc.extractReturnType(definitionNode);
+                    if (docReturn)
+                        methodSig.returnType = docReturn;
+                }
+            }
             const node = {
                 id: nodeId,
                 label: nodeLabel,
@@ -254,11 +219,27 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                     startLine: nameNode.startPosition.row + 1,
                     endLine: nameNode.endPosition.row + 1,
                     language: language,
-                    isExported: isNodeExported(nameNode, nodeName, language),
-                }
+                    isExported: isNodeExported(nameNode || definitionNodeForRange, nodeName, language),
+                    ...(frameworkHint ? {
+                        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,
+                returnType: methodSig?.returnType,
+                ownerId: enclosingClassId ?? undefined,
+            });
             const fileId = generateId('File', file.path);
             const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
             const relationship = {
@@ -270,8 +251,25 @@ 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: '',
+                });
+            }
         });
     }
+    if (skippedLanguages.size > 0) {
+        const summary = Array.from(skippedLanguages.entries())
+            .map(([lang, count]) => `${lang}: ${count}`)
+            .join(', ');
+        console.warn(`  Skipped unsupported languages: ${summary}`);
+    }
 };
 // ============================================================================
 // Public API