@getmikk/core 2.0.0 → 2.0.11

package/src/parser/tree-sitter/parser.ts

@@ -1,70 +1,80 @@
 import * as path from 'node:path'
+import { TreeSitterResolver } from './resolver.js'
 import { createRequire } from 'node:module'
 import { hashContent } from '../../hash/file-hasher.js'
 import { BaseParser } from '../base-parser.js'
-import type { ParsedFile, ParsedFunction, ParsedClass, ParsedParam, ParsedImport } from '../types.js'
+import type { ParsedFile, ParsedFunction, ParsedClass, ParsedParam, ParsedImport, ParsedGeneric } from '../types.js'
 import * as Queries from './queries.js'
 
-// Safely require web-tree-sitter via CJS
 const getRequire = () => {
     if (typeof require !== 'undefined') return require
     return createRequire(import.meta.url)
 }
 const _require = getRequire()
-const ParserModule = _require('web-tree-sitter')
-const Parser = ParserModule.Parser || ParserModule
-
-// ---------------------------------------------------------------------------
-// Language-specific export visibility rules
-// ---------------------------------------------------------------------------
-
-/**
- * Determine whether a function node is exported based on language conventions.
- * Python: public if name does not start with underscore.
- * Java/C#/Rust: requires an explicit visibility keyword in the node text.
- * Go: exported if name starts with an uppercase letter.
- * All others (C, C++, PHP, Ruby): default to false (no reliable static rule).
- */
+
+let Parser: any = null
+let Language: any = null
+let initialized = false
+let initPromise: Promise<void> | null = null
+
+try {
+    const ParserModule = _require('web-tree-sitter')
+    Parser = ParserModule
+    if (ParserModule.init) {
+        initPromise = ParserModule.init().then(() => {
+            Language = ParserModule.Language
+            initialized = true
+        }).catch(() => { /* ignore */ })
+    } else if (ParserModule.default?.Language) {
+        Language = ParserModule.default.Language
+    }
+} catch { /* web-tree-sitter not installed */ }
+
 function isExportedByLanguage(ext: string, name: string, nodeText: string): boolean {
     switch (ext) {
         case '.py':
             return !name.startsWith('_')
         case '.java':
-        case '.cs':
             return /\bpublic\b/.test(nodeText)
+        case '.cs':
+            return /\bpublic\b/.test(nodeText) && !/\binternal\b/.test(nodeText)
         case '.go':
             return name.length > 0 && name[0] === name[0].toUpperCase() && name[0] !== name[0].toLowerCase()
         case '.rs':
-            return /\bpub\b/.test(nodeText)
+            return /\bpub\b/.test(nodeText) || /\bpub\s*\(crate\)/.test(nodeText)
+        case '.php':
+            return !/\bprivate\b/.test(nodeText) && !/\bprotected\b/.test(nodeText)
+        case '.rb':
+            if (name.startsWith('private_') || name.startsWith('protected_')) return false
+            if (/\bprivate\b/.test(nodeText.split('\n')[0] || '')) return false
+            if (/\bprotected\b/.test(nodeText.split('\n')[0] || '')) return false
+            return true
+        case '.c':
+        case '.h':
+            return true
+        case '.cpp':
+        case '.cc':
+        case '.hpp':
+        case '.hh':
+            if (/\bprivate\b/.test(nodeText) || /\bprotected\b/.test(nodeText)) return false
+            return true
         default:
             return false
     }
 }
 
