ucn 3.7.28 → 3.7.30

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;
                 }
@@ -696,11 +719,20 @@ function findCallees(index, def, options = {}) {
                         const sameDir = symbols.find(s => path.dirname(s.file) === defDir);
                         if (sameDir) {
                             callee = sameDir;
-                        } else if (defReceiver) {
-                            // Priority 3: Same receiver type (for methods)
-                            const sameReceiver = symbols.find(s => s.receiver === defReceiver);
-                            if (sameReceiver) {
-                                callee = sameReceiver;
+                        } else {
+                            // Priority 2.5: Imported file — check if the caller's file imports
+                            // from any of the candidate callee files
+                            const callerImports = fileEntry?.imports || [];
+                            const importedFiles = new Set(callerImports.map(imp => imp.resolvedPath).filter(Boolean));
+                            const importedCallee = symbols.find(s => importedFiles.has(s.file));
+                            if (importedCallee) {
+                                callee = importedCallee;
+                            } else if (defReceiver) {
+                                // Priority 3: Same receiver type (for methods)
+                                const sameReceiver = symbols.find(s => s.receiver === defReceiver);
+                                if (sameReceiver) {
+                                    callee = sameReceiver;
+                                }
                             }
                         }
                     }
@@ -789,6 +821,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

@@ -126,6 +126,7 @@ const HANDLERS = {
         const result = index.impact(p.name, {
             file: p.file,
             exclude: toExcludeArray(p.exclude),
+            top: num(p.top, undefined),
         });
         if (!result) return { ok: false, error: `Function "${p.name}" not found.` };
         return { ok: true, result };
@@ -184,7 +185,13 @@ 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
+        // But only if the user didn't explicitly set include_tests=false
+        let includeTests = p.includeTests;
+        if (includeTests === undefined && 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/expand-cache.js

@@ -125,6 +125,50 @@ class ExpandCache {
     }
 }
 
+/**
+ * Detect the end of a function/method body starting from startLine.
+ * Uses brace/indent counting to find the closing boundary.
+ * Falls back to startLine + 30 if detection fails.
+ */
+function _detectFunctionEnd(fileLines, startLine) {
+    const maxScan = 500; // Avoid scanning huge files
+    const idx = startLine - 1;
+    if (idx >= fileLines.length) return startLine;
+
+    const firstLine = fileLines[idx];
+
+    // Python: indentation-based — find the first non-empty line at same or lesser indent
+    if (/^\s*def\s|^\s*class\s|^\s*async\s+def\s/.test(firstLine)) {
+        const baseIndent = firstLine.match(/^(\s*)/)[1].length;
+        let end = startLine;
+        for (let i = idx + 1; i < Math.min(idx + maxScan, fileLines.length); i++) {
+            const line = fileLines[i];
+            if (line.trim() === '') { end = i + 1; continue; } // blank lines are part of body
+            const indent = line.match(/^(\s*)/)[1].length;
+            if (indent <= baseIndent) break;
+            end = i + 1;
+        }
+        return end;
+    }
+
+    // Brace-based languages (JS/TS/Go/Java/Rust): count braces
+    let braceCount = 0;
+    let foundBrace = false;
+    for (let i = idx; i < Math.min(idx + maxScan, fileLines.length); i++) {
+        const line = fileLines[i];
+        for (const ch of line) {
+            if (ch === '{') { braceCount++; foundBrace = true; }
+            else if (ch === '}') { braceCount--; }
+        }
+        if (foundBrace && braceCount <= 0) {
+            return i + 1;
+        }
+    }
+
+    // Fallback: show 30 lines from start
+    return Math.min(startLine + 30, fileLines.length);
+}
+
 /**
  * Render an expand match to text lines.
  * Shared by MCP and interactive mode to avoid duplicated rendering logic.
@@ -156,7 +200,13 @@ function renderExpandItem(match, root, { validateRoot = false } = {}) {
     const content = fs.readFileSync(filePath, 'utf-8');
     const fileLines = content.split('\n');
     const startLine = match.startLine || match.line || 1;
-    const endLine = match.endLine || startLine + 20;
+    let endLine = match.endLine;
+
+    // When endLine is missing or equals startLine, the expand would show only 1 line.
+    // Scan forward from startLine to find the actual function/method body end.
+    if (!endLine || endLine <= startLine) {
+        endLine = _detectFunctionEnd(fileLines, startLine);
+    }
 
     const lines = [];
     lines.push(`[${match.num}] ${match.name} (${match.type})`);

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/output.js

@@ -938,7 +938,11 @@ function formatImpact(impact, options = {}) {
     lines.push('');
 
     // Summary
-    lines.push(`CALL SITES: ${impact.totalCallSites}`);
+    if (impact.shownCallSites !== undefined && impact.shownCallSites < impact.totalCallSites) {
+        lines.push(`CALL SITES: ${impact.shownCallSites} shown of ${impact.totalCallSites} total`);
+    } else {
+        lines.push(`CALL SITES: ${impact.totalCallSites}`);
+    }
     lines.push(`  Files affected: ${impact.byFile.length}`);
 
     // Patterns

package/core/project.js

@@ -735,6 +735,20 @@ class ProjectIndex {
         // Sort by score descending, then by index order for stability
         scored.sort((a, b) => b.score - a.score);
 
+        // Tiebreaker: when top candidates have equal score, prefer by usage count
+        if (scored.length > 1 && scored[0].score === scored[1].score) {
+            const tiedScore = scored[0].score;
+            const tiedCandidates = scored.filter(s => s.score === tiedScore);
+            for (const candidate of tiedCandidates) {
+                candidate.usageCount = this.countSymbolUsages(candidate.def).total;
+            }
+            tiedCandidates.sort((a, b) => b.usageCount - a.usageCount);
+            // Rebuild scored array: sorted tied candidates first, then rest
+            const rest = scored.filter(s => s.score !== tiedScore);
+            scored.length = 0;
+            scored.push(...tiedCandidates, ...rest);
+        }
+
         const def = scored[0].def;
 
         // Build warnings
@@ -759,10 +773,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 = [];
@@ -2661,6 +2682,12 @@ class ProjectIndex {
             filteredSites = callSites.filter(s => this.matchesFilters(s.file, { exclude: options.exclude }));
         }
 
+        // Apply top limit if specified (limits total call sites shown)
+        const totalBeforeLimit = filteredSites.length;
+        if (options.top && options.top > 0 && filteredSites.length > options.top) {
+            filteredSites = filteredSites.slice(0, options.top);
+        }
+
         // Group by file
         const byFile = new Map();
         for (const site of filteredSites) {
@@ -2680,7 +2707,8 @@ class ProjectIndex {
             signature: this.formatSignature(def),
             params: def.params,
             paramsStructured: def.paramsStructured,
-            totalCallSites: filteredSites.length,
+            totalCallSites: totalBeforeLimit,
+            shownCallSites: filteredSites.length,
             byFile: Array.from(byFile.entries()).map(([file, sites]) => ({
                 file,
                 count: sites.length,

package/core/verify.js

@@ -433,6 +433,29 @@ function plan(index, name, options = {}) {
                 });
             }
         }
+
+        // Also include import statements that reference the renamed function
+        const usages = index.usages(name, { codeOnly: true });
+        const importUsages = usages.filter(u => u.usageType === 'import' && !u.isDefinition);
+        for (const imp of importUsages) {
+            // Skip if already covered by a call site change in the same file:line
+            const alreadyCovered = changes.some(c =>
+                c.file === (imp.relativePath || imp.file) && c.line === imp.line
+            );
+            if (alreadyCovered) continue;
+            const newImport = imp.content.trim().replace(
+                new RegExp('\\b' + escapeRegExp(name) + '\\b'),
+                options.renameTo
+            );
+            changes.push({
+                file: imp.relativePath || imp.file,
+                line: imp.line,
+                expression: imp.content.trim(),
+                suggestion: `Update import: ${newImport}`,
+                newExpression: newImport,
+                isImport: true
+            });
+        }
     }
 
     return {

package/languages/python.js

@@ -330,6 +330,14 @@ function findStateObjects(code, parser) {
     const objects = [];
 
     const statePattern = /^(CONFIG|SETTINGS|[A-Z][A-Z0-9_]+|[A-Z][a-zA-Z]*(?:Config|Settings|Options|State|Store|Context))$/;
+    // Pattern for UPPER_CASE constants that may have scalar values (string, number, bool, etc.)
+    const constantPattern = /^[A-Z][A-Z0-9_]{1,}$/;
+    // RHS types that are scalar/simple values (not dict/list which are handled separately)
+    const scalarTypes = new Set([
+        'string', 'concatenated_string', 'integer', 'float', 'true', 'false', 'none',
+        'unary_operator', 'binary_operator', 'tuple', 'set', 'parenthesized_expression',
+        'call', 'attribute', 'identifier', 'subscript',
+    ]);
 
     traverseTree(tree.rootNode, (node) => {
         if (node.type === 'expression_statement' && node.parent === tree.rootNode) {
@@ -346,6 +354,10 @@ function findStateObjects(code, parser) {
                     if ((isObject || isArray) && statePattern.test(name)) {
                         const { startLine, endLine } = nodeToLocation(node, code);
                         objects.push({ name, startLine, endLine });
+                    } else if (constantPattern.test(name) && scalarTypes.has(rightNode.type)) {
+                        // Module-level UPPER_CASE constants with scalar values
+                        const { startLine, endLine } = nodeToLocation(node, code);
+                        objects.push({ name, startLine, endLine, isConstant: true });
                     }
                 }
             }
@@ -487,10 +499,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.30",
   "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",