ucn 3.8.13 → 3.8.15

package/core/discovery.js

@@ -6,6 +6,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { langTraits } = require('../languages');
 
 // Always ignore - unambiguous, never user code
 const DEFAULT_IGNORES = [
@@ -504,46 +505,10 @@ function findTestFileFor(sourceFile, language) {
     const ext = path.extname(sourceFile);
     const base = path.basename(sourceFile, ext);
 
-    const candidates = [];
-
-    switch (language) {
-        case 'javascript':
-        case 'typescript':
-        case 'tsx':
-            candidates.push(
-                `${base}.test${ext}`,
-                `${base}.spec${ext}`,
-                `${base}.test.ts`,
-                `${base}.test.js`,
-                `${base}.spec.ts`,
-                `${base}.spec.js`
-            );
-            break;
-        case 'python':
-            candidates.push(
-                `test_${base}.py`,
-                `${base}_test.py`
-            );
-            break;
-        case 'go':
-            candidates.push(`${base}_test.go`);
-            break;
-        case 'java':
-            candidates.push(
-                `${base}Test.java`,
-                `${base}Tests.java`,
-                `${base}TestCase.java`
-            );
-            break;
-        case 'rust':
-            candidates.push(`${base}_test.rs`);
-            break;
-        default:
-            candidates.push(
-                `${base}.test${ext}`,
-                `${base}.spec${ext}`
-            );
-    }
+    const traits = langTraits(language);
+    const candidates = traits?.testFileCandidates
+        ? traits.testFileCandidates(base, ext)
+        : [`${base}.test${ext}`, `${base}.spec${ext}`];
 
     // Check in same directory
     for (const candidate of candidates) {
@@ -553,20 +518,10 @@ function findTestFileFor(sourceFile, language) {
         }
     }
 
-    // Check in __tests__ subdirectory
-    if (language === 'javascript' || language === 'typescript' || language === 'tsx') {
-        const testsDir = path.join(dir, '__tests__');
-        for (const candidate of candidates) {
-            const testPath = path.join(testsDir, candidate);
-            if (fs.existsSync(testPath)) {
-                return testPath;
-            }
-        }
-    }
-
-    // Check in tests subdirectory
-    if (language === 'python' || language === 'rust') {
-        const testsDir = path.join(dir, 'tests');
+    // Check in language-specific test directories
+    const testDirs = traits?.testDirs || [];
+    for (const testDir of testDirs) {
+        const testsDir = path.join(dir, testDir);
         for (const candidate of candidates) {
             const testPath = path.join(testsDir, candidate);
             if (fs.existsSync(testPath)) {

package/core/execute.js

@@ -86,6 +86,21 @@ function applyTestExclusions(exclude, includeTests) {
     return includeTests ? arr : addTestExclusions(arr);
 }
 
+/**
+ * Build common caller/callee analysis options from handler params.
+ * Used by about, context, blast, reverseTrace, smart, trace, affectedTests.
+ */
+function buildCallerOptions(p) {
+    return {
+        file: p.file,
+        className: p.className,
+        includeMethods: p.includeMethods,
+        includeUncertain: p.includeUncertain || false,
+        exclude: toExcludeArray(p.exclude),
+        minConfidence: num(p.minConfidence, 0),
+    };
+}
+
 /** Check if a file-based result has a file error. */
 function checkFileError(result, file) {
     if (!result) return null;
@@ -140,6 +155,27 @@ function limitNote(limit, total) {
     return `Showing ${limit} of ${total} results. Use --limit N to see more.`;
 }
 
+/** Build a truncation warning when index is incomplete */
+function truncationNote(index) {
+    if (!index.truncated) return null;
+    return `Index limited to ${index.truncated.indexed} files (max ${index.truncated.maxFiles}). Results may be incomplete. Use --max-files N to increase.`;
+}
+
+/** Build notes for tree-based results (blast, trace, reverseTrace, affectedTests). */
+function treeNote(result) {
+    const parts = [];
+    if (result?.warnings?.length > 0) {
+        for (const w of result.warnings) parts.push(w.message || w);
+    }
+    if (result?.tree?.truncatedChildren > 0) {
+        parts.push(`${result.tree.truncatedChildren} children truncated. Use --depth=N or --all to expand.`);
+    }
+    if (result?.truncatedCallers > 0) {
+        parts.push(`${result.truncatedCallers} callers truncated. Use --all to expand.`);
+    }
+    return parts.length > 0 ? parts.join('\n') : null;
+}
+
 /**
  * Check if a --file pattern matches any files in the index.
  * Returns error string if no files match, null otherwise.
@@ -190,16 +226,11 @@ const HANDLERS = {
         if (err) return { ok: false, error: err };
         applyClassMethodSyntax(p);
         const result = index.about(p.name, {
+            ...buildCallerOptions(p),
             withTypes: p.withTypes || false,
-            file: p.file,
-            className: p.className,
             all: p.all,
-            includeMethods: p.includeMethods,
-            includeUncertain: p.includeUncertain || false,
-            exclude: toExcludeArray(p.exclude),
             maxCallers: num(p.top, undefined),
             maxCallees: num(p.top, undefined),
-            minConfidence: num(p.minConfidence, 0),
         });
         if (!result) {
             // Give better error if file/className filter is the problem
@@ -218,7 +249,8 @@ const HANDLERS = {
             }
             return { ok: false, error: `Symbol "${p.name}" not found.` };
         }
-        return { ok: true, result, showConfidence: !!p.showConfidence };
+        const tNote = truncationNote(index);
+        return { ok: true, result, showConfidence: !!p.showConfidence, ...(tNote && { note: tNote }) };
     },
 
     context: (index, p) => {
@@ -230,15 +262,11 @@ const HANDLERS = {
         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,
-            file: p.file,
-            className: p.className,
-            exclude: toExcludeArray(p.exclude),
-            minConfidence: num(p.minConfidence, 0),
+            ...buildCallerOptions(p),
         });
         if (!result) return { ok: false, error: `Symbol "${p.name}" not found.` };
-        return { ok: true, result, showConfidence: !!p.showConfidence };
+        const tNote = truncationNote(index);
+        return { ok: true, result, showConfidence: !!p.showConfidence, ...(tNote && { note: tNote }) };
     },
 
     impact: (index, p) => {
@@ -256,7 +284,8 @@ const HANDLERS = {
             top: num(p.top, undefined),
         });
         if (!result) return { ok: false, error: `Function "${p.name}" not found.` };
-        return { ok: true, result };
+        const tNote = truncationNote(index);
+        return { ok: true, result, ...(tNote && { note: tNote }) };
     },
 
     blast: (index, p) => {
@@ -269,16 +298,15 @@ const HANDLERS = {
         if (classErr) return { ok: false, error: classErr };
         const depthVal = num(p.depth, undefined);
         const result = index.blast(p.name, {
+            ...buildCallerOptions(p),
             depth: depthVal ?? 3,
-            file: p.file,
-            className: p.className,
             all: p.all || depthVal !== undefined,
-            exclude: toExcludeArray(p.exclude),
-            includeMethods: p.includeMethods,
-            includeUncertain: p.includeUncertain || false,
         });
         if (!result) return { ok: false, error: `Function "${p.name}" not found.` };
-        return { ok: true, result };
+        const note = treeNote(result);
+        const tNote = truncationNote(index);
+        const combined = [note, tNote].filter(Boolean).join('\n') || undefined;
+        return { ok: true, result, ...(combined && { note: combined }) };
     },
 
     reverseTrace: (index, p) => {
@@ -291,16 +319,15 @@ const HANDLERS = {
         if (classErr) return { ok: false, error: classErr };
         const depthVal = num(p.depth, undefined);
         const result = index.reverseTrace(p.name, {
+            ...buildCallerOptions(p),
             depth: depthVal ?? 5,
-            file: p.file,
-            className: p.className,
             all: p.all || depthVal !== undefined,
-            exclude: toExcludeArray(p.exclude),
-            includeMethods: p.includeMethods,
-            includeUncertain: p.includeUncertain || false,
         });
         if (!result) return { ok: false, error: `Function "${p.name}" not found.` };
-        return { ok: true, result };
+        const note = treeNote(result);
+        const tNote = truncationNote(index);
+        const combined = [note, tNote].filter(Boolean).join('\n') || undefined;
+        return { ok: true, result, ...(combined && { note: combined }) };
     },
 
     smart: (index, p) => {
@@ -309,12 +336,11 @@ const HANDLERS = {
         applyClassMethodSyntax(p);
         const fileErr = checkFilePatternMatch(index, p.file);
         if (fileErr) return { ok: false, error: fileErr };
+        const classErr = validateClassName(index, p.name, p.className);
+        if (classErr) return { ok: false, error: classErr };
         const result = index.smart(p.name, {
-            file: p.file,
-            className: p.className,
+            ...buildCallerOptions(p),
             withTypes: p.withTypes || false,
-            includeMethods: p.includeMethods,
-            includeUncertain: p.includeUncertain || false,
         });
         if (!result) return { ok: false, error: `Function "${p.name}" not found.` };
         return { ok: true, result };
@@ -326,17 +352,19 @@ const HANDLERS = {
         applyClassMethodSyntax(p);
         const fileErr = checkFilePatternMatch(index, p.file);
         if (fileErr) return { ok: false, error: fileErr };
+        const classErr = validateClassName(index, p.name, p.className);
+        if (classErr) return { ok: false, error: classErr };
         const depthVal = num(p.depth, undefined);
         const result = index.trace(p.name, {
+            ...buildCallerOptions(p),
             depth: depthVal ?? 3,
-            file: p.file,
-            className: p.className,
             all: p.all || depthVal !== undefined,
-            includeMethods: p.includeMethods,
-            includeUncertain: p.includeUncertain || false,
         });
         if (!result) return { ok: false, error: `Function "${p.name}" not found.` };
-        return { ok: true, result };
+        const note = treeNote(result);
+        const tNote = truncationNote(index);
+        const combined = [note, tNote].filter(Boolean).join('\n') || undefined;
+        return { ok: true, result, ...(combined && { note: combined }) };
     },
 
     example: (index, p) => {
@@ -345,6 +373,8 @@ const HANDLERS = {
         applyClassMethodSyntax(p);
         const fileErr = checkFilePatternMatch(index, p.file);
         if (fileErr) return { ok: false, error: fileErr };
+        const classErr = validateClassName(index, p.name, p.className);
+        if (classErr) return { ok: false, error: classErr };
         const result = index.example(p.name, { file: p.file, className: p.className });
         if (!result) return { ok: false, error: `No examples found for "${p.name}".` };
         return { ok: true, result };
@@ -363,7 +393,17 @@ const HANDLERS = {
             all: p.all,
         });
         if (!result) return { ok: false, error: `Function "${p.name}" not found.` };
-        return { ok: true, result };
+        const parts = [];
+        if (result.similarNamesTotal > result.similarNames.length)
+            parts.push(`similar names: showing ${result.similarNames.length} of ${result.similarNamesTotal}`);
+        if (result.sharedCallersTotal > result.sharedCallers.length)
+            parts.push(`shared callers: showing ${result.sharedCallers.length} of ${result.sharedCallersTotal}`);
+        if (result.sharedCalleesTotal > result.sharedCallees.length)
+            parts.push(`shared callees: showing ${result.sharedCallees.length} of ${result.sharedCalleesTotal}`);
+        const relatedNote = parts.length ? `Truncated: ${parts.join(', ')}. Use --all to show all.` : null;
+        const tNote = truncationNote(index);
+        const combined = [relatedNote, tNote].filter(Boolean).join('\n') || undefined;
+        return { ok: true, result, ...(combined && { note: combined }) };
     },
 
     // ── Finding Code ────────────────────────────────────────────────────
@@ -375,6 +415,10 @@ const HANDLERS = {
         // Check if --file pattern matches any files
         const fileErr = checkFilePatternMatch(index, p.file);
         if (fileErr) return { ok: false, error: fileErr };
+        if (p.className) {
+            const classErr = validateClassName(index, p.name, p.className);
+            if (classErr) return { ok: false, error: classErr };
+        }
         // Auto-include tests when pattern clearly targets test functions
         // But only if the user didn't explicitly set include_tests=false
         let includeTests = p.includeTests;
@@ -401,6 +445,8 @@ const HANDLERS = {
             if (limited) notes.push(limitNote(limit, total));
             result = items;
         }
+        const tNote = truncationNote(index);
+        if (tNote) notes.push(tNote);
         return { ok: true, result, note: notes.length ? notes.join('\n') : undefined };
     },
 
@@ -411,6 +457,10 @@ const HANDLERS = {
         const exclude = applyTestExclusions(p.exclude, p.includeTests);
         const fileErr = checkFilePatternMatch(index, p.file);
         if (fileErr) return { ok: false, error: fileErr };
+        if (p.className) {
+            const classErr = validateClassName(index, p.name, p.className);
+            if (classErr) return { ok: false, error: classErr };
+        }
         const result = index.usages(p.name, {
             codeOnly: p.codeOnly || false,
             context: num(p.context, 0),
@@ -431,6 +481,8 @@ const HANDLERS = {
     },
 
     toc: (index, p) => {
+        const fileErr = checkFilePatternMatch(index, p.file);
+        if (fileErr) return { ok: false, error: fileErr };
         const result = index.getToc({
             detailed: p.detailed,
             topLevel: p.topLevel,
@@ -482,10 +534,14 @@ const HANDLERS = {
                 note = limitNote(limit, totalEntries);
             }
         }
+        const tNote = truncationNote(index);
+        if (tNote) note = note ? `${note}\n${tNote}` : tNote;
         return { ok: true, result, note };
     },
 
     search: (index, p) => {
+        const fileErr = checkFilePatternMatch(index, p.file);
+        if (fileErr) return { ok: false, error: fileErr };
         // Detect structural search mode: any of these flags triggers index-based search
         const isStructural = p.type || p.param || p.receiver || p.returns || p.decorator || p.exported || p.unused;
         if (isStructural) {
@@ -527,13 +583,16 @@ const HANDLERS = {
             file: p.file,
         });
         if (result.meta) result.meta.testsExcluded = testsExcluded;
-        return { ok: true, result };
+        const tNote = truncationNote(index);
+        return { ok: true, result, ...(tNote && { note: tNote }) };
     },
 
     tests: (index, p) => {
         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.tests(p.name, {
             callsOnly: p.callsOnly || false,
             className: p.className,
@@ -551,15 +610,14 @@ const HANDLERS = {
         if (classErr) return { ok: false, error: classErr };
         const depthVal = num(p.depth, undefined);
         const result = index.affectedTests(p.name, {
+            ...buildCallerOptions(p),
             depth: depthVal ?? 3,
-            file: p.file,
-            className: p.className,
-            exclude: toExcludeArray(p.exclude),
-            includeMethods: p.includeMethods,
-            includeUncertain: p.includeUncertain || false,
         });
         if (!result) return { ok: false, error: `Function "${p.name}" not found.` };
-        return { ok: true, result };
+        const note = treeNote(result);
+        const tNote = truncationNote(index);
+        const combined = [note, tNote].filter(Boolean).join('\n') || undefined;
+        return { ok: true, result, ...(combined && { note: combined }) };
     },
 
     deadcode: (index, p) => {
@@ -584,6 +642,8 @@ const HANDLERS = {
             if (result.excludedDecorated != null) sliced.excludedDecorated = result.excludedDecorated;
             result = sliced;
         }
+        const tNote = truncationNote(index);
+        if (tNote) note = note ? `${note}\n${tNote}` : tNote;
         return { ok: true, result, note };
     },
 
@@ -591,13 +651,20 @@ const HANDLERS = {
         const fileErr = checkFilePatternMatch(index, p.file);
         if (fileErr) return { ok: false, error: fileErr };
         const { detectEntrypoints } = require('./entrypoints');
-        const result = detectEntrypoints(index, {
+        const exclude = applyTestExclusions(p.exclude, p.includeTests);
+        let result = detectEntrypoints(index, {
             type: p.type,
             framework: p.framework,
             file: p.file,
-            exclude: p.exclude,
+            exclude,
         });
-        return { ok: true, result };
+        const limit = num(p.limit, undefined);
+        let note;
+        if (limit && limit > 0 && Array.isArray(result) && result.length > limit) {
+            note = limitNote(limit, result.length);
+            result = result.slice(0, limit);
+        }
+        return { ok: true, result, note };
     },
 
     // ── Extracting Code ─────────────────────────────────────────────────
@@ -608,6 +675,10 @@ const HANDLERS = {
         applyClassMethodSyntax(p);
         const fileErr = checkFilePatternMatch(index, p.file);
         if (fileErr) return { ok: false, error: fileErr };
+        if (p.className) {
+            const classErr = validateClassName(index, p.name, p.className);
+            if (classErr) return { ok: false, error: classErr };
+        }
 
         const fnNames = p.name.includes(',')
             ? p.name.split(',').map(n => n.trim()).filter(Boolean)
@@ -662,7 +733,7 @@ const HANDLERS = {
         if (entries.length === 0 && notes.length > 0) {
             return { ok: false, error: notes.join('\n') };
         }
-        return { ok: true, result: { entries, notes } };
+        return { ok: true, result: { entries }, note: notes.length ? notes.map(n => 'Note: ' + n).join('\n') : undefined };
     },
 
     class: (index, p) => {
@@ -693,7 +764,7 @@ const HANDLERS = {
                 const totalLines = m.endLine - m.startLine + 1;
                 entries.push({ match: m, code, totalLines, summaryMode: false, truncated: false });
             }
-            return { ok: true, result: { entries, notes } };
+            return { ok: true, result: { entries }, note: notes.length ? notes.map(n => 'Note: ' + n).join('\n') : undefined };
         }
 
         const match = matches.length > 1 && !p.file
@@ -712,7 +783,7 @@ const HANDLERS = {
         if (totalLines > 200 && !maxLines) {
             const methods = index.findMethodsForType(match.name);
             entries.push({ match, code: null, methods, totalLines, summaryMode: true, truncated: false });
-            return { ok: true, result: { entries, notes } };
+            return { ok: true, result: { entries }, note: notes.length ? notes.map(n => 'Note: ' + n).join('\n') : undefined };
         }
 
         // Truncated mode (maxLines specified and class exceeds it)
@@ -722,13 +793,13 @@ const HANDLERS = {
             const truncated = fileLines.slice(match.startLine - 1, match.startLine - 1 + maxLines);
             const code = cleanHtmlScriptTags(truncated, detectLanguage(match.file)).join('\n');
             entries.push({ match, code, totalLines, summaryMode: false, truncated: true, maxLines });
-            return { ok: true, result: { entries, notes } };
+            return { ok: true, result: { entries }, note: notes.length ? notes.map(n => 'Note: ' + n).join('\n') : undefined };
         }
 
         // Full extraction
         const code = readAndExtract(match);
         entries.push({ match, code, totalLines, summaryMode: false, truncated: false });
-        return { ok: true, result: { entries, notes } };
+        return { ok: true, result: { entries }, note: notes.length ? notes.map(n => 'Note: ' + n).join('\n') : undefined };
     },
 
     lines: (index, p) => {
@@ -870,12 +941,18 @@ const HANDLERS = {
     },
 
     diffImpact: (index, p) => {
-        const result = index.diffImpact({
+        let result = index.diffImpact({
             base: p.base || 'HEAD',
             staged: p.staged || false,
             file: p.file,
         });
-        return { ok: true, result };
+        const limit = num(p.limit, undefined);
+        let note;
+        if (limit && limit > 0 && result && result.changed && result.changed.length > limit) {
+            note = limitNote(limit, result.changed.length);
+            result = { ...result, changed: result.changed.slice(0, limit) };
+        }
+        return { ok: true, result, note };
     },
 
     // ── Other ───────────────────────────────────────────────────────────
@@ -884,6 +961,10 @@ const HANDLERS = {
         const err = requireName(p.name);
         if (err) return { ok: false, error: err };
         applyClassMethodSyntax(p);
+        const fileErr = checkFilePatternMatch(index, p.file);
+        if (fileErr) return { ok: false, error: fileErr };
+        const classErr = validateClassName(index, p.name, p.className);
+        if (classErr) return { ok: false, error: classErr };
         const result = index.typedef(p.name, { exact: p.exact || false, className: p.className, file: p.file });
         return { ok: true, result };
     },
@@ -897,6 +978,10 @@ const HANDLERS = {
     },
 
     api: (index, p) => {
+        if (p.file) {
+            const fileErr = checkFilePatternMatch(index, p.file);
+            if (fileErr) return { ok: false, error: fileErr };
+        }
         let result = index.api(p.file);
         if (p.file) {
             const fileErr = checkFileError(result, p.file);