-// ---------------------------------------------------------------------------
-// Parameter extraction from tree-sitter nodes
-// ---------------------------------------------------------------------------
-
-/**
- * Best-effort parameter extraction from a function definition node.
- * Walks child nodes looking for parameter/formal_parameter identifiers.
- * Returns an empty array on failure — never throws.
- */
 function extractParamsFromNode(defNode: any): ParsedParam[] {
     const params: ParsedParam[] = []
     if (!defNode || !defNode.children) return params
 
-    // Walk all descendants looking for parameter-like nodes
     const walk = (node: any) => {
         if (!node) return
         const t = node.type ?? ''
-        // Common parameter node type names across tree-sitter grammars
         if (
             t === 'parameter' || t === 'formal_parameter' || t === 'simple_parameter' ||
             t === 'variadic_parameter' || t === 'typed_parameter' || t === 'typed_default_parameter' ||
             t === 'keyword_argument' || t === 'field_declaration'
         ) {
-            // Try to find the identifier within this param node
             const identNode = findFirstChild(node, n => n.type === 'identifier' || n.type === 'name')
             const typeNode = findFirstChild(node, n =>
                 n.type === 'type' || n.type === 'type_annotation' ||
@@ -73,9 +83,9 @@ function extractParamsFromNode(defNode: any): ParsedParam[] {
             const name = identNode?.text ?? node.text ?? ''
             const type = typeNode?.text ?? 'any'
             if (name && name !== '' && !params.some(p => p.name === name)) {
-                params.push({ name, type, optional: false })
+                params.push({ name, type, optional: /\?/.test(type) })
             }
-            return // Don't recurse into parameter children
+            return
         }
         if (node.children) {
             for (const child of node.children) walk(child)
@@ -94,25 +104,54 @@ function findFirstChild(node: any, predicate: (n: any) => boolean): any {
     return null
 }
 
-// ---------------------------------------------------------------------------
-// Scope-aware call resolver
-// ---------------------------------------------------------------------------
-
-/**
- * Given the ordered list of functions (with startLine/endLine already set)
- * and a map of callName → line, assign each call to the innermost function
- * whose line range contains that call's line.
- * 
- * Returns an array of call names that were NOT assigned to any function scope 
- * (these are module-scope calls).
- */
+function findAllChildren(node: any, predicate: (n: any) => boolean): any[] {
+    const results: any[] = []
+    if (!node?.children) return results
+    for (const child of node.children) {
+        if (predicate(child)) results.push(child)
+        results.push(...findAllChildren(child, predicate))
+    }
+    return results
+}
+
+function extractGenericsFromNode(defNode: any, filePath: string): ParsedGeneric[] {
+    const generics: ParsedGeneric[] = []
+    if (!defNode) return generics
+
+    const typeParamNodes = findAllChildren(defNode, n => 
+        n.type === 'type_parameter' || n.type === 'type_parameters'
+    )
+
+    for (const tpNode of typeParamNodes) {
+        if (tpNode.type === 'type_parameters') {
+            const params = findAllChildren(tpNode, n => n.type === 'type_parameter')
+            for (const param of params) {
+                const paramName = findFirstChild(param, n => n.type === 'type_identifier' || n.type === 'identifier')
+                if (paramName) {
+                    generics.push({
+                        id: `generic:${filePath}:${paramName.text}`,
+                        name: paramName.text,
+                        type: 'type',
+                        file: filePath,
+                        startLine: param.startPosition?.row + 1 || 0,
+                        endLine: param.endPosition?.row + 1 || 0,
+                        isExported: false,
+                        hash: '',
+                    })
+                }
+            }
+        }
+    }
+
+    return generics
+}
+
 function assignCallsToFunctions(
     functions: ParsedFunction[],
     callEntries: Array<{ name: string; line: number }>
 ): Array<{ name: string; line: number }> {
     const unassigned: Array<{ name: string; line: number }> = []
     for (const { name, line } of callEntries) {
-        // Find the innermost (smallest range) function that contains this line
         let best: ParsedFunction | null = null
         let bestRange = Infinity
         for (const fn of functions) {
@@ -135,14 +174,11 @@ function assignCallsToFunctions(
     return unassigned
 }
 
-// ---------------------------------------------------------------------------
-// Main parser class
-// ---------------------------------------------------------------------------
-
 export class TreeSitterParser extends BaseParser {
     private parser: any = null
     private languages = new Map<string, any>()
     private nameCounter = new Map<string, number>()
+    private wasmLoadError = false
 
     getSupportedExtensions(): string[] {
         return ['.py', '.java', '.c', '.cpp', '.cc', '.h', '.hpp', '.cs', '.go', '.rs', '.php', '.rb']
@@ -150,7 +186,9 @@ export class TreeSitterParser extends BaseParser {
 
     private async init() {
         if (!this.parser) {
-            await Parser.init()
+            if (!Parser || !initPromise) return
+            await initPromise.catch(() => {})
+            if (!Language) return
             this.parser = new Parser()
         }
     }
@@ -159,24 +197,43 @@ export class TreeSitterParser extends BaseParser {
         this.nameCounter.clear()
         await this.init()
         const ext = path.extname(filePath).toLowerCase()
+
+        if (!this.parser) {
+            return this.buildEmptyFile(filePath, content, ext)
+        }
+
         const config = await this.getLanguageConfig(ext)
 
         if (!config || !config.lang) {
             return this.buildEmptyFile(filePath, content, ext)
         }
 
+        try {
+            return this.parseWithConfig(filePath, content, ext, config)
+        } catch (err) {
+            console.warn(`Parse error for ${filePath}:`, err)
+            return this.buildEmptyFile(filePath, content, ext)
+        }
+    }
+
+    private async parseWithConfig(filePath: string, content: string, ext: string, config: any): Promise<ParsedFile> {
         this.parser!.setLanguage(config.lang)
         const tree = this.parser!.parse(content)
         const query = config.lang.query(config.query)
+        
+        if (!query) {
+            return this.buildEmptyFile(filePath, content, ext)
+        }
+
         const matches = query.matches(tree.rootNode)
 
         const functions: ParsedFunction[] = []
         const classesMap = new Map<string, ParsedClass>()
         const imports: ParsedImport[] = []
-        // callEntries stores name + line so we can scope them to the right function
+        const generics: ParsedGeneric[] = []
         const callEntries: Array<{ name: string; line: number }> = []
-        // Track processed function IDs to avoid collisions from overloads
         const seenFnIds = new Set<string>()
+        const routes: Array<{ method: string; path: string; handler: string; line: number }> = []
 
         for (const match of matches) {
             const captures: Record<string, any> = {}
@@ -184,11 +241,53 @@ export class TreeSitterParser extends BaseParser {
                 captures[c.name] = c.node
             }
 
-            // --- Calls: record name and line position ---
+            // --- Routes ---
+            if (captures['route.name'] || captures['call.name']) {
+                let routeName = ''
+                let routePath = '/'
+                let method = 'GET'
+                let routeLine = 0
+
+                if (captures['route.name']) {
+                    routeName = captures['route.name'].text ?? ''
+                    routeLine = (captures['route.name'].startPosition?.row ?? 0) + 1
+                } else if (captures['call.name']) {
+                    routeName = captures['call.name'].text ?? ''
+                    routeLine = (captures['call.name'].startPosition?.row ?? 0) + 1
+                }
+
+                if (routeName && /^(get|post|put|delete|patch|options|head|resource|apiResource|any)$/i.test(routeName)) {
+                    method = routeName.toUpperCase()
+                    
+                    if (captures['route.path']) {
+                        routePath = captures['route.path'].text?.replace(/['"]/g, '') || '/'
+                    } else {
+                        const args = findAllChildren(match.node, n => n.type === 'argument_list')
+                        for (const arg of args) {
+                            const str = findFirstChild(arg, n => n.type === 'string' || n.type === 'string_content')
+                            if (str) {
+                                routePath = str.text?.replace(/['"]/g, '') || '/'
+                                break
+                            }
+                        }
+                    }
+
+                    if (routePath !== '/' && routePath !== '') {
+                        routes.push({ method, path: routePath, handler: '', line: routeLine })
+                    }
+                }
+            }
+
+            // --- Base routes for class-level route ---
+            if (captures['route.basepath']) {
+                // Store base path for class-level routes
+            }
+
+            // --- Calls ---
             if (captures['call.name']) {
                 const callNode = captures['call.name']
-                const name = callNode.text
-                if (name) {
+                const name = callNode?.text
+                if (name && !/^(get|post|put|delete|patch|options|head|resource)$/i.test(name)) {
                     callEntries.push({
                         name,
                         line: (callNode.startPosition?.row ?? 0) + 1,
@@ -199,7 +298,7 @@ export class TreeSitterParser extends BaseParser {
 
             // --- Imports ---
             if (captures['import.source']) {
-                const src = captures['import.source'].text.replace(/['"]/g, '')
+                const src = captures['import.source'].text?.replace(/['"]/g, '') || ''
                 imports.push({
                     source: src,
                     resolvedPath: '',
@@ -210,6 +309,24 @@ export class TreeSitterParser extends BaseParser {
                 continue
             }
 
+            // --- Generic types ---
+            if (captures['generic.name'] || captures['generic.arg']) {
+                const genName = captures['generic.name']?.text || ''
+                const genArg = captures['generic.arg']?.text || ''
+                if (genArg && !generics.some(g => g.name === genArg)) {
+                    generics.push({
+                        id: `generic:${filePath}:${genArg}`,
+                        name: genArg,
+                        type: 'type',
+                        file: filePath,
+                        startLine: (captures['generic.arg']?.startPosition?.row ?? 0) + 1,
+                        endLine: (captures['generic.arg']?.endPosition?.row ?? 0) + 1,
+                        isExported: false,
+                        hash: '',
+                    })
+                }
+            }
+
             // --- Functions / Methods ---
             if (captures['definition.function'] || captures['definition.method']) {
                 const nameNode = captures['name']
@@ -223,8 +340,7 @@ export class TreeSitterParser extends BaseParser {
                     const count = (this.nameCounter.get(fnName) ?? 0) + 1
                     this.nameCounter.set(fnName, count)
 
-                    // Unique ID: use stable format with counter for collisions
-                    let fnId = count === 1 ? `fn:${filePath}:${fnName}` : `fn:${filePath}:${fnName}#${count}`
+                    const fnId = count === 1 ? `fn:${filePath}:${fnName}` : `fn:${filePath}:${fnName}#${count}`
                     if (seenFnIds.has(fnId)) {
                         continue
                     }
@@ -233,9 +349,7 @@ export class TreeSitterParser extends BaseParser {
                     const exported = isExportedByLanguage(ext, fnName, nodeText)
                     const isAsync = /\basync\b/.test(nodeText)
 
-                    // Detect return type — language-specific heuristics
-                    const returnType = extractReturnType(ext, defNode)
-
+                    const returnType = extractReturnType(ext, defNode, nodeText)
                     const params = extractParamsFromNode(defNode)
 
                     functions.push({
@@ -248,7 +362,7 @@ export class TreeSitterParser extends BaseParser {
                         returnType,
                         isExported: exported,
                         isAsync,
-                        calls: [], // populated after all functions are collected
+                        calls: [],
                         hash: hashContent(nodeText),
                         purpose: extractDocComment(content, startLine),
                         edgeCasesHandled: [],
@@ -258,46 +372,49 @@ export class TreeSitterParser extends BaseParser {
                 }
             }
 
-            // --- Classes / Structs / Interfaces ---
-            if (
-                captures['definition.class'] ||
-                captures['definition.struct'] ||
-                captures['definition.interface']
-            ) {
-                const nameNode = captures['name']
-                const defNode =
-                    captures['definition.class'] ||
-                    captures['definition.struct'] ||
-                    captures['definition.interface']
-
-                if (nameNode && defNode) {
-                    const clsName = nameNode.text
-                    const startLine = defNode.startPosition.row + 1
-                    const endLine = defNode.endPosition.row + 1
-                    const nodeText = defNode.text ?? ''
-                    const clsId = `class:${filePath}:${clsName}` // consistent with ts-extractor
-
-                    if (!classesMap.has(clsId)) {
-                        classesMap.set(clsId, {
-                            id: clsId,
-                            name: clsName,
-                            file: filePath,
-                            startLine,
-                            endLine,
-                            methods: [],
-                            properties: [],
-                            isExported: isExportedByLanguage(ext, clsName, nodeText),
-                            hash: hashContent(nodeText),
-                        })
+            // --- Classes / Structs / Interfaces / Enums / Unions ---
+            const classTypes = [
+                'definition.class', 'definition.struct', 'definition.interface',
+                'definition.enum', 'definition.union', 'definition.trait',
+                'definition.record', 'definition.module', 'definition.namespace'
+            ]
+            
+            for (const type of classTypes) {
+                if (captures[type]) {
+                    const nameNode = captures['name']
+                    const defNode = captures[type]
+
+                    if (nameNode && defNode) {
+                        const clsName = nameNode.text
+                        const startLine = defNode.startPosition.row + 1
+                        const endLine = defNode.endPosition.row + 1
+                        const nodeText = defNode.text ?? ''
+                        const clsId = `class:${filePath}:${clsName}`
+
+                        if (!classesMap.has(clsId)) {
+                            const isEnum = type === 'definition.enum'
+                            const isStruct = type === 'definition.struct'
+                            const isUnion = type === 'definition.union'
+                            
+                            classesMap.set(clsId, {
+                                id: clsId,
+                                name: clsName,
+                                file: filePath,
+                                startLine,
+                                endLine,
+                                methods: [],
+                                properties: [],
+                                isExported: isExportedByLanguage(ext, clsName, nodeText),
+                                hash: hashContent(nodeText),
+                            })
+                        }
                     }
                 }
             }
         }
 
-        // Assign calls to their enclosing function scopes.
         const unassignedCalls = assignCallsToFunctions(functions, callEntries)
 
-        // Only add a synthetic module-level function if there are actually calls made outside any function.
         if (unassignedCalls.length > 0) {
             const lineCount = content.split('\n').length
             functions.push({
@@ -308,7 +425,7 @@ export class TreeSitterParser extends BaseParser {
                 endLine: lineCount || 1,
                 params: [],
                 returnType: 'void',
-                isExported: false, // Don't export the synthetic module function
+                isExported: false,
                 isAsync: false,
                 calls: unassignedCalls.map(c => ({ name: c.name, line: c.line, type: 'function' })),
                 hash: '',
@@ -320,9 +437,6 @@ export class TreeSitterParser extends BaseParser {
         }
 
         const finalLang = extensionToLanguage(ext)
-
-        // Link methods: functions whose names contain '.' belong to a class
-        // (Go receiver methods, Java/C# member methods detected via method capture)
         linkMethodsToClasses(functions, classesMap)
 
         return {
@@ -330,14 +444,21 @@ export class TreeSitterParser extends BaseParser {
             language: finalLang,
             functions,
             classes: Array.from(classesMap.values()),
-            generics: [],
+            generics,
             imports,
             exports: functions.filter(f => f.isExported).map(f => ({
                 name: f.name,
                 type: 'function' as const,
                 file: filePath,
             })),
-            routes: [],
+            routes: routes.map(r => ({
+                method: r.method,
+                path: r.path,
+                handler: r.handler || '',
+                middlewares: [],
+                file: filePath,
+                line: r.line,
+            })),
             variables: [],
             calls: [],
             hash: hashContent(content),
@@ -345,10 +466,22 @@ export class TreeSitterParser extends BaseParser {
         }
     }
 
-    resolveImports(files: ParsedFile[], _projectRoot: string): ParsedFile[] {
-        // Tree-sitter resolver: no cross-file resolution implemented.
-        // Imports are left with resolvedPath = '' which signals unresolved to the graph builder.
-        // A future pass can resolve Go/Python/Java imports using language-specific rules.
+    async resolveImports(files: ParsedFile[], projectRoot: string): Promise<ParsedFile[]> {
+        if (files.length === 0) return files
+
+        const ext = path.extname(files[0].path).toLowerCase()
+        const language = extensionToLanguage(ext)
+        const resolver = new TreeSitterResolver(projectRoot, language)
+
+        const allFiles = files.map(f => f.path)
+
+        for (const file of files) {
+            if (file.imports.length > 0) {
+                const resolved = resolver.resolveAll(file.imports, file.path, allFiles)
+                file.imports = resolved
+            }
+        }
+
         return files
     }
 
@@ -371,13 +504,82 @@ export class TreeSitterParser extends BaseParser {
 
     private async loadLang(name: string): Promise<any> {
         if (this.languages.has(name)) return this.languages.get(name)
+        if (this.wasmLoadError) return null
+
         try {
-            const tcPath = _require.resolve('tree-sitter-wasms/package.json')
-            const wasmPath = path.join(path.dirname(tcPath), 'out', `tree-sitter-${name}.wasm`)
-            const lang = await Parser.Language.load(wasmPath)
-            this.languages.set(name, lang)
-            return lang
+            const nameForFile = name.replace(/-/g, '_')
+            
+            // Try multiple possible WASM locations
+            const possiblePaths = [
+                path.resolve('node_modules/tree-sitter-wasms/out', `tree-sitter-${nameForFile}.wasm`),
+                path.resolve('./node_modules/tree-sitter-wasms/out', `tree-sitter-${nameForFile}.wasm`),
+                path.resolve(process.cwd(), 'node_modules/tree-sitter-wasms/out', `tree-sitter-${nameForFile}.wasm`),
+                path.resolve(process.cwd(), 'node_modules', 'tree-sitter-wasms', 'out', `tree-sitter-${nameForFile}.wasm`),
+            ]
+            
+            let wasmPath = ''
+            for (const p of possiblePaths) {
+                try {
+                    const fs = await import('node:fs')
+                    if (fs.existsSync(p)) {
+                        wasmPath = p
+                        break
+                    }
+                } catch { /* skip */ }
+            }
+            
+            if (!wasmPath) {
+                // Try common variations of the language name
+                const variations = [
+                    nameForFile,
+                    name.replace(/_/g, '-'),
+                    name,
+                ]
+                
+                for (const variant of variations) {
+                    for (const base of possiblePaths) {
+                        const testPath = base.replace(/tree-sitter-[^/]+\.wasm/, `tree-sitter-${variant}.wasm`)
+                        try {
+                            const fs = await import('node:fs')
+                            if (fs.existsSync(testPath)) {
+                                wasmPath = testPath
+                                break
+                            }
+                        } catch { /* skip */ }
+                    }
+                    if (wasmPath) break
+                }
+            }
+            
+            if (!wasmPath) {
+                // WASM not found - but don't mark as permanent error, just skip this language
+                console.warn(`Tree-sitter WASM not found for ${name}`)
+                return null
+            }
+            
+            // Try to load the WASM file with error handling
+            let lang: any = null
+            try {
+                lang = await Language.load(wasmPath)
+            } catch (loadErr) {
+                console.warn(`Failed to load WASM for ${name} at ${wasmPath}:`, loadErr)
+                // Try with dynamic import as fallback
+                try {
+                    const wasmModule = await import(wasmPath)
+                    if (wasmModule.default) {
+                        lang = await wasmModule.default()
+                    }
+                } catch { /* skip */ }
+            }
+            
+            if (lang) {
+                this.languages.set(name, lang)
+                return lang
+            }
+            
+            return null
         } catch (err) {
+            // Only mark as permanent error after all retries exhausted
             console.warn(`Failed to load Tree-sitter WASM for ${name}:`, err)
             return null
         }
@@ -395,6 +597,7 @@ export class TreeSitterParser extends BaseParser {
             case '.cpp':
             case '.cc':
             case '.hpp':
+            case '.hh':
                 return { lang: await this.loadLang('cpp'), query: Queries.CPP_QUERIES }
             case '.cs':
                 return { lang: await this.loadLang('c-sharp'), query: Queries.CSHARP_QUERIES }
@@ -412,10 +615,6 @@ export class TreeSitterParser extends BaseParser {
     }
 }
 
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
 function extensionToLanguage(ext: string): ParsedFile['language'] {
     switch (ext) {
         case '.py': return 'python'
@@ -431,61 +630,97 @@ function extensionToLanguage(ext: string): ParsedFile['language'] {
     }
 }
 
-/**
- * Extract a simple return type hint from the function node text.
- * Falls back to 'unknown' rather than 'any' to distinguish "not parsed"
- * from "genuinely untyped".
- */
-function extractReturnType(ext: string, defNode: any): string {
-    const text: string = defNode?.text ?? ''
-    // TypeScript/Go/Rust: look for "-> Type" or ": Type" after parameters
-    const arrowMatch = text.match(/\)\s*->\s*([^\s{]+)/)
-    if (arrowMatch) return arrowMatch[1].trim()
-    // Java/C# style: "public int foo(" — type precedes the name
-    // This is too fragile to do reliably here; return 'unknown'
+function extractReturnType(ext: string, defNode: any, nodeText: string): string {
+    if (!defNode && !nodeText) return 'unknown'
+    const text = nodeText || defNode?.text || ''
+
+    // Try to find return type from AST node directly first
+    if (defNode?.children) {
+        const returnTypeNode = findFirstChild(defNode, n => 
+            n.type === 'type' || 
+            n.type === 'type_annotation' || 
+            n.type === 'return_type' ||
+            n.type === 'result_type'
+        )
+        if (returnTypeNode?.text) {
+            return returnTypeNode.text.trim()
+        }
+    }
+
+    // Arrow return type (Rust, TS, Go)
+    const arrowMatch = text.match(/\)\s*(->|=>)\s*([^\s{;]+)/)
+    if (arrowMatch && arrowMatch[3]) {
+        const ret = arrowMatch[3].trim()
+        if (ret && ret !== 'void' && ret !== 'null') return ret
+    }
+
+    // Go: "func foo() (int, error)" or "func foo() error"
     if (ext === '.go') {
-        // Go: "func foo() (int, error)" or "func foo() error"
         const goReturnTuple = text.match(/\)\s+(\([^)]+\))/)
-        if (goReturnTuple) return goReturnTuple[1].trim()
+        if (goReturnTuple && goReturnTuple[1]) return goReturnTuple[1].trim()
         const goReturn = text.match(/\)\s+([^\s{(]+)/)
-        if (goReturn) return goReturn[1].trim()
+        if (goReturn && goReturn[1]) return goReturn[1].trim()
     }
+
+    // Java/C#/TypeScript: "public int foo(" - type before name
+    const javaMatch = text.match(/(?:public|private|protected|internal)?\s*(?:static\s*)?(?:async\s*)?([\w<>[\],\s]+?)\s+\w+\s*\(/)
+    if (javaMatch && javaMatch[1]) {
+        const ret = javaMatch[1].trim()
+        if (ret && ret !== 'void' && ret !== 'public' && ret !== 'private' && ret !== 'protected') {
+            return ret
+        }
+    }
+
+    // Python type annotations
+    const pyMatch = text.match(/def\s+\w+.*?\)\s*->\s*([^\s:]+)/)
+    if (pyMatch && pyMatch[1]) return pyMatch[1].trim()
+
+    // Python: try to find return type from type comment
+    const pyTypeComment = text.match(/#\s*type:\s*([^\n]+)/)
+    if (pyTypeComment && pyTypeComment[1]) return pyTypeComment[1].trim()
+
+    // PHP return type
+    const phpMatch = text.match(/function\s+\w+.*?\)\s*:\s*(\??[\w\\]+)/)
+    if (phpMatch && phpMatch[1]) return phpMatch[1].trim()
+
+    // Ruby return type
+    const rubyMatch = text.match(/def\s+\w+.*?\s+(->\s*[\w?]+)?/)
+    if (rubyMatch && rubyMatch[1]) return rubyMatch[1].replace('->', '').trim()
+
+    // C/C++ return type
+    const cMatch = text.match(/^[\w*&\s]+\s+(\w+)\s*\(/m)
+    if (cMatch && cMatch[1] && cMatch[1] !== 'if' && cMatch[1] !== 'while') {
+        return cMatch[1]
+    }
+
+    // Rust: try to find return type from node directly
+    if (ext === '.rs') {
+        const rustMatch = text.match(/fn\s+\w+.*?\s*->\s*([^\s{]+)/)
+        if (rustMatch && rustMatch[1]) return rustMatch[1].trim()
+    }
+
     return 'unknown'
 }
 
-/**
- * Extract a single-line doc comment immediately preceding the given line.
- * Scans backwards from startLine looking for `#`, `//`, `/**`, or `"""` comments.
- */
 function extractDocComment(content: string, startLine: number): string {
     const lines = content.split('\n')
-    const targetIdx = startLine - 2 // 0-indexed line before the function
+    const targetIdx = startLine - 2
     if (targetIdx < 0) return ''
 
     const prev = lines[targetIdx]?.trim() ?? ''
-    // Single-line comment styles
     for (const prefix of ['# ', '// ', '/// ']) {
         if (prev.startsWith(prefix)) return prev.slice(prefix.length).trim()
     }
-    // JSDoc / block comment end
     if (prev === '*/') {
-        // Walk back to find the first meaningful JSDoc line
         for (let i = targetIdx - 1; i >= 0; i--) {
             const line = lines[i].trim()
-            if (line.startsWith('/*') || line.startsWith('/**')) break
             const cleaned = line.replace(/^\*+\s?/, '')
-            if (cleaned && !/^[\-_=*]{3,}$/.test(cleaned)) return cleaned
+            if (cleaned && !/^[ \-_=*]{3,}$/.test(cleaned)) return cleaned
         }
     }
     return ''
 }
 
-/**
- * Move functions that are class methods (identified by having a receiver or
- * by being within the line range of a class) into the class's methods array.
- * This is a best-effort heuristic; direct tree-sitter capture of method
- * declarations already places them correctly in most languages.
- */
 function linkMethodsToClasses(
     functions: ParsedFunction[],
     classesMap: Map<string, ParsedClass>
@@ -494,18 +729,14 @@ function linkMethodsToClasses(
     if (classes.length === 0) return
 
     for (const fn of functions) {
-        // Already categorised if name contains "." (e.g. "MyClass.method")
-        // and never link the synthetic <module> function to a class.
         if (fn.name === '<module>' || fn.name.includes('.')) continue
 
-        // Skip functions nested inside other functions (local helpers)
         const isNestedInFunction = functions.some(f => 
             f.id !== fn.id && 
             fn.startLine >= f.startLine && fn.endLine <= f.endLine
         )
         if (isNestedInFunction) continue
 
-        // Find the innermost (smallest range) class that contains this function
         let bestCls: ParsedClass | null = null
         let bestRange = Infinity
         for (const cls of classes) {