perf(builder): scope barrel iteration to newly-merged paths

Iteration 2+ of the JS barrel-discovery loop was re-querying the DB for
every key in fileSymbols rather than just barrels newly merged in the
previous pass, ballooning the work each iteration. The Rust orchestrator
already does this correctly via the `&newly_added` slice.

Wire the `string[]` returned by reparseBarrelFiles through the loop so
each pass only walks newly-merged paths' imports, and gate the
reexport-from DB query behind a `firstPass` flag — re-parsed barrels
haven't changed content, so they can't surface new reexport-from
candidates anyway. Matches the Rust seed-only
`collect_reexport_from_barrels` call.

No behavior change beyond perf; the regression test for #1174
(issue-1174-chained-barrel-incremental.test.ts) still passes on both
engines and full=1371 / incremental=1371 imports edges on the dogfooded
repo.

Addresses Greptile feedback on #1179.

Author: carlos-alm

src/domain/graph/builder/stages/resolve-imports.ts

@@ -33,15 +33,23 @@ function buildReexportMap(ctx: PipelineContext): void {
 }
 
 /**
- * Find barrel files related to changed files for scoped re-parsing.
- * For small incremental builds (<=smallFilesThreshold files), only barrels that re-export from
- * or are imported by the changed files. For larger changes, all barrels.
+ * Find barrel files related to `fromRelPaths` for scoped re-parsing.
+ * For small frontiers (<=smallFilesThreshold files), only barrels that re-export from
+ * or are imported by `fromRelPaths`. For larger frontiers, all barrels.
+ *
+ * `firstPass` gates the reexport-from DB scan: re-parsed barrels haven't
+ * changed content, so subsequent passes can't surface new reexport-from
+ * candidates and only need to follow imports of newly-merged barrels
+ * (mirrors the Rust orchestrator's seed-only `collect_reexport_from_barrels`).
  */
-function findBarrelCandidates(ctx: PipelineContext): Array<{ file: string }> {
+function findBarrelCandidates(
+  ctx: PipelineContext,
+  fromRelPaths: readonly string[],
+  firstPass: boolean,
+): Array<{ file: string }> {
   const { db, fileSymbols, rootDir, aliases } = ctx;
-  const changedRelPaths = new Set<string>(fileSymbols.keys());
 
-  if (changedRelPaths.size <= ctx.config.build.smallFilesThreshold) {
+  if (fromRelPaths.length <= ctx.config.build.smallFilesThreshold) {
     const allBarrelFiles = new Set(
       (
         db
@@ -56,9 +64,9 @@ function findBarrelCandidates(ctx: PipelineContext): Array<{ file: string }> {
 
     const barrels = new Set<string>();
 
-    // Find barrels imported by changed files using parsed import data
+    // Find barrels imported by `fromRelPaths` using parsed import data
     // (can't query DB edges -- they were purged for the changed files).
-    for (const relPath of changedRelPaths) {
+    for (const relPath of fromRelPaths) {
       const symbols = fileSymbols.get(relPath);
       if (!symbols) continue;
       for (const imp of symbols.imports) {
@@ -71,16 +79,17 @@ function findBarrelCandidates(ctx: PipelineContext): Array<{ file: string }> {
       }
     }
 
-    // Also find barrels that re-export from the changed files
-    const reexportSourceStmt = db.prepare(
-      `SELECT DISTINCT n1.file FROM edges e
-       JOIN nodes n1 ON e.source_id = n1.id
-       JOIN nodes n2 ON e.target_id = n2.id
-       WHERE e.kind = 'reexports' AND n1.kind = 'file' AND n2.file = ?`,
-    );
-    for (const relPath of changedRelPaths) {
-      for (const row of reexportSourceStmt.all(relPath) as Array<{ file: string }>) {
-        barrels.add(row.file);
+    if (firstPass) {
+      const reexportSourceStmt = db.prepare(
+        `SELECT DISTINCT n1.file FROM edges e
+         JOIN nodes n1 ON e.source_id = n1.id
+         JOIN nodes n2 ON e.target_id = n2.id
+         WHERE e.kind = 'reexports' AND n1.kind = 'file' AND n2.file = ?`,
+      );
+      for (const relPath of fromRelPaths) {
+        for (const row of reexportSourceStmt.all(relPath) as Array<{ file: string }>) {
+          barrels.add(row.file);
+        }
       }
     }
     return [...barrels].map((file) => ({ file }));
@@ -189,11 +198,19 @@ export async function resolveImports(ctx: PipelineContext): Promise<void> {
     // Convergence is guaranteed because fileSymbols grows monotonically and
     // is bounded by the set of barrel files in the project — each iteration
     // either adds a previously-unseen barrel or terminates.
-    while (true) {
-      const before = fileSymbols.size;
-      const barrelCandidates = findBarrelCandidates(ctx);
-      await reparseBarrelFiles(ctx, barrelCandidates);
-      if (fileSymbols.size === before) break;
+    //
+    // Subsequent passes only walk newly-merged barrels' imports (`frontier`
+    // = paths returned by reparseBarrelFiles), matching the Rust
+    // orchestrator's `&newly_added` slice. Without this, every pass would
+    // re-query the DB for every key in `fileSymbols`.
+    let frontier: readonly string[] = [...fileSymbols.keys()];
+    let firstPass = true;
+    while (frontier.length > 0) {
+      const barrelCandidates = findBarrelCandidates(ctx, frontier, firstPass);
+      const added = await reparseBarrelFiles(ctx, barrelCandidates);
+      if (added.length === 0) break;
+      frontier = added;
+      firstPass = false;
     }
   }
 }