ucn 3.7.40 → 3.7.42

package/cli/index.js

@@ -153,7 +153,7 @@ if (unknownFlags.length > 0) {
 const VALUE_FLAGS = new Set([
     '--file', '--depth', '--top', '--context', '--direction',
     '--add-param', '--remove-param', '--rename-to', '--default',
-    '--base', '--exclude', '--not', '--in', '--max-lines'
+    '--base', '--exclude', '--not', '--in', '--max-lines', '--class-name'
 ]);
 
 // Remove flags from args, then add args after -- (which are all positional)
@@ -555,7 +555,7 @@ function runProjectCommand(rootDir, command, arg) {
         }
 
         case 'verify': {
-            const { ok, result, error } = execute(index, 'verify', { name: arg, file: flags.file });
+            const { ok, result, error } = execute(index, 'verify', { name: arg, ...flags });
             if (!ok) fail(error);
             printOutput(result, output.formatVerifyJson, output.formatVerify);
             break;

package/core/callers.js

@@ -524,11 +524,18 @@ function findCallees(index, def, options = {}) {
                 if (bindings.length === 0 && call.isMethod) {
                     if (language !== 'go' && language !== 'java' && language !== 'rust') {
                         // JS/TS/Python: mark uncertain unless receiver has import/binding
-                        // evidence in file scope. Prevents false positives like m.get() →
-                        // repository.get() when m is just a parameter with no type info.
-                        const hasReceiverEvidence = call.receiver &&
-                            fileEntry?.bindings?.some(b => b.name === call.receiver);
-                        if (!hasReceiverEvidence) {
+                        // evidence in file scope AND that binding can plausibly have this method.
+                        // Prevents false positives like m.get() → repository.get() when m is
+                        // just a parameter, AND dict.get() → api.get() when dict is a state object.
+                        const receiverBinding = call.receiver &&
+                            fileEntry?.bindings?.find(b => b.name === call.receiver);
+                        if (!receiverBinding) {
+                            isUncertain = true;
+                        } else if (receiverBinding.type === 'state') {
+                            // State objects (module-level dicts/lists) don't have user-defined methods
+                            isUncertain = true;
+                        } else if (receiverBinding.type === 'function') {
+                            // Functions don't have user-defined methods (return value is unknown)
                             isUncertain = true;
                         }
                     } else {
@@ -542,6 +549,22 @@ function findCallees(index, def, options = {}) {
                     }
                 }
                 if (bindings.length === 1) {
+                    // For method calls with a receiver, verify the receiver plausibly
+                    // matches the binding's class. Prevents plt.close() → ReportGenerator.close()
+                    // when close is defined in the same file as a class method.
+                    if (call.isMethod && call.receiver && bindings[0].type === 'method' &&
+                        language !== 'go' && language !== 'java' && language !== 'rust') {
+                        // The binding is a class method — check if the receiver could be an instance
+                        const bindingSym = index.symbols.get(call.name)?.find(
+                            s => s.bindingId === bindings[0].id);
+                        if (bindingSym?.className) {
+                            // Receiver is not a known instance of this class → uncertain
+                            const receiverType = localTypes?.get(call.receiver);
+                            if (receiverType !== bindingSym.className) {
+                                isUncertain = true;
+                            }
+                        }
+                    }
                     bindingResolved = bindings[0].id;
                     calleeKey = bindingResolved;
                 } else if (bindings.length > 1) {

package/core/project.js

@@ -1018,12 +1018,38 @@ class ProjectIndex {
                 // Try AST-based detection first (with per-operation cache)
                 const astUsages = this._getCachedUsages(filePath, name);
                 if (astUsages !== null) {
+                    // Pre-compute: does any imported project file define this name?
+                    // Used to filter namespace member expressions (e.g., DropdownMenuPrimitive.Separator)
+                    // while keeping module access patterns (e.g., output.formatExample())
+                    let _importedHasDef = null;
+                    const importedFileHasDef = () => {
+                        if (_importedHasDef !== null) return _importedHasDef;
+                        const importedFiles = this.importGraph.get(filePath) || [];
+                        _importedHasDef = importedFiles.some(imp => {
+                            const impEntry = this.files.get(imp);
+                            return impEntry?.symbols?.some(s => s.name === name);
+                        });
+                        return _importedHasDef;
+                    };
+
                     for (const u of astUsages) {
                         // Skip if this is a definition line (already added above)
                         if (definitions.some(d => d.file === filePath && d.startLine === u.line)) {
                             continue;
                         }
 
+                        // Filter member expressions with unrelated receivers in JS/TS/Python.
+                        // Keeps: standalone usages, self/this/cls/super, method calls on known types,
+                        //        and module access (output.fn()) when the imported file defines the name.
+                        // Filters: namespace access to external packages (DropdownMenuPrimitive.Separator).
+                        if (u.receiver && !['self', 'this', 'cls', 'super'].includes(u.receiver) &&
+                            fileEntry.language !== 'go' && fileEntry.language !== 'java' && fileEntry.language !== 'rust') {
+                            const hasMethodDef = allDefinitions.some(d => d.className);
+                            if (!hasMethodDef && !importedFileHasDef()) {
+                                continue;
+                            }
+                        }
+
                         const lineContent = lines[u.line - 1] || '';
 
                         const usage = {
@@ -1032,7 +1058,8 @@ class ProjectIndex {
                             line: u.line,
                             content: lineContent,
                             usageType: u.usageType,
-                            isDefinition: false
+                            isDefinition: false,
+                            ...(u.receiver && { receiver: u.receiver })
                         };
 
                         // Add context lines if requested

package/languages/go.js

@@ -804,6 +804,12 @@ function findUsagesInCode(code, name, parser) {
                 } else {
                     usageType = 'reference';
                 }
+                // Track receiver for selector expressions (obj.name → receiver = 'obj')
+                const operand = parent.childForFieldName('operand');
+                if (operand && operand.type === 'identifier') {
+                    usages.push({ line, column, usageType, receiver: operand.text });
+                    return true;
+                }
             }
         }
 

package/languages/java.js

@@ -887,6 +887,12 @@ function findUsagesInCode(code, name, parser) {
             else if (parent.type === 'method_invocation' &&
                      parent.childForFieldName('name') === node) {
                 usageType = 'call';
+                // Track receiver for method invocations (obj.name() → receiver = 'obj')
+                const object = parent.childForFieldName('object');
+                if (object && object.type === 'identifier') {
+                    usages.push({ line, column, usageType, receiver: object.text });
+                    return true;
+                }
             }
             // Definition: method name
             else if (parent.type === 'method_declaration' &&
@@ -946,6 +952,12 @@ function findUsagesInCode(code, name, parser) {
             else if (parent.type === 'field_access' &&
                      parent.childForFieldName('field') === node) {
                 usageType = 'reference';
+                // Track receiver for field access (obj.field → receiver = 'obj')
+                const object = parent.childForFieldName('object');
+                if (object && object.type === 'identifier') {
+                    usages.push({ line, column, usageType, receiver: object.text });
+                    return true;
+                }
             }
         }
 

package/languages/javascript.js

@@ -1824,6 +1824,11 @@ function findUsagesInCode(code, name, parser) {
                 } else {
                     usageType = 'reference';
                 }
+                // Track receiver for member expressions (obj.name → receiver = 'obj')
+                if (object && object.type === 'identifier') {
+                    usages.push({ line, column, usageType, receiver: object.text });
+                    return true;
+                }
             }
             // JSX component usage: <Component /> or <Component>...</Component>
             else if (parent.type === 'jsx_self_closing_element' || parent.type === 'jsx_opening_element') {

package/languages/python.js

@@ -887,6 +887,12 @@ function findUsagesInCode(code, name, parser) {
                 } else {
                     usageType = 'reference';
                 }
+                // Track receiver for member expressions (obj.name → receiver = 'obj')
+                const object = parent.childForFieldName('object');
+                if (object && object.type === 'identifier') {
+                    usages.push({ line, column, usageType, receiver: object.text });
+                    return true;
+                }
             }
         }
 

package/languages/rust.js

@@ -1135,6 +1135,12 @@ function findUsagesInCode(code, name, parser) {
                 } else {
                     usageType = 'reference';
                 }
+                // Track receiver for field expressions (obj.name → receiver = 'obj')
+                const value = parent.childForFieldName('value');
+                if (value && value.type === 'identifier') {
+                    usages.push({ line, column, usageType, receiver: value.text });
+                    return true;
+                }
             }
         }
 

package/package.json

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