ucn 3.7.43 → 3.7.45

package/core/callers.js

@@ -646,9 +646,21 @@ function findCallees(index, def, options = {}) {
         // Respect includeMethods=false — skip self/this method resolution entirely
         if (selfAttrCalls && def.className && options.includeMethods !== false) {
             const attrTypes = getInstanceAttributeTypes(index, def.file, def.className);
-            if (attrTypes) {
-                for (const call of selfAttrCalls) {
-                    const targetClass = attrTypes.get(call.selfAttribute);
+            for (const call of selfAttrCalls) {
+                    let targetClass = attrTypes ? attrTypes.get(call.selfAttribute) : null;
+                    // Unique method heuristic: if attr type unknown but method exists on exactly one class
+                    if (!targetClass) {
+                        const methodSyms = index.symbols.get(call.name);
+                        if (methodSyms) {
+                            const classNames = new Set();
+                            for (const s of methodSyms) {
+                                if (s.className) classNames.add(s.className);
+                            }
+                            if (classNames.size === 1) {
+                                targetClass = classNames.values().next().value;
+                            }
+                        }
+                    }
                     if (!targetClass) continue;
 
                     // Find method in symbol table where className matches
@@ -670,7 +682,6 @@ function findCallees(index, def, options = {}) {
                         });
                     }
                 }
-            }
         }
 
         // Third pass: resolve self/this/super.method() calls to same-class or parent methods

package/core/execute.js

@@ -99,6 +99,24 @@ function checkFileError(result, file) {
     return null;
 }
 
