ucn 3.7.42 → 3.7.44

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

@@ -298,6 +298,7 @@ const HANDLERS = {
     search: (index, p) => {
         const err = requireTerm(p.term);
         if (err) return { ok: false, error: err };
+        const testsExcluded = !p.includeTests;
         const exclude = applyTestExclusions(p.exclude, p.includeTests);
         const result = index.search(p.term, {
             codeOnly: p.codeOnly || false,
@@ -308,6 +309,7 @@ const HANDLERS = {
             regex: p.regex,
             top: num(p.top, undefined),
         });
+        if (result.meta) result.meta.testsExcluded = testsExcluded;
         return { ok: true, result };
     },
 

package/core/output.js

@@ -2052,6 +2052,10 @@ function formatSearch(results, term) {
         lines.push(`\n${results.reduce((s, r) => s + r.matches.length, 0)} shown of ${meta.totalMatches} total matches. Use top= to see more.`);
     }
 
+    if (meta && meta.testsExcluded && meta.filesSkipped > 0) {
+        lines.push(`\nNote: ${meta.filesSkipped} file${meta.filesSkipped === 1 ? '' : 's'} excluded by filters (test files hidden by default; use include_tests=true to include).`);
+    }
+
     return lines.join('\n');
 }
 

package/core/project.js

@@ -2772,6 +2772,35 @@ class ProjectIndex {
                             }
                         }
                     }
+                    // Check parameter type annotations: def foo(tracker: SourceTracker) → tracker.record()
+                    if (c.callerFile && c.callerStartLine) {
+                        const callerSymbol = this.findEnclosingFunction(c.callerFile, c.line, true);
+                        if (callerSymbol && callerSymbol.paramsStructured) {
+                            for (const param of callerSymbol.paramsStructured) {
+                                if (param.name === r && param.type) {
+                                    // Check if the type annotation contains the target class name
+                                    const typeMatches = param.type.match(/\b([A-Za-z_]\w*)\b/g);
+                                    if (typeMatches && typeMatches.some(t => t === targetClassName)) {
+                                        return true;
+                                    }
+                                    // Type annotation exists but doesn't match target class — filter out
+                                    return false;
+                                }
+                            }
+                        }
+                    }
+                    // Unique method heuristic: if the called method exists on exactly one class
+                    // and it matches the target, include the call (no other class could match)
+                    const methodDefs = this.symbols.get(name);
+                    if (methodDefs) {
+                        const classNames = new Set();
+                        for (const d of methodDefs) {
+                            if (d.className) classNames.add(d.className);
+                        }
+                        if (classNames.size === 1 && classNames.has(targetClassName)) {
+                            return true;
+                        }
+                    }
                     // className explicitly set but receiver type unknown — filter it out.
                     // User asked for a specific class; unknown receivers are likely unrelated.
                     return false;

package/core/verify.js

@@ -203,11 +203,83 @@ function verify(index, name, options = {}) {
 
     // Get all call sites using findCallers for accurate resolution
     // (usages-based approach misses calls when className is set or local names collide)
-    const callerResults = index.findCallers(name, {
+    let callerResults = index.findCallers(name, {
         includeMethods: true,
         includeUncertain: false,
         targetDefinitions: [def],
     });
+
+    // When className is explicitly provided, filter out method calls whose
+    // receiver clearly belongs to a different type (same logic as impact()).
+    if (options.className && def.className) {
+        const targetClassName = def.className;
+        callerResults = callerResults.filter(c => {
+            if (!c.isMethod) return true;
+            const r = c.receiver;
+            if (!r || ['self', 'cls', 'this', 'super'].includes(r)) return true;
+            if (r.toLowerCase().includes(targetClassName.toLowerCase())) return true;
+            // Check local variable type inference from constructor assignments
+            if (c.callerFile) {
+                const callerDef = c.callerStartLine ? { file: c.callerFile, startLine: c.callerStartLine, endLine: c.callerEndLine } : null;
+                if (callerDef) {
+                    const callerCalls = index.getCachedCalls(c.callerFile);
+                    if (callerCalls && Array.isArray(callerCalls)) {
+                        const localTypes = new Map();
+                        for (const call of callerCalls) {
+                            if (call.line >= callerDef.startLine && call.line <= callerDef.endLine) {
+                                if (!call.isMethod && !call.receiver) {
+                                    const syms = index.symbols.get(call.name);
+                                    if (syms && syms.some(s => s.type === 'class')) {
+                                        const content = index._readFile(c.callerFile);
+                                        const clines = content.split('\n');
+                                        const cline = clines[call.line - 1] || '';
+                                        const m = cline.match(/^\s*(\w+)\s*=\s*(?:await\s+)?(\w+)\s*\(/);
+                                        if (m && m[2] === call.name) {
+                                            localTypes.set(m[1], call.name);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        const receiverType = localTypes.get(r);
+                        if (receiverType) {
+                            return receiverType === targetClassName;
+                        }
+                    }
+                }
+            }
+            // Check parameter type annotations: def foo(tracker: SourceTracker) → tracker.record()
+            if (c.callerFile && c.callerStartLine) {
+                const callerSymbol = index.findEnclosingFunction(c.callerFile, c.line, true);
+                if (callerSymbol && callerSymbol.paramsStructured) {
+                    for (const param of callerSymbol.paramsStructured) {
+                        if (param.name === r && param.type) {
+                            const typeMatches = param.type.match(/\b([A-Za-z_]\w*)\b/g);
+                            if (typeMatches && typeMatches.some(t => t === targetClassName)) {
+                                return true;
+                            }
+                            return false;
+                        }
+                    }
+                }
+            }
+            // Unique method heuristic: if the called method exists on exactly one class
+            // and it matches the target, include the call (no other class could match)
+            const methodDefs = index.symbols.get(name);
+            if (methodDefs) {
+                const classNames = new Set();
+                for (const d of methodDefs) {
+                    if (d.className) classNames.add(d.className);
+                }
+                if (classNames.size === 1 && classNames.has(targetClassName)) {
+                    return true;
+                }
+            }
+            // className explicitly set but receiver type unknown — filter it out
+            return false;
+        });
+    }
+
     // Convert caller results to usage-like objects for analyzeCallSite
     const calls = callerResults.map(c => ({
         file: c.file,

package/package.json

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