fix(cli): reuse warm index for graph queries (#189)

* fix(cli): reuse warm index for graph queries

* chore: synchronize npm lockfile

* fix(cli): reuse warm index for graph summaries

* fix(cli): reuse warm index for duplicates

Author: lzehrung

package-lock.json

@@ -1043,19 +1043,15 @@ async function runCliWithActiveRuntime(rawArgs: string[]) {
 
   if (cmd === "duplicates") {
     const files = await resolveFiles();
+    const duplicateIndexOptions = buildAgentOptions();
+    duplicateIndexOptions.cache ??= "disk";
     const { handleDuplicatesCommand } = await import("./cli/duplicates.js");
     await handleDuplicatesCommand({
       projectRootFs,
       files,
       getOpt,
       hasFlag,
-      indexOptions: {
-        onProgress: progressHandler,
-        discovery: discoveryOptions,
-        ...(hasGraphOverrides ? { graph: buildGraphOptions() } : {}),
-        ...(nativeMode !== "auto" ? { native: nativeMode } : {}),
-        ...workerOpts,
-      },
+      indexOptions: duplicateIndexOptions,
       writeJSONLine,
       writeStdoutLine,
       writeStderrLine,
@@ -1190,13 +1186,12 @@ async function runCliWithActiveRuntime(rawArgs: string[]) {
     return;
   }
 
-  const buildGraphQueryIndexOptions = (graphOptions: GraphBuildOptions | undefined): BuildOptions => ({
-    onProgress: progressHandler,
-    discovery: discoveryOptions,
-    ...(graphOptions ? { graph: graphOptions } : {}),
-    ...(nativeMode !== "auto" ? { native: nativeMode } : {}),
-    ...workerOpts,
-  });
+  const buildGraphQueryIndexOptions = (graphOptions: GraphBuildOptions | undefined): BuildOptions => {
+    const options = buildAgentOptions();
+    options.cache ??= "disk";
+    if (graphOptions) options.graph = graphOptions;
+    return options;
+  };
 
   if (cmd === "deps" || cmd === "rdeps") {
     const graphOptions = hasGraphOverrides || nativeMode !== "auto" ? buildGraphOptions() : undefined;
@@ -1222,7 +1217,8 @@ async function runCliWithActiveRuntime(rawArgs: string[]) {
   if (cmd === "path" || cmd === "cycles" || cmd === "unresolved") {
     const graphOptions = hasGraphOverrides || nativeMode !== "auto" ? buildGraphOptions() : undefined;
     const { handleGraphQueryCommand } = await import("./cli/graphQueries.js");
-    const collectGraph = cmd === "cycles" ? (await import("./graph-builder.js")).collectGraph : undefined;
+    const collectGraph =
+      cmd === "cycles" && includeRootsAbs.length ? (await import("./graph-builder.js")).collectGraph : undefined;
     await handleGraphQueryCommand({
       command: cmd,
       positionals: parsed.positionals,
@@ -1299,12 +1295,7 @@ async function runCliWithActiveRuntime(rawArgs: string[]) {
       writeStderrLine,
       exit: exitCli,
       listProjectFilesForScan: async () => await listProjectFilesForScan(projectRootFs),
-      indexOptions: {
-        onProgress: progressHandler,
-        discovery: discoveryOptions,
-        ...(nativeMode !== "auto" ? { native: nativeMode } : {}),
-        ...workerOpts,
-      },
+      indexOptions: buildGraphQueryIndexOptions(undefined),
     });
     return;
   }

src/cli.ts

@@ -1,4 +1,4 @@
-import { buildProjectIndexFromFiles } from "../indexer/build-index.js";
+import { buildProjectIndexIncremental } from "../indexer/build-index.js";
 import {
   findDuplicates,
   type DuplicateCleanupLabel,
@@ -441,7 +441,11 @@ export async function handleDuplicatesCommand(context: DuplicatesCommandContext)
       options.limit = boundedLimit;
     }
 
-    const index = await buildProjectIndexFromFiles(context.projectRootFs, context.files, context.indexOptions);
+    const index = await buildProjectIndexIncremental(context.projectRootFs, {
+      ...context.indexOptions,
+      files: context.files,
+      filesAreProjectScope: true,
+    });
     const result = await findDuplicates(index, options);
     const sorted = sortedResult(result, sortMode, requestedLimit, profile);
     if (!renderPretty) {

src/cli/duplicates.ts

@@ -1,4 +1,4 @@
-import { buildProjectIndex as defaultBuildProjectIndex } from "../indexer/build-index.js";
+import { buildProjectIndexIncremental as defaultBuildProjectIndex } from "../indexer/build-index.js";
 import { getApiSurface } from "../indexer/symbols.js";
 import { type BuildOptions, type ProjectIndex } from "../indexer/types.js";
 import type { GraphAdjacencyIndex } from "../graphs/adjacency.js";

src/cli/graphQueries.ts

@@ -1503,21 +1503,30 @@ describe("CLI command modules", () => {
 
     try {
       const deps = await captureCli(["deps", "main.ts", "--root", tempDir, "--json"]);
+      const warmDeps = await captureCli(["deps", "main.ts", "--root", tempDir, "--json", "--progress"]);
       const rdeps = await captureCli(["rdeps", "util.ts", "--root", tempDir]);
       const graphPath = await captureCli(["path", "main.ts", "util.ts", "--root", tempDir]);
-      const cycles = await captureCli(["cycles", "--root", tempDir]);
+      const cycles = await captureCli(["cycles", "--root", tempDir, "--progress"]);
       const unresolved = await captureCli(["unresolved", "--root", tempDir, "--verbose"]);
-      const apiSurface = await captureCli(["apisurface", "--root", tempDir]);
+      const apiSurface = await captureCli(["apisurface", "--root", tempDir, "--progress"]);
 
       expect(JSON.stringify(JSON.parse(deps.stdout))).toContain("util.ts");
+      expect(warmDeps.stderr).toContain("Checking project index");
+      expect(warmDeps.stderr).toContain("Checked project index");
+      expect(warmDeps.stderr).not.toContain("Building project index");
+      expect(warmDeps.stderr).not.toContain("files processed");
       expect(rdeps.stdout).toContain("Reverse dependencies for util.ts:");
       expect(graphPath.stdout).toContain("main.ts");
       expect(graphPath.stdout).toContain("util.ts");
       expect(cycles.stdout).toContain("No dependency cycles found.");
+      expect(cycles.stderr).toContain("Checked project index");
+      expect(cycles.stderr).not.toContain("Building project index");
       expect(unresolved.stdout).toContain("missing-pkg");
       expect(unresolved.stdout).toContain('as "missing-pkg"');
       expect(apiSurface.stdout).toContain("API Surface");
       expect(apiSurface.stdout).toContain("run");
+      expect(apiSurface.stderr).toContain("Checked project index");
+      expect(apiSurface.stderr).not.toContain("Building project index");
     } finally {
       await fsp.rm(tempDir, { recursive: true, force: true });
     }

tests/cli-command-modules.test.ts

@@ -1364,6 +1364,10 @@ export function formatUsage(value: string) {
     const result = await captureCli(["duplicates", "--root", ".", "src/app/[slug]", "--json", "--include-small"], {
       cwd: root,
     });
+    const warmResult = await captureCli(
+      ["duplicates", "--root", ".", "src/app/[slug]", "--json", "--include-small", "--progress"],
+      { cwd: root },
+    );
     const parsed = JSON.parse(result.stdout) as {
       groups?: Array<{ primaryLeft?: { file?: string }; primaryRight?: { file?: string } }>;
     };
@@ -1372,6 +1376,8 @@ export function formatUsage(value: string) {
     expect(parsed.groups?.length).toBeGreaterThan(0);
     expect(parsed.groups?.[0]?.primaryLeft?.file?.startsWith("src/app/[slug]/")).toBeTruthy();
     expect(parsed.groups?.[0]?.primaryRight?.file?.startsWith("src/app/[slug]/")).toBeTruthy();
+    expect(warmResult.stderr).toContain("Checked project index");
+    expect(warmResult.stderr).not.toContain("Building project index");
   });
 
   test("duplicates CLI cleanup profile defaults to reduced-lines and summary output", async () => {