@lzehrung/codegraph 2.3.14 → 2.3.16

package/dist/indexer/build-index.js

@@ -414,15 +414,67 @@ function emitIndexCheckActivity(opts, activity, current = 0, total = 0) {
         total,
     });
 }
-const DISCOVERY_TIMING_STEP_NAMES = new Set(["git-list", "git-ignore", "filesystem-scan"]);
-function resetDiscoveryTimingSteps(timings) {
+function emitIndexBuildActivity(opts, activity, current, total) {
+    opts?.onProgress?.({
+        type: "progress",
+        phase: "update",
+        mode: "build",
+        message: activity,
+        activity,
+        current,
+        total,
+    });
+}
+/**
+ * Names and times a post-parse persistence phase (cache write, manifest, graph finalize,
+ * snapshot write) so the interactive spinner shows what is happening instead of freezing at
+ * the last "Indexed N/N files" count, and so `--report` exposes each phase's cost.
+ */
+async function timeIndexBuildPhase(args) {
+    if (args.buildStartedAt !== undefined) {
+        emitIndexBuildActivity(args.opts, args.activity, args.current, args.total);
+    }
+    const startedAt = performance.now();
+    const result = await args.fn();
+    recordBuildTimingStep(args.timings, { name: args.stepName, ms: Math.round(performance.now() - startedAt) });
+    return result;
+}
+function createCountedCheckProgress(opts, activity, total) {
+    emitIndexCheckActivity(opts, activity, 0, total);
+    let completed = 0;
+    return () => {
+        completed += 1;
+        if (completed === total || completed % 100 === 0) {
+            emitIndexCheckActivity(opts, activity, completed, total);
+        }
+    };
+}
+const TRANSIENT_BUILD_TIMING_STEP_NAMES = {
+    "git-list": true,
+    "git-ignore": true,
+    "filesystem-scan": true,
+    "cache-probe": true,
+    "persist-cache": true,
+    "workspace-manifests": true,
+    "index-manifest": true,
+    finalize: true,
+    "snapshot-write": true,
+};
+/**
+ * Clears named step timings and coarse discovery fields left over from a prior build that
+ * reused the same `BuildReport` object (for example an MCP session's `buildOptions.report`
+ * across `refresh_index` calls), so a reused report never mixes this build's steps with a
+ * previous one's.
+ */
+function resetTransientBuildTimings(timings) {
     if (!timings)
         return;
     delete timings.gitListMs;
     delete timings.filesystemScanMs;
     delete timings.sourceDiscoveryMs;
     delete timings.metadataDiscoveryMs;
-    const remaining = (timings.steps ?? []).filter((step) => !DISCOVERY_TIMING_STEP_NAMES.has(step.name));
+    delete timings.cacheProbeMs;
+    const remaining = (timings.steps ?? []).filter((step) => !Object.hasOwn(TRANSIENT_BUILD_TIMING_STEP_NAMES, step.name));
     if (remaining.length) {
         timings.steps = remaining;
         return;
@@ -534,6 +586,12 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
         ? projectIndexManifestEntries(cachedGraphEntries ?? [])
         : new Map();
     const modules = new Map();
+    const moduleCacheAvailable = opts?.cache !== "disk" || diskModuleCacheExists(projectRoot, opts);
+    const shouldReportFileCacheCheck = Boolean(helperOpts?.reportDiscoveryProgress);
+    const reportFileCacheCheck = shouldReportFileCacheCheck
+        ? createCountedCheckProgress(opts, "Checking file cache", normalizedFiles.length)
+        : () => undefined;
+    const cacheProbeStart = performance.now();
     const gitAvailable = await isGitRepo(projectRoot);
     const needsPersistentSignatures = cacheEnabled || useManifest;
     const useGitSignatures = gitAvailable && needsPersistentSignatures;
@@ -580,7 +638,6 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
     // Cache lookup determines the work a full build will actually parse. Complete that cheap phase
     // before starting Piscina, so a warm build does not bootstrap workers and partial hits bound
     // the pool to real parse misses rather than the input file list.
-    const moduleCacheAvailable = opts?.cache !== "disk" || diskModuleCacheExists(projectRoot, opts);
     const cacheProbes = new Map(await mapLimit(normalizedFiles, conc, async (file) => {
         try {
             let sigInfo = fileSignatures.get(file);
@@ -616,7 +673,15 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
         catch (error) {
             return [file, { error }];
         }
+        finally {
+            reportFileCacheCheck();
+        }
     }));
+    if (timings) {
+        const cacheProbeMs = Math.round(performance.now() - cacheProbeStart);
+        timings.cacheProbeMs = cacheProbeMs;
+        recordBuildTimingStep(timings, { name: "cache-probe", ms: cacheProbeMs });
+    }
     const cacheMisses = Array.from(cacheProbes, ([file, probe]) => !("error" in probe) && !probe.mod ? file : null).filter((file) => file !== null);
     const workerSetup = await setupWorkerPool(opts, countNativeWorkerEligibleFiles(cacheMisses, opts?.languageExtensions));
     try {
@@ -658,6 +723,8 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
             buildStartedAt = performance.now();
             emitIndexLifecycleProgress(opts, "start", "build", totalFiles);
         };
+        if (cacheMisses.length)
+            ensureBuildProgressStarted();
         const fileResults = await mapLimit(normalizedFiles, conc, async (file) => {
             try {
                 const cacheProbe = cacheProbes.get(file);
@@ -823,9 +890,32 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                 pendingCacheWrites.push(cacheWrite);
         }
         if (pendingCacheWrites.length) {
-            writeModulesToCache(projectRoot, pendingCacheWrites, opts);
+            if (opts?.cache === "disk") {
+                await timeIndexBuildPhase({
+                    opts,
+                    timings,
+                    buildStartedAt,
+                    stepName: "persist-cache",
+                    activity: "Writing disk cache",
+                    current: totalFiles,
+                    total: totalFiles,
+                    fn: () => writeModulesToCache(projectRoot, pendingCacheWrites, opts),
+                });
+            }
+            else {
+                writeModulesToCache(projectRoot, pendingCacheWrites, opts);
+            }
         }
-        const workspaceManifestEdges = await collectWorkspaceManifestDependencyEdges(projectRoot, normalizedFiles.filter((file) => path.basename(file) === "package.json"), opts?.discovery, opts?.logLevel);
+        const workspaceManifestEdges = await timeIndexBuildPhase({
+            opts,
+            timings,
+            buildStartedAt,
+            stepName: "workspace-manifests",
+            activity: "Resolving workspace manifests",
+            current: totalFiles,
+            total: totalFiles,
+            fn: () => collectWorkspaceManifestDependencyEdges(projectRoot, normalizedFiles.filter((file) => path.basename(file) === "package.json"), opts?.discovery, opts?.logLevel),
+        });
         appendUniqueGraphEdges(workspaceManifestEdges);
         if (timings)
             timings.graphMs = Math.round(performance.now() - graphStart);
@@ -845,16 +935,27 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
             }
         }
         if (manifestEntries) {
-            await writeIndexManifestSnapshot({
-                projectRoot,
+            await timeIndexBuildPhase({
                 opts,
-                graphOptions,
-                ...(resolverEnvironmentFingerprint ? { resolverEnvironmentFingerprint } : {}),
-                files: manifestEntries,
                 timings,
-                manifestReport: report?.manifest,
-                ...(helperOpts?.transientFiles !== undefined ? { transientFiles: helperOpts.transientFiles } : {}),
-                ...(helperOpts?.symlinkDirectories !== undefined ? { symlinkDirectories: helperOpts.symlinkDirectories } : {}),
+                buildStartedAt,
+                stepName: "index-manifest",
+                activity: "Writing index manifest",
+                current: totalFiles,
+                total: totalFiles,
+                fn: () => writeIndexManifestSnapshot({
+                    projectRoot,
+                    opts,
+                    graphOptions,
+                    ...(resolverEnvironmentFingerprint ? { resolverEnvironmentFingerprint } : {}),
+                    files: manifestEntries,
+                    timings,
+                    manifestReport: report?.manifest,
+                    ...(helperOpts?.transientFiles !== undefined ? { transientFiles: helperOpts.transientFiles } : {}),
+                    ...(helperOpts?.symlinkDirectories !== undefined
+                        ? { symlinkDirectories: helperOpts.symlinkDirectories }
+                        : {}),
+                }),
             });
         }
         const indexManifestEntries = manifestEntries
@@ -863,22 +964,40 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                 return [file, { ...entry, ...(cacheSig ? { cacheSig } : {}) }];
             }))
             : manifestEntriesForIndex;
-        const index = await finalizeProjectIndex({
-            projectRoot,
-            normalizedProjectRoot,
+        const index = await timeIndexBuildPhase({
             opts,
             timings,
-            totalStart,
-            graph,
-            modules,
-            parsedMap,
-            bloomFilterCache,
-            ...(projectFiles !== undefined ? { projectFiles } : {}),
-            buildReport: report,
-            manifestEntries: indexManifestEntries,
+            buildStartedAt,
+            stepName: "finalize",
+            activity: "Finalizing project graph",
+            current: totalFiles,
+            total: totalFiles,
+            fn: () => finalizeProjectIndex({
+                projectRoot,
+                normalizedProjectRoot,
+                opts,
+                timings,
+                totalStart,
+                graph,
+                modules,
+                parsedMap,
+                bloomFilterCache,
+                ...(projectFiles !== undefined ? { projectFiles } : {}),
+                buildReport: report,
+                manifestEntries: indexManifestEntries,
+            }),
         });
         if (manifestEntries) {
-            await writeProjectIndexSnapshot(projectRoot, opts, index, projectSnapshotFilesSignature(manifestEntries, projectRoot));
+            await timeIndexBuildPhase({
+                opts,
+                timings,
+                buildStartedAt,
+                stepName: "snapshot-write",
+                activity: "Writing project snapshot",
+                current: totalFiles,
+                total: totalFiles,
+                fn: () => writeProjectIndexSnapshot(projectRoot, opts, index, projectSnapshotFilesSignature(manifestEntries, projectRoot)),
+            });
         }
         if (buildStartedAt !== undefined) {
             // Report the whole operation the caller waited on. Discovery runs before the first
@@ -896,7 +1015,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
 }
 async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpts) {
     const timings = opts?.report ? (opts.report.timings ??= {}) : undefined;
-    resetDiscoveryTimingSteps(timings);
+    resetTransientBuildTimings(timings);
     await initializeFileIdentityCaseSensitivity(projectRoot);
     try {
         const useDiskCache = (opts?.cache ?? "off") === "disk";
@@ -972,6 +1091,7 @@ async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpt
             manifestMode: useDiskCache ? "read-write" : "off",
             warnNoFilesMessage: `Warning: No files found in project root: ${projectRoot}. Check codegraph.config.json globs and CLI --include-glob/--ignore-glob filters. Diagnostic: codegraph doctor`,
             ...(helperOpts?.ignoreExistingManifest ? { ignoreExistingManifest: true } : {}),
+            ...(helperOpts?.reportDiscoveryProgress ? { reportDiscoveryProgress: true } : {}),
             projectFiles,
             transientFiles,
             ...(discoveredSymlinkDirectories !== undefined ? { symlinkDirectories: discoveredSymlinkDirectories } : {}),
@@ -1070,7 +1190,7 @@ export async function buildProjectIndexIncremental(projectRoot, rawOpts) {
         graphOptions.fast = false;
     const { normalizedProjectRoot, report, timings, totalStart, cacheMode, cacheEnabled, onFallbackImportExtraction } = createIndexBuildRunState(projectRoot, opts, graphOptions);
     const discoveryTimings = opts?.report ? (opts.report.timings ??= {}) : undefined;
-    resetDiscoveryTimingSteps(discoveryTimings);
+    resetTransientBuildTimings(discoveryTimings);
     let checkProgressActive = false;
     const startCheckProgress = () => {
         if (checkProgressActive)