ucn 3.7.28 → 3.7.29

package/core/callers.js

@@ -386,6 +386,13 @@ function findCallees(index, def, options = {}) {
         let selfAttrCalls = null;   // collected for Python self.attr.method() resolution
         let selfMethodCalls = null; // collected for Python self.method() resolution
 
+        // Build local variable type map for receiver resolution
+        // Scans for patterns like: bt = Backtester(...) → bt maps to Backtester
+        let localTypes = null;
+        if (language === 'python' || language === 'javascript') {
+            localTypes = _buildLocalTypeMap(index, def, calls);
+        }
+
         for (const call of calls) {
             // Filter to calls within this function's scope
             // Method 1: Direct match via enclosingFunction (fast path for direct calls)
@@ -412,6 +419,22 @@ function findCallees(index, def, options = {}) {
                     // self.method() / cls.method() / this.method() — resolve to same-class method below
                 } else if (call.receiver === 'super') {
                     // super().method() — resolve to parent class method below
+                } else if (localTypes && localTypes.has(call.receiver)) {
+                    // Resolve method calls on locally-constructed objects:
+                    // bt = Backtester(...); bt.run_backtest() → Backtester.run_backtest
+                    const className = localTypes.get(call.receiver);
+                    const symbols = index.symbols.get(call.name);
+                    const match = symbols?.find(s => s.className === className);
+                    if (match) {
+                        const key = match.bindingId || `${className}.${call.name}`;
+                        const existing = callees.get(key);
+                        if (existing) {
+                            existing.count += 1;
+                        } else {
+                            callees.set(key, { name: call.name, bindingId: match.bindingId, count: 1 });
+                        }
+                    }
+                    continue;
                 } else if (language !== 'go' && language !== 'java' && language !== 'rust' && !options.includeMethods) {
                     continue;
                 }
@@ -789,6 +812,60 @@ function getInstanceAttributeTypes(index, filePath, className) {
     return fileCache.get(className) || null;
 }
 
+/**
+ * Build a local variable type map for a function body.
+ * Scans for constructor-call assignments: var = ClassName(...)
+ * Returns Map<varName, className> or null if none found.
+ * @param {object} index - ProjectIndex instance
+ * @param {object} def - Function definition with file, startLine, endLine
+ * @param {Array} calls - Cached call sites for the file
+ */
+function _buildLocalTypeMap(index, def, calls) {
+    let content;
+    try {
+        content = index._readFile(def.file);
+    } catch {
+        return null;
+    }
+    const lines = content.split('\n');
+    const localTypes = new Map();
+
+    for (const call of calls) {
+        // Only look at calls within this function's scope
+        if (call.line < def.startLine || call.line > def.endLine) continue;
+        // Only direct calls (not method calls) — these are potential constructors
+        if (call.isMethod || call.isPotentialCallback) continue;
+
+        // Check if this call's name corresponds to a class in the symbol table
+        const symbols = index.symbols.get(call.name);
+        if (!symbols) continue;
+        const isClass = symbols.some(s => NON_CALLABLE_TYPES.has(s.type));
+        if (!isClass) continue;
+
+        // Check the source line for assignment pattern: var = ClassName(...)
+        const sourceLine = lines[call.line - 1];
+        if (!sourceLine) continue;
+
+        // Match: identifier = ClassName(...) or identifier: Type = ClassName(...)
+        const escapedName = call.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const assignMatch = sourceLine.match(
+            new RegExp(`(\\w+)\\s*(?::\\s*\\w+)?\\s*=\\s*${escapedName}\\s*\\(`)
+        );
+        if (assignMatch) {
+            localTypes.set(assignMatch[1], call.name);
+        }
+        // Match: with ClassName(...) as identifier:
+        const withMatch = sourceLine.match(
+            new RegExp(`with\\s+${escapedName}\\s*\\([^)]*\\)\\s+as\\s+(\\w+)`)
+        );
+        if (withMatch) {
+            localTypes.set(withMatch[1], call.name);
+        }
+    }
+
+    return localTypes.size > 0 ? localTypes : null;
+}
+
 /**
  * Check if a function is used as a callback anywhere in the codebase
  * @param {object} index - ProjectIndex instance

package/core/execute.js

@@ -184,7 +184,12 @@ const HANDLERS = {
     find: (index, p) => {
         const err = requireName(p.name);
         if (err) return { ok: false, error: err };
-        const exclude = applyTestExclusions(p.exclude, p.includeTests);
+        // Auto-include tests when pattern clearly targets test functions
+        let includeTests = p.includeTests;
+        if (!includeTests && p.name && /^test[_*?]/i.test(p.name)) {
+            includeTests = true;
+        }
+        const exclude = applyTestExclusions(p.exclude, includeTests);
         const result = index.find(p.name, {
             file: p.file,
             exact: p.exact || false,

package/core/imports.js

@@ -507,6 +507,32 @@ function loadTsConfig(tsconfigPath, visited) {
         }
     }
 
+    // Follow project references to collect paths from referenced configs
+    // (tsconfig.json with "references" pointing to tsconfig.app.json, tsconfig.node.json, etc.)
+    if (config.references && Array.isArray(config.references)) {
+        for (const ref of config.references) {
+            if (!ref.path) continue;
+            let refPath = path.resolve(configDir, ref.path);
+            // If reference points to a directory, look for tsconfig.json inside it
+            if (fs.existsSync(refPath) && fs.statSync(refPath).isDirectory()) {
+                refPath = path.join(refPath, 'tsconfig.json');
+            }
+            // Add .json extension if not present
+            if (!refPath.endsWith('.json')) refPath += '.json';
+            if (fs.existsSync(refPath)) {
+                try {
+                    const refResult = loadTsConfig(refPath, visited);
+                    if (refResult) {
+                        basePaths = { ...basePaths, ...refResult.paths };
+                        if (refResult.baseUrl && !baseUrl) baseUrl = refResult.baseUrl;
+                    }
+                } catch {
+                    // Skip malformed reference config
+                }
+            }
+        }
+    }
+
     // Child config values override base config
     const mergedPaths = { ...basePaths, ...(config.compilerOptions?.paths || {}) };
     const compiledPaths = Object.entries(mergedPaths).map(([pattern, targets]) => ({

package/core/project.js

@@ -759,10 +759,17 @@ class ProjectIndex {
         // Glob pattern matching (e.g., _update*, handle*Request, get?ata)
         const isGlob = name.includes('*') || name.includes('?');
         if (isGlob && !options.exact) {
-            // Guard against bare wildcards that would match everything
+            // Bare wildcard: return all symbols
             const stripped = name.replace(/[*?]/g, '');
             if (stripped.length === 0) {
-                return [];
+                const all = [];
+                for (const [, symbols] of this.symbols) {
+                    for (const sym of symbols) {
+                        all.push({ ...sym, _fuzzyScore: 800 });
+                    }
+                }
+                all.sort((a, b) => (a.name || '').localeCompare(b.name || ''));
+                return this._applyFindFilters(all, options);
             }
             const globRegex = new RegExp('^' + name.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.') + '$', 'i');
             const matches = [];

package/languages/python.js

@@ -487,10 +487,25 @@ function findCallsInCode(code, parser) {
                         }
                     }
                 }
-                // Track non-callable assignments: count = 5, name = "hello"
+                // Track non-callable assignments.
+                // First: explicit literal check (handles dicts-with-lambdas correctly)
                 if (right && isNonCallableInit(right)) {
                     nonCallableNames.add(left.text);
                 }
+                // Second: function call results are generally non-callable data
+                // (e.g., close = series.dropna(), result = db.query(...))
+                // Exception: partial() already handled above via alias tracking.
+                else if (right?.type === 'call' && !aliases.has(left.text)) {
+                    nonCallableNames.add(left.text);
+                }
+                // Third: subscript/attribute access results are non-callable data
+                // (e.g., close = candles["close"].values, item = data[0])
+                else if (right && !aliases.has(left.text) &&
+                    ['subscript', 'attribute', 'binary_operator', 'comparison_operator',
+                     'unary_operator', 'conditional_expression', 'await',
+                     'parenthesized_expression', 'not_operator', 'boolean_operator'].includes(right.type)) {
+                    nonCallableNames.add(left.text);
+                }
             }
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucn",
-  "version": "3.7.28",
+  "version": "3.7.29",
   "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",