ucn 5.3.6 → 5.3.8

package/core/graph.js

@@ -564,6 +564,8 @@ function api(index, filePath, options = {}) {
     const results = [];
     let scopedFiles = 0;
     let pythonImplicitFiles = 0;
+    let excludedTestFiles = 0;
+    let explicitFile = false;
 
     let fileIterator;
     if (filePath) {
@@ -573,6 +575,7 @@ function api(index, filePath, options = {}) {
             const fileEntry = index.files.get(resolved);
             if (!fileEntry) return { error: 'file-not-found', filePath };
             fileIterator = [[resolved, fileEntry]];
+            explicitFile = true;
         } else {
             // Fall back to pattern filter (substring match on relative path)
             const matches = [];
@@ -596,7 +599,8 @@ function api(index, filePath, options = {}) {
         }
 
         // Skip test files by default (test classes aren't part of public API)
-        if (!options.includeTests && isTestFile(fileEntry.relativePath, fileEntry.language)) {
+        if (!explicitFile && !options.includeTests && isTestFile(fileEntry.relativePath, fileEntry.language)) {
+            excludedTestFiles++;
             continue;
         }
         scopedFiles++;
@@ -612,7 +616,7 @@ function api(index, filePath, options = {}) {
     results.sort((a, b) => codeUnitCompare(a.file, b.file) ||
         (a.startLine - b.startLine) || codeUnitCompare(a.name, b.name));
     Object.defineProperty(results, 'apiInfo', {
-        value: { scopedFiles, pythonImplicitFiles },
+        value: { scopedFiles, pythonImplicitFiles, excludedTestFiles },
         enumerable: false, writable: true, configurable: true,
     });
     return results;

package/core/output/check.js

@@ -10,13 +10,17 @@ function formatCheck(result) {
         // The gate could not run — never render this like a clean tree.
         return `Pre-commit Check (${result.base}${result.staged ? ', staged' : ''})\n${'═'.repeat(60)}\nCHECK DID NOT RUN [${result.status || 'diff-failed'}] — ${result.error || 'git diff failed'}\nThis is not a pass. Fix the git context (run inside a git repository with a valid base ref) and rerun.`;
     }
+    const pathNotes = [];
+    if (result.nonSourcePaths > 0) pathNotes.push(`Note: ${result.nonSourcePaths} changed path(s) outside supported source files not analyzed.`);
+    if (result.untrackedPaths > 0) pathNotes.push(`Note: ${result.untrackedPaths} untracked source file(s) included as whole-file additions.`);
     if (result.empty) {
-        return `Pre-commit Check (${result.base}${result.staged ? ', staged' : ''})\n${'═'.repeat(60)}\nNo changes to analyze${result.reason ? ` (${result.reason})` : ''}.`;
+        return [`Pre-commit Check (${result.base}${result.staged ? ', staged' : ''})\n${'═'.repeat(60)}\nNo changes to analyze${result.reason ? ` (${result.reason})` : ''}.`, ...pathNotes].join('\n');
     }
 
     const lines = [];
     lines.push(`Pre-commit Check vs ${result.base}${result.staged ? ' (staged)' : ''}`);
     lines.push('═'.repeat(60));
+    lines.push(...pathNotes);
     if (result.trust) {
         lines.push(`TRUST: ${result.trust.status} — UCN evidence is not semantic proof; compiler and tests are required`);
         const trustDetails = [];

package/core/output/doctor.js

@@ -33,7 +33,7 @@ function formatDoctor(result, options = {}) {
     // 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` : '';
+        const buildHint = result.cache.buildMs ? `, ${result.cache.buildMs}ms last index build (excludes cache I/O and query execution)` : '';
         lines.push(`Cache: ${state}${buildHint}`);
     }
     if (result.commandTrust) {

package/core/output/lines.js

@@ -29,7 +29,8 @@ function record(pathLike, line, text, tag = '') {
     // Keep unusual filenames from becoming notes or extra physical records.
     let file = String(pathLike).replace(/\\/g, '\\\\').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t');
     if (file.startsWith('# ')) file = './' + file;
-    return `${file}:${line == null ? 0 : line}:${body}${tag ? `\t# ${tag}` : ''}`;
+    const tagText = String(tag || '').replace(/\s+/g, ' ').trim();
+    return `${file}:${line == null ? 0 : line}:${body}${tagText ? `\t# ${tagText}` : ''}`;
 }
 
 function commentLines(text) {
@@ -95,9 +96,14 @@ function searchRecords(result) {
     if (result && !Array.isArray(result) && Array.isArray(result.results)) {
         for (const item of result.results) {
             const text = item.params != null ? `${item.name}(${item.params})` : item.name;
-            out.push(record(item.file, item.line, text, item.kind || item.type));
+            const decorators = (item.decorators || []).map(d => `@${String(d).replace(/^@/, '')}`).join(', ');
+            const tag = [item.kind || item.type, decorators].filter(Boolean).join('; ');
+            out.push(record(item.file, item.line, text, tag));
         }
         const meta = result.meta;
+        if (meta?.query?.unused) {
+            notes.push(...commentLines(require('./search').unusedSearchNote()));
+        }
         if (meta && meta.totalMatched > meta.shown) {
             notes.push(`# ${meta.totalMatched - meta.shown} more match(es) (--limit=N / --all)`);
         }

package/core/output/public.js

@@ -372,6 +372,11 @@ function formatPublicText(command, result, params = {}, execution = {}) {
 function formatPublicJson(command, result, params = {}, execution = {}) {
     let commandMeta = {};
     let data = result;
+    if (Array.isArray(result) && result.limitInfo) {
+        commandMeta.total = result.limitInfo.total;
+        commandMeta.shown = result.limitInfo.shown;
+        commandMeta.truncated = result.limitInfo.shown < result.limitInfo.total;
+    }
 
     // Ambiguous bare-name resolution is a surface-level trust decision. Keep
     // it in the common envelope even for array results (notably `tests`, whose
@@ -419,6 +424,9 @@ function formatPublicJson(command, result, params = {}, execution = {}) {
         if (result.meta.truncatedMatches > 0) commandMeta.truncated = true;
         if (result.unsupportedMatches) commandMeta.unsupportedMatches = result.unsupportedMatches;
     }
+    if (command === 'api' && result?.apiInfo) {
+        commandMeta.apiInfo = result.apiInfo;
+    }
     if (command === 'entrypoints' && result?.filterInfo) {
         commandMeta.hiddenTestEntrypoints = result.filterInfo.hiddenTests;
         commandMeta.testsIncluded = result.filterInfo.testsIncluded;

package/core/output/reporting.js

@@ -125,7 +125,7 @@ function formatStats(stats, options = {}) {
         lines.push(`Files: ${stats.files}`);
     }
     lines.push(`Symbols: ${stats.symbols}`);
-    lines.push(`Build time: ${stats.buildTime}ms`);
+    lines.push(`Last index build: ${stats.buildTime}ms (excludes cache I/O and query execution; reused from cache)`);
 
     lines.push('\nBy Language:');
     for (const [lang, info] of Object.entries(stats.byLanguage)) {

package/core/output/search.js

@@ -87,6 +87,10 @@ function formatSearchJson(results, term) {
 /**
  * Format structural search results (index-based queries)
  */
+function unusedSearchNote(flag = '--unused') {
+    return `${flag} lists callable symbols with no resolved call edge; it does not assess type/field/reference liveness and is not safe-delete proof. Confirm with deadcode and usages.`;
+}
+
 function formatStructuralSearch(result, options = {}) {
     const { results, meta } = result;
     const lines = [];
@@ -106,7 +110,7 @@ function formatStructuralSearch(result, options = {}) {
     lines.push(`Structural search: ${queryStr}`);
     lines.push('═'.repeat(60));
     if (meta.query.unused) {
-        lines.push(`NOTE: ${options.unusedFlag || '--unused'} lists callable symbols with no resolved call edge; it does not assess type/field/reference liveness and is not safe-delete proof. Confirm with deadcode and usages.`);
+        lines.push(`NOTE: ${unusedSearchNote(options.unusedFlag)}`);
         lines.push('');
     }
 
@@ -447,6 +451,7 @@ function formatTestsJson(tests, name) {
 }
 
 module.exports = {
+    unusedSearchNote,
     formatSearch,
     formatSearchJson,
     formatStructuralSearch,

package/core/project.js

@@ -424,6 +424,7 @@ class ProjectIndex {
         const implicitProjectDiscovery = !Array.isArray(pattern) && !pattern;
         this.unsupportedFiles = [];
         this.discoveryIssues = [];
+        this.includeBundled = options.includeBundled === true;
         const discoveryIssueKeys = new Set();
         const recordDiscoveryIssue = (issue) => {
             const rel = path.relative(this.root, issue.path || this.root) || '.';
@@ -450,7 +451,8 @@ class ProjectIndex {
                 maxFiles: options.maxFiles || this.config.maxFiles || 50000,
                 maxDepth: options.maxDepth ?? this.config.maxDepth,
                 maxFileSize: options.maxFileSize ?? this.config.maxFileSize,
-                followSymlinks: options.followSymlinks
+                followSymlinks: options.followSymlinks,
+                includeBundled: this.includeBundled,
             };
 
             // Merge .gitignore and .ucn.json exclude into file discovery

package/core/public-command.js

@@ -22,7 +22,7 @@ function buildPublicParams(command, arg, params = {}) {
     if (clean.top === 0 && params.topRaw == null) delete clean.top;
     if (clean.maxLines == null) delete clean.maxLines;
     // Surface-only values never belong in execute params.
-    for (const key of ['json', 'quiet', 'cache', 'clearCache', 'followSymlinks', 'interactive',
+    for (const key of ['json', 'quiet', 'cache', 'clearCache', 'followSymlinks', 'includeBundled', 'interactive',
         'topRaw', 'limitRaw', 'maxFilesRaw', 'maxLinesRaw', 'maxChars', 'maxCharsRaw',
         'depthRaw', 'contextRaw', 'workersRaw',
         '_fileFromFileMode']) delete clean[key];

package/core/registry.js

@@ -114,6 +114,7 @@ const PARAM_MAP = {
     max_files:         'maxFiles',
     max_chars:         'maxChars',
     follow_symlinks:   'followSymlinks',
+    include_bundled:   'includeBundled',
     unreachable_only:  'unreachableOnly',
     server_only:       'serverOnly',
     client_only:       'clientOnly',
@@ -142,7 +143,7 @@ const FLAG_APPLICABILITY = {
     impact:       ['name', 'file', 'exclude', 'className', 'line', 'includeMethods', 'top', 'unreachableOnly', 'compact', 'base', 'staged', 'limit', 'all', 'lines'],
     tests:        ['name', 'file', 'exclude', 'className', 'line', 'callsOnly', 'depth', 'includeMethods', 'all'],
     deps:         ['file', 'exclude', 'depth', 'direction', 'all', 'detailed', 'cycles'],
-    api:          ['file', 'in', 'limit'],
+    api:          ['file', 'in', 'limit', 'includeTests'],
     check:        ['name', 'file', 'className', 'line', 'includeMethods', 'base', 'staged', 'limit'],
     plan:         ['name', 'file', 'className', 'line', 'addParam', 'removeParam', 'renameTo', 'defaultValue'],
     repo:         ['file', 'exclude', 'top', 'limit', 'all', 'detailed', 'topLevel', 'in', 'functions', 'hot', 'deep', 'sections'],
@@ -303,7 +304,7 @@ function formatSurfaceMessage(message, surface = 'cli') {
     const booleanParams = new Set([
         'includeTests', 'excludeTests', 'includeMethods', 'withTypes',
         'codeOnly', 'caseSensitive', 'includeExported', 'includeDecorated',
-        'showConfidence', 'callsOnly', 'topLevel', 'followSymlinks',
+        'showConfidence', 'callsOnly', 'topLevel', 'followSymlinks', 'includeBundled',
         'unreachableOnly', 'serverOnly', 'clientOnly', 'hideUncertain',
         'expandUnverified', 'withSource', 'all', 'compact', 'exact',
         'regex', 'exported', 'unused', 'staged', 'detailed', 'functions',
@@ -314,7 +315,7 @@ function formatSurfaceMessage(message, surface = 'cli') {
         rendered = rendered.replace(/--([a-z][a-z0-9-]*)(?:=([^\s,.)]+))?/g,
             (whole, flag, rawValue) => {
                 const camel = flag.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-                if (!knownParams.has(camel) && !['maxChars', 'maxFiles'].includes(camel)) {
+                if (!knownParams.has(camel) && !['maxChars', 'maxFiles', 'includeBundled'].includes(camel)) {
                     return whole;
                 }
                 const snake = REVERSE_PARAM_MAP[camel] || camel;
@@ -365,7 +366,7 @@ const CLI_GLOBAL_FLAGS = Object.freeze([
     '--help', '-h', '--version', '-v', '--mcp',
     '--json', '--verbose', '--no-quiet', '--quiet',
     '--interactive', '-i',
-    '--no-cache', '--clear-cache', '--no-follow-symlinks',
+    '--no-cache', '--clear-cache', '--no-follow-symlinks', '--include-bundled',
     '--max-files', '--max-chars', '--workers',
 ]);
 
@@ -408,7 +409,7 @@ function getCliAcceptedFlags() {
  * One line per command: `show: file, exclude, class_name, ...`
  */
 function generateMcpParamSection() {
-    const lines = ['', 'ACCEPTED FLAGS PER COMMAND (max_chars, max_files, follow_symlinks always accepted; flags not listed below are ignored):'];
+    const lines = ['', 'ACCEPTED FLAGS PER COMMAND (max_chars, max_files, follow_symlinks, include_bundled always accepted; flags not listed below are ignored):'];
     for (const cmd of CANONICAL_COMMANDS) {
         const flags = FLAG_APPLICABILITY[cmd];
         if (!flags || flags.length === 0) continue;

package/core/reporting.js

@@ -48,6 +48,7 @@ function getStats(index, options = {}) {
         files: scopedFiles.length,
         symbols: totalSymbols,  // Total symbol count, not unique names
         buildTime: index.buildTime,
+        buildTimeNote: 'Last index build, including discovery and graphs; excludes cache I/O and query execution. Reused when loading a cached index.',
         byLanguage: {},
         byType: {},
         ...(index.truncated && { truncated: index.truncated })
@@ -1044,6 +1045,7 @@ function orient(index, options = {}) {
         files: stats.files,
         symbols: stats.symbols,
         buildTime: stats.buildTime,
+        buildTimeNote: stats.buildTimeNote,
         byLanguage: stats.byLanguage,
         dirs,
         hot: {

package/core/search.js

@@ -204,9 +204,19 @@ function _applyFindFilters(index, matches, options) {
         return filtered;
     }
 
-    // Add per-symbol usage counts for disambiguation
-    const withCounts = filtered.map(m => {
-        const counts = index.countSymbolUsages(m);
+    // Rank cheaply before adjudicating callers. A broad inventory must never
+    // pay for pinned caller resolution on rows the caller will not receive.
+    const ranked = filtered.map(symbol => ({
+        symbol, counts: index.countSymbolUsages(symbol),
+    }));
+    if (options.limit > 0 && ranked.length > options.limit) {
+        ranked.sort((a, b) => b.counts.total - a.counts.total ||
+            codeUnitCompare(a.symbol.relativePath || '', b.symbol.relativePath || '') ||
+            a.symbol.startLine - b.symbol.startLine ||
+            codeUnitCompare(a.symbol.name, b.symbol.name));
+    }
+    const survivors = options.limit > 0 ? ranked.slice(0, options.limit) : ranked;
+    const withCounts = survivors.map(({ symbol: m, counts }) => {
         // The fast count supplies cheap definition/import totals, but its
         // name-only call bucket cannot distinguish json.dumps from a project
         // dumps, or one class's save from another's. The public `find`
@@ -873,7 +883,10 @@ function structuralSearch(index, options = {}) {
                         // expression position — never "unused" (the deadcode
                         // twin of the bodyScopedName audit skip).
                         if (def.bodyScopedName) continue;
-                        index.buildCalleeIndex();
+                        // buildCalleeIndex rebuilds the whole project. Reuse
+                        // the eagerly built (or cache-loaded) index, including
+                        // across every candidate in this operation.
+                        if (!index.calleeIndex) index.buildCalleeIndex();
                         // A name whose every call site is its own recursion
                         // has zero callers (fix #253c — the deadcode
                         // carve-out, applied here). Class-kind names are

package/languages/c-family.js

@@ -13,6 +13,7 @@ const { typeOrigin } = require('./type-evidence');
 
 const {
     traverseTree,
+    nodeTextWithoutComments,
     traverseTreeCached,
     nodeToLocation,
     extractJSDocstring,
@@ -989,7 +990,7 @@ function paramTypeText(param, identity) {
     const defaultValue = param.childForFieldName('default_value');
     const end = defaultValue ? defaultValue.startIndex : param.endIndex;
     if (identity.nameNode.startIndex < base || identity.nameNode.endIndex > end) return null;
-    const text = param.text.slice(0, end - base);
+    const text = nodeTextWithoutComments(param).slice(0, end - base);
     const typeText = (text.slice(0, identity.nameNode.startIndex - base) +
         text.slice(identity.nameNode.endIndex - base))
         .replace(/\s+/g, ' ')
@@ -1014,10 +1015,10 @@ function structuredParams(paramsNode) {
         // their type text alone — the type must not double as both name and
         // annotation, and `void *` must not collapse into the `(void)` form.
         const info = {
-            name: identity.name || param.text.replace(/\s+/g, ' ').trim(),
+            name: identity.name || nodeTextWithoutComments(param).replace(/\s+/g, ' ').trim(),
         };
         if (typeNode && identity.name) {
-            info.type = paramTypeText(param, identity) || typeNode.text;
+            info.type = paramTypeText(param, identity) || nodeTextWithoutComments(typeNode);
         }
         if (param.type === 'optional_parameter_declaration') info.optional = true;
         let declaratorCursor = declarator;
@@ -1164,7 +1165,7 @@ function returnTypeOf(node) {
             const descriptor = (current.namedChildren || []).find(child =>
                 child.type === 'type_descriptor') || current.namedChild(0);
             const type = descriptor?.childForFieldName('type') || descriptor;
-            return type?.text || null;
+            return nodeTextWithoutComments(type) || null;
         }
         for (const child of current.namedChildren || []) {
             const found = findTrailing(child);
@@ -1193,7 +1194,7 @@ function returnTypeOf(node) {
         current = current.childForFieldName('declarator') ||
             (current.namedChildren || []).find(child => child.type.endsWith('_declarator'));
     }
-    return stars > 0 ? `${typeNode.text} ${'*'.repeat(stars)}` : typeNode.text;
+    return stars > 0 ? `${nodeTextWithoutComments(typeNode)} ${'*'.repeat(stars)}` : nodeTextWithoutComments(typeNode);
 }
 
 function memberFromNode(node, className, access, lines, mode) {
@@ -1209,7 +1210,7 @@ function memberFromNode(node, className, access, lines, mode) {
     if (isConstructor && identity.name.startsWith('~')) modifiers.push('destructor');
     return {
         name: identity.name,
-        params: paramsNode ? paramsNode.text.replace(/^\(|\)$/g, '').trim() : '...',
+        params: paramsNode ? nodeTextWithoutComments(paramsNode).replace(/^\(|\)$/g, '').trim() : '...',
         paramsStructured: structuredParams(paramsNode),
         returnType: isConstructor ? null :
             (identity.conversionType || returnTypeOf(node)),
@@ -1510,7 +1511,7 @@ function findFunctionsInTree(code, tree, mode, sourceLines = null) {
             : null;
         functions.push({
             name: identity.name,
-            params: paramsNode ? paramsNode.text.replace(/^\(|\)$/g, '').trim() : '...',
+            params: paramsNode ? nodeTextWithoutComments(paramsNode).replace(/^\(|\)$/g, '').trim() : '...',
             paramsStructured: structuredParams(paramsNode),
             returnType: isConstructor ? null :
                 (identity.conversionType || returnTypeOf(node)),
@@ -1800,7 +1801,7 @@ function findMacrosInTree(tree, lines, parser) {
             startLine,
             endLine,
             indent,
-            params: paramsNode ? paramsNode.text.replace(/^\(|\)$/g, '').trim() : undefined,
+            params: paramsNode ? nodeTextWithoutComments(paramsNode).replace(/^\(|\)$/g, '').trim() : undefined,
             paramsStructured: paramsNode
                 ? (paramsNode.namedChildren || [])
                     .filter(child => child.type === 'identifier')

package/languages/csharp.js

@@ -2,6 +2,7 @@
 
 const {
     traverseTree,
+    nodeTextWithoutComments,
     traverseTreeCached,
     nodeToLocation,
     extractJSDocstring,
@@ -127,7 +128,7 @@ function structuredParams(paramsNode) {
         if (nameNode) {
             recoveredParams.push({
                 name: nameNode.text,
-                ...(typeNode && { type: typeNode.text }),
+                ...(typeNode && { type: nodeTextWithoutComments(typeNode) }),
                 rest: true,
             });
         }
@@ -138,14 +139,14 @@ function structuredParams(paramsNode) {
         const typeNode = param.childForFieldName('type');
         if (!nameNode) continue;
         const info = { name: nameNode.text };
-        if (typeNode) info.type = typeNode.text;
+        if (typeNode) info.type = nodeTextWithoutComments(typeNode);
         if (modifiersOf(param).includes('this')) info.extensionReceiver = true;
         if (param.type === 'parameter_array') info.rest = true;
         const value = param.childForFieldName('value') ||
             param.namedChildren.find(child => child !== nameNode && child !== typeNode &&
-                !['attribute_list', 'modifier'].includes(child.type));
+                !['attribute_list', 'modifier', 'comment'].includes(child.type));
         if (value) {
-            info.default = value.text;
+            info.default = nodeTextWithoutComments(value);
             info.optional = true;
         }
         params.push(info);
@@ -208,9 +209,9 @@ function memberFromNode(node, className, lines) {
     const paramsStructured = structuredParams(paramsNode);
     return {
         name,
-        params: paramsNode ? paramsNode.text.replace(/^\(|\)$/g, '').trim() : '...',
+        params: paramsNode ? nodeTextWithoutComments(paramsNode).replace(/^\(|\)$/g, '').trim() : '...',
         paramsStructured,
-        returnType: isConstructor ? null : returnNode?.text || null,
+        returnType: isConstructor ? null : nodeTextWithoutComments(returnNode).trim() || null,
         startLine,
         endLine,
         indent,
@@ -263,9 +264,9 @@ function indexerMember(node, className, lines) {
     const { startLine, endLine, indent } = nodeToLocation(node, lines);
     return {
         name: 'this[]',
-        params: paramsNode ? paramsNode.text.replace(/^\[|\]$/g, '').trim() : '...',
+        params: paramsNode ? nodeTextWithoutComments(paramsNode).replace(/^\[|\]$/g, '').trim() : '...',
         paramsStructured: structuredParams(paramsNode),
-        returnType: typeNode?.text || null,
+        returnType: nodeTextWithoutComments(typeNode).trim() || null,
         startLine,
         endLine,
         indent,
@@ -495,9 +496,9 @@ function findFunctions(code, parser) {
         const modifiers = modifiersOf(node);
         functions.push({
             name: nameNode.text,
-            params: paramsNode ? paramsNode.text.replace(/^\(|\)$/g, '').trim() : '...',
+            params: paramsNode ? nodeTextWithoutComments(paramsNode).replace(/^\(|\)$/g, '').trim() : '...',
             paramsStructured: structuredParams(paramsNode),
-            returnType: returnNode?.text || null,
+            returnType: nodeTextWithoutComments(returnNode).trim() || null,
             startLine,
             endLine,
             indent,

package/languages/go.js

@@ -10,6 +10,7 @@ const { ReceiverTypeMap, typeOrigin } = require('./type-evidence');
 
 const {
     traverseTree,
+    nodeTextWithoutComments,
     traverseTreeCached,
     nodeToLocation,
     parseStructuredParams,
@@ -29,7 +30,7 @@ function parseTree(parser, code) {
 function extractReturnType(node) {
     const resultNode = node.childForFieldName('result');
     if (resultNode) {
-        return resultNode.text.trim() || null;
+        return nodeTextWithoutComments(resultNode).trim() || null;
     }
     return null;
 }
@@ -39,7 +40,7 @@ function extractReturnedFunctionResult(node) {
     const resultNode = node.childForFieldName('result');
     if (resultNode?.type !== 'function_type') return null;
     const innerResult = resultNode.childForFieldName('result');
-    return innerResult?.text.trim() || null;
+    return nodeTextWithoutComments(innerResult).trim() || null;
 }
 
 /**
@@ -51,7 +52,7 @@ function extractGoParams(paramsNode) {
     // unknown signatures in JSON output (fix #238; the shared
     // utils.extractParams already had this fix).
     if (!paramsNode) return '...';
-    const text = paramsNode.text;
+    const text = nodeTextWithoutComments(paramsNode);
     return text.replace(/^\(|\)$/g, '').trim();
 }
 
@@ -115,7 +116,7 @@ function _processFunction(node, functions, processedRanges, lines) {
                 indent,
                 modifiers: isExported ? ['export'] : [],
                 isFunctionVariable: true,
-                ...(resultNode?.text.trim() && { returnType: resultNode.text.trim() }),
+                ...(resultNode && { returnType: nodeTextWithoutComments(resultNode).trim() || null }),
             });
         }
         return true;
@@ -491,11 +492,11 @@ function extractInterfaceMembers(interfaceNode, codeOrLines) {
                 } else if (sub.type === 'parameter_list') {
                     hasParams = true;
                     if (!paramsText) {
-                        paramsText = sub.text.slice(1, -1); // strip parens
+                        paramsText = nodeTextWithoutComments(sub).slice(1, -1); // strip parens
                         paramsNode = sub;
                     } else {
                         // Second parameter_list is the return type tuple
-                        returnType = sub.text;
+                        returnType = nodeTextWithoutComments(sub);
                     }
                 }
             }
@@ -514,7 +515,7 @@ function extractInterfaceMembers(interfaceNode, codeOrLines) {
                 for (let j = 0; j < child.namedChildCount; j++) {
                     const sub = child.namedChild(j);
                     if (returnTypeNodes.has(sub.type) && sub.text !== nameText) {
-                        returnType = sub.text;
+                        returnType = nodeTextWithoutComments(sub);
                     }
                 }
             }

package/languages/java.js

@@ -10,6 +10,7 @@ const { ReceiverTypeMap, typeOrigin } = require('./type-evidence');
 
 const {
     traverseTree,
+    nodeTextWithoutComments,
     traverseTreeCached,
     nodeToLocation,
     parseStructuredParams,
@@ -32,7 +33,7 @@ function extractJavaParams(paramsNode) {
     // unknown signatures in JSON output (fix #241; go/rust got this in #238,
     // the shared utils.extractParams already had it).
     if (!paramsNode) return '...';
-    const text = paramsNode.text;
+    const text = nodeTextWithoutComments(paramsNode);
     let params = text.replace(/^\(|\)$/g, '').trim();
     return params;
 }
@@ -201,7 +202,7 @@ function stripJavaString(text) {
 function extractReturnType(node) {
     const typeNode = node.childForFieldName('type');
     if (typeNode) {
-        return typeNode.text;
+        return nodeTextWithoutComments(typeNode);
     }
     return null;
 }

package/languages/javascript.js

@@ -10,6 +10,7 @@ const { ReceiverTypeMap, typeOrigin } = require('./type-evidence');
 
 const {
     traverseTree,
+    nodeTextWithoutComments,
     traverseTreeCached,
     nodeToLocation,
     extractParams,
@@ -34,7 +35,7 @@ function parseTree(parser, code) {
 function extractReturnType(node) {
     const returnTypeNode = node.childForFieldName('return_type');
     if (returnTypeNode) {
-        let text = returnTypeNode.text.trim();
+        let text = nodeTextWithoutComments(returnTypeNode).trim();
         if (text.startsWith(':')) {
             text = text.slice(1).trim();
         }

package/languages/python.js

@@ -10,6 +10,7 @@ const { ReceiverTypeMap, typeOrigin } = require('./type-evidence');
 
 const {
     traverseTree,
+    nodeTextWithoutComments,
     traverseTreeCached,
     nodeToLocation,
     parseStructuredParams,
@@ -32,7 +33,7 @@ function parseTree(parser, code) {
 function extractReturnType(node) {
     const returnTypeNode = node.childForFieldName('return_type');
     if (returnTypeNode) {
-        let text = returnTypeNode.text.trim();
+        let text = nodeTextWithoutComments(returnTypeNode).trim();
         if (text.startsWith('->')) {
             text = text.slice(2).trim();
         }
@@ -129,7 +130,7 @@ function extractPythonParams(paramsNode) {
     // unknown signatures in JSON output (fix #241; go/rust got this in #238,
     // the shared utils.extractParams already had it).
     if (!paramsNode) return '...';
-    const text = paramsNode.text;
+    const text = nodeTextWithoutComments(paramsNode);
     let params = text.replace(/^\(|\)$/g, '').trim();
     return params;
 }

package/languages/rust.js

@@ -10,6 +10,7 @@ const { ReceiverTypeMap, typeOrigin } = require('./type-evidence');
 
 const {
     traverseTree,
+    nodeTextWithoutComments,
     traverseTreeCached,
     nodeToLocation,
     parseStructuredParams,
@@ -128,7 +129,7 @@ function declarationTrees(code, parser) {
 function extractReturnType(node) {
     const returnTypeNode = node.childForFieldName('return_type');
     if (returnTypeNode) {
-        let text = returnTypeNode.text.trim();
+        let text = nodeTextWithoutComments(returnTypeNode).trim();
         if (text.startsWith('->')) {
             text = text.slice(2).trim();
         }
@@ -198,7 +199,7 @@ function extractRustParams(paramsNode) {
     // unknown signatures in JSON output (fix #238; the shared
     // utils.extractParams already had this fix).
     if (!paramsNode) return '...';
-    const text = paramsNode.text;
+    const text = nodeTextWithoutComments(paramsNode);
     return text.replace(/^\(|\)$/g, '').trim();
 }