ucn 3.7.33 → 3.7.35

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,33 @@ class ProjectIndex {
 
     /**
      * Extract type names from a function definition
+     * Finds all word-like type identifiers from param types and return type,
+     * then filters to only those that exist in the project symbol table.
      */
     extractTypeNames(def) {
         const types = new Set();
-
-        // From params
+        // Collect all type annotation strings
+        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);
 
-        // From return type
-        if (def.returnType) {
-            const match = def.returnType.match(/^([A-Z]\w*)/);
-            if (match) types.add(match[1]);
+        // Extract all word-like identifiers from type annotations
+        // Handles: Dict[str, Any], Optional[QuoteData], str | None, List[int], CustomType
+        for (const ts of typeStrings) {
+            const matches = ts.match(/\b([A-Za-z_]\w*)\b/g);
+            if (matches) {
+                for (const m of matches) {
+                    // Only include names that exist as type/interface/class/struct in the symbol table
+                    const syms = this.symbols.get(m);
+                    if (syms && syms.some(s => ['type', 'interface', 'class', 'struct'].includes(s.type))) {
+                        types.add(m);
+                    }
+                }
+            }
         }
 
         return types;
@@ -2716,6 +2735,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 +2767,8 @@ class ProjectIndex {
                 count: sites.length,
                 sites
             })),
-            patterns
+            patterns,
+            scopeWarning
         };
         } finally { this._endOp(); }
     }
@@ -2878,7 +2916,7 @@ class ProjectIndex {
 
         // Get type definitions if requested
         let types = [];
-        if (options.withTypes && (primary.params !== undefined || primary.returnType)) {
+        if (options.withTypes) {
             const typeNames = this.extractTypeNames(primary);
             for (const typeName of typeNames) {
                 const typeSymbols = this.symbols.get(typeName);

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/languages/python.js

@@ -982,6 +982,30 @@ function findInstanceAttributeTypes(code, parser) {
             const initBody = child.childForFieldName('body');
             if (!initBody) continue;
 
+            // Build parameter type map from __init__ annotations
+            // e.g. def __init__(self, market: MarketDataFetcher = None) → {market: MarketDataFetcher}
+            const paramTypes = new Map();
+            const params = child.childForFieldName('parameters');
+            if (params) {
+                for (let p = 0; p < params.childCount; p++) {
+                    const param = params.child(p);
+                    // typed_parameter or typed_default_parameter
+                    if (param.type === 'typed_parameter' || param.type === 'typed_default_parameter') {
+                        const pName = param.childForFieldName('name') || param.child(0);
+                        const pType = param.childForFieldName('type');
+                        if (pName && pType) {
+                            const typeIdent = pType.type === 'type' ? pType.firstChild : pType;
+                            if (typeIdent?.type === 'identifier') {
+                                const tn = typeIdent.text;
+                                if (!PRIMITIVE_TYPES.has(tn) && tn[0] >= 'A' && tn[0] <= 'Z') {
+                                    paramTypes.set(pName.text, tn);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
             traverseTree(initBody, (stmt) => {
                 if (stmt.type !== 'expression_statement') return true;
 
@@ -1004,6 +1028,9 @@ function findInstanceAttributeTypes(code, parser) {
                 const typeName = extractConstructorName(rhs);
                 if (typeName) {
                     attrTypes.set(attrName, typeName);
+                } else if (rhs.type === 'identifier' && paramTypes.has(rhs.text)) {
+                    // self.X = param where param has type annotation
+                    attrTypes.set(attrName, paramTypes.get(rhs.text));
                 }
 
                 return true;

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.33",
+  "version": "3.7.35",
   "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",