ucn 3.8.22 → 3.8.25

package/core/callers.js

@@ -13,6 +13,14 @@ const { isTestFile } = require('./discovery');
 const { NON_CALLABLE_TYPES } = require('./shared');
 const { scoreEdge } = require('./confidence');
 
+/** Set.some() helper — like Array.some() but for Sets */
+function setSome(set, predicate) {
+    for (const item of set) {
+        if (predicate(item)) return true;
+    }
+    return false;
+}
+
 /**
  * Extract a single line from content without splitting the entire string.
  * @param {string} content - Full file content
@@ -40,6 +48,11 @@ function getLine(content, lineNum) {
  */
 function getCachedCalls(index, filePath, options = {}) {
     try {
+        // Trigger lazy calls cache load if prepared but not yet loaded
+        if (index._callsCachePrepared && !index._callsCacheLoaded) {
+            const { ensureCallsCacheLoaded } = require('./cache');
+            ensureCallsCacheLoaded(index);
+        }
         const cached = index.callsCache.get(filePath);
 
         // Fast path: check mtime first (stat is much faster than read+hash)
@@ -91,6 +104,8 @@ function getCachedCalls(index, filePath, options = {}) {
         }
         const calls = langModule.findCallsInCode(content, parser, callOpts);
 
+        // Remove old callee index entries before overwriting cache
+        if (cached) index._removeFromCalleeIndex(filePath, cached.calls);
         index.callsCache.set(filePath, {
             mtime,
             hash,
@@ -98,6 +113,8 @@ function getCachedCalls(index, filePath, options = {}) {
             content: options.includeContent ? content : undefined
         });
         index.callsCacheDirty = true;
+        // Incrementally update callee index with new calls
+        index._addToCalleeIndex(filePath, calls);
 
         if (options.includeContent) {
             return { calls, content };
@@ -143,6 +160,11 @@ function findCallers(index, name, options = {}) {
     const pendingByFile = new Map(); // filePath -> [{ call, fileEntry, callerSymbol, isMethod, isFunctionReference, receiver }]
     let pendingCount = 0;
     const maxResults = options.maxResults;
+    // BUG-H1: when consumers (like `about`) need an accurate truncation header
+    // ("showing N of <total>"), they pass needsTotal:true so Phase 1 runs to
+    // completion. Phase 2 still only enriches the first `maxResults` items —
+    // file reads stay bounded, but the candidate count reflects the true total.
+    const needsTotal = !!options.needsTotal;
     const localTypeCache = new Map(); // `${filePath}:${startLine}` -> localTypes Map or null
 
     // Use inverted callee index to skip files that don't contain calls to this name
@@ -152,8 +174,8 @@ function findCallers(index, name, options = {}) {
         : index.files;
 
     for (const [filePath, fileEntry] of fileIterator) {
-        // Early exit when maxResults is reached
-        if (maxResults && pendingCount >= maxResults) break;
+        // Early exit when maxResults is reached (skip when caller needs the true total)
+        if (maxResults && !needsTotal && pendingCount >= maxResults) break;
         try {
             const calls = getCachedCalls(index, filePath);
             if (!calls) continue;
@@ -390,14 +412,14 @@ function findCallers(index, name, options = {}) {
                     langTraits(fileEntry.language)?.typeSystem === 'structural') {
                     const targetFiles = new Set(targetDefs.map(d => d.file).filter(Boolean));
                     if (targetFiles.size > 0 && !targetFiles.has(filePath)) {
-                        const imports = index.importGraph.get(filePath) || [];
-                        const importsTarget = imports.some(imp => targetFiles.has(imp));
+                        const imports = index.importGraph.get(filePath);
+                        const importsTarget = imports && setSome(imports, imp => targetFiles.has(imp));
                         if (!importsTarget) {
                             // Check one level of re-exports (barrel files)
                             let foundViaReexport = false;
-                            for (const imp of imports) {
-                                const transImports = index.importGraph.get(imp) || [];
-                                if (transImports.some(ti => targetFiles.has(ti))) {
+                            if (imports) for (const imp of imports) {
+                                const transImports = index.importGraph.get(imp);
+                                if (transImports && setSome(transImports, ti => targetFiles.has(ti))) {
                                     foundViaReexport = true;
                                     break;
                                 }
@@ -455,10 +477,10 @@ function findCallers(index, name, options = {}) {
                             continue;
                         }
                         // Multi-segment import — verify via import graph
-                        const callerImportedFiles = index.importGraph.get(filePath) || [];
+                        const callerImportedFiles = index.importGraph.get(filePath);
                         const targetFiles = new Set(targetDefs.map(d => d.file).filter(Boolean));
                         if (!targetFiles.has(filePath)) {
-                            const hasImportEdge = callerImportedFiles.some(imp => targetFiles.has(imp));
+                            const hasImportEdge = callerImportedFiles && setSome(callerImportedFiles, imp => targetFiles.has(imp));
                             if (!hasImportEdge) {
                                 // No import edge — allow same-package (same directory) calls
                                 const callerDir = path.dirname(filePath);
@@ -583,13 +605,13 @@ function findCallers(index, name, options = {}) {
                 // Check import graph evidence: does this file import from the target definition's file?
                 const targetDefs2 = options.targetDefinitions || definitions;
                 const targetFiles2 = new Set(targetDefs2.map(d => d.file).filter(Boolean));
-                const callerImports = index.importGraph.get(filePath) || [];
-                let hasImportLink = targetFiles2.has(filePath) || callerImports.some(imp => targetFiles2.has(imp));
+                const callerImports = index.importGraph.get(filePath);
+                let hasImportLink = targetFiles2.has(filePath) || (callerImports && setSome(callerImports, imp => targetFiles2.has(imp)));
                 // Check one level of re-exports (barrel files) for import evidence
-                if (!hasImportLink) {
+                if (!hasImportLink && callerImports) {
                     for (const imp of callerImports) {
-                        const transImports = index.importGraph.get(imp) || [];
-                        if (transImports.some(ti => targetFiles2.has(ti))) {
+                        const transImports = index.importGraph.get(imp);
+                        if (transImports && setSome(transImports, ti => targetFiles2.has(ti))) {
                             hasImportLink = true;
                             break;
                         }
@@ -626,34 +648,83 @@ function findCallers(index, name, options = {}) {
         }
     }
 
+    // True total candidate count from Phase 1 (before any Phase 2 truncation).
+    // Used by callers that need accurate "showing N of <total>" headers.
+    const totalCount = pendingCount;
+    // When needsTotal is set with a maxResults cap, only enrich the first
+    // `maxResults` candidates in Phase 2 — file reads stay bounded.
+    const enrichLimit = (needsTotal && maxResults) ? maxResults : Infinity;
+    let enrichedCount = 0;
+
+    // BUG-H1: shadow records for un-enriched candidates so post-call filters
+    // (exclude / minConfidence) can produce an accurate total without forcing
+    // a Phase-2 file read for every candidate. Each shadow has just enough
+    // info to drive the filter predicates: relativePath + confidence.
+    const shadowEntries = [];
+
     // Phase 2: Read content only for files with matching calls (eliminates ~98% of file reads)
-    for (const [filePath, pending] of pendingByFile) {
-        try {
-            const content = fs.readFileSync(filePath, 'utf-8');
-            for (const { call, fileEntry, callerSymbol, isMethod, isFunctionReference, receiver, receiverType, _evidence } of pending) {
-                const scored = scoreEdge(_evidence || {});
-                callers.push({
+    outer: for (const [filePath, pending] of pendingByFile) {
+        let content = null;
+        for (const { call, fileEntry, callerSymbol, isMethod, isFunctionReference, receiver, receiverType, _evidence } of pending) {
+            const scored = scoreEdge(_evidence || {});
+            if (enrichedCount >= enrichLimit) {
+                // Push shadow only — no file read needed.
+                shadowEntries.push({
                     file: filePath,
                     relativePath: fileEntry.relativePath,
                     line: call.line,
-                    content: getLine(content, call.line),
-                    callerName: callerSymbol ? callerSymbol.name : null,
-                    callerFile: callerSymbol ? filePath : null,
-                    callerStartLine: callerSymbol ? callerSymbol.startLine : null,
-                    callerEndLine: callerSymbol ? callerSymbol.endLine : null,
-                    isMethod,
+                    confidence: scored.confidence,
+                    resolution: scored.resolution,
+                    isMethod: call.isMethod || false,
                     ...(isFunctionReference && { isFunctionReference: true }),
                     ...(receiver !== undefined && { receiver }),
                     ...(receiverType && { receiverType }),
-                    confidence: scored.confidence,
-                    resolution: scored.resolution,
                 });
+                continue;
             }
-        } catch (e) {
-            // File may have been deleted between Phase 1 and Phase 2
+            // First time we hit this file's enrichment loop — read the file once.
+            if (content === null) {
+                try { content = fs.readFileSync(filePath, 'utf-8'); }
+                catch (e) { content = ''; /* deleted/unreadable; skip enrichment for rest */ break; }
+            }
+            callers.push({
+                file: filePath,
+                relativePath: fileEntry.relativePath,
+                line: call.line,
+                content: getLine(content, call.line),
+                callerName: callerSymbol ? callerSymbol.name : null,
+                callerFile: callerSymbol ? filePath : null,
+                callerStartLine: callerSymbol ? callerSymbol.startLine : null,
+                callerEndLine: callerSymbol ? callerSymbol.endLine : null,
+                isMethod,
+                ...(isFunctionReference && { isFunctionReference: true }),
+                ...(receiver !== undefined && { receiver }),
+                ...(receiverType && { receiverType }),
+                confidence: scored.confidence,
+                resolution: scored.resolution,
+            });
+            enrichedCount++;
         }
     }
 
+    // Tag the returned array with the true total candidate count (only meaningful
+    // when needsTotal:true was passed). Defined as non-enumerable so JSON.stringify
+    // won't surprise consumers; defaults to callers.length when not set.
+    Object.defineProperty(callers, 'totalCount', {
+        value: needsTotal ? totalCount : callers.length,
+        enumerable: false,
+        writable: true,
+        configurable: true,
+    });
+    // Attach shadow entries so consumers can compute post-filter totals without
+    // re-running findCallers. Empty when needsTotal:false or all candidates fit.
+    Object.defineProperty(callers, 'shadowEntries', {
+        value: shadowEntries,
+        enumerable: false,
+        writable: true,
+        configurable: true,
+    });
+
     return callers;
     } finally { index._endOp(); }
 }
@@ -1175,7 +1246,7 @@ function findCallees(index, def, options = {}) {
         const defFileEntry = fileEntry;
         const callerIsTest = defFileEntry && isTestFile(defFileEntry.relativePath, defFileEntry.language);
         // Pre-compute import graph for callee confidence scoring
-        const callerImportSet = new Set(index.importGraph.get(def.file) || []);
+        const callerImportSet = index.importGraph.get(def.file) || new Set();
 
         for (const { name: calleeName, bindingId, count, isConstructor } of callees.values()) {
             const symbols = index.symbols.get(calleeName);
@@ -1366,6 +1437,7 @@ function _buildLocalTypeMap(index, def, calls) {
     }
     const lines = content.split('\n');
     const localTypes = new Map();
+    const regexCache = new Map();
 
     for (const call of calls) {
         // Only look at calls within this function's scope
@@ -1383,18 +1455,21 @@ function _buildLocalTypeMap(index, def, calls) {
         const sourceLine = lines[call.line - 1];
         if (!sourceLine) continue;
 
-        // Match: identifier = ClassName(...) or identifier: Type = ClassName(...)
-        const escapedName = call.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const assignMatch = sourceLine.match(
-            new RegExp(`(\\w+)\\s*(?::\\s*\\w+)?\\s*=\\s*${escapedName}\\s*\\(`)
-        );
+        // Memoize compiled regex per call name (same name → same pattern)
+        let patterns = regexCache.get(call.name);
+        if (!patterns) {
+            const esc = call.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            patterns = {
+                assign: new RegExp(`(\\w+)\\s*(?::\\s*\\w+)?\\s*=\\s*${esc}\\s*\\(`),
+                with: new RegExp(`with\\s+${esc}\\s*\\([^)]*\\)\\s+as\\s+(\\w+)`)
+            };
+            regexCache.set(call.name, patterns);
+        }
+        const assignMatch = sourceLine.match(patterns.assign);
         if (assignMatch) {
             localTypes.set(assignMatch[1], call.name);
         }
-        // Match: with ClassName(...) as identifier:
-        const withMatch = sourceLine.match(
-            new RegExp(`with\\s+${escapedName}\\s*\\([^)]*\\)\\s+as\\s+(\\w+)`)
-        );
+        const withMatch = sourceLine.match(patterns.with);
         if (withMatch) {
             localTypes.set(withMatch[1], call.name);
         }
@@ -1432,10 +1507,11 @@ function _buildTypedLocalTypeMap(index, def, calls) {
         // Handles: x := NewFoo(), x, err := NewFoo(), x := pkg.NewFoo(), x, err := pkg.NewFoo()
         const newName = call.isMethod ? call.name : call.name;
         if (/^New[A-Z]/.test(newName) && !call.isPotentialCallback) {
+            if (_cachedLines === false) continue; // File unreadable, skip all
             if (!_cachedLines) {
                 try {
                     _cachedLines = index._readFile(def.file).split('\n');
-                } catch { continue; }
+                } catch { _cachedLines = false; continue; }
             }
             const sourceLine = _cachedLines[call.line - 1];
             if (!sourceLine) continue;

package/core/check.js

@@ -0,0 +1,200 @@
+/**
+ * core/check.js — Pre-commit summary command.
+ *
+ * Composes diff-impact + verify + affected-tests into a single output.
+ * Tells the caller, in one shot:
+ *   - which functions changed
+ *   - which call sites might break (signature drift)
+ *   - which tests are likely affected
+ *   - which new functions look orphaned
+ */
+
+'use strict';
+
+const { diffImpact } = require('./analysis');
+
+/**
+ * Run the pre-commit check.
+ *
+ * @param {object} index - ProjectIndex
+ * @param {object} options - { base, staged, file, limit }
+ * @returns {object}
+ */
+function check(index, options = {}) {
+    let dr;
+    try {
+        dr = diffImpact(index, {
+            base: options.base || 'HEAD',
+            staged: !!options.staged,
+            file: options.file,
+        });
+    } catch (e) {
+        // Not a git repo, or git command failed — treat as empty
+        return {
+            base: options.base || 'HEAD',
+            staged: !!options.staged,
+            empty: true,
+            reason: e && e.message ? e.message : 'diff failed',
+        };
+    }
+
+    // diffImpact returns { base, functions, newFunctions, deletedFunctions }
+    const modified = (dr && Array.isArray(dr.functions)) ? dr.functions : [];
+    const added    = (dr && Array.isArray(dr.newFunctions)) ? dr.newFunctions : [];
+    const deleted  = (dr && Array.isArray(dr.deletedFunctions)) ? dr.deletedFunctions : [];
+
+    const allChanged = [
+        ...modified.map(f => ({ ...f, _kind: 'modified' })),
+        ...added.map(f => ({ ...f, _kind: 'added' })),
+    ];
+
+    if (!dr || (modified.length === 0 && added.length === 0 && deleted.length === 0)) {
+        return {
+            base: options.base || 'HEAD',
+            staged: !!options.staged,
+            empty: true,
+            reason: dr && dr.error ? dr.error : 'no changes detected',
+        };
+    }
+
+    const limit = options.limit && options.limit > 0 ? options.limit : null;
+    const changed = limit ? allChanged.slice(0, limit) : allChanged;
+
+    const items = [];
+    const reachable = computeReachableSet(index);
+
+    // For each changed function, run verify and gather caller summary
+    for (const fn of changed) {
+        const filePath = fn.relativePath || fn.file || '';
+        let verifyResult = null;
+        try {
+            verifyResult = index.verify(fn.name, { file: filePath });
+        } catch (e) {
+            verifyResult = null;
+        }
+        // Note: verify() returns `mismatches` as a COUNT and `mismatchDetails` as the array.
+        const mismatches = verifyResult && Array.isArray(verifyResult.mismatchDetails)
+            ? verifyResult.mismatchDetails
+            : [];
+
+        // For modified functions, the existing diffImpact result has `callers` already
+        let callers = Array.isArray(fn.callers) ? fn.callers : [];
+        if (callers.length === 0 && fn._kind === 'added') {
+            try {
+                callers = index.findCallers(fn.name, { includeMethods: true, includeUncertain: false }) || [];
+            } catch (e) { /* skip */ }
+        }
+
+        const item = {
+            name: fn.name,
+            file: filePath,
+            line: fn.startLine || fn.line,
+            kind: fn._kind,
+            callerCount: callers.length,
+            signatureMismatches: mismatches.length,
+            ...(mismatches.length > 0 && { mismatches: mismatches.slice(0, 5) }),
+        };
+
+        // Orphan = newly added with zero callers AND not detected as an entry point.
+        // (A new helper called by another new helper is still NOT orphan; reachability
+        //  is rebuilt as the user iterates, and false positives here cause noise.)
+        if (item.kind === 'added' && callers.length === 0) {
+            // Check entry points: if the symbol is a known entry-point pattern, not orphan
+            let isEntry = false;
+            try {
+                const ep = require('./entrypoints');
+                if (typeof ep.detectEntrypoints === 'function') {
+                    const eps = ep.detectEntrypoints(index) || [];
+                    isEntry = eps.some(e => e.name === fn.name && (e.file === filePath || e.relativePath === filePath));
+                }
+            } catch (e) { /* skip */ }
+            item.orphan = !isEntry;
+        }
+
+        items.push(item);
+    }
+
+    // Surface deleted functions inline — they don't have line/file but still matter
+    for (const d of deleted) {
+        items.push({
+            name: d.name || '(unnamed)',
+            file: d.relativePath || d.file || '',
+            line: d.startLine || 0,
+            kind: 'deleted',
+            callerCount: 0,
+            signatureMismatches: 0,
+        });
+    }
+
+    // Affected tests (top-level summary, capped)
+    let testFiles = [];
+    let testCount = 0;
+    for (const fn of changed.slice(0, 10)) {
+        try {
+            const t = index.affectedTests(fn.name, { depth: 2 });
+            if (t && t.testFiles) {
+                for (const tf of t.testFiles) {
+                    if (!testFiles.find(x => x.file === tf.file)) {
+                        testFiles.push(tf);
+                        testCount += tf.testCount || 0;
+                    }
+                }
+            }
+        } catch (e) { /* skip */ }
+    }
+
+    // Action items
+    const actions = [];
+    for (const it of items) {
+        if (it.signatureMismatches > 0) {
+            actions.push({
+                severity: 'warn',
+                kind: 'signature_drift',
+                message: `${it.name}: ${it.signatureMismatches} call site(s) need updating`,
+            });
+        }
+        if (it.orphan) {
+            actions.push({
+                severity: 'warn',
+                kind: 'orphan_new',
+                message: `${it.name} is new but has no callers and is not an entry point`,
+            });
+        }
+    }
+    if (testFiles.length > 0) {
+        const filesList = testFiles.slice(0, 5).map(t => t.file).join(' ');
+        actions.push({
+            severity: 'info',
+            kind: 'tests_to_run',
+            message: `Run tests: ${filesList}`,
+        });
+    }
+
+    return {
+        base: options.base || 'HEAD',
+        staged: !!options.staged,
+        changed: items,
+        totalChanged: allChanged.length + deleted.length,
+        truncated: !!(limit && allChanged.length > limit),
+        testFiles,
+        totalTestFiles: testFiles.length,
+        totalTests: testCount,
+        actions,
+    };
+}
+
+function symbolKey(file, line) {
+    return `${file}:${line}`;
+}
+
+function computeReachableSet(index) {
+    try {
+        const ep = require('./entrypoints');
+        if (typeof ep.computeReachability === 'function') {
+            return ep.computeReachability(index);
+        }
+    } catch (e) { /* fall through */ }
+    return null;
+}
+
+module.exports = { check };

package/core/deadcode.js

@@ -212,6 +212,28 @@ function deadcode(index, options = {}) {
         }
     }
 
+    // Pre-filter exported symbols from the scan set when not auditing exports.
+    // Go exports ~63K capitalized names on K8s — scanning these in Phase 2 only to
+    // skip them in Phase 3 wastes O(63K × 11K files) = ~700M comparisons.
+    if (!options.includeExported) {
+        const narrowed = new Set();
+        for (const name of potentiallyDeadNames) {
+            const syms = index.symbols.get(name) || [];
+            // Keep the name only if at least one definition is NOT exported
+            const allExported = syms.every(s => {
+                const fe = index.files.get(s.file);
+                const lang = fe?.language;
+                if (!fe) return false;
+                return fe.exports.includes(name) ||
+                    (s.modifiers || []).includes('export') ||
+                    (s.modifiers || []).includes('public') ||
+                    (langTraits(lang)?.exportVisibility === 'capitalization' && /^[A-Z]/.test(name));
+            });
+            if (!allExported) narrowed.add(name);
+        }
+        potentiallyDeadNames = narrowed;
+    }
+
     // When --file is provided, pre-filter to only names of symbols in the target scope.
     // The text scan below is O(potentiallyDeadNames × files) — narrowing the name set
     // avoids scanning all files for names that will be filtered out at the result stage.
@@ -236,9 +258,16 @@ function deadcode(index, options = {}) {
         for (const [filePath, fileEntry] of index.files) {
             try {
                 const content = index._readFile(filePath);
-                const lines = content.split('\n');
+                // Fast pre-filter: extract identifiers from file, intersect with target names.
+                // One regex pass over content (O(content)) vs O(names × content) substring searches.
+                const fileIdentifiers = new Set(content.match(/\b[a-zA-Z_]\w*\b/g));
+                const namesInFile = [];
                 for (const name of potentiallyDeadNames) {
-                    if (!content.includes(name)) continue;
+                    if (fileIdentifiers.has(name)) namesInFile.push(name);
+                }
+                if (namesInFile.length === 0) continue;
+                const lines = content.split('\n');
+                for (const name of namesInFile) {
                     const nameLen = name.length;
                     for (let i = 0; i < lines.length; i++) {
                         const line = lines[i];

package/core/discovery.js

@@ -393,43 +393,68 @@ function findProjectRoot(startDir) {
     return path.resolve(startDir);
 }
 
+// All file extensions for languages UCN supports as code analysis (excludes .rb/.php/.c/.cpp etc.
+// which are extensions UCN scans but doesn't analyze). When build manifests can't tell us
+// what's in a project, we scan all of these — the file extension alone determines language.
+const ALL_SUPPORTED_EXTENSIONS = ['js', 'jsx', 'ts', 'tsx', 'mjs', 'cjs', 'py', 'go', 'java', 'rs', 'html', 'htm'];
+
+// Build-manifest hints: when present, we know the project has files of that language
+// regardless of whether sources are visible at the time of scan. Used as hints, not gates —
+// any source file extension is included whether or not its manifest is present.
+const MANIFEST_HINTS = {
+    'package.json':      ['js', 'jsx', 'ts', 'tsx', 'mjs', 'cjs', 'html', 'htm'],
+    'pyproject.toml':    ['py'],
+    'setup.py':          ['py'],
+    'requirements.txt':  ['py'],
+    'go.mod':            ['go'],
+    'Cargo.toml':        ['rs'],
+    'pom.xml':           ['java'],
+    'build.gradle':      ['java'],
+    'build.gradle.kts':  ['java'],
+};
+
 /**
- * Auto-detect the glob pattern for a project based on its type
- * Checks both project root and immediate subdirectories for config files
+ * Auto-detect the glob pattern for a project.
+ *
+ * Discovery rule: build manifests are HINTS, not gates. We always scan ALL supported
+ * language extensions (JS/TS/Python/Go/Rust/Java/HTML). Manifests only inform metadata
+ * (e.g., flagging a project as "has Go") and never exclude files.
+ *
+ * This means a polyglot project with only `package.json` still discovers .py/.go/.rs
+ * files — language is determined by extension, not by manifest presence.
+ *
+ * Manifests are still useful for:
+ *   - Project root detection (see findProjectRoot / PROJECT_MARKERS)
+ *   - Conditional ignores (vendor/target/Pods/etc. — see CONDITIONAL_IGNORES)
+ *   - Language hints in stats output
  */
 function detectProjectPattern(projectRoot) {
-    const extensions = [];
-
-    // Helper to check for config files in a directory
-    const checkDir = (dir) => {
-        if (fs.existsSync(path.join(dir, 'package.json'))) {
-            extensions.push('js', 'jsx', 'ts', 'tsx', 'mjs', 'cjs', 'html', 'htm');
-        }
-
-        if (fs.existsSync(path.join(dir, 'pyproject.toml')) ||
-            fs.existsSync(path.join(dir, 'setup.py')) ||
-            fs.existsSync(path.join(dir, 'requirements.txt'))) {
-            extensions.push('py');
-        }
-
-        if (fs.existsSync(path.join(dir, 'go.mod'))) {
-            extensions.push('go');
-        }
+    // Always scan all supported language extensions. Build manifests no longer gate
+    // language inclusion — file extension alone determines what gets analyzed.
+    return `**/*.{${ALL_SUPPORTED_EXTENSIONS.join(',')}}`;
+}
 
-        if (fs.existsSync(path.join(dir, 'Cargo.toml'))) {
-            extensions.push('rs');
-        }
+/**
+ * Detect which manifest hints are present in a project root or immediate subdirectories.
+ * Returns array of detected language extension hints. Used purely informationally —
+ * not as a gate on which files get scanned.
+ *
+ * @param {string} projectRoot - Project root directory
+ * @returns {string[]} Array of language extension strings (e.g., ['js', 'py', 'go'])
+ */
+function detectManifestHints(projectRoot) {
+    const hints = new Set();
 
-        if (fs.existsSync(path.join(dir, 'pom.xml')) ||
-            fs.existsSync(path.join(dir, 'build.gradle'))) {
-            extensions.push('java');
+    const checkDir = (dir) => {
+        for (const [marker, exts] of Object.entries(MANIFEST_HINTS)) {
+            if (fs.existsSync(path.join(dir, marker))) {
+                for (const ext of exts) hints.add(ext);
+            }
         }
     };
 
-    // Check project root
     checkDir(projectRoot);
 
-    // Also check immediate subdirectories for multi-language projects (e.g., web/, frontend/, server/)
     try {
         const entries = fs.readdirSync(projectRoot, { withFileTypes: true });
         for (const entry of entries) {
@@ -442,12 +467,7 @@ function detectProjectPattern(projectRoot) {
         // Ignore errors reading directory
     }
 
-    if (extensions.length > 0) {
-        const unique = [...new Set(extensions)];
-        return `**/*.{${unique.join(',')}}`;
-    }
-
-    return '**/*.{js,jsx,ts,tsx,py,go,java,rs,rb,php,c,cpp,h,hpp,html,htm}';
+    return [...hints];
 }
 
 /**
@@ -541,11 +561,14 @@ module.exports = {
     shouldIgnore,
     findProjectRoot,
     detectProjectPattern,
+    detectManifestHints,
     getFileStats,
     isTestFile,
     findTestFileFor,
     parseGitignore,
     DEFAULT_IGNORES,
     PROJECT_MARKERS,
-    TEST_PATTERNS
+    TEST_PATTERNS,
+    ALL_SUPPORTED_EXTENSIONS,
+    MANIFEST_HINTS
 };