ucn 3.4.1 → 3.4.2

package/core/project.js

@@ -1021,6 +1021,14 @@ class ProjectIndex {
                             const matchesDef = definitions.some(d => d.className === targetClass);
                             if (!matchesDef) continue;
                             // Falls through to add as caller
+                        } else if (fileEntry.language === 'python' && ['self', 'cls'].includes(call.receiver)) {
+                            // self.method() / cls.method() — resolve to same-class method
+                            const callerSymbol = this.findEnclosingFunction(filePath, call.line, true);
+                            if (!callerSymbol?.className) continue;
+                            // Check if any definition of searched function belongs to caller's class
+                            const matchesDef = definitions.some(d => d.className === callerSymbol.className);
+                            if (!matchesDef) continue;
+                            // Falls through to add as caller
                         } else {
                             // Always skip this/self/cls calls (internal state access, not function calls)
                             if (['this', 'self', 'cls'].includes(call.receiver)) continue;
@@ -1125,6 +1133,7 @@ class ProjectIndex {
 
             const callees = new Map();  // key -> { name, bindingId, count }
             let selfAttrCalls = null;   // collected for Python self.attr.method() resolution
+            let selfMethodCalls = null; // collected for Python self.method() resolution
 
             for (const call of calls) {
                 // Filter to calls within this function's scope using enclosingFunction
@@ -1134,11 +1143,14 @@ class ProjectIndex {
 
                 // Smart method call handling:
                 // - Go: include all method calls (Go doesn't use this/self/cls)
+                // - Python self.method(): resolve to same-class method (handled below)
                 // - Python self.attr.method(): resolve via selfAttribute (handled below)
                 // - Other languages: skip method calls unless explicitly requested
                 if (call.isMethod) {
                     if (call.selfAttribute && language === 'python') {
                         // Will be resolved in second pass below
+                    } else if (language === 'python' && ['self', 'cls'].includes(call.receiver)) {
+                        // self.method() / cls.method() — resolve to same-class method below
                     } else if (language !== 'go' && !options.includeMethods) {
                         continue;
                     }
@@ -1154,6 +1166,13 @@ class ProjectIndex {
                     continue;
                 }
 
+                // Collect Python self.method() calls for same-class resolution
+                if (language === 'python' && call.isMethod && ['self', 'cls'].includes(call.receiver)) {
+                    if (!selfMethodCalls) selfMethodCalls = [];
+                    selfMethodCalls.push(call);
+                    continue;
+                }
+
                 // Resolve binding within this file (without mutating cached call objects)
                 let calleeKey = call.bindingId || call.name;
                 let bindingResolved = call.bindingId;
@@ -1236,6 +1255,30 @@ class ProjectIndex {
                 }
             }
 
+            // Third pass: resolve Python self.method() calls to same-class methods
+            if (selfMethodCalls && def.className) {
+                for (const call of selfMethodCalls) {
+                    const symbols = this.symbols.get(call.name);
+                    if (!symbols) continue;
+
+                    // Find method in same class
+                    const match = symbols.find(s => s.className === def.className);
+                    if (!match) continue;
+
+                    const key = match.bindingId || `${def.className}.${call.name}`;
+                    const existing = callees.get(key);
+                    if (existing) {
+                        existing.count += 1;
+                    } else {
+                        callees.set(key, {
+                            name: call.name,
+                            bindingId: match.bindingId,
+                            count: 1
+                        });
+                    }
+                }
+            }
+
             // 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 = [];

package/package.json

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

@@ -6188,5 +6188,51 @@ class Line:
     });
 });
 
+describe('Regression: Python self.method() same-class resolution', () => {
+    it('findCallees should resolve self.method() to same-class methods', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-selfmethod-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'service.py'), `
+class DataService:
+    def _fetch_remote(self, key, days):
+        return self._make_request(f"/api/{key}")
+
+    def _make_request(self, url):
+        return None
+
+    def get_records(self, key, days=365):
+        if self._is_valid(key):
+            return self._fetch_remote(key, days)
+        return None
+
+    def _is_valid(self, key):
+        return len(key) > 0
+`);
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.py', { quiet: true });
+
+            // get_records should have _fetch_remote and _is_valid as callees
+            const defs = index.symbols.get('get_records');
+            assert.ok(defs && defs.length > 0, 'Should find get_records');
+            const callees = index.findCallees(defs[0]);
+            const calleeNames = callees.map(c => c.name);
+            assert.ok(calleeNames.includes('_fetch_remote'),
+                `Should resolve self._fetch_remote(), got: ${calleeNames.join(', ')}`);
+            assert.ok(calleeNames.includes('_is_valid'),
+                `Should resolve self._is_valid(), got: ${calleeNames.join(', ')}`);
+
+            // _fetch_remote should have get_records as caller
+            const fetchDefs = index.symbols.get('_fetch_remote');
+            assert.ok(fetchDefs && fetchDefs.length > 0, 'Should find _fetch_remote');
+            const callers = index.findCallers('_fetch_remote');
+            const callerNames = callers.map(c => c.callerName);
+            assert.ok(callerNames.includes('get_records'),
+                `Should find get_records as caller of _fetch_remote, got: ${callerNames.join(', ')}`);
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+
 console.log('UCN v3 Test Suite');
 console.log('Run with: node --test test/parser.test.js');