ucn 4.0.2 → 4.1.1

package/core/reporting.js

@@ -8,6 +8,8 @@
 'use strict';
 
 const fs = require('fs');
+const { codeUnitCompare, CALLABLE_SYMBOL_KINDS } = require('./shared');
+const { _declaredFieldType, _projectTopLevelNames } = require('./callers');
 const path = require('path');
 const { isTestFile } = require('./discovery');
 
@@ -67,9 +69,7 @@ function getStats(index, options = {}) {
         const functions = [];
         for (const [name, symbols] of index.symbols) {
             for (const sym of symbols) {
-                if (sym.type === 'function' || sym.type === 'method' || sym.type === 'static' ||
-                    sym.type === 'constructor' || sym.type === 'public' || sym.type === 'abstract' ||
-                    sym.type === 'classmethod') {
+                if (CALLABLE_SYMBOL_KINDS.has(sym.type)) {
                     const lineCount = sym.endLine - sym.startLine + 1;
                     const relativePath = sym.relativePath || (sym.file ? path.relative(index.root, sym.file) : '');
                     functions.push({
@@ -97,10 +97,7 @@ function getStats(index, options = {}) {
         const top = options.top === 0
             ? 0
             : ((options.top != null && Number(options.top) > 0) ? Number(options.top) : 10);
-        const FUNCTION_TYPES = new Set([
-            'function', 'method', 'static', 'constructor',
-            'public', 'abstract', 'classmethod'
-        ]);
+        const FUNCTION_TYPES = CALLABLE_SYMBOL_KINDS;
 
         // Ensure the calls cache is fully populated before counting.
         // First-time stats --hot may need to parse files to extract calls;
@@ -135,6 +132,15 @@ function getStats(index, options = {}) {
         // Pre-compute import-alias sets per file. Used to distinguish `mod.foo()`
         // (resolves to top-level foo) from `obj.foo()` on a local variable.
         const fileImportAliases = new Map();         // filePath -> Set<string> of alias names
+        const fieldHopCache = new Map();             // rootType\0field -> declared type|null
+        // Names import-bound to an EXTERNAL module, per file (fix #256,
+        // dogfood-measured: 895 node:test `describe(...)` calls in test
+        // files were attributed to a project closure named `describe` —
+        // the #215 name discipline says an externally-bound bare name
+        // cannot reach a project def, so it never counts toward the hot
+        // leaderboard). Relative modules, resolved modules, and resolver
+        // gaps (first segment names a project path) all stay countable.
+        const fileExternalNames = new Map();         // filePath -> Set<string>
         for (const [filePath, fileEntry] of index.files) {
             const aliases = new Set();
             // importNames are the named imports/exports brought into this file.
@@ -147,6 +153,16 @@ function getStats(index, options = {}) {
                 }
             }
             fileImportAliases.set(filePath, aliases);
+            let ext = null;
+            for (const b of (fileEntry.importBindings || [])) {
+                const mod = String(b.module || '');
+                if (!b.name || !mod || mod.startsWith('.') || mod.startsWith('/')) continue;
+                if (fileEntry.moduleResolved && fileEntry.moduleResolved[mod]) continue;
+                const firstSeg = mod.split(/[./]/).filter(Boolean)[0];
+                if (firstSeg && _projectTopLevelNames(index).has(firstSeg)) continue;
+                (ext || (ext = new Set())).add(b.name);
+            }
+            if (ext) fileExternalNames.set(filePath, ext);
         }
 
         for (const [filePath, entry] of index.callsCache) {
@@ -164,6 +180,9 @@ function getStats(index, options = {}) {
                     // Bare-name call: foo() or pkg.Foo() (Go package call has receiver
                     // but isMethod:false — keep counting under bareName since they
                     // resolve like top-level functions in their package).
+                    // Externally-bound names are the external library's calls,
+                    // never a project def's (fix #256).
+                    if (fileExternalNames.get(filePath)?.has(c.name)) continue;
                     bareNameCounts.set(c.name, (bareNameCounts.get(c.name) || 0) + 1);
                 } else if (isSelfMethod) {
                     // self/this.foo() — attributed to the enclosing class's foo
@@ -178,11 +197,26 @@ function getStats(index, options = {}) {
                         importedReceiverCounts.set(c.name,
                             (importedReceiverCounts.get(c.name) || 0) + 1);
                     }
-                    if (c.receiverType) {
-                        let inner = methodByReceiverType.get(c.receiverType);
+                    // Field-access receivers (fix #251): `tm.service.Save()`
+                    // carries receiverRootType, not receiverType — the same
+                    // #202/#231 declared-field hop the caller/callee engine
+                    // uses. Without it, edges `context` confirms were
+                    // invisible to the hot leaderboard.
+                    let recvType = c.receiverType;
+                    if (!recvType && c.receiverField && c.receiverRootType) {
+                        const hopKey = `${c.receiverRootType}\u0000${c.receiverField}`;
+                        if (!fieldHopCache.has(hopKey)) {
+                            const lang = index.files.get(filePath)?.language;
+                            fieldHopCache.set(hopKey,
+                                lang ? _declaredFieldType(index, c.receiverRootType, c.receiverField, lang) : null);
+                        }
+                        recvType = fieldHopCache.get(hopKey);
+                    }
+                    if (recvType) {
+                        let inner = methodByReceiverType.get(recvType);
                         if (!inner) {
                             inner = new Map();
-                            methodByReceiverType.set(c.receiverType, inner);
+                            methodByReceiverType.set(recvType, inner);
                         }
                         inner.set(c.name, (inner.get(c.name) || 0) + 1);
                     }
@@ -304,7 +338,7 @@ function getStats(index, options = {}) {
             if (approximate) usedHeuristicSplit = true;
             // Sort locations by (file, startLine) for stable display.
             locations.sort((a, b) =>
-                a.file.localeCompare(b.file) ||
+                codeUnitCompare(a.file, b.file) ||
                 (a.startLine || 0) - (b.startLine || 0)
             );
             const primary = locations[0];
@@ -329,7 +363,7 @@ function getStats(index, options = {}) {
         // Stable order: callCount desc, then (relativePath, startLine) asc.
         hotList.sort((a, b) =>
             (b.callCount - a.callCount) ||
-            a.file.localeCompare(b.file) ||
+            codeUnitCompare(a.file, b.file) ||
             (a.startLine || 0) - (b.startLine || 0)
         );
 
@@ -736,4 +770,88 @@ function computeCoverageSample(index, { sampleSize, inFilter, matchInFilter }) {
     return buckets;
 }
 
-module.exports = { getStats, getToc, doctor };
+/**
+ * orient — one-call cold-repo orientation: size + language mix, densest
+ * directories, most-called functions, entry-point counts, and the doctor
+ * trust verdict. Composes existing engine reads; counts and pointers only
+ * (no caller claims, so no account — the toc/stats category).
+ */
+function orient(index, options = {}) {
+    const top = options.top || 8;
+    // Fetch a deeper hot list so production functions survive the filter
+    // below even when test helpers dominate raw call counts.
+    const stats = getStats(index, { hot: true, top: Math.min(top * 5, 200) });
+    const health = doctor(index, {});
+
+    // Densest directories (leaf dirname rollup — "where does the code live")
+    const dirMap = new Map();
+    for (const [, fe] of index.files) {
+        const rp = fe.relativePath;
+        if (!rp) continue;
+        const slash = rp.lastIndexOf('/');
+        const dir = slash === -1 ? '.' : rp.slice(0, slash);
+        const e = dirMap.get(dir) || { dir, files: 0, symbols: 0 };
+        e.files += 1;
+        e.symbols += (fe.symbols || []).length;
+        dirMap.set(dir, e);
+    }
+    const dirs = [...dirMap.values()]
+        .sort((a, b) => b.symbols - a.symbols || codeUnitCompare(a.dir, b.dir))
+        .slice(0, top);
+
+    // Entry-point counts by type — orientation must not fail on detection
+    let entrypoints = null;
+    try {
+        const { detectEntrypoints } = require('./entrypoints');
+        const eps = detectEntrypoints(index, {});
+        if (Array.isArray(eps)) {
+            const byType = new Map();
+            for (const e of eps) byType.set(e.type, (byType.get(e.type) || 0) + 1);
+            entrypoints = {
+                total: eps.length,
+                byType: [...byType.entries()]
+                    .map(([type, count]) => ({ type, count }))
+                    .sort((a, b) => b.count - a.count || codeUnitCompare(a.type, b.type)),
+            };
+        }
+    } catch { /* detection error → entrypoints stays null, rendered as unavailable */ }
+
+    // Orientation wants the ENGINE's hot functions, not fixture helpers —
+    // prefer production-path entries (labeled as such by the formatter);
+    // an all-test project falls back to the raw ranking.
+    const { isTestPath } = require('./shared');
+    const allHot = (stats.hot?.items || []).map(i => ({
+        name: i.name,
+        file: i.file,
+        line: i.startLine,
+        callCount: i.callCount,
+        ...(i.className ? { className: i.className } : {}),
+    }));
+    const prodHot = allHot.filter(i => i.file && !isTestPath(i.file));
+    const production = prodHot.length > 0;
+    const hotItems = (production ? prodHot : allHot).slice(0, top);
+    const hottestProd = hotItems[0] || null;
+
+    return {
+        root: stats.root,
+        files: stats.files,
+        symbols: stats.symbols,
+        buildTime: stats.buildTime,
+        byLanguage: stats.byLanguage,
+        dirs,
+        hot: { total: stats.hot?.total ?? 0, top, production, items: hotItems },
+        entrypoints,
+        trust: {
+            level: health.trust,
+            blindSpots: {
+                dynamicImports: health.blindSpots?.dynamicImports?.count ?? 0,
+                evalCalls: health.blindSpots?.evalCalls?.count ?? 0,
+                reflection: health.blindSpots?.reflection?.count ?? 0,
+                parseFailures: health.blindSpots?.parseFailures?.count ?? 0,
+            },
+        },
+        suggest: hottestProd ? hottestProd.name : null,
+    };
+}
+
+module.exports = { getStats, getToc, doctor, orient };