ucn 3.7.23 → 3.7.25

package/core/output.js

@@ -130,13 +130,12 @@ function formatMemberSignature(member) {
     // Generator
     if (member.isGenerator) parts.push('*');
 
-    // Name
-    parts.push(member.name);
-
-    // Parameters
+    // Name + Parameters (no space between name and parens)
     if (member.params !== undefined) {
         const params = normalizeParams(member.params);
-        parts.push(`(${params})`);
+        parts.push(`${member.name}(${params})`);
+    } else {
+        parts.push(member.name);
     }
 
     // Return type
@@ -204,12 +203,14 @@ function printDefinition(def, relativePath) {
  * Format TOC data as JSON
  */
 function formatTocJson(data) {
-    return JSON.stringify({
+    const obj = {
         meta: data.meta || { complete: true, skipped: 0, dynamicImports: 0, uncertain: 0 },
         totals: data.totals,
         summary: data.summary,
         files: data.files
-    });
+    };
+    if (data.hiddenFiles > 0) obj.hiddenFiles = data.hiddenFiles;
+    return JSON.stringify(obj);
 }
 
 /**
@@ -289,7 +290,7 @@ function formatUsagesJson(usages, name) {
 function formatContextJson(context) {
     const meta = context.meta || { complete: true, skipped: 0, dynamicImports: 0, uncertain: 0 };
     // Handle struct/interface types differently
-    if (context.type && ['struct', 'interface', 'type'].includes(context.type)) {
+    if (context.type && ['class', 'struct', 'interface', 'type'].includes(context.type)) {
         const callers = context.callers || [];
         const methods = context.methods || [];
         return JSON.stringify({
@@ -374,7 +375,8 @@ function formatFunctionJson(fn, code) {
  * Format search results as JSON
  */
 function formatSearchJson(results, term) {
-    return JSON.stringify({
+    const meta = results.meta;
+    const obj = {
         term,
         totalMatches: results.reduce((sum, r) => sum + r.matches.length, 0),
         files: results.map(r => ({
@@ -385,7 +387,14 @@ function formatSearchJson(results, term) {
                 content: m.content  // FULL content
             }))
         }))
-    }, null, 2);
+    };
+    if (meta) {
+        obj.filesScanned = meta.filesScanned;
+        obj.filesSkipped = meta.filesSkipped;
+        obj.totalFiles = meta.totalFiles;
+        if (meta.regexFallback) obj.regexFallback = meta.regexFallback;
+    }
+    return JSON.stringify(obj, null, 2);
 }
 
 /**
@@ -418,11 +427,15 @@ function formatStatsJson(stats) {
  */
 function formatGraphJson(graph) {
     if (graph?.error) return JSON.stringify({ found: false, error: graph.error, file: graph.filePath }, null, 2);
-    return JSON.stringify({
-        file: graph.file,
-        depth: graph.depth,
-        dependencies: graph.dependencies
-    }, null, 2);
+    const result = {
+        root: graph.root,
+        direction: graph.direction,
+        nodes: graph.nodes,
+        edges: graph.edges
+    };
+    if (graph.imports) result.imports = graph.imports;
+    if (graph.importers) result.importers = graph.importers;
+    return JSON.stringify(result, null, 2);
 }
 
 /**
@@ -430,6 +443,7 @@ function formatGraphJson(graph) {
  * Includes function + all dependencies
  */
 function formatSmartJson(result) {
+    if (!result) return JSON.stringify({ found: false, error: 'Function not found' }, null, 2);
     const meta = result.meta || { complete: true, skipped: 0, dynamicImports: 0, uncertain: 0 };
     return JSON.stringify({
         meta,
@@ -806,7 +820,7 @@ function formatTrace(trace, options = {}) {
         lines.push(`\nSome results truncated. ${allHint}`);
     }
 
-    if (!trace.includeMethods) {
+    if (trace.includeMethods === false) {
         const methodsHint = options.methodsHint || 'Note: obj.method() calls excluded (--include-methods=false). Remove flag to include them (default).';
         lines.push(`\n${methodsHint}`);
     }
@@ -843,7 +857,7 @@ function formatRelated(related, options = {}) {
     // Same file
     let relatedTruncated = false;
     if (related.sameFile.length > 0) {
-        const maxSameFile = options.top || (options.showAll ? Infinity : 8);
+        const maxSameFile = options.top || (options.all ? Infinity : 8);
         lines.push(`SAME FILE (${related.sameFile.length}):`);
         for (const f of related.sameFile.slice(0, maxSameFile)) {
             const params = f.params ? `(${f.params})` : '';
@@ -974,11 +988,11 @@ function formatPlan(plan, options = {}) {
         return 'Function not found.';
     }
     if (!plan.found) {
-        if (plan.error) {
-            return `Error: ${plan.error}\nCurrent parameters: ${plan.currentParams?.join(', ') || 'none'}`;
-        }
         return `Function "${plan.function}" not found.`;
     }
+    if (plan.error) {
+        return `Error: ${plan.error}\nCurrent parameters: ${plan.currentParams?.join(', ') || 'none'}`;
+    }
 
     const lines = [];
 
@@ -1153,12 +1167,12 @@ function formatAbout(about, options = {}) {
     const { expand, root, depth } = options;
 
     // Depth=0: location only
-    if (depth === '0') {
+    if (depth !== null && depth !== undefined && Number(depth) === 0) {
         return `${sym.file}:${sym.startLine}`;
     }
 
     // Depth=1: location + signature + usage counts
-    if (depth === '1') {
+    if (depth !== null && depth !== undefined && Number(depth) === 1) {
         lines.push(`${sym.file}:${sym.startLine}`);
         if (sym.signature) {
             lines.push(sym.signature);
@@ -1217,8 +1231,8 @@ function formatAbout(about, options = {}) {
             lines.push(`CALLEES (${about.callees.total}):`);
         }
         for (const c of about.callees.top) {
-            const weight = c.weight !== 'normal' ? `[${c.weight}]` : '';
-            lines.push(`  ${c.name} ${weight} - ${c.file}:${c.line} (${c.callCount}x)`);
+            const weight = c.weight && c.weight !== 'normal' ? ` [${c.weight}]` : '';
+            lines.push(`  ${c.name}${weight} - ${c.file}:${c.line} (${c.callCount}x)`);
 
             // Inline expansion: show first 3 lines of callee code
             if (expand && root && c.file && c.startLine) {
@@ -1315,7 +1329,7 @@ function formatAboutJson(about) {
  * Format example result as text
  */
 function formatExample(result, name) {
-    if (!result) return `No call examples found for "${name}"`;
+    if (!result || !result.best) return `No call examples found for "${name}"`;
 
     const best = result.best;
     const lines = [];
@@ -1455,7 +1469,9 @@ function formatFind(symbols, query, top) {
             if (c.definitions > 0) parts.push(`${c.definitions} def`);
             if (c.imports > 0) parts.push(`${c.imports} imports`);
             if (c.references > 0) parts.push(`${c.references} refs`);
-            lines.push(`  (${c.total} usages: ${parts.join(', ')})`);
+            lines.push(parts.length > 0
+                ? `  (${c.total} usages: ${parts.join(', ')})`
+                : `  (${c.total} usages)`);
         } else if (s.usageCount !== undefined) {
             lines.push(`  (${s.usageCount} usages)`);
         }
@@ -1578,7 +1594,7 @@ function formatContext(ctx, options = {}) {
                 num: itemNum++,
                 type: 'method',
                 name: m.name,
-                file: m.file,
+                file: null,
                 relativePath: m.file,
                 startLine: m.line,
                 endLine: m.endLine || m.line
@@ -1624,7 +1640,7 @@ function formatContext(ctx, options = {}) {
         }
     }
 
-    if (ctx.meta && !ctx.meta.includeMethods) {
+    if (ctx.meta && ctx.meta.includeMethods === false) {
         lines.push(`  ${methodsHint}`);
     }
 
@@ -1849,10 +1865,11 @@ function formatGraph(graph, options = {}) {
         let truncatedNodes = 0;
         let depthLimited = false;
 
-        function printNode(file, indent = 0) {
+        function printNode(file, indent = 0, isLast = true) {
             const fileEntry = nodes.find(n => n.file === file);
             const relPath = fileEntry ? fileEntry.relativePath : file;
-            const prefix = indent === 0 ? '' : '  '.repeat(indent - 1) + '├── ';
+            const connector = isLast ? '└── ' : '├── ';
+            const prefix = indent === 0 ? '' : '  '.repeat(indent - 1) + connector;
 
             if (ancestors.has(file)) {
                 lines.push(`${prefix}${relPath} (circular)`);
@@ -1877,8 +1894,9 @@ function formatGraph(graph, options = {}) {
             const displayEdges = fileEdges.slice(0, maxChildren);
             const hiddenCount = fileEdges.length - displayEdges.length;
 
-            for (const edge of displayEdges) {
-                printNode(edge.to, indent + 1);
+            for (let i = 0; i < displayEdges.length; i++) {
+                const childIsLast = i === displayEdges.length - 1 && hiddenCount === 0;
+                printNode(displayEdges[i].to, indent + 1, childIsLast);
             }
             ancestors.delete(file);
 
@@ -1899,19 +1917,38 @@ function formatGraph(graph, options = {}) {
         lines.push(`Dependency graph for ${rootRelPath}`);
         lines.push('═'.repeat(60));
 
+        let totalTruncated = 0;
+        let anyDepthLimited = false;
+
         lines.push(`\nIMPORTS (what this file depends on): ${importCount} files`);
         if (importCount > 0) {
-            printTree(graph.imports.nodes, graph.imports.edges, graph.root);
+            const r = printTree(graph.imports.nodes, graph.imports.edges, graph.root);
+            totalTruncated += r.truncatedNodes;
+            anyDepthLimited = anyDepthLimited || r.depthLimited;
         } else {
             lines.push('  (none)');
         }
 
         lines.push(`\nIMPORTERS (what depends on this file): ${importerCount} files`);
         if (importerCount > 0) {
-            printTree(graph.importers.nodes, graph.importers.edges, graph.root);
+            const r = printTree(graph.importers.nodes, graph.importers.edges, graph.root);
+            totalTruncated += r.truncatedNodes;
+            anyDepthLimited = anyDepthLimited || r.depthLimited;
         } else {
             lines.push('  (none)');
         }
+
+        if (anyDepthLimited || totalTruncated > 0) {
+            lines.push('\n' + '─'.repeat(60));
+            if (anyDepthLimited) {
+                const depthHint = options.depthHint || `Use --depth=N for deeper graph.`;
+                lines.push(`Depth limited to ${maxDepth}. ${depthHint}`);
+            }
+            if (totalTruncated > 0) {
+                const allHint = options.allHint || 'Use --all to show all children.';
+                lines.push(`${totalTruncated} nodes hidden. ${allHint}`);
+            }
+        }
     } else {
         lines.push(`Dependency graph for ${rootRelPath}`);
         lines.push('═'.repeat(60));
@@ -2060,12 +2097,12 @@ function formatDiffImpact(result) {
     lines.push(`Diff Impact Analysis (vs ${result.base})`);
     lines.push('═'.repeat(60));
 
-    const s = result.summary;
+    const s = result.summary || {};
     const parts = [];
     if (s.modifiedFunctions > 0) parts.push(`${s.modifiedFunctions} modified`);
     if (s.deletedFunctions > 0) parts.push(`${s.deletedFunctions} deleted`);
     if (s.newFunctions > 0) parts.push(`${s.newFunctions} new`);
-    parts.push(`${s.totalCallSites} call sites across ${s.affectedFiles} files`);
+    parts.push(`${s.totalCallSites || 0} call sites across ${s.affectedFiles || 0} files`);
     lines.push(parts.join(', '));
     lines.push('');
 
@@ -2161,6 +2198,13 @@ function formatPlanJson(plan) {
             ...(plan.currentParams && { currentParams: plan.currentParams })
         }, null, 2);
     }
+    if (plan.error) {
+        return JSON.stringify({
+            found: true,
+            error: plan.error,
+            ...(plan.currentParams && { currentParams: plan.currentParams })
+        }, null, 2);
+    }
 
     return JSON.stringify({
         found: true,
@@ -2256,7 +2300,7 @@ function formatVerifyJson(result) {
  * Format example command output - JSON
  */
 function formatExampleJson(result, name) {
-    if (!result) {
+    if (!result || !result.best) {
         return JSON.stringify({ found: false, query: name, error: `No call examples found for "${name}"` }, null, 2);
     }
 
@@ -2302,6 +2346,293 @@ function formatDiffImpactJson(result) {
     return JSON.stringify(result, null, 2);
 }
 
+// ============================================================================
+// Extraction command formatters (fn, class, lines)
+// ============================================================================
+
+/**
+ * Format fn handler result (from execute.js).
+ * Notes are NOT included — surfaces render those separately (e.g. stderr for CLI).
+ * @param {{ entries: Array<{match, code}>, notes: string[] }} result
+ */
+function formatFnResult(result) {
+    const parts = [];
+    for (const { match, code } of result.entries) {
+        parts.push(formatFn(match, code));
+    }
+    const separator = result.entries.length > 1 ? '\n\n' + '═'.repeat(60) + '\n\n' : '';
+    return parts.join(separator);
+}
+
+/**
+ * Format fn handler result as JSON.
+ */
+function formatFnResultJson(result) {
+    if (result.entries.length === 1) {
+        return formatFunctionJson(result.entries[0].match, result.entries[0].code);
+    }
+    const arr = result.entries.map(({ match, code }) => ({
+        name: match.name,
+        params: match.params,
+        paramsStructured: match.paramsStructured || [],
+        startLine: match.startLine,
+        endLine: match.endLine,
+        modifiers: match.modifiers || [],
+        ...(match.returnType && { returnType: match.returnType }),
+        ...(match.generics && { generics: match.generics }),
+        ...(match.docstring && { docstring: match.docstring }),
+        ...(match.isArrow && { isArrow: true }),
+        ...(match.isGenerator && { isGenerator: true }),
+        file: match.relativePath || match.file,
+        code,
+    }));
+    return JSON.stringify(arr, null, 2);
+}
+
+/**
+ * Format class handler result (from execute.js).
+ * @param {{ entries: Array<{match, code, methods?, summaryMode, truncated, totalLines, maxLines?}>, notes: string[] }} result
+ */
+function formatClassResult(result) {
+    const parts = [];
+    for (const entry of result.entries) {
+        if (entry.summaryMode) {
+            // Large class summary
+            const lines = [];
+            lines.push(`${entry.match.relativePath}:${entry.match.startLine}`);
+            lines.push(`${lineRange(entry.match.startLine, entry.match.endLine)} ${formatClassSignature(entry.match)}`);
+            lines.push('\u2500'.repeat(60));
+            if (entry.methods && entry.methods.length > 0) {
+                lines.push(`\nMethods (${entry.methods.length}):`);
+                for (const m of entry.methods) {
+                    lines.push(`  ${formatFunctionSignature(m)}  [line ${m.startLine}]`);
+                }
+            }
+            lines.push(`\nClass is ${entry.totalLines} lines. Use --max-lines=N to see source, or "fn <method>" for individual methods.`);
+            parts.push(lines.join('\n'));
+        } else if (entry.truncated) {
+            parts.push(formatClass(entry.match, entry.code) + `\n\n... showing ${entry.maxLines} of ${entry.totalLines} lines`);
+        } else {
+            parts.push(formatClass(entry.match, entry.code));
+        }
+    }
+
+    return parts.join('\n\n');
+}
+
+/**
+ * Format class handler result as JSON.
+ */
+function formatClassResultJson(result) {
+    if (result.entries.length === 1) {
+        const entry = result.entries[0];
+        return JSON.stringify({
+            ...entry.match,
+            code: entry.code,
+            ...(entry.summaryMode && { summaryMode: true }),
+            ...(entry.methods && { methods: entry.methods }),
+            ...(entry.truncated && { truncated: true }),
+            totalLines: entry.totalLines,
+        }, null, 2);
+    }
+    const arr = result.entries.map(entry => ({
+        ...entry.match,
+        code: entry.code,
+        ...(entry.summaryMode && { summaryMode: true }),
+        ...(entry.methods && { methods: entry.methods }),
+        ...(entry.truncated && { truncated: true }),
+        totalLines: entry.totalLines,
+    }));
+    return JSON.stringify(arr, null, 2);
+}
+
+/**
+ * Format lines handler result (from execute.js).
+ * @param {{ relativePath: string, lines: string[], startLine: number, endLine: number }} result
+ */
+function formatLines(result) {
+    const lines = [];
+    lines.push(`${result.relativePath}:${result.startLine}-${result.endLine}`);
+    lines.push('\u2500'.repeat(60));
+    for (let i = 0; i < result.lines.length; i++) {
+        lines.push(`${lineNum(result.startLine + i)} \u2502 ${result.lines[i]}`);
+    }
+    return lines.join('\n');
+}
+
+// ============================================================================
+// FIND DETAILED (moved from CLI — depth/confidence features)
+// ============================================================================
+
+/**
+ * Count depth of nested generic brackets.
+ */
+function countNestedGenerics(str) {
+    let maxDepth = 0;
+    let depth = 0;
+    for (const char of str) {
+        if (char === '<') {
+            depth++;
+            maxDepth = Math.max(maxDepth, depth);
+        } else if (char === '>') {
+            depth--;
+        }
+    }
+    return maxDepth;
+}
+
+/**
+ * Compute confidence level for a symbol match.
+ * @returns {{ level: 'high'|'medium'|'low', reasons: string[] }}
+ */
+function computeConfidence(symbol) {
+    const reasons = [];
+    let score = 100;
+
+    const span = (symbol.endLine || symbol.startLine) - symbol.startLine;
+    if (span > 500) {
+        score -= 30;
+        reasons.push('very long function (>500 lines)');
+    } else if (span > 200) {
+        score -= 15;
+        reasons.push('long function (>200 lines)');
+    }
+
+    const params = Array.isArray(symbol.params) ? symbol.params : [];
+    const signature = params.map(p => p.type || '').join(' ') + (symbol.returnType || '');
+    const genericDepth = countNestedGenerics(signature);
+    if (genericDepth > 3) {
+        score -= 20;
+        reasons.push('complex nested generics');
+    } else if (genericDepth > 2) {
+        score -= 10;
+        reasons.push('nested generics');
+    }
+
+    if (symbol.file) {
+        try {
+            const stats = fs.statSync(symbol.file);
+            const sizeKB = stats.size / 1024;
+            if (sizeKB > 500) {
+                score -= 20;
+                reasons.push('very large file (>500KB)');
+            } else if (sizeKB > 200) {
+                score -= 10;
+                reasons.push('large file (>200KB)');
+            }
+        } catch (e) {
+            // Skip file size check on error
+        }
+    }
+
+    let level = 'high';
+    if (score < 50) level = 'low';
+    else if (score < 80) level = 'medium';
+
+    return { level, reasons };
+}
+
+/**
+ * Format find results with depth/confidence features (detailed view).
+ * Returns a string. Used by CLI and interactive mode.
+ *
+ * @param {Array} symbols - Find result array
+ * @param {string} query - Original search query
+ * @param {object} options - { depth, top, all }
+ */
+function formatFindDetailed(symbols, query, options = {}) {
+    const { depth, top, all } = options;
+    const DEFAULT_LIMIT = 5;
+
+    if (symbols.length === 0) {
+        return `No symbols found for "${query}"`;
+    }
+
+    const lines = [];
+    const limit = all ? symbols.length : (top > 0 ? top : DEFAULT_LIMIT);
+    const showing = Math.min(limit, symbols.length);
+    const hidden = symbols.length - showing;
+
+    if (hidden > 0) {
+        lines.push(`Found ${symbols.length} match(es) for "${query}" (showing top ${showing}):`);
+    } else {
+        lines.push(`Found ${symbols.length} match(es) for "${query}":`);
+    }
+    lines.push('─'.repeat(60));
+
+    for (let i = 0; i < showing; i++) {
+        const s = symbols[i];
+        // Depth 0: just location
+        if (depth === '0') {
+            lines.push(`${s.relativePath}:${s.startLine}`);
+            continue;
+        }
+
+        // Depth 1 (default): location + signature
+        const sig = s.params !== undefined
+            ? formatFunctionSignature(s)
+            : formatClassSignature(s);
+
+        const confidence = computeConfidence(s);
+        const confStr = confidence.level !== 'high' ? ` [${confidence.level}]` : '';
+
+        lines.push(`${s.relativePath}:${s.startLine}  ${sig}${confStr}`);
+        if (s.usageCounts !== undefined) {
+            const c = s.usageCounts;
+            const parts = [];
+            if (c.calls > 0) parts.push(`${c.calls} calls`);
+            if (c.definitions > 0) parts.push(`${c.definitions} def`);
+            if (c.imports > 0) parts.push(`${c.imports} imports`);
+            if (c.references > 0) parts.push(`${c.references} refs`);
+            lines.push(`  (${c.total} usages: ${parts.join(', ')})`);
+        } else if (s.usageCount !== undefined) {
+            lines.push(`  (${s.usageCount} usages)`);
+        }
+
+        if (confidence.level !== 'high' && confidence.reasons.length > 0) {
+            lines.push(`  ⚠ ${confidence.reasons.join(', ')}`);
+        }
+
+        // Depth 2: + first 10 lines of code
+        if (depth === '2' || depth === 'full') {
+            try {
+                const content = fs.readFileSync(s.file, 'utf-8');
+                const fileLines = content.split('\n');
+                const maxLines = depth === 'full' ? (s.endLine - s.startLine + 1) : 10;
+                const endLine = Math.min(s.startLine + maxLines - 1, s.endLine);
+                lines.push('  ───');
+                for (let j = s.startLine - 1; j < endLine; j++) {
+                    lines.push(`  ${fileLines[j]}`);
+                }
+                if (depth === '2' && s.endLine > endLine) {
+                    lines.push(`  ... (${s.endLine - endLine} more lines)`);
+                }
+            } catch (e) {
+                // Skip code extraction on error
+            }
+        }
+        lines.push('');
+    }
+
+    if (hidden > 0) {
+        lines.push(`... ${hidden} more result(s). Use --all to see all, or --top=N to see more.`);
+    }
+
+    return lines.join('\n');
+}
+
+/**
+ * Format lines handler result as JSON.
+ */
+function formatLinesJson(result) {
+    return JSON.stringify({
+        file: result.relativePath,
+        startLine: result.startLine,
+        endLine: result.endLine,
+        lines: result.lines,
+    }, null, 2);
+}
+
 module.exports = {
     // Utilities
     normalizeParams,
@@ -2394,5 +2725,16 @@ module.exports = {
 
     // Diff impact command
     formatDiffImpact,
-    formatDiffImpactJson
+    formatDiffImpactJson,
+
+    // Find detailed (depth/confidence)
+    formatFindDetailed,
+
+    // Extraction commands (fn, class, lines)
+    formatFnResult,
+    formatFnResultJson,
+    formatClassResult,
+    formatClassResultJson,
+    formatLines,
+    formatLinesJson
 };