ucn 3.1.2 → 3.1.4

package/core/project.js

@@ -1010,11 +1010,37 @@ class ProjectIndex {
             }
 
             // Look up each callee in the symbol table
+            // For methods, prefer callees from: 1) same file, 2) same package, 3) same receiver type
             const result = [];
+            const defDir = path.dirname(def.file);
+            const defReceiver = def.receiver;
+
             for (const [calleeName, count] of callees) {
                 const symbols = this.symbols.get(calleeName);
                 if (symbols && symbols.length > 0) {
-                    const callee = symbols[0];
+                    let callee = symbols[0];
+
+                    // If multiple definitions, try to find the best match
+                    if (symbols.length > 1) {
+                        // Priority 1: Same file
+                        const sameFile = symbols.find(s => s.file === def.file);
+                        if (sameFile) {
+                            callee = sameFile;
+                        } else {
+                            // Priority 2: Same directory (package)
+                            const sameDir = symbols.find(s => path.dirname(s.file) === defDir);
+                            if (sameDir) {
+                                callee = sameDir;
+                            } else if (defReceiver) {
+                                // Priority 3: Same receiver type (for methods)
+                                const sameReceiver = symbols.find(s => s.receiver === defReceiver);
+                                if (sameReceiver) {
+                                    callee = sameReceiver;
+                                }
+                            }
+                        }
+                    }
+
                     result.push({
                         ...callee,
                         callCount: count,
@@ -2137,23 +2163,15 @@ class ProjectIndex {
 
         const def = definitions[0];
         const visited = new Set();
+        const defDir = path.dirname(def.file);
 
-        const buildTree = (funcName, currentDepth, dir) => {
-            if (currentDepth > maxDepth || visited.has(funcName)) {
+        const buildTree = (funcDef, currentDepth, dir) => {
+            const funcName = funcDef.name;
+            if (currentDepth > maxDepth || visited.has(`${funcDef.file}:${funcDef.startLine}`)) {
                 return null;
             }
-            visited.add(funcName);
-
-            const funcDefs = this.symbols.get(funcName);
-            if (!funcDefs || funcDefs.length === 0) {
-                return {
-                    name: funcName,
-                    external: true,
-                    children: []
-                };
-            }
+            visited.add(`${funcDef.file}:${funcDef.startLine}`);
 
-            const funcDef = funcDefs[0];
             const node = {
                 name: funcName,
                 file: funcDef.relativePath,
@@ -2165,7 +2183,8 @@ class ProjectIndex {
             if (dir === 'down' || dir === 'both') {
                 const callees = this.findCallees(funcDef);
                 for (const callee of callees.slice(0, 10)) {  // Limit children
-                    const childTree = buildTree(callee.name, currentDepth + 1, 'down');
+                    // callee already has the best-matched definition from findCallees
+                    const childTree = buildTree(callee, currentDepth + 1, 'down');
                     if (childTree) {
                         node.children.push({
                             ...childTree,
@@ -2179,7 +2198,7 @@ class ProjectIndex {
             return node;
         };
 
-        const tree = buildTree(name, 0, direction);
+        const tree = buildTree(def, 0, direction);
 
         // Also get callers if direction is 'up' or 'both'
         let callers = [];

package/languages/javascript.js

@@ -1248,8 +1248,9 @@ function findUsagesInCode(code, name, parser) {
     const usages = [];
 
     traverseTree(tree.rootNode, (node) => {
-        // Only look for identifiers with the matching name
-        if (node.type !== 'identifier' || node.text !== name) {
+        // Look for both identifier and property_identifier (method names in obj.method() calls)
+        const isIdentifier = node.type === 'identifier' || node.type === 'property_identifier';
+        if (!isIdentifier || node.text !== name) {
             return true;
         }
 
@@ -1318,6 +1319,17 @@ function findUsagesInCode(code, name, parser) {
             // Property access (method call): a.name() - the name after dot
             else if (parent.type === 'member_expression' &&
                      parent.childForFieldName('property') === node) {
+                // Skip built-in objects and common module names (JSON.parse, path.parse, etc.)
+                const object = parent.childForFieldName('object');
+                const builtins = [
+                    // JS built-in objects
+                    'JSON', 'Math', 'console', 'Object', 'Array', 'String', 'Number', 'Date', 'RegExp', 'Promise', 'Reflect', 'Proxy', 'Map', 'Set', 'WeakMap', 'WeakSet', 'Symbol', 'Intl', 'WebAssembly', 'Atomics', 'SharedArrayBuffer', 'ArrayBuffer', 'DataView', 'Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array', 'BigInt64Array', 'BigUint64Array', 'Error', 'EvalError', 'RangeError', 'ReferenceError', 'SyntaxError', 'TypeError', 'URIError', 'URL', 'URLSearchParams',
+                    // Node.js core modules
+                    'path', 'fs', 'os', 'http', 'https', 'net', 'dgram', 'dns', 'tls', 'crypto', 'zlib', 'stream', 'util', 'events', 'buffer', 'child_process', 'cluster', 'readline', 'repl', 'vm', 'assert', 'querystring', 'url', 'punycode', 'string_decoder', 'timers', 'tty', 'v8', 'perf_hooks', 'worker_threads', 'inspector', 'trace_events', 'async_hooks', 'process'
+                ];
+                if (object && object.type === 'identifier' && builtins.includes(object.text)) {
+                    return true; // Skip built-in method calls
+                }
                 // Check if this is a method call
                 const grandparent = parent.parent;
                 if (grandparent && grandparent.type === 'call_expression') {

package/languages/rust.js

@@ -910,8 +910,9 @@ function findUsagesInCode(code, name, parser) {
     const usages = [];
 
     traverseTree(tree.rootNode, (node) => {
-        // Only look for identifiers with the matching name
-        if (node.type !== 'identifier' || node.text !== name) {
+        // Look for both identifier and field_identifier (method names in obj.method() calls)
+        const isIdentifier = node.type === 'identifier' || node.type === 'field_identifier';
+        if (!isIdentifier || node.text !== name) {
             return true;
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucn",
-  "version": "3.1.2",
+  "version": "3.1.4",
   "description": "Code navigation built by AI, for AI. Reduces context usage when working with large codebases.",
   "main": "index.js",
   "bin": {

package/test/parser.test.js

@@ -4459,6 +4459,132 @@ func (s *ServiceB) Process() error {
             fs.rmSync(tmpDir, { recursive: true, force: true });
         }
     });
+
+    it('should detect JavaScript method calls but filter built-ins', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-js-method-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'test.js'), `
+class Service {
+  process() {}
+}
+
+function main() {
+  const svc = new Service();
+  svc.process();     // user method - SHOULD be counted
+  JSON.parse('{}');  // built-in - should NOT be counted
+  process();         // direct call - SHOULD be counted
+}
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.js', { quiet: true });
+
+            const usages = index.usages('process', { codeOnly: true });
+            const calls = usages.filter(u => u.usageType === 'call' && !u.isDefinition);
+
+            // Should find 2 calls: svc.process() and process()
+            assert.strictEqual(calls.length, 2, 'Should find 2 calls (user method + direct)');
+
+            // Should NOT include JSON.parse
+            const hasJsonParse = calls.some(c => c.content && c.content.includes('JSON.parse'));
+            assert.strictEqual(hasJsonParse, false, 'JSON.parse should NOT be counted');
+
+            // Should include svc.process()
+            const hasUserMethod = calls.some(c => c.content && c.content.includes('svc.process'));
+            assert.strictEqual(hasUserMethod, true, 'svc.process() SHOULD be counted');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+
+    it('should prefer same-file callees for Go methods', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-go-callee-disambig-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'go.mod'), `module example.com/test
+go 1.21
+`);
+
+            // Two files with same method name 'helper'
+            fs.writeFileSync(path.join(tmpDir, 'service_a.go'), `package main
+
+type ServiceA struct{}
+
+func (s *ServiceA) Process() {
+    s.helper()
+}
+
+func (s *ServiceA) helper() {}
+`);
+
+            fs.writeFileSync(path.join(tmpDir, 'service_b.go'), `package main
+
+type ServiceB struct{}
+
+func (s *ServiceB) Process() {
+    s.helper()
+}
+
+func (s *ServiceB) helper() {}
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.go', { quiet: true });
+
+            // Get callees for ServiceA.Process - should find ServiceA.helper, not ServiceB.helper
+            const defs = index.symbols.get('Process') || [];
+            const serviceAProcess = defs.find(d => d.relativePath.includes('service_a.go'));
+            assert.ok(serviceAProcess, 'Should find ServiceA.Process');
+
+            const callees = index.findCallees(serviceAProcess);
+            assert.ok(callees.length >= 1, 'Should find at least 1 callee');
+
+            const helperCallee = callees.find(c => c.name === 'helper');
+            assert.ok(helperCallee, 'Should find helper callee');
+            assert.ok(helperCallee.relativePath.includes('service_a.go'),
+                'helper callee should be from service_a.go, not service_b.go');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+
+    it('should detect Rust method calls in usages', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-rust-method-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'Cargo.toml'), `[package]
+name = "test"
+version = "0.1.0"
+`);
+
+            fs.writeFileSync(path.join(tmpDir, 'main.rs'), `
+struct Client {}
+
+impl Client {
+    fn process(&self) {}
+}
+
+fn main() {
+    let c = Client{};
+    c.process();
+    process();
+}
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.rs', { quiet: true });
+
+            const usages = index.usages('process', { codeOnly: true });
+            const calls = usages.filter(u => u.usageType === 'call' && !u.isDefinition);
+
+            // Should find 2 calls: c.process() and process()
+            assert.ok(calls.length >= 2, 'Should find at least 2 calls');
+
+            // Should include c.process()
+            const hasMethodCall = calls.some(c => c.content && c.content.includes('c.process'));
+            assert.strictEqual(hasMethodCall, true, 'c.process() SHOULD be counted');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
 });
 
 console.log('UCN v3 Test Suite');