ucn 3.7.31 → 3.7.33

package/core/callers.js

@@ -227,47 +227,54 @@ function findCallers(index, name, options = {}) {
                     if (call.selfAttribute && fileEntry.language === 'python') {
                         // self.attr.method() — resolve via attribute type inference
                         const callerSymbol = index.findEnclosingFunction(filePath, call.line, true);
-                        if (!callerSymbol?.className) continue;
-                        const attrTypes = getInstanceAttributeTypes(index, filePath, callerSymbol.className);
-                        if (!attrTypes) continue;
-                        const targetClass = attrTypes.get(call.selfAttribute);
-                        if (!targetClass) continue;
-                        // Check if any definition of searched function belongs to targetClass
-                        const matchesDef = definitions.some(d => d.className === targetClass);
-                        if (!matchesDef) continue;
-                        resolvedBySameClass = true;
-                        // Falls through to add as caller
+                        if (!callerSymbol?.className) {
+                            // Can't resolve — include only if includeMethods requested
+                            if (!options.includeMethods) continue;
+                        } else {
+                            const attrTypes = getInstanceAttributeTypes(index, filePath, callerSymbol.className);
+                            const targetClass = attrTypes?.get(call.selfAttribute);
+                            if (targetClass && definitions.some(d => d.className === targetClass)) {
+                                resolvedBySameClass = true;
+                            } else if (!options.includeMethods) {
+                                continue;
+                            }
+                        }
                     } else if (['self', 'cls', 'this', 'super'].includes(call.receiver)) {
                         // self/this/super.method() — resolve to same-class or parent method
                         const callerSymbol = index.findEnclosingFunction(filePath, call.line, true);
-                        if (!callerSymbol?.className) continue;
-                        // For super(), skip same-class — only check parent chain
-                        let matchesDef = call.receiver === 'super'
-                            ? false
-                            : definitions.some(d => d.className === callerSymbol.className);
-                        // Walk inheritance chain using BFS if not found in same class
-                        if (!matchesDef) {
-                            const visited = new Set([callerSymbol.className]);
-                            const callerFile = callerSymbol.file || filePath;
-                            const startParents = index._getInheritanceParents(callerSymbol.className, callerFile) || [];
-                            const queue = startParents.map(p => ({ name: p, contextFile: callerFile }));
-                            while (queue.length > 0 && !matchesDef) {
-                                const { name: current, contextFile } = queue.shift();
-                                if (visited.has(current)) continue;
-                                visited.add(current);
-                                matchesDef = definitions.some(d => d.className === current);
-                                if (!matchesDef) {
-                                    const resolvedFile = index._resolveClassFile(current, contextFile);
-                                    const grandparents = index._getInheritanceParents(current, resolvedFile) || [];
-                                    for (const gp of grandparents) {
-                                        if (!visited.has(gp)) queue.push({ name: gp, contextFile: resolvedFile });
+                        if (!callerSymbol?.className) {
+                            if (!options.includeMethods) continue;
+                        } else {
+                            // For super(), skip same-class — only check parent chain
+                            let matchesDef = call.receiver === 'super'
+                                ? false
+                                : definitions.some(d => d.className === callerSymbol.className);
+                            // Walk inheritance chain using BFS if not found in same class
+                            if (!matchesDef) {
+                                const visited = new Set([callerSymbol.className]);
+                                const callerFile = callerSymbol.file || filePath;
+                                const startParents = index._getInheritanceParents(callerSymbol.className, callerFile) || [];
+                                const queue = startParents.map(p => ({ name: p, contextFile: callerFile }));
+                                while (queue.length > 0 && !matchesDef) {
+                                    const { name: current, contextFile } = queue.shift();
+                                    if (visited.has(current)) continue;
+                                    visited.add(current);
+                                    matchesDef = definitions.some(d => d.className === current);
+                                    if (!matchesDef) {
+                                        const resolvedFile = index._resolveClassFile(current, contextFile);
+                                        const grandparents = index._getInheritanceParents(current, resolvedFile) || [];
+                                        for (const gp of grandparents) {
+                                            if (!visited.has(gp)) queue.push({ name: gp, contextFile: resolvedFile });
+                                        }
                                     }
                                 }
                             }
+                            if (matchesDef) {
+                                resolvedBySameClass = true;
+                            } else if (!options.includeMethods) {
+                                continue;
+                            }
                         }
-                        if (!matchesDef) continue;
-                        resolvedBySameClass = true;
-                        // Falls through to add as caller
                     } else {
                         // Go doesn't use this/self/cls - always include Go method calls
                         // Java method calls are always obj.method() - include by default

package/core/project.js

@@ -2420,7 +2420,7 @@ class ProjectIndex {
             const symParts = symName.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase().split('_');
 
             // Check for shared parts (require ≥50% of the longer name to match)
-            const sharedParts = nameParts.filter(p => symParts.includes(p) && p.length > 2);
+            const sharedParts = nameParts.filter(p => symParts.includes(p) && p.length > 3);
             const maxParts = Math.max(nameParts.length, symParts.length);
             if (sharedParts.length > 0 && sharedParts.length / maxParts >= 0.5) {
                 const sym = symbols[0];
@@ -2786,7 +2786,7 @@ class ProjectIndex {
         try {
         const maxCallers = options.all ? Infinity : (options.maxCallers || 10);
         const maxCallees = options.all ? Infinity : (options.maxCallees || 10);
-        const includeMethods = options.includeMethods ?? true;
+        const includeMethods = options.includeMethods ?? false;
 
         // Find symbol definition(s) — skip counts since about() computes its own via usages()
         const definitions = this.find(name, { exact: true, file: options.file, className: options.className, skipCounts: true });

package/core/verify.js

@@ -327,6 +327,14 @@ function plan(index, name, options = {}) {
     let changes = [];
 
     if (options.addParam) {
+        // Check if parameter already exists
+        if (currentParams.some(p => p.name === options.addParam)) {
+            return {
+                found: true,
+                error: `Parameter "${options.addParam}" already exists in ${name}`,
+                currentParams: currentParams.map(p => p.name)
+            };
+        }
         operation = 'add-param';
         const newParam = {
             name: options.addParam,

package/package.json

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