ucn 3.7.39 → 3.7.41

package/cli/index.js

@@ -101,6 +101,7 @@ function parseFlags(tokens) {
         maxLines: getValueFlag('--max-lines') || null,
         regex: tokens.includes('--no-regex') ? false : undefined,
         functions: tokens.includes('--functions'),
+        className: getValueFlag('--class-name'),
     };
 }
 
@@ -125,7 +126,7 @@ const knownFlags = new Set([
     '--default', '--top', '--no-follow-symlinks',
     '--base', '--staged', '--stack',
     '--regex', '--no-regex', '--functions',
-    '--max-lines'
+    '--max-lines', '--class-name'
 ]);
 
 // Handle help flag
@@ -152,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)
@@ -554,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

@@ -1032,7 +1032,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
@@ -2745,9 +2746,9 @@ class ProjectIndex {
                             }
                         }
                     }
-                    // When className is explicitly set and we can't determine the receiver type,
-                    // still include the call (conservative: prefer false positives over false negatives)
-                    return true;
+                    // className explicitly set but receiver type unknown — filter it out.
+                    // User asked for a specific class; unknown receivers are likely unrelated.
+                    return false;
                 });
             }
 

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.39",
+  "version": "3.7.41",
   "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",