ucn 3.7.29 → 3.7.30

package/core/callers.js

@@ -719,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;
+                                }
                             }
                         }
                     }

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 };
@@ -185,8 +186,9 @@ const HANDLERS = {
         const err = requireName(p.name);
         if (err) return { ok: false, error: err };
         // 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 && p.name && /^test[_*?]/i.test(p.name)) {
+        if (includeTests === undefined && p.name && /^test[_*?]/i.test(p.name)) {
             includeTests = true;
         }
         const exclude = applyTestExclusions(p.exclude, includeTests);

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/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
@@ -2668,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) {
@@ -2687,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 });
                     }
                 }
             }

package/package.json

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