ucn 3.1.1 → 3.1.3

package/cli/index.js

@@ -745,7 +745,7 @@ function runProjectCommand(rootDir, command, arg) {
 
         case 'context': {
             requireArg(arg, 'Usage: ucn . context <name>');
-            const ctx = index.context(arg, { includeMethods: flags.includeMethods });
+            const ctx = index.context(arg, { includeMethods: flags.includeMethods, file: flags.file });
             printOutput(ctx,
                 output.formatContextJson,
                 r => { printContext(r, { expand: flags.expand, root: index.root }); }
@@ -787,7 +787,7 @@ function runProjectCommand(rootDir, command, arg) {
 
         case 'about': {
             requireArg(arg, 'Usage: ucn . about <name>');
-            const aboutResult = index.about(arg, { withTypes: flags.withTypes });
+            const aboutResult = index.about(arg, { withTypes: flags.withTypes, file: flags.file });
             printOutput(aboutResult,
                 output.formatAboutJson,
                 r => output.formatAbout(r, { expand: flags.expand, root: index.root, depth: flags.depth })
@@ -797,7 +797,7 @@ function runProjectCommand(rootDir, command, arg) {
 
         case 'impact': {
             requireArg(arg, 'Usage: ucn . impact <name>');
-            const impactResult = index.impact(arg);
+            const impactResult = index.impact(arg, { file: flags.file });
             printOutput(impactResult, output.formatImpactJson, output.formatImpact);
             break;
         }
@@ -821,7 +821,7 @@ function runProjectCommand(rootDir, command, arg) {
         case 'trace': {
             requireArg(arg, 'Usage: ucn . trace <name>');
             const traceDepth = flags.depth ? parseInt(flags.depth) : 3;
-            const traceResult = index.trace(arg, { depth: traceDepth });
+            const traceResult = index.trace(arg, { depth: traceDepth, file: flags.file });
             printOutput(traceResult, output.formatTraceJson, output.formatTrace);
             break;
         }

package/core/project.js

@@ -706,11 +706,21 @@ class ProjectIndex {
      * Get context for a symbol (callers + callees)
      */
     context(name, options = {}) {
-        const definitions = this.symbols.get(name) || [];
+        let definitions = this.symbols.get(name) || [];
         if (definitions.length === 0) {
             return { function: name, file: null, callers: [], callees: [] };
         }
 
+        // Filter by file if specified
+        if (options.file) {
+            const filtered = definitions.filter(d =>
+                d.relativePath && d.relativePath.includes(options.file)
+            );
+            if (filtered.length > 0) {
+                definitions = filtered;
+            }
+        }
+
         // Prefer class/struct/interface definitions over functions/methods/constructors
         // This ensures context('ClassName') finds the class, not a constructor with same name
         const typeOrder = ['class', 'struct', 'interface', 'type', 'impl'];
@@ -974,6 +984,10 @@ class ProjectIndex {
             const calls = this.getCachedCalls(def.file);
             if (!calls) return [];
 
+            // Get file language for smart method call handling
+            const fileEntry = this.files.get(def.file);
+            const language = fileEntry?.language;
+
             const callees = new Map();  // name -> count
 
             for (const call of calls) {
@@ -982,8 +996,12 @@ class ProjectIndex {
                 if (call.enclosingFunction.name !== def.name) continue;
                 if (call.enclosingFunction.startLine !== def.startLine) continue;
 
-                // Skip method calls unless explicitly requested
-                if (call.isMethod && !options.includeMethods) continue;
+                // Smart method call handling:
+                // - Go: include all method calls (Go doesn't use this/self/cls)
+                // - Other languages: skip method calls unless explicitly requested
+                if (call.isMethod) {
+                    if (language !== 'go' && !options.includeMethods) continue;
+                }
 
                 // Skip keywords and built-ins
                 if (this.isKeyword(call.name)) continue;
@@ -2102,11 +2120,21 @@ class ProjectIndex {
         const maxDepth = Math.max(0, rawDepth);
         const direction = options.direction || 'down';  // 'down' = callees, 'up' = callers, 'both'
 
-        const definitions = this.symbols.get(name);
+        let definitions = this.symbols.get(name);
         if (!definitions || definitions.length === 0) {
             return null;
         }
 
+        // Filter by file if specified
+        if (options.file) {
+            const filtered = definitions.filter(d =>
+                d.relativePath && d.relativePath.includes(options.file)
+            );
+            if (filtered.length > 0) {
+                definitions = filtered;
+            }
+        }
+
         const def = definitions[0];
         const visited = new Set();
 
@@ -2184,11 +2212,21 @@ class ProjectIndex {
      * @returns {object} Impact analysis
      */
     impact(name, options = {}) {
-        const definitions = this.symbols.get(name);
+        let definitions = this.symbols.get(name);
         if (!definitions || definitions.length === 0) {
             return null;
         }
 
+        // Filter by file if specified
+        if (options.file) {
+            const filtered = definitions.filter(d =>
+                d.relativePath && d.relativePath.includes(options.file)
+            );
+            if (filtered.length > 0) {
+                definitions = filtered;
+            }
+        }
+
         const def = definitions[0];
         const usages = this.usages(name, { codeOnly: true });
         const calls = usages.filter(u => u.usageType === 'call' && !u.isDefinition);
@@ -2899,10 +2937,10 @@ class ProjectIndex {
         const maxCallees = options.maxCallees || 5;
 
         // Find symbol definition(s)
-        const definitions = this.find(name, { exact: true });
+        const definitions = this.find(name, { exact: true, file: options.file });
         if (definitions.length === 0) {
             // Try fuzzy match
-            const fuzzy = this.find(name);
+            const fuzzy = this.find(name, { file: options.file });
             if (fuzzy.length === 0) {
                 return null;
             }

package/languages/go.js

@@ -567,8 +567,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 selector expressions)
+        const isIdentifier = node.type === 'identifier' || node.type === 'field_identifier';
+        if (!isIdentifier || node.text !== name) {
             return true;
         }
 
@@ -622,9 +623,8 @@ function findUsagesInCode(code, name, parser) {
             else if (parent.type === 'parameter_declaration') {
                 usageType = 'definition';
             }
-            // Method call: selector_expression followed by call
-            else if (parent.type === 'selector_expression' &&
-                     parent.childForFieldName('field') === node) {
+            // Method call: selector_expression followed by call (field_identifier case)
+            else if (parent.type === 'selector_expression') {
                 const grandparent = parent.parent;
                 if (grandparent && grandparent.type === 'call_expression') {
                     usageType = 'call';

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.1",
+  "version": "3.1.3",
   "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

@@ -4344,6 +4344,197 @@ func main() {
             fs.rmSync(tmpDir, { recursive: true, force: true });
         }
     });
+
+    it('should detect Go method calls in usages (field_identifier)', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-go-method-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'go.mod'), `module example.com/test
+go 1.21
+`);
+
+            fs.writeFileSync(path.join(tmpDir, 'service.go'), `package main
+
+type Service struct{}
+
+func (s *Service) CollectAll() error {
+    return nil
+}
+
+func main() {
+    svc := &Service{}
+    svc.CollectAll()
+}
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.go', { quiet: true });
+
+            // usages should find the method call
+            const usages = index.usages('CollectAll', { codeOnly: true });
+            const calls = usages.filter(u => u.usageType === 'call' && !u.isDefinition);
+            assert.ok(calls.length >= 1, 'Should find at least 1 call to CollectAll');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+
+    it('should find callees for Go receiver methods', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-go-callees-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'go.mod'), `module example.com/test
+go 1.21
+`);
+
+            fs.writeFileSync(path.join(tmpDir, 'client.go'), `package main
+
+type Client struct{}
+
+func (c *Client) GetPods() []string {
+    return nil
+}
+
+func (c *Client) GetNodes() []string {
+    return nil
+}
+
+func (c *Client) CollectAll() {
+    c.GetPods()
+    c.GetNodes()
+}
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.go', { quiet: true });
+
+            // context should find callees (Go method calls)
+            const ctx = index.context('CollectAll');
+            assert.ok(ctx.callees, 'Should have callees');
+            assert.ok(ctx.callees.length >= 2, 'Should find at least 2 callees (GetPods, GetNodes)');
+
+            const calleeNames = ctx.callees.map(c => c.name);
+            assert.ok(calleeNames.includes('GetPods'), 'GetPods should be a callee');
+            assert.ok(calleeNames.includes('GetNodes'), 'GetNodes should be a callee');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+
+    it('should filter by --file for Go methods with same name', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-go-file-filter-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'go.mod'), `module example.com/test
+go 1.21
+`);
+
+            fs.writeFileSync(path.join(tmpDir, 'service_a.go'), `package main
+
+type ServiceA struct{}
+
+func (s *ServiceA) Process() error {
+    return nil
+}
+`);
+
+            fs.writeFileSync(path.join(tmpDir, 'service_b.go'), `package main
+
+type ServiceB struct{}
+
+func (s *ServiceB) Process() error {
+    return nil
+}
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.go', { quiet: true });
+
+            // Without file filter, should find both
+            const allDefs = index.find('Process');
+            assert.strictEqual(allDefs.length, 2, 'Should find 2 definitions of Process');
+
+            // With file filter, should find only one
+            const filteredDefs = index.find('Process', { file: 'service_a.go' });
+            assert.strictEqual(filteredDefs.length, 1, 'Should find 1 definition with file filter');
+            assert.ok(filteredDefs[0].relativePath.includes('service_a.go'), 'Should be from service_a.go');
+        } finally {
+            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 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');