ucn 3.7.32 → 3.7.34

package/core/callers.js

@@ -227,47 +227,54 @@ function findCallers(index, name, options = {}) {
                     if (call.selfAttribute && fileEntry.language === 'python') {
                         // self.attr.method() — resolve via attribute type inference
                         const callerSymbol = index.findEnclosingFunction(filePath, call.line, true);
-                        if (!callerSymbol?.className) continue;
-                        const attrTypes = getInstanceAttributeTypes(index, filePath, callerSymbol.className);
-                        if (!attrTypes) continue;
-                        const targetClass = attrTypes.get(call.selfAttribute);
-                        if (!targetClass) continue;
-                        // Check if any definition of searched function belongs to targetClass
-                        const matchesDef = definitions.some(d => d.className === targetClass);
-                        if (!matchesDef) continue;
-                        resolvedBySameClass = true;
-                        // Falls through to add as caller
+                        if (!callerSymbol?.className) {
+                            // Can't resolve — include only if includeMethods requested
+                            if (!options.includeMethods) continue;
+                        } else {
+                            const attrTypes = getInstanceAttributeTypes(index, filePath, callerSymbol.className);
+                            const targetClass = attrTypes?.get(call.selfAttribute);
+                            if (targetClass && definitions.some(d => d.className === targetClass)) {
+                                resolvedBySameClass = true;
+                            } else if (!options.includeMethods) {
+                                continue;
+                            }
+                        }
                     } else if (['self', 'cls', 'this', 'super'].includes(call.receiver)) {
                         // self/this/super.method() — resolve to same-class or parent method
                         const callerSymbol = index.findEnclosingFunction(filePath, call.line, true);
-                        if (!callerSymbol?.className) continue;
-                        // For super(), skip same-class — only check parent chain
-                        let matchesDef = call.receiver === 'super'
-                            ? false
-                            : definitions.some(d => d.className === callerSymbol.className);
-                        // Walk inheritance chain using BFS if not found in same class
-                        if (!matchesDef) {
-                            const visited = new Set([callerSymbol.className]);
-                            const callerFile = callerSymbol.file || filePath;
-                            const startParents = index._getInheritanceParents(callerSymbol.className, callerFile) || [];
-                            const queue = startParents.map(p => ({ name: p, contextFile: callerFile }));
-                            while (queue.length > 0 && !matchesDef) {
-                                const { name: current, contextFile } = queue.shift();
-                                if (visited.has(current)) continue;
-                                visited.add(current);
-                                matchesDef = definitions.some(d => d.className === current);
-                                if (!matchesDef) {
-                                    const resolvedFile = index._resolveClassFile(current, contextFile);
-                                    const grandparents = index._getInheritanceParents(current, resolvedFile) || [];
-                                    for (const gp of grandparents) {
-                                        if (!visited.has(gp)) queue.push({ name: gp, contextFile: resolvedFile });
+                        if (!callerSymbol?.className) {
+                            if (!options.includeMethods) continue;
+                        } else {
+                            // For super(), skip same-class — only check parent chain
+                            let matchesDef = call.receiver === 'super'
+                                ? false
+                                : definitions.some(d => d.className === callerSymbol.className);
+                            // Walk inheritance chain using BFS if not found in same class
+                            if (!matchesDef) {
+                                const visited = new Set([callerSymbol.className]);
+                                const callerFile = callerSymbol.file || filePath;
+                                const startParents = index._getInheritanceParents(callerSymbol.className, callerFile) || [];
+                                const queue = startParents.map(p => ({ name: p, contextFile: callerFile }));
+                                while (queue.length > 0 && !matchesDef) {
+                                    const { name: current, contextFile } = queue.shift();
+                                    if (visited.has(current)) continue;
+                                    visited.add(current);
+                                    matchesDef = definitions.some(d => d.className === current);
+                                    if (!matchesDef) {
+                                        const resolvedFile = index._resolveClassFile(current, contextFile);
+                                        const grandparents = index._getInheritanceParents(current, resolvedFile) || [];
+                                        for (const gp of grandparents) {
+                                            if (!visited.has(gp)) queue.push({ name: gp, contextFile: resolvedFile });
+                                        }
                                     }
                                 }
                             }
+                            if (matchesDef) {
+                                resolvedBySameClass = true;
+                            } else if (!options.includeMethods) {
+                                continue;
+                            }
                         }
-                        if (!matchesDef) continue;
-                        resolvedBySameClass = true;
-                        // Falls through to add as caller
                     } else {
                         // Go doesn't use this/self/cls - always include Go method calls
                         // Java method calls are always obj.method() - include by default

package/languages/python.js

@@ -982,6 +982,30 @@ function findInstanceAttributeTypes(code, parser) {
             const initBody = child.childForFieldName('body');
             if (!initBody) continue;
 
+            // Build parameter type map from __init__ annotations
+            // e.g. def __init__(self, market: MarketDataFetcher = None) → {market: MarketDataFetcher}
+            const paramTypes = new Map();
+            const params = child.childForFieldName('parameters');
+            if (params) {
+                for (let p = 0; p < params.childCount; p++) {
+                    const param = params.child(p);
+                    // typed_parameter or typed_default_parameter
+                    if (param.type === 'typed_parameter' || param.type === 'typed_default_parameter') {
+                        const pName = param.childForFieldName('name') || param.child(0);
+                        const pType = param.childForFieldName('type');
+                        if (pName && pType) {
+                            const typeIdent = pType.type === 'type' ? pType.firstChild : pType;
+                            if (typeIdent?.type === 'identifier') {
+                                const tn = typeIdent.text;
+                                if (!PRIMITIVE_TYPES.has(tn) && tn[0] >= 'A' && tn[0] <= 'Z') {
+                                    paramTypes.set(pName.text, tn);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
             traverseTree(initBody, (stmt) => {
                 if (stmt.type !== 'expression_statement') return true;
 
@@ -1004,6 +1028,9 @@ function findInstanceAttributeTypes(code, parser) {
                 const typeName = extractConstructorName(rhs);
                 if (typeName) {
                     attrTypes.set(attrName, typeName);
+                } else if (rhs.type === 'identifier' && paramTypes.has(rhs.text)) {
+                    // self.X = param where param has type annotation
+                    attrTypes.set(attrName, paramTypes.get(rhs.text));
                 }
 
                 return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucn",
-  "version": "3.7.32",
+  "version": "3.7.34",
   "mcpName": "io.github.mleoca/ucn",
   "description": "Universal Code Navigator — AST-based call graph analysis for AI agents. Find callers, trace impact, detect dead code across JS/TS, Python, Go, Rust, Java, and HTML. CLI, MCP server, and agent skill.",
   "main": "index.js",