+/**
+ * Validate that className filter actually matches a definition.
+ * Returns error string if className is invalid, null if OK.
+ */
+function validateClassName(index, name, className) {
+    if (!className) return null;
+    const allDefs = index.symbols.get(name);
+    if (!allDefs || allDefs.length === 0) return null; // no defs at all — let the command handle "not found"
+    const matching = allDefs.filter(d => d.className === className);
+    if (matching.length > 0) return null; // className matched
+    // className specified but no definitions match
+    const available = [...new Set(allDefs.filter(d => d.className).map(d => d.className))];
+    if (available.length > 0) {
+        return `Symbol "${name}" not found in class "${className}". Available in: ${available.join(', ')}.`;
+    }
+    return `Symbol "${name}" is not a method of any class. Defined in: ${allDefs[0].relativePath}:${allDefs[0].startLine}.`;
+}
+
 /** Parse a number param (handles string from CLI, number from MCP). */
 function num(val, fallback) {
     if (val == null) return fallback;
@@ -162,6 +180,8 @@ const HANDLERS = {
         const err = requireName(p.name);
         if (err) return { ok: false, error: err };
         applyClassMethodSyntax(p);
+        const classErr = validateClassName(index, p.name, p.className);
+        if (classErr) return { ok: false, error: classErr };
         const result = index.context(p.name, {
             includeMethods: p.includeMethods,
             includeUncertain: p.includeUncertain || false,
@@ -177,6 +197,8 @@ const HANDLERS = {
         const err = requireName(p.name);
         if (err) return { ok: false, error: err };
         applyClassMethodSyntax(p);
+        const classErr = validateClassName(index, p.name, p.className);
+        if (classErr) return { ok: false, error: classErr };
         const result = index.impact(p.name, {
             file: p.file,
             className: p.className,
@@ -291,6 +313,7 @@ const HANDLERS = {
             topLevel: p.topLevel,
             all: p.all,
             top: num(p.top, undefined),
+            file: p.file,
         });
         return { ok: true, result };
     },
@@ -562,6 +585,8 @@ const HANDLERS = {
         const err = requireName(p.name);
         if (err) return { ok: false, error: err };
         applyClassMethodSyntax(p);
+        const classErr = validateClassName(index, p.name, p.className);
+        if (classErr) return { ok: false, error: classErr };
         const result = index.verify(p.name, { file: p.file, className: p.className });
         return { ok: true, result };
     },
@@ -570,6 +595,8 @@ const HANDLERS = {
         const err = requireName(p.name);
         if (err) return { ok: false, error: err };
         applyClassMethodSyntax(p);
+        const classErr = validateClassName(index, p.name, p.className);
+        if (classErr) return { ok: false, error: classErr };
         if (!p.addParam && !p.removeParam && !p.renameTo) {
             return { ok: false, error: 'Plan requires an operation: add_param, remove_param, or rename_to.' };
         }

package/core/project.js

@@ -919,6 +919,21 @@ class ProjectIndex {
             }
         }
 
+        // For methods (symbols with className), objects can be passed as parameters
+        // to files with no import relationship to the definition file.
+        // Expand to all project files that mention the name (fast text pre-check).
+        if (symbol.className) {
+            for (const filePath of this.files.keys()) {
+                if (relevantFiles.has(filePath)) continue;
+                try {
+                    const content = this._readFile(filePath);
+                    if (content.includes(name)) {
+                        relevantFiles.add(filePath);
+                    }
+                } catch (e) { /* skip unreadable */ }
+            }
+        }
+
         let calls = 0;
         let definitions = 0;
         let imports = 0;
@@ -3393,7 +3408,38 @@ class ProjectIndex {
         let totalDynamic = 0;
         let totalTests = 0;
 
+        // When file= is specified, scope to matching files only
+        let fileFilter = null;
+        if (options.file) {
+            const resolved = this.findFile(options.file);
+            if (resolved) {
+                fileFilter = new Set([resolved]);
+            } else {
+                // Try substring match for partial paths
+                const matching = [];
+                for (const fp of this.files.keys()) {
+                    const rp = path.relative(this.root, fp);
+                    if (rp.includes(options.file) || fp.includes(options.file)) {
+                        matching.push(fp);
+                    }
+                }
+                if (matching.length > 0) {
+                    fileFilter = new Set(matching);
+                } else {
+                    return {
+                        meta: { complete: true, skipped: 0, dynamicImports: 0, uncertain: 0 },
+                        totals: { files: 0, lines: 0, functions: 0, classes: 0, state: 0, testFiles: 0 },
+                        summary: { topFunctionFiles: [], topLineFiles: [], entryFiles: [] },
+                        files: [],
+                        hiddenFiles: 0,
+                        error: `File not found in project: ${options.file}`
+                    };
+                }
+            }
+        }
+
         for (const [filePath, fileEntry] of this.files) {
+            if (fileFilter && !fileFilter.has(filePath)) continue;
             let functions = fileEntry.symbols.filter(s =>
                 s.type === 'function' || s.type === 'method' || s.type === 'static' ||
                 s.type === 'constructor' || s.type === 'public' || s.type === 'abstract'

package/core/verify.js

@@ -482,7 +482,23 @@ function plan(index, name, options = {}) {
             name: options.addParam,
             ...(options.defaultValue && { default: options.defaultValue })
         };
-        newParams.push(newParam);
+
+        // When adding a required param (no default), insert before the first
+        // optional param to avoid producing invalid signatures in Python/TS
+        // (required params must precede optional ones).
+        if (!options.defaultValue) {
+            const firstOptIdx = newParams.findIndex(p => p.optional || p.default !== undefined);
+            if (firstOptIdx !== -1) {
+                // Also skip self/cls/&self/&mut self at position 0
+                const insertIdx = Math.max(firstOptIdx,
+                    (newParams.length > 0 && ['self', 'cls', '&self', '&mut self'].includes(newParams[0].name)) ? 1 : 0);
+                newParams.splice(insertIdx, 0, newParam);
+            } else {
+                newParams.push(newParam);
+            }
+        } else {
+            newParams.push(newParam);
+        }
 
         // Generate new signature
         const paramsList = newParams.map(p => {

package/package.json

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