ucn 3.8.3 → 3.8.4

package/.claude/scheduled_tasks.lock

@@ -0,0 +1 @@
+{"sessionId":"5e2a28ce-7f65-4369-a922-8d1d902f9d8f","pid":18086,"acquiredAt":1773363188494}

package/cli/index.js

@@ -169,7 +169,9 @@ if (unknownFlags.length > 0) {
 const VALUE_FLAGS = new Set([
     '--file', '--depth', '--top', '--context', '--direction',
     '--add-param', '--remove-param', '--rename-to', '--default',
-    '--base', '--exclude', '--not', '--in', '--max-lines', '--class-name'
+    '--base', '--exclude', '--not', '--in', '--max-lines', '--class-name',
+    '--type', '--param', '--receiver', '--returns', '--decorator',
+    '--limit', '--max-files', '--min-confidence', '--stack'
 ]);
 
 // Remove flags from args, then add args after -- (which are all positional)
@@ -1246,7 +1248,7 @@ Flags can be added per-command: context myFunc --include-methods
         const tokens = input.split(/\s+/);
         const command = tokens[0];
         // Flags that take a space-separated value (--flag value)
-        const valueFlagNames = new Set(['--file', '--in', '--base', '--add-param', '--remove-param', '--rename-to', '--default', '--depth', '--top', '--context', '--max-lines', '--direction', '--exclude', '--not', '--stack']);
+        const valueFlagNames = new Set(['--file', '--in', '--base', '--add-param', '--remove-param', '--rename-to', '--default', '--depth', '--top', '--context', '--max-lines', '--direction', '--exclude', '--not', '--stack', '--type', '--param', '--receiver', '--returns', '--decorator', '--limit', '--max-files', '--min-confidence', '--class-name']);
         const flagTokens = [];
         const argTokens = [];
         const skipNext = new Set();
@@ -1456,7 +1458,7 @@ function executeInteractiveCommand(index, command, arg, iflags = {}, cache = nul
         }
 
         case 'graph': {
-            const { ok, result, error } = execute(index, 'graph', { file: arg, ...iflags });
+            const { ok, result, error } = execute(index, 'graph', { file: arg || iflags.file, direction: iflags.direction, depth: iflags.depth, all: iflags.all });
             if (!ok) { console.log(error); return; }
             const graphDepth = iflags.depth ? parseInt(iflags.depth) : 2;
             console.log(output.formatGraph(result, { showAll: iflags.all || !!iflags.depth, maxDepth: graphDepth, file: arg }));

package/core/callers.js

@@ -456,6 +456,15 @@ function findCallers(index, name, options = {}) {
                             const receiverLower = call.receiver.toLowerCase();
                             const matchesTarget = [...targetTypes].some(cn => cn.toLowerCase() === receiverLower);
                             if (!matchesTarget) {
+                                // Rust/Go path calls (Type::method() / pkg.Method()): receiver IS the type name
+                                // If it doesn't match target, it's definitely a different type — filter it
+                                if (call.isPathCall && /^[A-Z]/.test(call.receiver)) {
+                                    isUncertain = true;
+                                    if (!options.includeUncertain) {
+                                        if (stats) stats.uncertain = (stats.uncertain || 0) + 1;
+                                        continue;
+                                    }
+                                }
                                 const nonTargetClasses = new Set();
                                 for (const d of definitions) {
                                     const t = d.className || (d.receiver && d.receiver.replace(/^\*/, ''));
@@ -915,7 +924,8 @@ function findCallees(index, def, options = {}) {
                 callees.set(calleeKey, {
                     name: effectiveName,
                     bindingId: bindingResolved,
-                    count: 1
+                    count: 1,
+                    ...(call.isConstructor && { isConstructor: true })
                 });
             }
         }
@@ -1023,7 +1033,7 @@ function findCallees(index, def, options = {}) {
         // Pre-compute import graph for callee confidence scoring
         const callerImportSet = new Set(index.importGraph.get(def.file) || []);
 
-        for (const { name: calleeName, bindingId, count } of callees.values()) {
+        for (const { name: calleeName, bindingId, count, isConstructor } of callees.values()) {
             const symbols = index.symbols.get(calleeName);
             if (symbols && symbols.length > 0) {
                 let callee = symbols[0];
@@ -1122,7 +1132,8 @@ function findCallees(index, def, options = {}) {
                 if (!bindingId && NON_CALLABLE_TYPES.has(callee.type)) {
                     const isFuncField = callee.type === 'field' && callee.fieldType &&
                         /^func\b/.test(callee.fieldType);
-                    if (!isFuncField) continue;
+                    // Constructor calls (new Foo()) are always callable regardless of type
+                    if (!isFuncField && !isConstructor) continue;
                 }
 
                 // Skip test-file callees when caller is production code and

package/core/deadcode.js

@@ -328,9 +328,8 @@ function deadcode(index, options = {}) {
 
             // Rust: trait impl methods are invoked via trait dispatch, not direct calls
             // They can never be "dead" - the trait contract requires them to exist
-            // className for trait impls contains " for " (e.g., "PartialEq for Glob")
             const isRustTraitImpl = lang === 'rust' && symbol.isMethod &&
-                symbol.className && symbol.className.includes(' for ');
+                symbol.className && symbol.traitImpl;
 
             // Go: Test*, Benchmark*, Example* functions are called by go test
             const isGoTestFunc = lang === 'go' &&

package/core/execute.js

@@ -393,36 +393,25 @@ const HANDLERS = {
         if (err) return { ok: false, error: err };
         applyClassMethodSyntax(p);
         const exclude = applyTestExclusions(p.exclude, p.includeTests);
+        const fileErr = checkFilePatternMatch(index, p.file);
+        if (fileErr) return { ok: false, error: fileErr };
         const result = index.usages(p.name, {
             codeOnly: p.codeOnly || false,
             context: num(p.context, 0),
             className: p.className,
+            file: p.file,
             exclude,
             in: p.in,
         });
-        // Apply limit to total usages across files
+        // Apply limit to total usages (result is a flat array)
         const limit = num(p.limit, undefined);
         let note;
-        if (limit && limit > 0 && result.files) {
-            let total = result.files.reduce((s, f) => s + f.usages.length, 0);
-            if (total > limit) {
-                let remaining = limit;
-                const truncated = [];
-                for (const f of result.files) {
-                    if (remaining <= 0) break;
-                    if (f.usages.length <= remaining) {
-                        truncated.push(f);
-                        remaining -= f.usages.length;
-                    } else {
-                        truncated.push({ ...f, usages: f.usages.slice(0, remaining) });
-                        remaining = 0;
-                    }
-                }
-                result.files = truncated;
-                note = limitNote(limit, total);
-            }
+        let limited = result;
+        if (limit && limit > 0 && Array.isArray(result) && result.length > limit) {
+            note = limitNote(limit, result.length);
+            limited = result.slice(0, limit);
         }
-        return { ok: true, result, note };
+        return { ok: true, result: limited, note };
     },
 
     toc: (index, p) => {
@@ -432,34 +421,44 @@ const HANDLERS = {
             all: p.all,
             top: num(p.top, undefined),
             file: p.file,
+            exclude: p.exclude,
         });
-        // Apply limit to detailed toc entries
+        // Apply limit to detailed toc entries (symbols are in f.symbols.functions/classes arrays)
         const limit = num(p.limit, undefined);
         let note;
         if (limit && limit > 0 && p.detailed && result.files) {
-            let totalEntries = result.files.reduce((s, f) => s + (f.functions?.length || 0) + (f.classes?.length || 0), 0);
+            let totalEntries = result.files.reduce((s, f) => {
+                const syms = f.symbols || {};
+                return s + (syms.functions?.length || 0) + (syms.classes?.length || 0);
+            }, 0);
             if (totalEntries > limit) {
                 let remaining = limit;
                 for (const f of result.files) {
+                    const syms = f.symbols || {};
                     if (remaining <= 0) {
-                        f.functions = [];
-                        f.classes = [];
+                        if (syms.functions) syms.functions = [];
+                        if (syms.classes) syms.classes = [];
+                        f.functions = 0;
+                        f.classes = 0;
                         continue;
                     }
-                    const fns = f.functions?.length || 0;
-                    const cls = f.classes?.length || 0;
+                    const fns = syms.functions?.length || 0;
+                    const cls = syms.classes?.length || 0;
                     if (fns + cls <= remaining) {
                         remaining -= fns + cls;
                     } else {
-                        if (f.functions && remaining > 0) {
-                            f.functions = f.functions.slice(0, remaining);
-                            remaining -= f.functions.length;
+                        if (syms.functions && remaining > 0) {
+                            syms.functions = syms.functions.slice(0, remaining);
+                            remaining -= syms.functions.length;
+                            f.functions = syms.functions.length;
                         }
-                        if (f.classes && remaining > 0) {
-                            f.classes = f.classes.slice(0, remaining);
-                            remaining -= f.classes.length;
-                        } else if (f.classes) {
-                            f.classes = [];
+                        if (syms.classes && remaining > 0) {
+                            syms.classes = syms.classes.slice(0, remaining);
+                            remaining -= syms.classes.length;
+                            f.classes = syms.classes.length;
+                        } else if (syms.classes) {
+                            syms.classes = [];
+                            f.classes = 0;
                         }
                     }
                 }
@@ -549,7 +548,7 @@ const HANDLERS = {
     deadcode: (index, p) => {
         const fileErr = checkFilePatternMatch(index, p.file);
         if (fileErr) return { ok: false, error: fileErr };
-        const result = index.deadcode({
+        let result = index.deadcode({
             includeExported: p.includeExported || false,
             includeDecorated: p.includeDecorated || false,
             includeTests: p.includeTests || false,
@@ -557,15 +556,16 @@ const HANDLERS = {
             in: p.in,
             file: p.file,
         });
-        // Apply limit to dead code results
+        // Apply limit to dead code results (result is an array with custom properties)
         const limit = num(p.limit, undefined);
         let note;
-        if (limit && limit > 0 && result.dead) {
-            const { items, total, limited } = applyLimit(result.dead, limit);
-            if (limited) {
-                note = limitNote(limit, total);
-                result.dead = items;
-            }
+        if (limit && limit > 0 && Array.isArray(result) && result.length > limit) {
+            note = limitNote(limit, result.length);
+            const sliced = result.slice(0, limit);
+            // Preserve custom properties (excludedExported, excludedDecorated) from deadcode()
+            if (result.excludedExported != null) sliced.excludedExported = result.excludedExported;
+            if (result.excludedDecorated != null) sliced.excludedDecorated = result.excludedDecorated;
+            result = sliced;
         }
         return { ok: true, result, note };
     },
@@ -866,7 +866,7 @@ const HANDLERS = {
         const err = requireName(p.name);
         if (err) return { ok: false, error: err };
         applyClassMethodSyntax(p);
-        const result = index.typedef(p.name, { exact: p.exact || false, className: p.className });
+        const result = index.typedef(p.name, { exact: p.exact || false, className: p.className, file: p.file });
         return { ok: true, result };
     },
 

package/core/output.js

@@ -392,7 +392,7 @@ function formatSearchJson(results, term) {
     const meta = results.meta;
     const obj = {
         term,
-        totalMatches: results.reduce((sum, r) => sum + r.matches.length, 0),
+        totalMatches: (meta && meta.totalMatches != null) ? meta.totalMatches : results.reduce((sum, r) => sum + r.matches.length, 0),
         files: results.map(r => ({
             file: r.file,
             matchCount: r.matches.length,
@@ -407,6 +407,7 @@ function formatSearchJson(results, term) {
         obj.filesSkipped = meta.filesSkipped;
         obj.totalFiles = meta.totalFiles;
         if (meta.regexFallback) obj.regexFallback = meta.regexFallback;
+        if (meta.truncatedMatches > 0) obj.truncatedMatches = meta.truncatedMatches;
     }
     return JSON.stringify(obj, null, 2);
 }
@@ -839,7 +840,7 @@ function formatTrace(trace, options = {}) {
     }
 
     if (trace.includeMethods === false) {
-        const methodsHint = options.methodsHint || 'Note: obj.method() calls excluded (--include-methods=false). Remove flag to include them (default).';
+        const methodsHint = options.methodsHint || 'Note: obj.method() calls excluded — use --include-methods to include them';
         lines.push(`\n${methodsHint}`);
     }
 
@@ -1634,7 +1635,7 @@ function formatAbout(about, options = {}) {
     }
 
     if (about.includeMethods === false) {
-        const methodsHint = options.methodsHint || 'Note: obj.method() callers/callees excluded (--include-methods=false). Remove flag to include them (default).';
+        const methodsHint = options.methodsHint || 'Note: obj.method() callers/callees excluded — use --include-methods to include them';
         lines.push(`\n${methodsHint}`);
     }
 
@@ -2322,7 +2323,7 @@ function formatCircularDeps(result) {
         lines.push(`Filtered to cycles involving: ${result.fileFilter}`);
     }
 
-    const scannedCount = result.filesWithImports || result.totalFiles;
+    const scannedCount = result.filesWithImports != null ? result.filesWithImports : result.totalFiles;
 
     if (result.cycles.length === 0) {
         lines.push('');
@@ -2413,7 +2414,7 @@ function formatSearch(results, term) {
     }
 
     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).`);
+        lines.push(`\nNote: ${meta.filesSkipped} test file${meta.filesSkipped === 1 ? '' : 's'} hidden by default (use include_tests=true to include).`);
     }
 
     return lines.join('\n');

package/core/project.js

@@ -365,7 +365,9 @@ class ProjectIndex {
                 ...(item.memberType && { memberType: item.memberType }),
                 ...(item.fieldType && { fieldType: item.fieldType }),
                 ...(item.decorators && item.decorators.length > 0 && { decorators: item.decorators }),
-                ...(item.nameLine && { nameLine: item.nameLine })
+                ...(item.nameLine && { nameLine: item.nameLine }),
+                ...(item.traitImpl && { traitImpl: true }),
+                ...(item.isSignature && { isSignature: true })
             };
             fileEntry.symbols.push(symbol);
             fileEntry.bindings.push({
@@ -396,7 +398,7 @@ class ProjectIndex {
             if (cls.members) {
                 for (const m of cls.members) {
                     const memberType = m.memberType || 'method';
-                    addSymbol({ ...m, className: cls.name }, memberType);
+                    addSymbol({ ...m, className: cls.name, ...(cls.traitName && { traitImpl: true }) }, memberType);
                 }
             }
         }
@@ -780,6 +782,8 @@ class ProjectIndex {
         // Check inclusion (directory or file path)
         if (filters.in) {
             const inPattern = filters.in.replace(/\/$/, ''); // strip trailing slash
+            // '.' means current directory = entire project, always matches
+            if (inPattern === '.') return true;
             // Detect if pattern looks like a file path (has an extension)
             const looksLikeFile = /\.\w+$/.test(inPattern);
             if (looksLikeFile) {
@@ -908,6 +912,13 @@ class ProjectIndex {
             if (/^(lib|src|core|internal|pkg|crates)\//i.test(rp)) {
                 score += 200;
             }
+            // Deprioritize type-only overload signatures (TypeScript function_signature)
+            if (d.isSignature) score -= 200;
+            // Prefer larger function bodies (implementation over overload signature)
+            // Only for functions/methods — not for class-level types (struct vs impl)
+            if (d.startLine && d.endLine && d.type === 'function') {
+                score += Math.min(d.endLine - d.startLine, 100);
+            }
             return { def: d, score };
         });
 
@@ -1257,11 +1268,17 @@ class ProjectIndex {
         try {
         const usages = [];
 
+        // Resolve file pattern for --file filter
+        const fileFilter = options.file ? this.resolveFilePathForQuery(options.file) : null;
+
         // Get definitions (filtered)
         let allDefinitions = this.symbols.get(name) || [];
         if (options.className) {
             allDefinitions = allDefinitions.filter(d => d.className === options.className);
         }
+        if (fileFilter) {
+            allDefinitions = allDefinitions.filter(d => d.file === fileFilter);
+        }
         const definitions = options.exclude || options.in
             ? allDefinitions.filter(d => this.matchesFilters(d.relativePath, options))
             : allDefinitions;
@@ -1278,6 +1295,10 @@ class ProjectIndex {
 
         // Scan all files for usages
         for (const [filePath, fileEntry] of this.files) {
+            // Apply --file filter
+            if (fileFilter && filePath !== fileFilter) {
+                continue;
+            }
             // Apply filters
             if (!this.matchesFilters(fileEntry.relativePath, options)) {
                 continue;
@@ -2247,7 +2268,7 @@ class ProjectIndex {
      * @returns {Array} Matching type definitions
      */
     typedef(name, options = {}) {
-        const typeKinds = ['type', 'interface', 'enum', 'struct', 'trait', 'class'];
+        const typeKinds = ['type', 'interface', 'enum', 'struct', 'trait', 'class', 'record'];
         const matches = this.find(name, options);
 
         return matches.filter(m => typeKinds.includes(m.type)).map(m => ({
@@ -2277,6 +2298,15 @@ class ProjectIndex {
         for (const [filePath, fileEntry] of this.files) {
             if (isTestFile(fileEntry.relativePath, fileEntry.language)) {
                 testFiles.push({ path: filePath, entry: fileEntry });
+            } else if (fileEntry.language === 'rust') {
+                // Rust idiomatically puts tests in #[cfg(test)] modules inside source files.
+                // Check if file has any symbols with 'test' modifier (#[test] attribute).
+                const hasInlineTests = fileEntry.symbols?.some(s =>
+                    s.modifiers?.includes('test')
+                );
+                if (hasInlineTests) {
+                    testFiles.push({ path: filePath, entry: fileEntry });
+                }
             }
         }
 
@@ -2592,6 +2622,75 @@ class ProjectIndex {
             }
         }
 
+        // Python __all__ re-exports: names listed in __all__ that come from imports
+        // e.g. __init__.py: `from .utils import helper` + `__all__ = ["helper"]`
+        // `helper` is in fileEntry.exports but not in fileEntry.symbols
+        if (fileEntry.language === 'python' && fileEntry.exports.length > 0) {
+            const matchedNames = new Set(results.map(r => r.name));
+            const unmatched = fileEntry.exports.filter(name => !matchedNames.has(name));
+            if (unmatched.length > 0) {
+                // Re-extract raw imports to get name→module mapping (not stored in fileEntry)
+                const { extractImports, resolveImport } = require('./imports');
+                try {
+                    const content = this._readFile(absPath);
+                    const { imports: rawImports } = extractImports(content, 'python');
+                    // Build name→module map from raw imports
+                    const nameToModule = new Map();
+                    for (const imp of rawImports) {
+                        if (imp.names) {
+                            for (const name of imp.names) {
+                                if (name !== '*') nameToModule.set(name, imp.module);
+                            }
+                        }
+                    }
+                    for (const name of unmatched) {
+                        const sourceModule = nameToModule.get(name);
+                        if (!sourceModule) continue;
+                        const resolvedSrc = resolveImport(sourceModule, absPath, {
+                            language: 'python',
+                            root: this.root,
+                            extensions: this.extensions
+                        });
+                        if (!resolvedSrc) continue;
+                        const sourceEntry = this.files.get(resolvedSrc);
+                        const srcSymbol = sourceEntry && sourceEntry.symbols.find(s => s.name === name);
+                        if (srcSymbol) {
+                            matchedNames.add(name);
+                            results.push({
+                                name,
+                                type: srcSymbol.type,
+                                file: fileEntry.relativePath,
+                                startLine: srcSymbol.startLine,
+                                endLine: srcSymbol.endLine,
+                                params: srcSymbol.params,
+                                returnType: srcSymbol.returnType,
+                                signature: this.formatSignature(srcSymbol),
+                                reExportedFrom: sourceEntry.relativePath
+                            });
+                        } else {
+                            // Source not indexed or symbol not found — still list it
+                            matchedNames.add(name);
+                            results.push({
+                                name,
+                                type: 're-export',
+                                file: fileEntry.relativePath,
+                                startLine: undefined,
+                                endLine: undefined,
+                                params: undefined,
+                                returnType: null,
+                                signature: `re-export ${name} from '${sourceModule}'`,
+                                reExportedFrom: resolvedSrc
+                                    ? (sourceEntry ? sourceEntry.relativePath : resolvedSrc)
+                                    : sourceModule
+                            });
+                        }
+                    }
+                } catch (_) {
+                    // File read failure — skip Python re-export resolution
+                }
+            }
+        }
+
         return results;
     }
 
@@ -3181,8 +3280,8 @@ class ProjectIndex {
                                                     const content = this._readFile(c.callerFile);
                                                     const lines = content.split('\n');
                                                     const line = lines[call.line - 1] || '';
-                                                    // Match "var = ClassName(...)"
-                                                    const m = line.match(/^\s*(\w+)\s*=\s*(?:await\s+)?(\w+)\s*\(/);
+                                                    // Match "var = ClassName(...)" or "var = new ClassName(...)" or "Type var = new ClassName<>(...)"
+                                                    const m = line.match(/(\w+)\s*=\s*(?:await\s+)?(?:new\s+)?(\w+)\s*(?:<[^>]*>)?\s*\(/);
                                                     if (m && m[2] === call.name) {
                                                         localTypes.set(m[1], call.name);
                                                     }
@@ -3198,6 +3297,31 @@ class ProjectIndex {
                             }
                         }
                     }
+                    // Check class field declarations for receiver type: private DataService service
+                    if (c.callerFile) {
+                        const callerEnclosing = this.findEnclosingFunction(c.callerFile, c.line, true);
+                        if (callerEnclosing?.className) {
+                            const classSyms = this.symbols.get(callerEnclosing.className);
+                            if (classSyms) {
+                                const classDef = classSyms.find(s => s.type === 'class' || s.type === 'struct' || s.type === 'interface');
+                                if (classDef) {
+                                    const content = this._readFile(c.callerFile);
+                                    const lines = content.split('\n');
+                                    // Scan class body for field declarations matching the receiver
+                                    for (let li = classDef.startLine - 1; li < (classDef.endLine || classDef.startLine + 50) && li < lines.length; li++) {
+                                        const line = lines[li];
+                                        // Match Java/TS field: [modifiers] TypeName<...> receiverName [= ...]
+                                        const fieldMatch = line.match(new RegExp(`\\b(\\w+)(?:<[^>]*>)?\\s+${r.replace(/[.*+?^${}()|[\]\\]/g, '\\\\$&')}\\s*[;=]`));
+                                        if (fieldMatch) {
+                                            const fieldType = fieldMatch[1];
+                                            if (fieldType === targetClassName) return true;
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
                     // Check parameter type annotations: def foo(tracker: SourceTracker) → tracker.record()
                     if (c.callerFile && c.callerStartLine) {
                         const callerSymbol = this.findEnclosingFunction(c.callerFile, c.line, true);
@@ -3357,7 +3481,7 @@ class ProjectIndex {
                 const classNames = [...new Set(allDefs
                     .filter(d => d.className && d.className !== def.className)
                     .map(d => d.className))];
-                if (classNames.length > 0) {
+                if (classNames.length > 0 && !options.className && !options.file) {
                     scopeWarning = {
                         targetClass: def.className || '(unknown)',
                         otherClasses: classNames,
@@ -3678,6 +3802,19 @@ class ProjectIndex {
                         node.entryPoint = true;
                         entryPoints.push({ name: funcDef.name, file: funcDef.relativePath, line: funcDef.startLine });
                     }
+                } else if (currentDepth > 0) {
+                    // At depth limit: check if this node is an entry point
+                    const callers = this.findCallers(funcDef.name, {
+                        includeMethods,
+                        includeUncertain,
+                        targetDefinitions: funcDef.bindingId ? [funcDef] : undefined,
+                    });
+                    const hasCallers = callers.some(c => c.callerName &&
+                        (exclude.length === 0 || this.matchesFilters(c.relativePath, { exclude })));
+                    if (!hasCallers) {
+                        node.entryPoint = true;
+                        entryPoints.push({ name: funcDef.name, file: funcDef.relativePath, line: funcDef.startLine });
+                    }
                 }
 
                 return node;
@@ -3764,7 +3901,12 @@ class ProjectIndex {
             const excludeArr = exclude ? (Array.isArray(exclude) ? exclude : [exclude]) : [];
             const results = [];
             for (const [filePath, fileEntry] of this.files) {
-                if (!isTestFile(fileEntry.relativePath, fileEntry.language)) continue;
+                let isTest = isTestFile(fileEntry.relativePath, fileEntry.language);
+                // Rust inline #[cfg(test)] modules: source files with #[test]-marked symbols
+                if (!isTest && fileEntry.language === 'rust') {
+                    isTest = fileEntry.symbols?.some(s => s.modifiers?.includes('test'));
+                }
+                if (!isTest) continue;
                 if (excludeArr.length > 0 && !this.matchesFilters(fileEntry.relativePath, { exclude: excludeArr })) continue;
                 try {
                     const content = this._readFile(filePath);
@@ -4082,6 +4224,7 @@ class ProjectIndex {
         const results = [];
         let filesScanned = 0;
         let filesSkipped = 0;
+        let filesFilteredByFlag = 0;
         const regexFlags = options.caseSensitive ? 'g' : 'gi';
         const useRegex = options.regex !== false; // Default: regex ON
         let regex;
@@ -4103,7 +4246,7 @@ class ProjectIndex {
             if (options.file) {
                 const fp = fileEntry.relativePath;
                 if (!fp.includes(options.file) && !fp.endsWith(options.file)) {
-                    filesSkipped++;
+                    filesFilteredByFlag++;
                     continue;
                 }
             }
@@ -4228,7 +4371,7 @@ class ProjectIndex {
             results.push(...truncated);
         }
 
-        results.meta = { filesScanned, filesSkipped, totalFiles: this.files.size, regexFallback, totalMatches, truncatedMatches };
+        results.meta = { filesScanned, filesSkipped, filesFilteredByFlag, totalFiles: this.files.size, regexFallback, totalMatches, truncatedMatches };
         return results;
         } finally { this._endOp(); }
     }
@@ -4330,7 +4473,7 @@ class ProjectIndex {
                 }
             } else {
                 // Search symbols (functions, classes, methods, types)
-                const functionTypes = new Set(['function', 'constructor', 'method', 'arrow', 'static', 'classmethod']);
+                const functionTypes = new Set(['function', 'constructor', 'method', 'arrow', 'static', 'classmethod', 'abstract']);
                 const classTypes = new Set(['class', 'struct', 'interface', 'impl', 'trait']);
                 const typeTypes = new Set(['type', 'enum', 'interface', 'trait']);
                 const methodTypes = new Set(['method', 'constructor']);
@@ -4361,6 +4504,11 @@ class ProjectIndex {
                             if (!hasMatch) continue;
                         }
 
+                        // Receiver filter: match className for methods
+                        if (receiver) {
+                            if (!def.className || !matchesSubstring(def.className, receiver, options.caseSensitive)) continue;
+                        }
+
                         // Return type filter
                         if (returnType) {
                             if (!def.returnType || !matchesSubstring(def.returnType, returnType, options.caseSensitive)) continue;
@@ -4546,6 +4694,9 @@ class ProjectIndex {
 
         for (const [filePath, fileEntry] of this.files) {
             if (fileFilter && !fileFilter.has(filePath)) continue;
+            if (options.exclude && options.exclude.length > 0) {
+                if (!this.matchesFilters(fileEntry.relativePath, { exclude: options.exclude })) 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/shared.js

@@ -19,6 +19,8 @@ function pickBestDefinition(matches) {
         if (isTestFile(rp, detectLanguage(m.file))) score -= 500;
         if (/^(examples?|docs?|vendor|third[_-]?party|benchmarks?|samples?)\//i.test(rp)) score -= 300;
         if (/^(lib|src|core|internal|pkg|crates)\//i.test(rp)) score += 200;
+        // Deprioritize type-only overload signatures (TypeScript function_signature)
+        if (m.isSignature) score -= 200;
         // Tiebreaker: prefer larger function bodies (more important/complex)
         if (m.startLine && m.endLine) {
             score += Math.min(m.endLine - m.startLine, 100);

package/core/verify.js

@@ -29,11 +29,17 @@ function findCallNode(node, callTypes, targetRow, funcName) {
             }
         } else {
             // Check if this call is for our target function
-            const funcNode = node.childForFieldName('function') ||
+            let funcNode = node.childForFieldName('function') ||
                              node.childForFieldName('name'); // Java method_invocation uses 'name'
+            // Unwrap turbofish/generic_function: process::<T>() wraps the function in generic_function
+            if (funcNode && funcNode.type === 'generic_function') {
+                funcNode = funcNode.childForFieldName('function') || funcNode.namedChild(0);
+            }
             if (funcNode) {
                 const funcText = funcNode.type === 'member_expression' || funcNode.type === 'selector_expression' || funcNode.type === 'field_expression' || funcNode.type === 'attribute'
                     ? (funcNode.childForFieldName('property') || funcNode.childForFieldName('field') || funcNode.childForFieldName('attribute') || funcNode.namedChild(funcNode.namedChildCount - 1))?.text
+                    : funcNode.type === 'scoped_identifier'
+                    ? (funcNode.childForFieldName('name') || funcNode.namedChild(funcNode.namedChildCount - 1))?.text
                     : funcNode.text;
                 if (funcText === funcName) return node;
             }
@@ -190,7 +196,7 @@ function verify(index, name, options = {}) {
     let params = def.paramsStructured || [];
     if ((lang === 'python' || lang === 'rust') && params.length > 0) {
         const firstName = params[0].name;
-        if (firstName === 'self' || firstName === 'cls' || firstName === '&self' || firstName === '&mut self') {
+        if (firstName === 'self' || firstName === 'cls' || firstName === '&self' || firstName === '&mut self' || firstName === 'mut self') {
             params = params.slice(1);
         }
     }
@@ -420,7 +426,7 @@ function verify(index, name, options = {}) {
             const classNames = [...new Set(allDefs
                 .filter(d => d.className && d.className !== def.className)
                 .map(d => d.className))];
-            if (classNames.length > 0) {
+            if (classNames.length > 0 && !options.className && !options.file) {
                 scopeWarning = {
                     targetClass: def.className || '(unknown)',
                     otherClasses: classNames,
@@ -494,31 +500,39 @@ function plan(index, name, options = {}) {
             ...(options.defaultValue && { default: options.defaultValue })
         };
 
-        // 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);
+        // When adding a param, insert before rest params (*args/**kwargs) and
+        // before optional params (required must precede optional in Python/TS).
+        {
+            const selfNames = ['self', 'cls', '&self', '&mut self', 'mut self'];
+            const minIdx = (newParams.length > 0 && selfNames.includes(newParams[0].name)) ? 1 : 0;
+            const firstRestIdx = newParams.findIndex(p => p.rest || (p.name && (p.name.startsWith('*') || p.name.startsWith('...'))));
+            if (firstRestIdx !== -1) {
+                // Always insert before rest params (*args, **kwargs, ...rest)
+                const insertIdx = Math.max(firstRestIdx, minIdx);
                 newParams.splice(insertIdx, 0, newParam);
+            } else if (!options.defaultValue) {
+                const firstOptIdx = newParams.findIndex(p => p.optional || p.default !== undefined);
+                if (firstOptIdx !== -1) {
+                    const insertIdx = Math.max(firstOptIdx, minIdx);
+                    newParams.splice(insertIdx, 0, newParam);
+                } else {
+                    newParams.push(newParam);
+                }
             } else {
                 newParams.push(newParam);
             }
-        } else {
-            newParams.push(newParam);
         }
 
         // Generate new signature
         const paramsList = newParams.map(p => {
-            let str = p.name;
+            let str = (p.rest && !p.name.startsWith('*')) ? `...${p.name}` : p.name;
+            if (p.optional && !p.default) str += '?';
             if (p.type) str += `: ${p.type}`;
             if (p.default) str += ` = ${p.default}`;
             return str;
         }).join(', ');
-        newSignature = `${name}(${paramsList})`;
+        const asyncPrefix = (def.async || def.isAsync || def.modifiers?.includes('async')) ? 'async ' : '';
+        newSignature = `${asyncPrefix}${name}(${paramsList})`;
         if (def.returnType) newSignature += `: ${def.returnType}`;
 
         // Describe changes needed at each call site
@@ -540,7 +554,13 @@ function plan(index, name, options = {}) {
 
     if (options.removeParam) {
         operation = 'remove-param';
-        const paramIndex = currentParams.findIndex(p => p.name === options.removeParam);
+        // Normalize self-parameter lookup: 'self' matches '&self', '&mut self', 'mut self'
+        let removeTarget = options.removeParam;
+        let paramIndex = currentParams.findIndex(p => p.name === removeTarget);
+        if (paramIndex === -1 && removeTarget === 'self') {
+            paramIndex = currentParams.findIndex(p => /^&?(?:mut )?self$/.test(p.name));
+            if (paramIndex !== -1) removeTarget = currentParams[paramIndex].name;
+        }
         if (paramIndex === -1) {
             return {
                 found: true,
@@ -549,16 +569,18 @@ function plan(index, name, options = {}) {
             };
         }
 
-        newParams = currentParams.filter(p => p.name !== options.removeParam);
+        newParams = currentParams.filter(p => p.name !== removeTarget);
 
         // Generate new signature
         const paramsList = newParams.map(p => {
-            let str = p.name;
+            let str = (p.rest && !p.name.startsWith('*')) ? `...${p.name}` : p.name;
+            if (p.optional && !p.default) str += '?';
             if (p.type) str += `: ${p.type}`;
             if (p.default) str += ` = ${p.default}`;
             return str;
         }).join(', ');
-        newSignature = `${name}(${paramsList})`;
+        const asyncPrefix = (def.async || def.isAsync || def.modifiers?.includes('async')) ? 'async ' : '';
+        newSignature = `${asyncPrefix}${name}(${paramsList})`;
         if (def.returnType) newSignature += `: ${def.returnType}`;
 
         // For Python/Rust methods, self/cls/&self/&mut self is in paramsStructured
@@ -568,7 +590,7 @@ function plan(index, name, options = {}) {
         let selfOffset = 0;
         if ((lang === 'python' || lang === 'rust') && currentParams.length > 0) {
             const firstName = currentParams[0].name;
-            if (firstName === 'self' || firstName === 'cls' || firstName === '&self' || firstName === '&mut self') {
+            if (firstName === 'self' || firstName === 'cls' || firstName === '&self' || firstName === '&mut self' || firstName === 'mut self') {
                 selfOffset = 1;
             }
         }
@@ -643,11 +665,21 @@ function plan(index, name, options = {}) {
         operation,
         before: {
             signature: currentSignature,
-            params: currentParams.map(p => p.name)
+            params: currentParams.map(p => {
+                let n = p.name;
+                if (p.optional && !p.default) n += '?';
+                if (p.type) n += `: ${p.type}`;
+                return n;
+            })
         },
         after: {
             signature: newSignature,
-            params: newParams.map(p => p.name)
+            params: newParams.map(p => {
+                let n = p.name;
+                if (p.optional && !p.default) n += '?';
+                if (p.type) n += `: ${p.type}`;
+                return n;
+            })
         },
         totalChanges: changes.length,
         filesAffected: new Set(changes.map(c => c.file)).size,

package/languages/go.js

@@ -290,6 +290,7 @@ function extractInterfaceMembers(interfaceNode, code) {
             // Name is in a field_identifier child
             let nameText = null;
             let paramsText = null;
+            let paramsNode = null;
             let returnType = null;
             let hasParams = false;
             for (let j = 0; j < child.namedChildCount; j++) {
@@ -300,6 +301,7 @@ function extractInterfaceMembers(interfaceNode, code) {
                     hasParams = true;
                     if (!paramsText) {
                         paramsText = sub.text.slice(1, -1); // strip parens
+                        paramsNode = sub;
                     } else {
                         // Second parameter_list is the return type tuple
                         returnType = sub.text;
@@ -312,10 +314,15 @@ function extractInterfaceMembers(interfaceNode, code) {
                 if (nameNode) nameText = nameNode.text;
             }
             if (!returnType) {
-                // Single return type (not a tuple) is a type_identifier
+                // Single return type — can be type_identifier, pointer_type, slice_type, map_type, etc.
+                const returnTypeNodes = new Set([
+                    'type_identifier', 'pointer_type', 'slice_type', 'map_type',
+                    'array_type', 'channel_type', 'function_type', 'interface_type',
+                    'struct_type', 'generic_type', 'qualified_type',
+                ]);
                 for (let j = 0; j < child.namedChildCount; j++) {
                     const sub = child.namedChild(j);
-                    if (sub.type === 'type_identifier' && sub.text !== nameText) {
+                    if (returnTypeNodes.has(sub.type) && sub.text !== nameText) {
                         returnType = sub.text;
                     }
                 }
@@ -341,6 +348,7 @@ function extractInterfaceMembers(interfaceNode, code) {
                         endLine,
                         memberType: 'method',
                         ...(paramsText !== null && { params: paramsText }),
+                        ...(paramsNode && { paramsStructured: parseStructuredParams(paramsNode, 'go') }),
                         ...(returnType && { returnType })
                     });
                 }

package/languages/java.js

@@ -51,7 +51,11 @@ function extractModifiers(node) {
             if (mod.type === 'marker_annotation' || mod.type === 'annotation') {
                 // Store annotation name (without @) as modifier (e.g., @Test -> 'test', @Override -> 'override')
                 const annoText = mod.text.replace(/^@/, '').split('(')[0].toLowerCase();
-                modifiers.push(annoText);
+                // Skip noise annotations that don't carry semantic meaning
+                const SKIP_ANNOTATIONS = new Set(['suppresswarnings', 'safevarargs', 'serial', 'generated']);
+                if (!SKIP_ANNOTATIONS.has(annoText)) {
+                    modifiers.push(annoText);
+                }
                 continue;
             }
             modifiers.push(mod.text);
@@ -59,10 +63,11 @@ function extractModifiers(node) {
     }
 
     // Also check text before parameter list for modifiers (avoid matching keywords in params)
+    // Use the parameters node position to find the real paren (not annotation parens)
     const text = node.text;
-    const firstLine = text.split('\n')[0];
-    const parenIdx = firstLine.indexOf('(');
-    const preParams = parenIdx >= 0 ? firstLine.substring(0, parenIdx) : firstLine;
+    const paramsNode = node.childForFieldName('parameters');
+    const paramOffset = paramsNode ? paramsNode.startIndex - node.startIndex : -1;
+    const preParams = paramOffset >= 0 ? text.substring(0, paramOffset) : text.split('\n').slice(0, 3).join(' ');
     const keywords = ['public', 'private', 'protected', 'static', 'final', 'abstract', 'synchronized', 'native', 'default'];
     for (const kw of keywords) {
         if (preParams.includes(kw + ' ') && !modifiers.includes(kw)) {
@@ -130,10 +135,10 @@ function findFunctions(code, parser) {
             if (processedRanges.has(rangeKey)) return true;
             processedRanges.add(rangeKey);
 
-            // Skip methods inside a class body (they're extracted as class members)
+            // Skip methods inside a class/interface/enum body (they're extracted as class members)
             let parent = node.parent;
-            if (parent && parent.type === 'class_body') {
-                return true;  // Skip - this is a class method
+            if (parent && (parent.type === 'class_body' || parent.type === 'interface_body' || parent.type === 'enum_body' || parent.type === 'enum_body_declarations')) {
+                return true;  // Skip - this is a class/interface/enum method
             }
 
             const nameNode = node.childForFieldName('name');
@@ -172,10 +177,10 @@ function findFunctions(code, parser) {
             if (processedRanges.has(rangeKey)) return true;
             processedRanges.add(rangeKey);
 
-            // Skip constructors inside a class body (they're extracted as class members)
+            // Skip constructors inside a class/enum body (they're extracted as class members)
             let parent = node.parent;
-            if (parent && parent.type === 'class_body') {
-                return true;  // Skip - this is a class constructor
+            if (parent && (parent.type === 'class_body' || parent.type === 'enum_body' || parent.type === 'enum_body_declarations')) {
+                return true;  // Skip - this is a class/enum constructor
             }
 
             const nameNode = node.childForFieldName('name');
@@ -524,6 +529,7 @@ function extractClassMembers(classNode, code) {
     const members = [];
     const bodyNode = classNode.childForFieldName('body');
     if (!bodyNode) return members;
+    const isInterface = bodyNode.type === 'interface_body';
 
     for (let i = 0; i < bodyNode.namedChildCount; i++) {
         const child = bodyNode.namedChild(i);
@@ -536,6 +542,13 @@ function extractClassMembers(classNode, code) {
             if (nameNode) {
                 const { startLine, endLine } = nodeToLocation(child, code);
                 const modifiers = extractModifiers(child);
+                // Interface methods are implicitly public and abstract in Java
+                if (isInterface) {
+                    if (!modifiers.includes('public')) modifiers.push('public');
+                    if (!modifiers.includes('abstract') && !modifiers.includes('default') && !modifiers.includes('static')) {
+                        modifiers.push('abstract');
+                    }
+                }
                 const returnType = extractReturnType(child);
                 const docstring = extractJavaDocstring(code, startLine);
                 const nameLine = nameNode.startPosition.row + 1;

package/languages/javascript.js

@@ -181,6 +181,7 @@ function findFunctions(code, parser) {
                     indent,
                     isArrow: false,
                     isGenerator: false,
+                    isSignature: true,
                     modifiers: [],
                     ...(returnType && { returnType }),
                     ...(generics && { generics }),
@@ -1950,6 +1951,13 @@ function findExportsInCode(code, parser) {
                         exports.push({ name: propNode.text, type: 'exports', line });
                         return true;
                     }
+
+                    // module.exports.name = ...
+                    if (objNode.type === 'member_expression' && objNode.text === 'module.exports') {
+                        const line = node.startPosition.row + 1;
+                        exports.push({ name: propNode.text, type: 'module.exports', line });
+                        return true;
+                    }
                 }
             }
             return true;

package/languages/python.js

@@ -231,6 +231,10 @@ function extractBases(classNode) {
             const arg = argsNode.namedChild(i);
             if (arg.type === 'identifier' || arg.type === 'attribute') {
                 bases.push(arg.text);
+            } else if (arg.type === 'subscript') {
+                // Parameterized base: Generic[T], Protocol[T], Dict[str, int]
+                const baseNode = arg.childForFieldName('value');
+                if (baseNode) bases.push(baseNode.text);
             }
         }
     }

package/languages/rust.js

@@ -77,7 +77,11 @@ function extractAttributes(node, code) {
                 const attrContent = match[1];
                 // Get just the attribute name (without arguments)
                 const attrName = attrContent.split('(')[0].trim();
-                attributes.push(attrName);
+                // Skip compiler hint attributes that aren't semantically meaningful for display
+                const SKIP_ATTRS = new Set(['allow', 'deny', 'warn', 'forbid', 'cfg_attr', 'doc']);
+                if (!SKIP_ATTRS.has(attrName)) {
+                    attributes.push(attrName);
+                }
             }
         } else if (!line.startsWith('//')) {
             // Stop at non-comment, non-attribute lines
@@ -491,19 +495,25 @@ function extractImplInfo(implNode) {
         typeName = typeNode.text;
     }
 
-    const prefix = typeParams ? `${typeParams} ` : '';
+    // Strip generic type arguments from typeName and traitName for lookup
+    // e.g., "CacheService<T>" → "CacheService", "Entity" stays "Entity"
+    const stripGenerics = (s) => s ? s.replace(/<[^>]*>/g, '').trim() : s;
+    const bareTypeName = stripGenerics(typeName);
+    const bareTraitName = stripGenerics(traitName);
+
     let name;
-    if (traitName && typeName) {
-        name = `${prefix}${traitName} for ${typeName}`;
-    } else if (typeName) {
-        name = `${prefix}${typeName}`;
+    if (bareTraitName && bareTypeName) {
+        // Use the concrete type as className so Task.get_id works for `impl Entity for Task`
+        name = bareTypeName;
+    } else if (bareTypeName) {
+        name = bareTypeName;
     } else {
         const text = implNode.text;
         const match = text.match(/impl\s*(?:<[^>]+>\s*)?(\w+(?:\s+for\s+\w+)?)/);
-        name = match ? `${prefix}${match[1]}` : 'impl';
+        name = match ? match[1] : 'impl';
     }
 
-    return { name, traitName, typeName };
+    return { name, traitName, typeName: bareTypeName, generics: typeParams || undefined };
 }
 
 /**
@@ -565,7 +575,9 @@ function extractTraitMembers(traitNode, code) {
                     endLine,
                     memberType: 'method',
                     isMethod: true,
+                    modifiers: ['public'], // Trait methods are implicitly public
                     ...(paramsNode && { params: extractRustParams(paramsNode) }),
+                    ...(paramsNode && { paramsStructured: parseStructuredParams(paramsNode, 'rust') }),
                     ...(returnType && { returnType }),
                     ...(hasSelf && { receiver: 'self' })
                 });

package/languages/utils.js

@@ -100,9 +100,37 @@ function parseJSParam(param, info) {
     } else if (param.type === 'required_parameter' || param.type === 'optional_parameter') {
         const patternNode = param.childForFieldName('pattern');
         const typeNode = param.childForFieldName('type');
-        if (patternNode) info.name = patternNode.text;
+        if (patternNode) {
+            // Check if pattern is a rest_pattern (e.g., ...args inside required_parameter)
+            if (patternNode.type === 'rest_pattern') {
+                const innerName = patternNode.namedChild(0);
+                info.name = innerName ? innerName.text : patternNode.text.replace(/^\.\.\./, '');
+                info.rest = true;
+            } else {
+                info.name = patternNode.text;
+            }
+        }
         if (typeNode) info.type = typeNode.text.replace(/^:\s*/, '');
         if (param.type === 'optional_parameter') info.optional = true;
+        // Check for default value (e.g., priority: number = 1)
+        const valueNode = param.childForFieldName('value');
+        if (valueNode) {
+            info.default = valueNode.text;
+            info.optional = true;
+        } else if (!info.rest) {
+            // Also check for bare number/string/etc. children as defaults
+            for (let i = 0; i < param.namedChildCount; i++) {
+                const child = param.namedChild(i);
+                if (child !== patternNode && child !== (typeNode && typeNode.parent === param ? typeNode : null) &&
+                    child.type !== 'type_annotation' && child.type !== 'rest_pattern' &&
+                    !['identifier', 'type_annotation'].includes(child.type)) {
+                    // This is likely a default value node
+                    info.default = child.text;
+                    info.optional = true;
+                    break;
+                }
+            }
+        }
     } else if (param.type === 'rest_parameter' || param.type === 'rest_pattern') {
         // rest_parameter = TypeScript, rest_pattern = JavaScript
         const patternNode = param.childForFieldName('pattern') || param.namedChild(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucn",
-  "version": "3.8.3",
+  "version": "3.8.4",
   "mcpName": "io.github.mleoca/ucn",
   "description": "Code intelligence toolkit for AI agents — extract functions, trace call chains, find callers, detect dead code without reading entire files. Works as MCP server, CLI, or agent skill. Supports JS/TS, Python, Go, Rust, Java.",
   "main": "index.js",