ucn 3.7.34 → 3.7.36

package/cli/index.js

@@ -563,7 +563,7 @@ function runProjectCommand(rootDir, command, arg) {
         case 'related': {
             const { ok, result, error } = execute(index, 'related', { name: arg, ...flags });
             if (!ok) fail(error);
-            printOutput(result, output.formatRelatedJson, r => output.formatRelated(r, { showAll: flags.all, top: flags.top }));
+            printOutput(result, output.formatRelatedJson, r => output.formatRelated(r, { all: flags.all, top: flags.top }));
             break;
         }
 
@@ -1421,7 +1421,7 @@ function executeInteractiveCommand(index, command, arg, iflags = {}, cache = nul
         case 'related': {
             const { ok, result, error } = execute(index, 'related', { name: arg, ...iflags });
             if (!ok) { console.log(error); return; }
-            console.log(output.formatRelated(result, { showAll: iflags.all, top: iflags.top }));
+            console.log(output.formatRelated(result, { all: iflags.all, top: iflags.top }));
             break;
         }
 

package/core/output.js

@@ -959,6 +959,11 @@ function formatImpact(impact, options = {}) {
         }
     }
 
+    // Scope pollution warning
+    if (impact.scopeWarning) {
+        lines.push(`  Note: ${impact.scopeWarning.hint}`);
+    }
+
     // By file
     lines.push('');
     lines.push('BY FILE:');
@@ -1019,6 +1024,9 @@ function formatPlan(plan, options = {}) {
     // Summary
     lines.push(`CHANGES NEEDED: ${plan.totalChanges}`);
     lines.push(`  Files affected: ${plan.filesAffected}`);
+    if (plan.scopeWarning) {
+        lines.push(`  Note: ${plan.scopeWarning.hint}`);
+    }
     lines.push('');
 
     // Group by file
@@ -1124,6 +1132,9 @@ function formatVerify(result, options = {}) {
     lines.push(`  Valid: ${result.valid}`);
     lines.push(`  Mismatches: ${result.mismatches}`);
     lines.push(`  Uncertain: ${result.uncertain}`);
+    if (result.scopeWarning) {
+        lines.push(`  Note: ${result.scopeWarning.hint}`);
+    }
 
     // Show mismatches
     if (result.mismatchDetails.length > 0) {

package/core/project.js

@@ -617,13 +617,24 @@ class ProjectIndex {
             }
         }
 
-        // Check inclusion (must be within specified directory, path-boundary-aware)
+        // Check inclusion (directory or file path)
         if (filters.in) {
-            const inPattern = filters.in;
-            // Match at path boundaries: start of string or after /
-            // e.g. --in=src matches "src/foo.js" and "lib/src/foo.js" but NOT "my-src-backup/foo.js"
-            if (!(filePath.startsWith(inPattern + '/') || filePath.includes('/' + inPattern + '/'))) {
-                return false;
+            const inPattern = filters.in.replace(/\/$/, ''); // strip trailing slash
+            // Detect if pattern looks like a file path (has an extension)
+            const looksLikeFile = /\.\w+$/.test(inPattern);
+            if (looksLikeFile) {
+                // File path matching: exact match or suffix match
+                // e.g. --in=tools/analyzer.py matches "tools/analyzer.py"
+                // e.g. --in=analyzer.py matches "tools/analyzer.py"
+                if (!(filePath === inPattern || filePath.endsWith('/' + inPattern))) {
+                    return false;
+                }
+            } else {
+                // Directory matching: path-boundary-aware
+                // e.g. --in=src matches "src/foo.js" and "lib/src/foo.js" but NOT "my-src-backup/foo.js"
+                if (!(filePath.startsWith(inPattern + '/') || filePath.includes('/' + inPattern + '/'))) {
+                    return false;
+                }
             }
         }
 
@@ -1694,25 +1705,55 @@ class ProjectIndex {
 
     /**
      * Extract type names from a function definition
+     * Finds all word-like type identifiers from param types, return type,
+     * class membership, and function body — filters to project-defined types only.
      */
     extractTypeNames(def) {
+        const TYPE_KINDS = ['type', 'interface', 'class', 'struct'];
         const types = new Set();
 
-        // From params
+        const addIfType = (name) => {
+            const syms = this.symbols.get(name);
+            if (syms && syms.some(s => TYPE_KINDS.includes(s.type))) {
+                types.add(name);
+            }
+        };
+
+        // 1. From param and return type annotations
+        const typeStrings = [];
         if (def.paramsStructured) {
             for (const param of def.paramsStructured) {
-                if (param.type) {
-                    // Extract base type name (before < or [)
-                    const match = param.type.match(/^([A-Z]\w*)/);
-                    if (match) types.add(match[1]);
-                }
+                if (param.type) typeStrings.push(param.type);
+            }
+        }
+        if (def.returnType) typeStrings.push(def.returnType);
+        for (const ts of typeStrings) {
+            const matches = ts.match(/\b([A-Za-z_]\w*)\b/g);
+            if (matches) {
+                for (const m of matches) addIfType(m);
             }
         }
 
-        // From return type
-        if (def.returnType) {
-            const match = def.returnType.match(/^([A-Z]\w*)/);
-            if (match) types.add(match[1]);
+        // 2. From the class the method belongs to
+        if (def.className) addIfType(def.className);
+
+        // 3. From function body — scan for project-defined type references
+        //    (constructors, type annotations, isinstance checks)
+        if (types.size === 0) {
+            const code = this.extractCode(def);
+            if (code) {
+                // Find capitalized identifiers that match project types
+                const bodyMatches = code.match(/\b([A-Z][A-Za-z0-9_]*)\b/g);
+                if (bodyMatches) {
+                    const seen = new Set();
+                    for (const m of bodyMatches) {
+                        if (!seen.has(m)) {
+                            seen.add(m);
+                            addIfType(m);
+                        }
+                    }
+                }
+            }
         }
 
         return types;
@@ -2716,6 +2757,24 @@ class ProjectIndex {
         // Identify patterns
         const patterns = this.identifyCallPatterns(filteredSites, name);
 
+        // Detect scope pollution: multiple class definitions for the same method name
+        let scopeWarning = null;
+        if (defIsMethod) {
+            const allDefs = this.symbols.get(name);
+            if (allDefs && allDefs.length > 1) {
+                const classNames = [...new Set(allDefs
+                    .filter(d => d.className && d.className !== def.className)
+                    .map(d => d.className))];
+                if (classNames.length > 0) {
+                    scopeWarning = {
+                        targetClass: def.className || '(unknown)',
+                        otherClasses: classNames,
+                        hint: `Results may include calls to ${classNames.join(', ')}.${name}(). Use file= or className= to narrow scope.`
+                    };
+                }
+            }
+        }
+
         return {
             function: name,
             file: def.relativePath,
@@ -2730,7 +2789,8 @@ class ProjectIndex {
                 count: sites.length,
                 sites
             })),
-            patterns
+            patterns,
+            scopeWarning
         };
         } finally { this._endOp(); }
     }
@@ -2878,13 +2938,17 @@ class ProjectIndex {
 
         // Get type definitions if requested
         let types = [];
-        if (options.withTypes && (primary.params !== undefined || primary.returnType)) {
-            const typeNames = this.extractTypeNames(primary);
-            for (const typeName of typeNames) {
+        if (options.withTypes) {
+            const TYPE_KINDS = ['type', 'interface', 'class', 'struct'];
+            const seen = new Set();
+
+            const addType = (typeName) => {
+                if (seen.has(typeName)) return;
+                seen.add(typeName);
                 const typeSymbols = this.symbols.get(typeName);
                 if (typeSymbols) {
                     for (const sym of typeSymbols) {
-                        if (['type', 'interface', 'class', 'struct'].includes(sym.type)) {
+                        if (TYPE_KINDS.includes(sym.type)) {
                             types.push({
                                 name: sym.name,
                                 type: sym.type,
@@ -2894,6 +2958,18 @@ class ProjectIndex {
                         }
                     }
                 }
+            };
+
+            // From signature annotations
+            const typeNames = this.extractTypeNames(primary);
+            for (const typeName of typeNames) addType(typeName);
+
+            // From callee signatures — types used by functions this function calls
+            if (allCallees) {
+                for (const callee of allCallees) {
+                    const calleeTypeNames = this.extractTypeNames(callee);
+                    for (const tn of calleeTypeNames) addType(tn);
+                }
             }
         }
 

package/core/verify.js

@@ -278,6 +278,24 @@ function verify(index, name, options = {}) {
     }
     clearTreeCache(index);
 
+    // Detect scope pollution for methods
+    let scopeWarning = null;
+    if (defIsMethod) {
+        const allDefs = index.symbols.get(name);
+        if (allDefs && allDefs.length > 1) {
+            const classNames = [...new Set(allDefs
+                .filter(d => d.className && d.className !== def.className)
+                .map(d => d.className))];
+            if (classNames.length > 0) {
+                scopeWarning = {
+                    targetClass: def.className || '(unknown)',
+                    otherClasses: classNames,
+                    hint: `Results may include calls to ${classNames.join(', ')}.${name}(). Use file= or className= to narrow scope.`
+                };
+            }
+        }
+    }
+
     return {
         found: true,
         function: name,
@@ -295,7 +313,8 @@ function verify(index, name, options = {}) {
         mismatches: mismatches.length,
         uncertain: uncertain.length,
         mismatchDetails: mismatches,
-        uncertainDetails: uncertain
+        uncertainDetails: uncertain,
+        scopeWarning
     };
     } finally { index._endOp(); }
 }
@@ -482,7 +501,8 @@ function plan(index, name, options = {}) {
         },
         totalChanges: changes.length,
         filesAffected: new Set(changes.map(c => c.file)).size,
-        changes
+        changes,
+        scopeWarning: impact?.scopeWarning || null
     };
     } finally { index._endOp(); }
 }

package/languages/javascript.js

@@ -212,6 +212,54 @@ function findFunctions(code, parser) {
                                 ...(docstring && { docstring })
                             });
                         }
+
+                        // React wrapper patterns: React.forwardRef(...), React.memo(...), forwardRef(...), memo(...)
+                        // const Button = React.forwardRef<Props, Ref>((props, ref) => ...)
+                        // const Memoized = memo((props) => ...)
+                        if (!isArrow && !isFnExpr && valueNode.type === 'call_expression') {
+                            const funcNode = valueNode.childForFieldName('function');
+                            if (funcNode) {
+                                let wrapperName = null;
+                                if (funcNode.type === 'member_expression') {
+                                    const prop = funcNode.childForFieldName('property');
+                                    wrapperName = prop?.text;
+                                } else if (funcNode.type === 'identifier') {
+                                    wrapperName = funcNode.text;
+                                }
+                                if (wrapperName === 'forwardRef' || wrapperName === 'memo') {
+                                    const argsNode = valueNode.childForFieldName('arguments');
+                                    if (argsNode && argsNode.namedChildCount > 0) {
+                                        const innerFn = argsNode.namedChild(0);
+                                        if (innerFn && (innerFn.type === 'arrow_function' || innerFn.type === 'function_expression')) {
+                                            processedRanges.add(rangeKey);
+                                            const paramsNode = innerFn.childForFieldName('parameters');
+                                            const { startLine, endLine, indent } = nodeToLocation(node, code);
+                                            const returnType = extractReturnType(innerFn);
+                                            const generics = extractGenerics(innerFn);
+                                            const docstring = extractJSDocstring(code, startLine);
+                                            const modifiers = node.parent && node.parent.type === 'export_statement'
+                                                ? extractModifiers(node.parent.text)
+                                                : extractModifiers(node.text);
+
+                                            functions.push({
+                                                name: nameNode.text,
+                                                params: extractParams(paramsNode),
+                                                paramsStructured: parseStructuredParams(paramsNode, 'javascript'),
+                                                startLine,
+                                                endLine,
+                                                indent,
+                                                isArrow: innerFn.type === 'arrow_function',
+                                                isGenerator: false,
+                                                modifiers,
+                                                ...(returnType && { returnType }),
+                                                ...(generics && { generics }),
+                                                ...(docstring && { docstring })
+                                            });
+                                        }
+                                    }
+                                }
+                            }
+                        }
                     }
                 }
             }

package/mcp/server.js

@@ -336,7 +336,7 @@ server.registerTool(
                 if (!ok) return toolResult(error);
                 if (!result) return toolResult(`Symbol "${name}" not found.`);
                 return toolResult(output.formatRelated(result, {
-                    showAll: all || false, top,
+                    all: all || false, top,
                     allHint: 'Repeat with all=true to show all.'
                 }));
             }

package/package.json

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