ucn 3.7.45 → 3.7.47

package/languages/java.js

@@ -623,12 +623,57 @@ function findCallsInCode(code, parser) {
     const tree = parseTree(parser, code);
     const calls = [];
     const functionStack = [];  // Stack of { name, startLine, endLine }
+    // Track variable -> type mappings per function scope (scopeStartLine -> Map<varName, typeName>)
+    const scopeTypes = new Map();
 
     // Helper to check if a node creates a function scope
     const isFunctionNode = (node) => {
         return ['method_declaration', 'constructor_declaration', 'lambda_expression'].includes(node.type);
     };
 
+    // Extract type name from a Java type node (strips generics, qualified names)
+    const extractTypeName = (typeNode) => {
+        if (!typeNode) return null;
+        if (typeNode.type === 'type_identifier') return typeNode.text;
+        if (typeNode.type === 'generic_type') {
+            // List<String> -> List (first named child is the base type)
+            for (let i = 0; i < typeNode.namedChildCount; i++) {
+                const r = extractTypeName(typeNode.namedChild(i));
+                if (r) return r;
+            }
+        }
+        if (typeNode.type === 'scoped_type_identifier') {
+            // pkg.Type -> Type (last identifier)
+            const nameNode = typeNode.childForFieldName('name') ||
+                typeNode.namedChild(typeNode.namedChildCount - 1);
+            return nameNode?.text || null;
+        }
+        if (typeNode.type === 'array_type') {
+            return extractTypeName(typeNode.namedChild(0));
+        }
+        return null;
+    };
+
+    // Build type map from method/constructor parameters
+    const buildScopeTypeMap = (node) => {
+        const typeMap = new Map();
+        const paramsNode = node.childForFieldName('parameters');
+        if (paramsNode) {
+            for (let i = 0; i < paramsNode.namedChildCount; i++) {
+                const param = paramsNode.namedChild(i);
+                if (param.type === 'formal_parameter' || param.type === 'spread_parameter') {
+                    const nameNode = param.childForFieldName('name');
+                    const typeNode = param.childForFieldName('type');
+                    const typeName = extractTypeName(typeNode);
+                    if (nameNode && typeName) {
+                        typeMap.set(nameNode.text, typeName);
+                    }
+                }
+            }
+        }
+        return typeMap;
+    };
+
     // Helper to extract function name from a function node
     const extractFunctionName = (node) => {
         if (node.type === 'method_declaration') {
@@ -652,14 +697,25 @@ function findCallsInCode(code, parser) {
             : null;
     };
 
+    // Look up variable type from scope chain
+    const getReceiverType = (varName) => {
+        for (let i = functionStack.length - 1; i >= 0; i--) {
+            const typeMap = scopeTypes.get(functionStack[i].startLine);
+            if (typeMap?.has(varName)) return typeMap.get(varName);
+        }
+        return undefined;
+    };
+
     traverseTree(tree.rootNode, (node) => {
         // Track function entry
         if (isFunctionNode(node)) {
-            functionStack.push({
+            const entry = {
                 name: extractFunctionName(node),
                 startLine: node.startPosition.row + 1,
                 endLine: node.endPosition.row + 1
-            });
+            };
+            functionStack.push(entry);
+            scopeTypes.set(entry.startLine, buildScopeTypeMap(node));
         }
 
         // Handle method invocations: foo(), obj.foo(), this.foo()
@@ -669,11 +725,14 @@ function findCallsInCode(code, parser) {
 
             if (nameNode) {
                 const enclosingFunction = getCurrentEnclosingFunction();
+                const receiver = (objNode?.type === 'identifier' || objNode?.type === 'this') ? objNode.text : undefined;
+                const receiverType = (receiver && receiver !== 'this') ? getReceiverType(receiver) : undefined;
                 calls.push({
                     name: nameNode.text,
                     line: node.startPosition.row + 1,
                     isMethod: !!objNode,
-                    receiver: (objNode?.type === 'identifier' || objNode?.type === 'this') ? objNode.text : undefined,
+                    receiver,
+                    ...(receiverType && { receiverType }),
                     enclosingFunction
                 });
             }
@@ -708,11 +767,57 @@ function findCallsInCode(code, parser) {
             return true;
         }
 
+        // Detect method references passed as arguments: this::worker, obj::method
+        if (node.type === 'method_reference') {
+            const nameNode = node.namedChild(node.namedChildCount - 1);
+            const objNode = node.namedChild(0);
+            if (nameNode && nameNode.type === 'identifier') {
+                const receiver = objNode ? (objNode.type === 'identifier' || objNode.type === 'this' ? objNode.text : undefined) : undefined;
+                const receiverType = (receiver && receiver !== 'this') ? getReceiverType(receiver) : undefined;
+                const enclosingFunction = getCurrentEnclosingFunction();
+                calls.push({
+                    name: nameNode.text,
+                    line: node.startPosition.row + 1,
+                    isMethod: !!receiver,
+                    receiver,
+                    ...(receiverType && { receiverType }),
+                    isFunctionReference: true,
+                    isPotentialCallback: true,
+                    enclosingFunction
+                });
+            }
+            return true;
+        }
+
+        // Track local variable types from new Type() assignments
+        // e.g., Foo f = new Foo(); or var f = new Foo();
+        if (node.type === 'local_variable_declaration' && functionStack.length > 0) {
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const child = node.namedChild(i);
+                if (child.type === 'variable_declarator') {
+                    const nameNode = child.childForFieldName('name');
+                    const valueNode = child.childForFieldName('value');
+                    if (nameNode && valueNode && valueNode.type === 'object_creation_expression') {
+                        const typeNode = valueNode.childForFieldName('type');
+                        const typeName = extractTypeName(typeNode);
+                        if (typeName) {
+                            const scopeKey = functionStack[functionStack.length - 1].startLine;
+                            const typeMap = scopeTypes.get(scopeKey);
+                            if (typeMap) typeMap.set(nameNode.text, typeName);
+                        }
+                    }
+                }
+            }
+        }
+
         return true;
     }, {
         onLeave: (node) => {
             if (isFunctionNode(node)) {
-                functionStack.pop();
+                const leaving = functionStack.pop();
+                if (leaving) {
+                    scopeTypes.delete(leaving.startLine);
+                }
             }
         }
     });

package/languages/rust.js

@@ -631,12 +631,59 @@ function findCallsInCode(code, parser) {
     const tree = parseTree(parser, code);
     const calls = [];
     const functionStack = [];  // Stack of { name, startLine, endLine }
+    // Track variable -> type mappings per function scope (scopeStartLine -> Map<varName, typeName>)
+    const scopeTypes = new Map();
 
     // Helper to check if a node creates a function scope
     const isFunctionNode = (node) => {
         return ['function_item', 'closure_expression'].includes(node.type);
     };
 
+    // Extract the base type name from a Rust type node (strips &, &mut, Box<>, etc.)
+    const extractTypeName = (typeNode) => {
+        if (!typeNode) return null;
+        if (typeNode.type === 'type_identifier') return typeNode.text;
+        if (typeNode.type === 'reference_type') {
+            // &Filter or &mut Filter -> Filter
+            for (let i = 0; i < typeNode.namedChildCount; i++) {
+                const r = extractTypeName(typeNode.namedChild(i));
+                if (r) return r;
+            }
+        }
+        if (typeNode.type === 'generic_type') {
+            // Box<Filter> -> Filter (or get the outer type)
+            return extractTypeName(typeNode.namedChild(0));
+        }
+        if (typeNode.type === 'scoped_type_identifier') {
+            // module::Type -> Type
+            const nameNode = typeNode.childForFieldName('name');
+            return nameNode?.text || null;
+        }
+        return null;
+    };
+
+    // Build type map from function parameters (including self receiver for impl methods)
+    const buildScopeTypeMap = (node) => {
+        const typeMap = new Map();
+        const paramsNode = node.childForFieldName('parameters');
+        if (paramsNode) {
+            for (let i = 0; i < paramsNode.namedChildCount; i++) {
+                const param = paramsNode.namedChild(i);
+                if (param.type === 'parameter') {
+                    const patternNode = param.childForFieldName('pattern');
+                    const typeNode = param.childForFieldName('type');
+                    const typeName = extractTypeName(typeNode);
+                    if (patternNode && typeName) {
+                        // Pattern can be identifier or _
+                        const name = patternNode.type === 'identifier' ? patternNode.text : null;
+                        if (name) typeMap.set(name, typeName);
+                    }
+                }
+            }
+        }
+        return typeMap;
+    };
+
     // Helper to extract function name from a function node
     const extractFunctionName = (node) => {
         if (node.type === 'function_item') {
@@ -656,14 +703,25 @@ function findCallsInCode(code, parser) {
             : null;
     };
 
+    // Look up variable type from scope chain
+    const getReceiverType = (varName) => {
+        for (let i = functionStack.length - 1; i >= 0; i--) {
+            const typeMap = scopeTypes.get(functionStack[i].startLine);
+            if (typeMap?.has(varName)) return typeMap.get(varName);
+        }
+        return undefined;
+    };
+
     traverseTree(tree.rootNode, (node) => {
         // Track function entry
         if (isFunctionNode(node)) {
-            functionStack.push({
+            const entry = {
                 name: extractFunctionName(node),
                 startLine: node.startPosition.row + 1,
                 endLine: node.endPosition.row + 1
-            });
+            };
+            functionStack.push(entry);
+            scopeTypes.set(entry.startLine, buildScopeTypeMap(node));
         }
 
         // Handle function calls: foo(), obj.method(), Type::func(), foo::<T>()
@@ -692,11 +750,14 @@ function findCallsInCode(code, parser) {
                 const valueNode = funcNode.childForFieldName('value');
 
                 if (fieldNode) {
+                    const receiver = (valueNode?.type === 'identifier' || valueNode?.type === 'self') ? valueNode.text : undefined;
+                    const receiverType = (receiver && receiver !== 'self') ? getReceiverType(receiver) : undefined;
                     calls.push({
                         name: fieldNode.text,
                         line: node.startPosition.row + 1,
                         isMethod: true,
-                        receiver: (valueNode?.type === 'identifier' || valueNode?.type === 'self') ? valueNode.text : undefined,
+                        receiver,
+                        ...(receiverType && { receiverType }),
                         enclosingFunction
                     });
                 }
@@ -738,11 +799,39 @@ function findCallsInCode(code, parser) {
             return true;
         }
 
+        // Detect function/method references passed as arguments:
+        // field_expression inside arguments (obj.method as callback)
+        if (node.type === 'field_expression' && node.parent?.type === 'arguments') {
+            const grandparent = node.parent?.parent;
+            if (!grandparent || grandparent.type !== 'call_expression' || grandparent.childForFieldName('function') !== node) {
+                const fieldNode = node.childForFieldName('field');
+                const valueNode = node.childForFieldName('value');
+                if (fieldNode) {
+                    const receiver = (valueNode?.type === 'identifier' || valueNode?.type === 'self') ? valueNode.text : undefined;
+                    const receiverType = (receiver && receiver !== 'self') ? getReceiverType(receiver) : undefined;
+                    const enclosingFunction = getCurrentEnclosingFunction();
+                    calls.push({
+                        name: fieldNode.text,
+                        line: node.startPosition.row + 1,
+                        isMethod: true,
+                        receiver,
+                        ...(receiverType && { receiverType }),
+                        isFunctionReference: true,
+                        isPotentialCallback: true,
+                        enclosingFunction
+                    });
+                }
+            }
+        }
+
         return true;
     }, {
         onLeave: (node) => {
             if (isFunctionNode(node)) {
-                functionStack.pop();
+                const leaving = functionStack.pop();
+                if (leaving) {
+                    scopeTypes.delete(leaving.startLine);
+                }
             }
         }
     });

package/mcp/server.js

@@ -52,11 +52,17 @@ function getIndex(projectDir) {
     }
     const root = findProjectRoot(absDir);
     const cached = indexCache.get(root);
+    const STALE_CHECK_INTERVAL_MS = 2000;
 
-    // Always check staleness — isCacheStale() is cheap (mtime/size checks)
-    if (cached && !cached.index.isCacheStale()) {
-        cached.checkedAt = Date.now(); // True LRU: refresh on access
-        return cached.index;
+    // Throttle staleness checks — isCacheStale() re-globs and stats all files
+    if (cached) {
+        if (Date.now() - cached.checkedAt < STALE_CHECK_INTERVAL_MS) {
+            return cached.index; // Recently verified fresh
+        }
+        if (!cached.index.isCacheStale()) {
+            cached.checkedAt = Date.now();
+            return cached.index;
+        }
     }
 
     // Build new index (or rebuild stale one)
@@ -158,7 +164,7 @@ function requireName(name) {
 // CONSOLIDATED TOOL REGISTRATION
 // ============================================================================
 
-const TOOL_DESCRIPTION = `Universal Code Navigator powered by tree-sitter ASTs. Analyzes code structure — functions, callers, callees, dependencies — across JavaScript/TypeScript, Python, Go, Rust, Java, and HTML (inline scripts and event handlers). Use instead of grep/read for code relationships.
+const TOOL_DESCRIPTION = `Code intelligence toolkit for AI agents. Extract specific functions, trace call chains, find all callers, and detect dead code — without reading entire files or scanning full projects. Use instead of grep/read for code relationships. Supports JavaScript/TypeScript, Python, Go, Rust, Java, and HTML.
 
 TOP 5 (covers 90% of tasks): about, impact, trace, find, deadcode
 
@@ -252,7 +258,9 @@ server.registerTool(
             case_sensitive: z.boolean().optional().describe('Case-sensitive search (default: false, case-insensitive)'),
             all: z.boolean().optional().describe('Show all results (expand truncated sections). Applies to about, toc, related, trace, and others.'),
             top_level: z.boolean().optional().describe('Show only top-level functions in toc (exclude nested/indented)'),
-            class_name: z.string().optional().describe('Class name to scope method analysis (e.g. "MarketDataFetcher" for close)')
+            class_name: z.string().optional().describe('Class name to scope method analysis (e.g. "MarketDataFetcher" for close)'),
+            limit: z.number().optional().describe('Max results to return (default: 500). Caps find, usages, search, deadcode, api, toc --detailed.'),
+            max_files: z.number().optional().describe('Max files to index (default: 10000). Use for very large codebases.')
 
         })
     },
@@ -350,18 +358,22 @@ server.registerTool(
 
             case 'usages': {
                 const index = getIndex(project_dir);
-                const { ok, result, error } = execute(index, 'usages', ep);
+                const { ok, result, error, note } = execute(index, 'usages', ep);
                 if (!ok) return toolResult(error); // soft error
-                return toolResult(output.formatUsages(result, ep.name));
+                let text = output.formatUsages(result, ep.name);
+                if (note) text += '\n\n' + note;
+                return toolResult(text);
             }
 
             case 'toc': {
                 const index = getIndex(project_dir);
-                const { ok, result, error } = execute(index, 'toc', ep);
+                const { ok, result, error, note } = execute(index, 'toc', ep);
                 if (!ok) return toolResult(error); // soft error
-                return toolResult(output.formatToc(result, {
+                let text = output.formatToc(result, {
                     topHint: 'Set top=N or use detailed=false for compact view.'
-                }));
+                });
+                if (note) text += '\n\n' + note;
+                return toolResult(text);
             }
 
             case 'search': {
@@ -380,13 +392,16 @@ server.registerTool(
 
             case 'deadcode': {
                 const index = getIndex(project_dir);
-                const { ok, result, error } = execute(index, 'deadcode', ep);
+                const { ok, result, error, note } = execute(index, 'deadcode', ep);
                 if (!ok) return toolResult(error); // soft error
-                return toolResult(output.formatDeadcode(result, {
+                const dcNote = note;
+                let dcText = output.formatDeadcode(result, {
                     top: ep.top || 0,
                     decoratedHint: !ep.includeDecorated && result.excludedDecorated > 0 ? `${result.excludedDecorated} decorated/annotated symbol(s) hidden (framework-registered). Use include_decorated=true to include them.` : undefined,
                     exportedHint: !ep.includeExported && result.excludedExported > 0 ? `${result.excludedExported} exported symbol(s) excluded (all have callers). Use include_exported=true to audit them.` : undefined
-                }));
+                });
+                if (dcNote) dcText += '\n\n' + dcNote;
+                return toolResult(dcText);
             }
 
             // ── File Dependencies ───────────────────────────────────────
@@ -465,9 +480,11 @@ server.registerTool(
 
             case 'api': {
                 const index = getIndex(project_dir);
-                const { ok, result, error } = execute(index, 'api', ep);
+                const { ok, result, error, note } = execute(index, 'api', ep);
                 if (!ok) return toolResult(error); // soft error
-                return toolResult(output.formatApi(result, ep.file || '.'));
+                let apiText = output.formatApi(result, ep.file || '.');
+                if (note) apiText += '\n\n' + note;
+                return toolResult(apiText);
             }
 
             case 'stats': {

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "ucn",
-  "version": "3.7.45",
+  "version": "3.7.47",
   "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.",
+  "description": "Code intelligence toolkit for AI agents — extract functions, trace call chains, find callers, detect dead code without reading entire files. Works as MCP server, CLI, or agent skill. Supports JS/TS, Python, Go, Rust, Java.",
   "main": "index.js",
   "bin": {
     "ucn": "cli/index.js",
@@ -16,28 +16,29 @@
     "mcp",
     "mcp-server",
     "model-context-protocol",
+    "ai-agent",
+    "ai-coding",
+    "code-intelligence",
     "code-navigation",
     "code-analysis",
-    "static-analysis",
+    "code-extraction",
     "call-graph",
     "callers",
     "impact-analysis",
     "dead-code",
     "deadcode",
-    "ast",
-    "tree-sitter",
-    "parser",
-    "skill",
     "agent-skill",
+    "skill",
     "cli",
-    "ai-agent",
+    "tree-sitter",
+    "ast",
+    "static-analysis",
     "javascript",
     "typescript",
     "python",
     "go",
     "rust",
-    "java",
-    "html"
+    "java"
   ],
   "author": "Constantin-Mihail Leoca (https://github.com/mleoca)",
   "repository": {