ucn 3.7.24 → 3.7.26

package/languages/html.js

@@ -190,6 +190,7 @@ function extractEventHandlerCalls(htmlContent, htmlParser) {
             if (!valueText) return;
 
             const line = nameNode.startPosition.row + 1; // 1-indexed
+            const column = nameNode.startPosition.column;
 
             // Extract standalone function calls (not method calls like obj.method())
             const regex = /([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g;
@@ -203,6 +204,7 @@ function extractEventHandlerCalls(htmlContent, htmlParser) {
                 calls.push({
                     name: fnName,
                     line,
+                    column,
                     isMethod: false,
                     enclosingFunction: null,
                     uncertain: false,
@@ -295,9 +297,18 @@ function findExportsInCode(code, parser) {
 }
 
 function findUsagesInCode(code, name, parser) {
-    const result = extractJS(code, parser);
-    if (!result) return [];
-    return result.jsModule.findUsagesInCode(result.virtualJS, name, result.jsParser);
+    const jsUsages = (() => {
+        const result = extractJS(code, parser);
+        if (!result) return [];
+        return result.jsModule.findUsagesInCode(result.virtualJS, name, result.jsParser);
+    })();
+    // Also check event handler attributes (onclick="foo()", onload="bar()")
+    const handlerCalls = extractEventHandlerCalls(code, parser);
+    const handlerUsages = handlerCalls
+        .filter(c => c.name === name)
+        .map(c => ({ line: c.line, column: c.column || 0, usageType: 'call' }));
+    if (handlerUsages.length === 0) return jsUsages;
+    return jsUsages.concat(handlerUsages);
 }
 
 module.exports = {

package/languages/java.js

@@ -58,12 +58,14 @@ function extractModifiers(node) {
         }
     }
 
-    // Also check first line for modifiers
+    // Also check text before parameter list for modifiers (avoid matching keywords in params)
     const text = node.text;
     const firstLine = text.split('\n')[0];
+    const parenIdx = firstLine.indexOf('(');
+    const preParams = parenIdx >= 0 ? firstLine.substring(0, parenIdx) : firstLine;
     const keywords = ['public', 'private', 'protected', 'static', 'final', 'abstract', 'synchronized', 'native', 'default'];
     for (const kw of keywords) {
-        if (firstLine.includes(kw + ' ') && !modifiers.includes(kw)) {
+        if (preParams.includes(kw + ' ') && !modifiers.includes(kw)) {
             modifiers.push(kw);
         }
     }

package/languages/javascript.js

@@ -80,9 +80,9 @@ function getAssignmentName(leftNode) {
 function extractModifiers(text) {
     const mods = [];
     const firstLine = text.split('\n')[0];
-    if (firstLine.includes('export ')) mods.push('export');
-    if (firstLine.includes('async ')) mods.push('async');
-    if (firstLine.includes('default ')) mods.push('default');
+    if (/\bexport\b/.test(firstLine)) mods.push('export');
+    if (/\basync\b/.test(firstLine)) mods.push('async');
+    if (/\bdefault\b/.test(firstLine)) mods.push('default');
     return mods;
 }
 
@@ -462,6 +462,28 @@ function extractExtends(classNode) {
     return null;
 }
 
+/**
+ * Split comma-separated type names, respecting angle bracket nesting.
+ * "Bar<A, B>, Baz" → ["Bar<A, B>", "Baz"]
+ */
+function splitTypeList(text) {
+    const result = [];
+    let depth = 0;
+    let current = '';
+    for (const ch of text) {
+        if (ch === '<') depth++;
+        else if (ch === '>') depth--;
+        if (ch === ',' && depth === 0) {
+            result.push(current.trim());
+            current = '';
+        } else {
+            current += ch;
+        }
+    }
+    if (current.trim()) result.push(current.trim());
+    return result;
+}
+
 /**
  * Extract implements clause from class
  */
@@ -472,7 +494,7 @@ function extractImplements(classNode) {
         if (child.type === 'class_heritage') {
             const implMatch = child.text.match(/implements\s+([^{]+)/);
             if (implMatch) {
-                const names = implMatch[1].split(',').map(n => n.trim());
+                const names = splitTypeList(implMatch[1]);
                 implements_.push(...names);
             }
         }
@@ -488,9 +510,9 @@ function extractInterfaceExtends(interfaceNode) {
     for (let i = 0; i < interfaceNode.namedChildCount; i++) {
         const child = interfaceNode.namedChild(i);
         if (child.type === 'extends_type_clause') {
-            // Parse comma-separated type names
+            // Parse comma-separated type names respecting generics
             const text = child.text.replace(/^extends\s+/, '');
-            const names = text.split(',').map(n => n.trim());
+            const names = splitTypeList(text);
             extends_.push(...names);
         }
     }
@@ -1532,18 +1554,23 @@ function findExportsInCode(code, parser) {
                 }
             }
 
-            // Named exports: export function/class/const
+            // Named/default exports: export function/class/const, export default function/class
+            // Check if this is a default export by looking for the 'default' token
+            let isDefaultExport = false;
+            for (let ci = 0; ci < node.childCount; ci++) {
+                if (node.child(ci).type === 'default') { isDefaultExport = true; break; }
+            }
             for (let i = 0; i < node.namedChildCount; i++) {
                 const child = node.namedChild(i);
                 if (child.type === 'function_declaration' || child.type === 'generator_function_declaration') {
                     const nameNode = child.childForFieldName('name');
                     if (nameNode) {
-                        exports.push({ name: nameNode.text, type: 'named', line });
+                        exports.push({ name: nameNode.text, type: isDefaultExport ? 'default' : 'named', line });
                     }
                 } else if (child.type === 'class_declaration') {
                     const nameNode = child.childForFieldName('name');
                     if (nameNode) {
-                        exports.push({ name: nameNode.text, type: 'named', line });
+                        exports.push({ name: nameNode.text, type: isDefaultExport ? 'default' : 'named', line });
                     }
                 } else if (child.type === 'type_alias_declaration') {
                     // export type X = ...

package/languages/rust.js

@@ -69,7 +69,7 @@ function extractAttributes(node, code) {
     const startLine = node.startPosition.row;
     for (let i = startLine - 1; i >= 0 && i >= startLine - 5; i--) {
         const line = lines[i]?.trim();
-        if (!line) continue;
+        if (!line) break;
         if (line.startsWith('#[')) {
             // Extract attribute name (e.g., #[test] -> test, #[tokio::main] -> tokio::main)
             const match = line.match(/#\[([^\]]+)\]/);
@@ -103,16 +103,16 @@ function findFunctions(code, parser) {
             if (processedRanges.has(rangeKey)) return true;
             processedRanges.add(rangeKey);
 
-            // Skip functions inside impl blocks (they're extracted as impl members)
+            // Skip functions inside impl/trait blocks (they're extracted as members)
             let parent = node.parent;
-            if (parent && (parent.type === 'impl_item' || parent.type === 'declaration_list')) {
-                // declaration_list is the body of an impl block
+            if (parent && (parent.type === 'impl_item' || parent.type === 'trait_item' || parent.type === 'declaration_list')) {
+                // declaration_list is the body of an impl/trait block
                 const grandparent = parent.parent;
-                if (grandparent && grandparent.type === 'impl_item') {
-                    return true;  // Skip - this is an impl method
+                if (grandparent && (grandparent.type === 'impl_item' || grandparent.type === 'trait_item')) {
+                    return true;  // Skip - this is an impl/trait method
                 }
-                if (parent.type === 'impl_item') {
-                    return true;  // Skip - this is an impl method
+                if (parent.type === 'impl_item' || parent.type === 'trait_item') {
+                    return true;  // Skip - this is an impl/trait method
                 }
             }
 
@@ -549,8 +549,8 @@ function extractImplMembers(implNode, code, typeName) {
                     endLine,
                     memberType: visibility ? 'public' : 'method',
                     isAsync: firstLine.includes('async '),
-                    isMethod: true,  // Mark as method for context() lookups
-                    ...(typeName && { receiver: typeName }),  // Track which type this impl is for
+                    isMethod: hasSelf,  // Only true methods (with self) — associated functions are false
+                    ...(typeName && { receiver: typeName }),  // All impl members get receiver for findMethodsForType
                     ...(returnType && { returnType }),
                     ...(docstring && { docstring })
                 });
@@ -666,11 +666,16 @@ function findCallsInCode(code, parser) {
             });
         }
 
-        // Handle function calls: foo(), obj.method(), Type::func()
+        // Handle function calls: foo(), obj.method(), Type::func(), foo::<T>()
         if (node.type === 'call_expression') {
-            const funcNode = node.childForFieldName('function');
+            let funcNode = node.childForFieldName('function');
             if (!funcNode) return true;
 
+            // Unwrap turbofish: parse::<i32>() has generic_function wrapping the actual function
+            if (funcNode.type === 'generic_function') {
+                funcNode = funcNode.childForFieldName('function') || funcNode;
+            }
+
             const enclosingFunction = getCurrentEnclosingFunction();
 
             if (funcNode.type === 'identifier') {
@@ -763,7 +768,22 @@ function findImportsInCode(code, parser) {
             for (let i = 0; i < node.namedChildCount; i++) {
                 const child = node.namedChild(i);
 
-                if (child.type === 'scoped_identifier' || child.type === 'identifier') {
+                if (child.type === 'use_as_clause') {
+                    // use foo::bar as baz
+                    const pathNode = child.namedChild(0); // the original path
+                    const aliasNode = child.childForFieldName('alias');
+                    if (pathNode) {
+                        const originalPath = pathNode.text;
+                        const alias = aliasNode ? aliasNode.text : originalPath.split('::').pop();
+                        imports.push({
+                            module: originalPath,
+                            names: [alias],
+                            type: 'use',
+                            dynamic: false,
+                            line
+                        });
+                    }
+                } else if (child.type === 'scoped_identifier' || child.type === 'identifier') {
                     // use std::io or use foo
                     const path = child.text;
                     const segments = path.split('::');
@@ -800,8 +820,11 @@ function findImportsInCode(code, parser) {
                             if (item.type === 'identifier') {
                                 names.push(item.text);
                             } else if (item.type === 'use_as_clause') {
-                                const nameNode = item.namedChild(0);
-                                if (nameNode) names.push(nameNode.text);
+                                const aliasNode = item.childForFieldName('alias');
+                                const pathItem = item.namedChild(0);
+                                names.push(aliasNode ? aliasNode.text : (pathItem ? pathItem.text : item.text));
+                            } else if (item.type === 'scoped_identifier') {
+                                names.push(item.text);
                             }
                         }
                         imports.push({
@@ -1024,10 +1047,19 @@ function findUsagesInCode(code, name, parser) {
         let usageType = 'reference';
 
         if (parent) {
-            // Import: use path::name
+            // Import: use path::name (walk up scoped_identifier chain for deeply nested paths)
             if (parent.type === 'use_declaration' ||
                 parent.type === 'use_as_clause' ||
-                parent.type === 'scoped_identifier' && parent.parent?.type === 'use_declaration') {
+                parent.type === 'use_list' ||
+                (parent.type === 'scoped_identifier' && (() => {
+                    let p = parent;
+                    while (p) {
+                        if (p.type === 'use_declaration' || p.type === 'use_as_clause') return true;
+                        if (p.type !== 'scoped_identifier' && p.type !== 'scoped_use_list' && p.type !== 'use_list') return false;
+                        p = p.parent;
+                    }
+                    return false;
+                })())) {
                 usageType = 'import';
             }
             // Call: name()

package/mcp/server.js

@@ -33,10 +33,9 @@ try {
 const { ProjectIndex } = require('../core/project');
 const { findProjectRoot } = require('../core/discovery');
 const output = require('../core/output');
-const { pickBestDefinition } = require('../core/shared');
 const { getMcpCommandEnum, normalizeParams } = require('../core/registry');
 const { execute } = require('../core/execute');
-const { ExpandCache, renderExpandItem } = require('../core/expand-cache');
+const { ExpandCache } = require('../core/expand-cache');
 
 // ============================================================================
 // INDEX CACHE
@@ -73,7 +72,7 @@ function getIndex(projectDir) {
     }
 
     // LRU eviction
-    if (indexCache.size >= MAX_CACHE_SIZE) {
+    if (indexCache.size >= MAX_CACHE_SIZE && !indexCache.has(root)) {
         let oldestKey = null;
         let oldestTime = Infinity;
         for (const [key, val] of indexCache) {
@@ -326,7 +325,7 @@ server.registerTool(
             case 'example': {
                 const index = getIndex(project_dir);
                 const { ok, result, error } = execute(index, 'example', { name });
-                if (!ok) return toolError(error);
+                if (!ok) return toolResult(error);
                 if (!result) return toolResult(`No usage examples found for "${name}".`);
                 return toolResult(output.formatExample(result, name));
             }
@@ -334,7 +333,7 @@ server.registerTool(
             case 'related': {
                 const index = getIndex(project_dir);
                 const { ok, result, error } = execute(index, 'related', { name, file, top, all });
-                if (!ok) return toolError(error);
+                if (!ok) return toolResult(error);
                 if (!result) return toolResult(`Symbol "${name}" not found.`);
                 return toolResult(output.formatRelated(result, {
                     showAll: all || false, top,
@@ -487,179 +486,52 @@ server.registerTool(
                 return toolResult(output.formatStats(result, { top: top || 0 }));
             }
 
-            // ── Extracting Code (adapter-specific) ──────────────────────
+            // ── Extracting Code (via execute) ────────────────────────────
 
             case 'fn': {
                 const err = requireName(name);
                 if (err) return err;
                 const index = getIndex(project_dir);
-
-                // Support comma-separated names for bulk extraction
-                const fnNames = name.includes(',') ? name.split(',').map(n => n.trim()).filter(Boolean) : [name];
-                const parts = [];
-
-                for (const fnName of fnNames) {
-                    const matches = index.find(fnName, { file }).filter(m => m.type === 'function' || m.params !== undefined);
-
-                    if (matches.length === 0) {
-                        parts.push(`Function "${fnName}" not found.`);
-                        continue;
-                    }
-
-                    // Show all definitions when all=true and multiple matches
-                    if (matches.length > 1 && !file && all) {
-                        for (const m of matches) {
-                            const mPathCheck = resolveAndValidatePath(index, m.relativePath || path.relative(index.root, m.file));
-                            if (typeof mPathCheck !== 'string') return mPathCheck;
-                            const mCode = fs.readFileSync(m.file, 'utf-8');
-                            const mLines = mCode.split('\n');
-                            const mFnCode = mLines.slice(m.startLine - 1, m.endLine).join('\n');
-                            parts.push(output.formatFn(m, mFnCode));
-                        }
-                        continue;
-                    }
-
-                    const match = matches.length > 1 ? pickBestDefinition(matches) : matches[0];
-                    const fnPathCheck = resolveAndValidatePath(index, match.relativePath || path.relative(index.root, match.file));
-                    if (typeof fnPathCheck !== 'string') return fnPathCheck;
-                    const code = fs.readFileSync(match.file, 'utf-8');
-                    const codeLines = code.split('\n');
-                    const fnCode = codeLines.slice(match.startLine - 1, match.endLine).join('\n');
-
-                    let note = '';
-                    if (matches.length > 1 && !file) {
-                        note = `Note: Found ${matches.length} definitions for "${fnName}". Showing ${match.relativePath}:${match.startLine}. Use file parameter or all=true to show all.\n`;
-                    }
-                    parts.push(note + output.formatFn(match, fnCode));
+                const ep = normalizeParams({ name, file, all });
+                const { ok, result, error } = execute(index, 'fn', ep);
+                if (!ok) return toolError(error);
+                // MCP path security: validate all result files are within project root
+                for (const entry of result.entries) {
+                    const check = resolveAndValidatePath(index, entry.match.relativePath || path.relative(index.root, entry.match.file));
+                    if (typeof check !== 'string') return check;
                 }
-
-                const separator = fnNames.length > 1 ? '\n\n' + '═'.repeat(60) + '\n\n' : '\n\n';
-                return toolResult(parts.join(separator));
+                const notes = result.notes.length ? result.notes.map(n => 'Note: ' + n).join('\n') + '\n\n' : '';
+                return toolResult(notes + output.formatFnResult(result));
             }
 
             case 'class': {
                 const err = requireName(name);
                 if (err) return err;
-                const index = getIndex(project_dir);
-                const matches = index.find(name, { file }).filter(m =>
-                    ['class', 'interface', 'type', 'enum', 'struct', 'trait'].includes(m.type)
-                );
-
-                if (matches.length === 0) {
-                    return toolResult(`Class "${name}" not found.`);
-                }
-
-                // Show all definitions when all=true and multiple matches
-                if (matches.length > 1 && !file && all) {
-                    const allParts = [];
-                    for (const m of matches) {
-                        const mPathCheck = resolveAndValidatePath(index, m.relativePath || path.relative(index.root, m.file));
-                        if (typeof mPathCheck !== 'string') return mPathCheck;
-                        const mCode = fs.readFileSync(m.file, 'utf-8');
-                        const mLines = mCode.split('\n');
-                        const clsCode = mLines.slice(m.startLine - 1, m.endLine).join('\n');
-                        allParts.push(output.formatClass(m, clsCode));
-                    }
-                    return toolResult(allParts.join('\n\n'));
-                }
-
-                const match = matches.length > 1 ? pickBestDefinition(matches) : matches[0];
-                // Validate file is within project root
-                const clsPathCheck = resolveAndValidatePath(index, match.relativePath || path.relative(index.root, match.file));
-                if (typeof clsPathCheck !== 'string') return clsPathCheck;
-
-                const code = fs.readFileSync(match.file, 'utf-8');
-                const codeLines = code.split('\n');
-                const clsCode = codeLines.slice(match.startLine - 1, match.endLine).join('\n');
-
-                let note = '';
-                if (matches.length > 1 && !file) {
-                    note = `Note: Found ${matches.length} definitions for "${name}". Showing ${match.relativePath}:${match.startLine}. Use file parameter to disambiguate.\n\n`;
-                }
-
                 if (max_lines !== undefined && (!Number.isInteger(max_lines) || max_lines < 1)) {
                     return toolError(`Invalid max_lines: ${max_lines}. Must be a positive integer.`);
                 }
-
-                const classLineCount = match.endLine - match.startLine + 1;
-
-                // Large class: show summary by default, truncated source with max_lines
-                if (classLineCount > 200 && max_lines === undefined) {
-                    const lines = [];
-                    lines.push(`${match.relativePath}:${match.startLine}`);
-                    lines.push(`${output.lineRange(match.startLine, match.endLine)} ${output.formatClassSignature(match)}`);
-                    lines.push('\u2500'.repeat(60));
-
-                    const methods = index.findMethodsForType(match.name);
-                    if (methods.length > 0) {
-                        lines.push(`\nMethods (${methods.length}):`);
-                        for (const m of methods) {
-                            lines.push(`  ${output.formatFunctionSignature(m)}  [line ${m.startLine}]`);
-                        }
-                    }
-
-                    lines.push(`\nClass is ${classLineCount} lines. Use max_lines param to see source, or fn command for individual methods.`);
-                    return toolResult(note + lines.join('\n'));
-                }
-
-                if (max_lines !== undefined && classLineCount > max_lines) {
-                    const truncatedCode = codeLines.slice(match.startLine - 1, match.startLine - 1 + max_lines).join('\n');
-                    const result = output.formatClass(match, truncatedCode);
-                    return toolResult(note + result + `\n\n... showing ${max_lines} of ${classLineCount} lines`);
+                const index = getIndex(project_dir);
+                const ep = normalizeParams({ name, file, all, max_lines });
+                const { ok, result, error } = execute(index, 'class', ep);
+                if (!ok) return toolResult(error);  // soft error (class not found)
+                // MCP path security: validate all result files are within project root
+                for (const entry of result.entries) {
+                    const check = resolveAndValidatePath(index, entry.match.relativePath || path.relative(index.root, entry.match.file));
+                    if (typeof check !== 'string') return check;
                 }
-
-                return toolResult(note + output.formatClass(match, clsCode));
+                const notes = result.notes.length ? result.notes.map(n => 'Note: ' + n).join('\n') + '\n\n' : '';
+                return toolResult(notes + output.formatClassResult(result));
             }
 
             case 'lines': {
-                if (!file) {
-                    return toolError('File parameter is required for lines command.');
-                }
-                if (!range || !range.trim()) {
-                    return toolError('Line range is required (e.g. "10-20" or "15").');
-                }
                 const index = getIndex(project_dir);
-                const resolved = resolveAndValidatePath(index, file);
-                if (typeof resolved !== 'string') return resolved; // toolError response
-                const filePath = resolved;
-
-                const parts = range.split('-');
-                const start = parseInt(parts[0], 10);
-                const end = parts.length > 1 ? parseInt(parts[1], 10) : start;
-
-                if (isNaN(start) || isNaN(end)) {
-                    return toolError(`Invalid line range: "${range}". Expected format: <start>-<end> or <line>`);
-                }
-                if (start < 1) {
-                    return toolError(`Invalid start line: ${start}. Line numbers must be >= 1`);
-                }
-                if (end < 1) {
-                    return toolError(`Invalid end line: ${end}. Line numbers must be >= 1`);
-                }
-                if (end < start) {
-                    return toolError(`Invalid range: end line (${end}) must be >= start line (${start})`);
-                }
-
-                const content = fs.readFileSync(filePath, 'utf-8');
-                const fileLines = content.split('\n');
-
-                const startLine = start;
-                const endLine = end;
-
-                if (startLine > fileLines.length) {
-                    return toolError(`Line ${startLine} is out of bounds. File has ${fileLines.length} lines.`);
-                }
-
-                const actualEnd = Math.min(endLine, fileLines.length);
-                const lines = [];
-                const relPath = path.relative(index.root, filePath);
-                lines.push(`${relPath}:${startLine}-${actualEnd}`);
-                lines.push('\u2500'.repeat(60));
-                for (let i = startLine - 1; i < actualEnd; i++) {
-                    lines.push(`${output.lineNum(i + 1)} | ${fileLines[i]}`);
-                }
-
-                return toolResult(lines.join('\n'));
+                const ep = normalizeParams({ file, range });
+                const { ok, result, error } = execute(index, 'lines', ep);
+                if (!ok) return toolError(error);
+                // MCP path security: validate file is within project root
+                const check = resolveAndValidatePath(index, result.relativePath);
+                if (typeof check !== 'string') return check;
+                return toolResult(output.formatLines(result));
             }
 
             case 'expand': {
@@ -667,19 +539,14 @@ server.registerTool(
                     return toolError('Item number is required (e.g. item=1).');
                 }
                 const index = getIndex(project_dir);
-                const { match, itemCount, symbolName } = expandCacheInstance.lookup(index.root, item);
-
-                if (!match && itemCount === 0) {
-                    return toolError('No expandable items found. Run context command first to get numbered items.');
-                }
-                if (!match) {
-                    const scopeHint = symbolName ? ` (from last context for "${symbolName}")` : '';
-                    return toolError(`Item ${item} not found${scopeHint}. Available items: 1-${itemCount}`);
-                }
-
-                const rendered = renderExpandItem(match, index.root, { validateRoot: true });
-                if (!rendered.ok) return toolError(rendered.error);
-                return toolResult(rendered.text);
+                const lookup = expandCacheInstance.lookup(index.root, item);
+                const { ok, result, error } = execute(index, 'expand', {
+                    match: lookup.match, itemNum: item,
+                    itemCount: lookup.itemCount, symbolName: lookup.symbolName,
+                    validateRoot: true
+                });
+                if (!ok) return toolError(error);
+                return toolResult(result.text);
             }
 
             default:

package/package.json

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