ucn 3.8.23 → 3.8.25

package/core/output/analysis.js

@@ -4,7 +4,44 @@
 const fs = require('fs');
 const path = require('path');
 const { langTraits } = require('../../languages');
-const { dynamicImportsNote } = require('./shared');
+const { dynamicImportsNote, formatGitLine } = require('./shared');
+
+/**
+ * One short sentence (~80 chars) of a docstring, suitable for inline display
+ * in caller/callee listings.
+ */
+function calleeDocstringSnippet(text) {
+    if (!text) return null;
+    const trimmed = text.trim();
+    const m = trimmed.match(/^(.+?[.!?])(?:\s|$)/);
+    let s = m ? m[1] : trimmed;
+    if (s.length > 80) s = s.slice(0, 77) + '...';
+    return s;
+}
+
+/**
+ * Render a single-line confidence histogram for caller/callee sections.
+ * Returns null when there are <= 1 edges (not informative).
+ *
+ * @param {{high:number, medium:number, low:number, total:number}|null} h
+ * @returns {string|null}
+ */
+function formatHistogramLine(h) {
+    if (!h || h.total <= 1) return null;
+    return `  confidence: ${h.high} high (>0.8), ${h.medium} medium (0.5-0.8), ${h.low} low (<0.5)`;
+}
+
+/**
+ * Decide whether the formatter should print reachability markers per item.
+ * To reduce noise, markers only appear when at least one item is unreachable.
+ *
+ * @param {Array} items - Caller or callee objects with `reachable` field
+ * @returns {boolean}
+ */
+function shouldShowReachability(items) {
+    if (!items || items.length === 0) return false;
+    return items.some(c => c.reachable === false);
+}
 
 /** Format context (callers + callees) as JSON */
 function formatContextJson(context) {
@@ -52,12 +89,15 @@ function formatContextJson(context) {
             file: context.file,
             callerCount: callers.length,
             calleeCount: callees.length,
+            callerHistogram: context.callerHistogram || null,
+            calleeHistogram: context.calleeHistogram || null,
             callers: callers.map(c => ({
                 file: c.relativePath || c.file,
                 line: c.line,
                 expression: c.content,  // FULL expression
                 callerName: c.callerName,
                 ...(c.confidence != null && { confidence: c.confidence, resolution: c.resolution }),
+                ...(c.reachable !== undefined && { reachable: c.reachable }),
             })),
             callees: callees.map(c => ({
                 name: c.name,
@@ -67,6 +107,7 @@ function formatContextJson(context) {
                 params: c.params,  // FULL params
                 weight: c.weight || 'normal',  // Dependency weight: core, setup, utility
                 ...(c.confidence != null && { confidence: c.confidence, resolution: c.resolution }),
+                ...(c.reachable !== undefined && { reachable: c.reachable }),
             })),
             ...(context.warnings && { warnings: context.warnings })
         }
@@ -143,8 +184,13 @@ function formatContext(ctx, options = {}) {
     }
 
     // Standard function/method context
-    lines.push(`Context for ${ctx.function}:`);
-    lines.push('═'.repeat(60));
+    const compact = !!options.compact;
+    if (compact) {
+        lines.push(`Context: ${ctx.function}`);
+    } else {
+        lines.push(`Context for ${ctx.function}:`);
+        lines.push('═'.repeat(60));
+    }
 
     if (ctx.meta) {
         const notes = [];
@@ -169,14 +215,26 @@ function formatContext(ctx, options = {}) {
 
     const showConf = options.showConfidence || false;
     const callers = ctx.callers || [];
-    lines.push(`\nCALLERS (${callers.length}):`);
+    lines.push(`${compact ? '' : '\n'}CALLERS (${callers.length}):`);
+    const callerHistLine = showConf ? formatHistogramLine(ctx.callerHistogram) : null;
+    if (callerHistLine) lines.push(callerHistLine);
+    const showCallerReach = shouldShowReachability(callers);
     for (const c of callers) {
         const callerName = c.callerName ? ` [${c.callerName}]` : '';
-        lines.push(`  [${itemNum}] ${c.relativePath}:${c.line}${callerName}`);
-        lines.push(`    ${c.content.trim()}`);
-        if (showConf && c.confidence != null) {
+        if (compact) {
+            // One line per caller: "[N] file:line [callerName]: expression"
+            const expr = c.content ? c.content.trim().replace(/\s+/g, ' ').slice(0, 100) : '';
+            lines.push(`  [${itemNum}] ${c.relativePath}:${c.line}${callerName}: ${expr}`);
+        } else {
+            lines.push(`  [${itemNum}] ${c.relativePath}:${c.line}${callerName}`);
+            lines.push(`    ${c.content.trim()}`);
+        }
+        if (showConf && c.confidence != null && !compact) {
             lines.push(`    confidence: ${c.confidence.toFixed(2)} (${c.resolution})`);
         }
+        if (showCallerReach && c.reachable === false && !compact) {
+            lines.push('    (unreachable from any entry point)');
+        }
         expandable.push({
             num: itemNum++,
             type: 'caller',
@@ -196,13 +254,31 @@ function formatContext(ctx, options = {}) {
     }
 
     const callees = ctx.callees || [];
-    lines.push(`\nCALLEES (${callees.length}):`);
+    lines.push(`${compact ? '' : '\n'}CALLEES (${callees.length}):`);
+    const calleeHistLine = showConf ? formatHistogramLine(ctx.calleeHistogram) : null;
+    if (calleeHistLine && !compact) lines.push(calleeHistLine);
+    const showCalleeReach = shouldShowReachability(callees);
     for (const c of callees) {
         const weight = c.weight && c.weight !== 'normal' ? ` [${c.weight}]` : '';
-        lines.push(`  [${itemNum}] ${c.name}${weight} - ${c.relativePath}:${c.startLine}`);
-        if (showConf && c.confidence != null) {
+        const returnSuffix = c.returnType ? ` → ${c.returnType}` : '';
+        const sideEffects = (c.sideEffects && c.sideEffects.length) ? ` {${c.sideEffects.join(',')}}` : '';
+        if (compact) {
+            const snip = c.docstring ? calleeDocstringSnippet(c.docstring) : '';
+            const docPart = snip ? `: ${snip}` : '';
+            lines.push(`  [${itemNum}] ${c.name}${returnSuffix}${sideEffects} - ${c.relativePath}:${c.startLine}${docPart}`);
+        } else {
+            lines.push(`  [${itemNum}] ${c.name}${weight}${returnSuffix}${sideEffects} - ${c.relativePath}:${c.startLine}`);
+            if (c.docstring) {
+                const snip = calleeDocstringSnippet(c.docstring);
+                if (snip) lines.push(`    "${snip}"`);
+            }
+        }
+        if (showConf && c.confidence != null && !compact) {
             lines.push(`    confidence: ${c.confidence.toFixed(2)} (${c.resolution})`);
         }
+        if (showCalleeReach && c.reachable === false && !compact) {
+            lines.push('    (unreachable from any entry point)');
+        }
         expandable.push({
             num: itemNum++,
             type: 'callee',
@@ -227,14 +303,15 @@ function formatImpact(impact, options = {}) {
         return 'Function not found.';
     }
 
+    const compact = !!options.compact;
     const lines = [];
 
     // Header
     lines.push(`Impact analysis for ${impact.function}`);
-    lines.push('═'.repeat(60));
+    if (!compact) lines.push('═'.repeat(60));
     lines.push(`${impact.file}:${impact.startLine}`);
-    lines.push(impact.signature);
-    lines.push('');
+    if (!compact) lines.push(impact.signature);
+    if (!compact) lines.push('');
 
     // Summary
     if (impact.shownCallSites !== undefined && impact.shownCallSites < impact.totalCallSites) {
@@ -245,14 +322,21 @@ function formatImpact(impact, options = {}) {
     lines.push(`  Files affected: ${impact.byFile.length}`);
 
     // Patterns
+    // BUG-1: also surface structural classification counts (inLoop / inTry /
+    // inCallback / inTestCase) — they're already in the JSON shape and in
+    // verify text, but were dropped from impact text.
     const p = impact.patterns;
-    if (p) {
+    if (p && !compact) {
         const patternParts = [];
         if (p.constantArgs > 0) patternParts.push(`${p.constantArgs} with literals`);
         if (p.variableArgs > 0) patternParts.push(`${p.variableArgs} with variables`);
         if (p.awaitedCalls > 0) patternParts.push(`${p.awaitedCalls} awaited`);
         if (p.chainedCalls > 0) patternParts.push(`${p.chainedCalls} chained`);
         if (p.spreadCalls > 0) patternParts.push(`${p.spreadCalls} with spread`);
+        if (p.inLoop > 0) patternParts.push(`${p.inLoop} in loop`);
+        if (p.inTry > 0) patternParts.push(`${p.inTry} in try`);
+        if (p.inCallback > 0) patternParts.push(`${p.inCallback} in callback`);
+        if (p.inTestCase > 0) patternParts.push(`${p.inTestCase} in test`);
         if (patternParts.length > 0) {
             lines.push(`  Patterns: ${patternParts.join(', ')}`);
         }
@@ -264,16 +348,38 @@ function formatImpact(impact, options = {}) {
     }
 
     // By file
-    lines.push('');
+    if (!compact) lines.push('');
     lines.push('BY FILE:');
+
+    // Histogram (over the trust signals collected before truncation)
+    const impactHistLine = formatHistogramLine(impact.callerHistogram);
+    if (impactHistLine) lines.push(impactHistLine);
+
+    // Compute reachability marker visibility across ALL sites (not per-file)
+    const allSites = impact.byFile.flatMap(g => g.sites);
+    const showImpactReach = shouldShowReachability(allSites);
+
     for (const fileGroup of impact.byFile) {
-        lines.push(`\n${fileGroup.file} (${fileGroup.count} calls)`);
-        for (const site of fileGroup.sites) {
-            const caller = site.callerName ? `[${site.callerName}]` : '';
-            lines.push(`  :${site.line} ${caller}`);
-            lines.push(`    ${site.expression}`);
-            if (site.args && site.args.length > 0) {
-                lines.push(`    args: ${site.args.join(', ')}`);
+        if (compact) {
+            // One line per call site, prefixed with file: "file (N) line [caller]: expr"
+            for (const site of fileGroup.sites) {
+                const caller = site.callerName ? ` [${site.callerName}]` : '';
+                const expr = site.expression ? site.expression.replace(/\s+/g, ' ').slice(0, 100) : '';
+                const reach = (showImpactReach && site.reachable === false) ? ' (unreachable)' : '';
+                lines.push(`  ${fileGroup.file}:${site.line}${caller}${reach}: ${expr}`);
+            }
+        } else {
+            lines.push(`\n${fileGroup.file} (${fileGroup.count} calls)`);
+            for (const site of fileGroup.sites) {
+                const caller = site.callerName ? `[${site.callerName}]` : '';
+                lines.push(`  :${site.line} ${caller}`);
+                lines.push(`    ${site.expression}`);
+                if (site.args && site.args.length > 0) {
+                    lines.push(`    args: ${site.args.join(', ')}`);
+                }
+                if (showImpactReach && site.reachable === false) {
+                    lines.push('    (unreachable from any entry point)');
+                }
             }
         }
     }
@@ -325,10 +431,12 @@ function formatAbout(about, options = {}) {
         return lines.join('\n');
     }
 
+    const compact = !!options.compact;
+
     // Header with signature
     lines.push(`${sym.name} (${sym.type})`);
-    lines.push('═'.repeat(60));
-    lines.push(`${sym.file}:${sym.startLine}-${sym.endLine}`);
+    if (!compact) lines.push('═'.repeat(60));
+    lines.push(`${sym.file}:${sym.startLine}-${sym.endLine}${sym.handle ? '  →  ' + sym.handle : ''}`);
     if (sym.signature) {
         lines.push(sym.signature);
     }
@@ -336,6 +444,12 @@ function formatAbout(about, options = {}) {
         lines.push(`"${sym.docstring}"`);
     }
 
+    // Git enrichment (opt-in via --git). Only render when available — non-git
+    // dirs and untracked files are skipped silently.
+    if (about.git && about.git.available) {
+        lines.push(formatGitLine(about.git));
+    }
+
     // Warnings (show early for visibility)
     if (about.warnings && about.warnings.length > 0) {
         for (const w of about.warnings) {
@@ -362,6 +476,9 @@ function formatAbout(about, options = {}) {
         } else {
             lines.push(`CALLERS (${about.callers.total}):`);
         }
+        const aboutCallerHist = showConf ? formatHistogramLine(about.callers.histogram) : null;
+        if (aboutCallerHist) lines.push(aboutCallerHist);
+        const showAboutCallerReach = shouldShowReachability(about.callers.top);
         for (const c of about.callers.top) {
             const caller = c.callerName ? `[${c.callerName}]` : '';
             lines.push(`  ${c.file}:${c.line} ${caller}`);
@@ -369,6 +486,9 @@ function formatAbout(about, options = {}) {
             if (showConf && c.confidence != null) {
                 lines.push(`    confidence: ${c.confidence.toFixed(2)} (${c.resolution})`);
             }
+            if (showAboutCallerReach && c.reachable === false) {
+                lines.push('    (unreachable from any entry point)');
+            }
         }
     }
 
@@ -381,12 +501,24 @@ function formatAbout(about, options = {}) {
         } else {
             lines.push(`CALLEES (${about.callees.total}):`);
         }
+        const aboutCalleeHist = showConf ? formatHistogramLine(about.callees.histogram) : null;
+        if (aboutCalleeHist) lines.push(aboutCalleeHist);
+        const showAboutCalleeReach = shouldShowReachability(about.callees.top);
         for (const c of about.callees.top) {
             const weight = c.weight && c.weight !== 'normal' ? ` [${c.weight}]` : '';
-            lines.push(`  ${c.name}${weight} - ${c.file}:${c.line} (${c.callCount}x)`);
+            const returnSuffix = c.returnType ? ` → ${c.returnType}` : '';
+            const sideEffects = (c.sideEffects && c.sideEffects.length) ? ` {${c.sideEffects.join(',')}}` : '';
+            lines.push(`  ${c.name}${weight}${returnSuffix}${sideEffects} - ${c.file}:${c.line} (${c.callCount}x)`);
+            if (c.docstring) {
+                const snip = calleeDocstringSnippet(c.docstring);
+                if (snip) lines.push(`    "${snip}"`);
+            }
             if (showConf && c.confidence != null) {
                 lines.push(`    confidence: ${c.confidence.toFixed(2)} (${c.resolution})`);
             }
+            if (showAboutCalleeReach && c.reachable === false) {
+                lines.push('    (unreachable from any entry point)');
+            }
 
             // Inline expansion: show first 3 lines of callee code
             if (expand && root && c.file && c.startLine) {

package/core/output/brief.js

@@ -0,0 +1,100 @@
+/**
+ * core/output/brief.js — Formatter for `brief`.
+ */
+
+'use strict';
+
+const { renderTypedParams, formatGitLine } = require('./shared');
+
+/**
+ * Build a typed signature line for a callable symbol.
+ * Falls back to the raw `params` string when no type info is available.
+ */
+function signatureLine(sym) {
+    const parts = [];
+    if (sym.modifiers && sym.modifiers.length) parts.push(sym.modifiers.join(' '));
+    let sig = sym.name;
+    const typed = renderTypedParams(sym);
+    // If we have a structured-params array of length 0, the function has no params.
+    // Render `()` rather than the legacy `(...)` placeholder.
+    const noParams = Array.isArray(sym.paramsStructured) && sym.paramsStructured.length === 0;
+    let paramText;
+    if (typed != null) paramText = typed;
+    else if (noParams) paramText = '';
+    else if (sym.params != null && sym.params !== '...') paramText = sym.params;
+    else paramText = '...';
+    sig += `(${paramText})`;
+    if (sym.returnType) sig += `: ${sym.returnType}`;
+    parts.push(sig);
+    return parts.join(' ');
+}
+
+/**
+ * Format a brief result for human/agent consumption.
+ *
+ * Example output:
+ *   resolveSymbol(name: string, options: object = {}): {def, definitions, warnings}
+ *     core/project.js:808-936  (129 lines)
+ *     "Resolve a symbol name to the best matching definition."
+ *     async: no, side_effects: [fs], complexity: branches=12, depth=3
+ */
+function formatBrief(result) {
+    if (!result) return 'Symbol not found.';
+    const lines = [];
+    const sym = result.symbol || {};
+
+    if (result.kind === 'type') {
+        lines.push(`${sym.type} ${sym.name}`);
+        const lineLabel = `${result.lineCount} line${result.lineCount === 1 ? '' : 's'}`;
+        const memberPart = result.memberCount > 0
+            ? `, ${result.memberCount} member${result.memberCount === 1 ? '' : 's'}`
+            : '';
+        lines.push(`  ${sym.file}:${sym.startLine}-${sym.endLine}  (${lineLabel}${memberPart})`);
+        if (sym.handle) lines.push(`  handle: ${sym.handle}`);
+        if (sym.docstring) lines.push(`  "${sym.docstring}"`);
+        const gitLineType = formatGitLine(result.git);
+        if (gitLineType) lines.push(`  ${gitLineType}`);
+        return lines.join('\n');
+    }
+
+    // Header line: signature
+    lines.push(signatureLine(sym));
+    // Location + line count
+    lines.push(`  ${sym.file}:${sym.startLine}-${sym.endLine}  (${result.lineCount || 0} line${result.lineCount === 1 ? '' : 's'})`);
+    if (sym.handle) lines.push(`  handle: ${sym.handle}`);
+    if (sym.docstring) lines.push(`  "${sym.docstring}"`);
+    if (sym.className) lines.push(`  in class ${sym.className}`);
+    const gitLineFn = formatGitLine(result.git);
+    if (gitLineFn) lines.push(`  ${gitLineFn}`);
+
+    // Async/generator/decorators
+    const flags = [];
+    flags.push(`async: ${result.isAsync ? 'yes' : 'no'}`);
+    if (result.isGenerator) flags.push('generator: yes');
+    if (sym.decorators && sym.decorators.length) flags.push(`decorators: [${sym.decorators.join(', ')}]`);
+
+    // Side effects
+    const se = (result.sideEffects && result.sideEffects.length) ? result.sideEffects : ['none'];
+    flags.push(`side_effects: [${se.join(', ')}]`);
+
+    // Complexity
+    const c = result.complexity || {};
+    const cParts = [];
+    if (c.branches != null) cParts.push(`branches=${c.branches}`);
+    if (c.maxDepth != null) cParts.push(`depth=${c.maxDepth}`);
+    flags.push(`complexity: ${cParts.join(', ')}`);
+
+    lines.push('  ' + flags.join('  |  '));
+    if (result.error) lines.push(`  Note: ${result.error}`);
+    return lines.join('\n');
+}
+
+function formatBriefJson(result) {
+    if (!result) return JSON.stringify({ found: false, error: 'Symbol not found' }, null, 2);
+    return JSON.stringify({ found: true, ...result }, null, 2);
+}
+
+module.exports = {
+    formatBrief,
+    formatBriefJson,
+};

package/core/output/check.js

@@ -0,0 +1,79 @@
+/**
+ * core/output/check.js — Pre-commit check formatter.
+ */
+
+'use strict';
+
+function formatCheck(result) {
+    if (!result) return 'No check result.';
+    if (result.empty) {
+        return `Pre-commit Check (${result.base}${result.staged ? ', staged' : ''})\n${'═'.repeat(60)}\nNo changes to analyze${result.reason ? ` (${result.reason})` : ''}.`;
+    }
+
+    const lines = [];
+    lines.push(`Pre-commit Check vs ${result.base}${result.staged ? ' (staged)' : ''}`);
+    lines.push('═'.repeat(60));
+
+    // Changed functions section
+    const items = result.changed || [];
+    if (result.truncated) {
+        lines.push(`Changed: ${items.length} of ${result.totalChanged} functions`);
+    } else {
+        lines.push(`Changed: ${items.length} function${items.length === 1 ? '' : 's'}`);
+    }
+    if (items.length === 0) {
+        lines.push('  (none — only non-function changes)');
+    } else {
+        for (const it of items) {
+            const tags = [];
+            if (it.kind && it.kind !== 'changed') tags.push(it.kind.toUpperCase());
+            if (it.signatureMismatches > 0) tags.push(`SIG-DRIFT(${it.signatureMismatches})`);
+            if (it.orphan) tags.push('ORPHAN');
+            const tagStr = tags.length ? ' [' + tags.join(', ') + ']' : '';
+            const callers = it.callerCount != null ? `${it.callerCount} caller${it.callerCount === 1 ? '' : 's'}` : '';
+            lines.push(`  ${it.name} (${it.file}:${it.line})${tagStr}  ${callers}`);
+            if (it.mismatches && it.mismatches.length > 0) {
+                for (const m of it.mismatches.slice(0, 3)) {
+                    const where = m.file ? ` at ${m.file}:${m.line}` : '';
+                    const reason = m.expected
+                        ? `expected ${m.expected}, got ${m.actual}`
+                        : (m.reason || 'arity mismatch');
+                    lines.push(`    ↳ ${reason}${where}`);
+                }
+            }
+        }
+    }
+
+    // Tests
+    lines.push('');
+    if (result.testFiles && result.testFiles.length > 0) {
+        lines.push(`Tests potentially affected: ${result.totalTests || result.testFiles.length} in ${result.testFiles.length} file${result.testFiles.length === 1 ? '' : 's'}`);
+        for (const tf of result.testFiles.slice(0, 8)) {
+            const cnt = tf.testCount ? ` (${tf.testCount})` : '';
+            lines.push(`  ${tf.file}${cnt}`);
+        }
+        if (result.testFiles.length > 8) {
+            lines.push(`  ... and ${result.testFiles.length - 8} more`);
+        }
+    } else {
+        lines.push('Tests: none detected for changed functions');
+    }
+
+    // Action items
+    if (result.actions && result.actions.length > 0) {
+        lines.push('');
+        lines.push('Action items:');
+        for (const a of result.actions) {
+            const marker = a.severity === 'warn' ? '⚠' : a.severity === 'error' ? '✖' : '·';
+            lines.push(`  ${marker} ${a.message}`);
+        }
+    }
+
+    return lines.join('\n');
+}
+
+function formatCheckJson(result) {
+    return JSON.stringify(result, null, 2);
+}
+
+module.exports = { formatCheck, formatCheckJson };

package/core/output/doctor.js

@@ -0,0 +1,85 @@
+/**
+ * core/output/doctor.js — Project trust report formatter.
+ */
+
+'use strict';
+
+function pad(n, width = 4) {
+    return String(n).padStart(width);
+}
+
+function formatDoctor(result) {
+    if (!result) return 'No project to analyze.';
+    const lines = [];
+    lines.push(`UCN Trust Report — ${result.root}`);
+    lines.push('═'.repeat(60));
+    lines.push(`Index: ${result.files.scanned} file${result.files.scanned === 1 ? '' : 's'}, ${result.symbols} symbol${result.symbols === 1 ? '' : 's'}`);
+
+    if (result.filter) lines.push(`Filter: ${result.filter}`);
+
+    // Languages
+    const langEntries = Object.entries(result.languages || {}).sort((a, b) => b[1].files - a[1].files);
+    if (langEntries.length) {
+        const totalFiles = langEntries.reduce((s, [, v]) => s + v.files, 0) || 1;
+        const langStr = langEntries.map(([name, v]) => `${name} (${Math.round(v.files / totalFiles * 100)}%)`).join(', ');
+        lines.push(`Languages: ${langStr}`);
+    }
+
+    // Cache state
+    if (result.cache) {
+        const state = result.cache.fresh === true ? 'fresh' : result.cache.fresh === false ? 'stale' : 'unknown';
+        const buildHint = result.cache.buildMs ? `, ${result.cache.buildMs}ms build` : '';
+        lines.push(`Cache: ${state}${buildHint}`);
+    }
+
+    // Coverage (if computed)
+    if (result.coverage && result.coverage.total > 0) {
+        lines.push('');
+        lines.push('Resolution coverage (sampled):');
+        const c = result.coverage;
+        const total = c.total || 1;
+        lines.push(`  High confidence (>0.8): ${c.high} (${(c.high / total * 100).toFixed(1)}%)`);
+        lines.push(`  Medium (0.5-0.8):       ${c.medium} (${(c.medium / total * 100).toFixed(1)}%)`);
+        lines.push(`  Low (<0.5):             ${c.low} (${(c.low / total * 100).toFixed(1)}%)`);
+        lines.push(`  Sampled ${c.sampled} symbols → ${c.total} edges examined`);
+    } else if (result.coverage) {
+        lines.push('');
+        lines.push('Resolution coverage: no edges in sample — likely a small or isolated project.');
+    } else {
+        lines.push('');
+        lines.push('Resolution coverage: not computed (use --deep for sampled analysis)');
+    }
+
+    // Blind spots
+    lines.push('');
+    lines.push('Blind spots:');
+    const bs = result.blindSpots || {};
+    const bsLines = [
+        ['Dynamic imports', bs.dynamicImports],
+        ['Eval/exec calls', bs.evalCalls],
+        ['Reflection',      bs.reflection],
+        ['Parse failures',  bs.parseFailures],
+    ];
+    let anyBlindSpot = false;
+    for (const [label, info] of bsLines) {
+        if (info && info.count > 0) {
+            anyBlindSpot = true;
+            const sample = info.files.slice(0, 3).map(f => `    - ${f}`).join('\n');
+            const more = info.files.length > 3 ? `\n    ... and ${info.files.length - 3} more` : '';
+            lines.push(`  ${label}: ${info.count} in ${info.files.length} file${info.files.length === 1 ? '' : 's'}`);
+            if (sample) lines.push(sample + more);
+        }
+    }
+    if (!anyBlindSpot) lines.push('  (none detected)');
+
+    // Verdict
+    lines.push('');
+    lines.push(`Trust level: ${result.trust}${result.trustReason ? ' — ' + result.trustReason : ''}`);
+    return lines.join('\n');
+}
+
+function formatDoctorJson(result) {
+    return JSON.stringify(result, null, 2);
+}
+
+module.exports = { formatDoctor, formatDoctorJson };