ucn 3.7.21 → 3.7.23

package/core/output.js

@@ -754,10 +754,13 @@ function formatTrace(trace, options = {}) {
         if (node.callCount) {
             label += ` ${node.callCount}x`;
         }
+        if (node.alreadyShown) {
+            label += ' (see above)';
+        }
 
         lines.push(prefix + connector + label);
 
-        if (node.children) {
+        if (node.children && !node.alreadyShown) {
             const hasMore = node.truncatedChildren > 0;
             for (let i = 0; i < node.children.length; i++) {
                 const isChildLast = !hasMore && i === node.children.length - 1;

package/core/project.js

@@ -3007,10 +3007,30 @@ class ProjectIndex {
                 // Filter out usages that are at the definition location
                 // nameLine: when decorators/annotations are present, startLine is the decorator line
                 // but the name identifier is on a different line (nameLine). Check both.
-                const nonDefUsages = allUsages.filter(u =>
+                let nonDefUsages = allUsages.filter(u =>
                     !(u.file === symbol.file && (u.line === symbol.startLine || u.line === symbol.nameLine))
                 );
 
+                // For exported symbols in --include-exported mode, also filter out export-site
+                // references (e.g., `module.exports = { helperC }` or `export { helperC }`).
+                // These are just re-statements of the export, not actual consumption.
+                if (isExported && options.includeExported) {
+                    nonDefUsages = nonDefUsages.filter(u => {
+                        if (u.file !== symbol.file) return true; // cross-file usage always counts
+                        // Check if same-file usage is on an export line
+                        const content = this._readFile(u.file);
+                        if (!content) return true;
+                        const lines = content.split('\n');
+                        const line = lines[u.line - 1] || '';
+                        const trimmed = line.trim();
+                        // CJS: module.exports = { ... } or exports.name = ...
+                        if (trimmed.startsWith('module.exports') || /^exports\.\w+\s*=/.test(trimmed)) return false;
+                        // ESM: export { ... } or export default
+                        if (/^export\s*\{/.test(trimmed) || /^export\s+default\s/.test(trimmed)) return false;
+                        return true;
+                    });
+                }
+
                 // Total includes all usage types (calls, references, callbacks, re-exports)
                 const totalUsages = nonDefUsages.length;
 
@@ -3376,10 +3396,22 @@ class ProjectIndex {
 
         const buildTree = (funcDef, currentDepth, dir) => {
             const funcName = funcDef.name;
-            if (currentDepth > maxDepth || visited.has(`${funcDef.file}:${funcDef.startLine}`)) {
+            const key = `${funcDef.file}:${funcDef.startLine}`;
+            if (currentDepth > maxDepth) {
                 return null;
             }
-            visited.add(`${funcDef.file}:${funcDef.startLine}`);
+            if (visited.has(key)) {
+                // Already explored — show as leaf node without recursing (prevents infinite loops)
+                return {
+                    name: funcName,
+                    file: funcDef.relativePath,
+                    line: funcDef.startLine,
+                    type: funcDef.type,
+                    children: [],
+                    alreadyShown: true
+                };
+            }
+            visited.add(key);
 
             const node = {
                 name: funcName,
@@ -4011,10 +4043,12 @@ class ProjectIndex {
                 params = params.slice(1);
             }
         }
-        const expectedParamCount = params.length;
-        const optionalCount = params.filter(p => p.optional || p.default !== undefined).length;
-        const minArgs = expectedParamCount - optionalCount;
         const hasRest = params.some(p => p.rest);
+        // Rest params don't count toward expected/min — they accept 0+ extra args
+        const nonRestParams = params.filter(p => !p.rest);
+        const expectedParamCount = nonRestParams.length;
+        const optionalCount = nonRestParams.filter(p => p.optional || p.default !== undefined).length;
+        const minArgs = expectedParamCount - optionalCount;
 
         // Get all call sites
         const usages = this.usages(name, { codeOnly: true });

package/languages/utils.js

@@ -81,6 +81,13 @@ function parseStructuredParams(paramsNode, language) {
 
         if (paramInfo.name) {
             params.push(paramInfo);
+            // Go multi-name declarations: `a, b int` → expand additional params
+            if (paramInfo._additionalNames) {
+                for (const extraName of paramInfo._additionalNames) {
+                    params.push({ name: extraName, type: paramInfo.type });
+                }
+                delete paramInfo._additionalNames;
+            }
         }
     }
 
@@ -96,8 +103,9 @@ function parseJSParam(param, info) {
         if (patternNode) info.name = patternNode.text;
         if (typeNode) info.type = typeNode.text.replace(/^:\s*/, '');
         if (param.type === 'optional_parameter') info.optional = true;
-    } else if (param.type === 'rest_parameter') {
-        const patternNode = param.childForFieldName('pattern');
+    } else if (param.type === 'rest_parameter' || param.type === 'rest_pattern') {
+        // rest_parameter = TypeScript, rest_pattern = JavaScript
+        const patternNode = param.childForFieldName('pattern') || param.namedChild(0);
         if (patternNode) info.name = patternNode.text;
         info.rest = true;
     } else if (param.type === 'assignment_pattern') {
@@ -105,6 +113,9 @@ function parseJSParam(param, info) {
         const rightNode = param.childForFieldName('right');
         if (leftNode) info.name = leftNode.text;
         if (rightNode) info.default = rightNode.text;
+    } else if (param.type === 'object_pattern' || param.type === 'array_pattern') {
+        // Destructured params: { name, value } or [a, b]
+        info.name = param.text;
     }
 }
 
@@ -130,10 +141,30 @@ function parsePythonParam(param, info) {
 
 function parseGoParam(param, info) {
     if (param.type === 'parameter_declaration') {
+        const typeNode = param.childForFieldName('type');
+        // Go allows multiple names per declaration: `a, b int`
+        // Collect all identifier children (names come before the type)
+        const names = [];
+        for (let i = 0; i < param.namedChildCount; i++) {
+            const child = param.namedChild(i);
+            if (child && child.type === 'identifier') {
+                names.push(child.text);
+            }
+        }
+        if (names.length > 0) info.name = names[0];
+        if (typeNode) info.type = typeNode.text;
+        // Store additional names for multi-param declarations (handled by parseStructuredParams)
+        if (names.length > 1) {
+            info._additionalNames = names.slice(1);
+        }
+    } else if (param.type === 'variadic_parameter_declaration') {
+        // Go variadic: `args ...int`
         const nameNode = param.childForFieldName('name');
         const typeNode = param.childForFieldName('type');
         if (nameNode) info.name = nameNode.text;
-        if (typeNode) info.type = typeNode.text;
+        else info.name = '...';
+        if (typeNode) info.type = '...' + typeNode.text;
+        info.rest = true;
     }
 }
 

package/package.json

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