ucn 3.7.41 → 3.7.43

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

@@ -1018,12 +1018,38 @@ class ProjectIndex {
                 // Try AST-based detection first (with per-operation cache)
                 const astUsages = this._getCachedUsages(filePath, name);
                 if (astUsages !== null) {
+                    // Pre-compute: does any imported project file define this name?
+                    // Used to filter namespace member expressions (e.g., DropdownMenuPrimitive.Separator)
+                    // while keeping module access patterns (e.g., output.formatExample())
+                    let _importedHasDef = null;
+                    const importedFileHasDef = () => {
+                        if (_importedHasDef !== null) return _importedHasDef;
+                        const importedFiles = this.importGraph.get(filePath) || [];
+                        _importedHasDef = importedFiles.some(imp => {
+                            const impEntry = this.files.get(imp);
+                            return impEntry?.symbols?.some(s => s.name === name);
+                        });
+                        return _importedHasDef;
+                    };
+
                     for (const u of astUsages) {
                         // Skip if this is a definition line (already added above)
                         if (definitions.some(d => d.file === filePath && d.startLine === u.line)) {
                             continue;
                         }
 
+                        // Filter member expressions with unrelated receivers in JS/TS/Python.
+                        // Keeps: standalone usages, self/this/cls/super, method calls on known types,
+                        //        and module access (output.fn()) when the imported file defines the name.
+                        // Filters: namespace access to external packages (DropdownMenuPrimitive.Separator).
+                        if (u.receiver && !['self', 'this', 'cls', 'super'].includes(u.receiver) &&
+                            fileEntry.language !== 'go' && fileEntry.language !== 'java' && fileEntry.language !== 'rust') {
+                            const hasMethodDef = allDefinitions.some(d => d.className);
+                            if (!hasMethodDef && !importedFileHasDef()) {
+                                continue;
+                            }
+                        }
+
                         const lineContent = lines[u.line - 1] || '';
 
                         const usage = {
@@ -2746,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.41",
+  "version": "3.7.43",
   "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",