refactor: add DirEntry type and precomputeDirListing returning DirEntry[] directly

Extract inline entry shape into a named DirEntry type and add
precomputeDirListing() that returns DirEntry[] instead of LocalOpResult,
so callers get the entries array directly without type assertions.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: betegon

src/lib/init/local-ops.ts

@@ -15,6 +15,7 @@ import {
 } from "./constants.js";
 import type {
   ApplyPatchsetPayload,
+  DirEntry,
   FileExistsBatchPayload,
   ListDirPayload,
   LocalOpPayload,
@@ -218,11 +219,7 @@ function listDir(payload: ListDirPayload): LocalOpResult {
   const maxEntries = params.maxEntries ?? 500;
   const recursive = params.recursive ?? false;
 
-  const entries: Array<{
-    name: string;
-    path: string;
-    type: "file" | "directory";
-  }> = [];
+  const entries: DirEntry[] = [];
 
   // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: walking the directory tree is a complex operation
   function walk(dir: string, depth: number): void {
@@ -470,3 +467,13 @@ function applyPatchset(
 
   return { ok: true, data: { applied } };
 }
+
+export function precomputeDirListing(directory: string): DirEntry[] {
+  const result = listDir({
+    type: "local-op",
+    operation: "list-dir",
+    cwd: directory,
+    params: { path: ".", recursive: true, maxDepth: 3, maxEntries: 500 },
+  });
+  return (result.data as { entries?: DirEntry[] })?.entries ?? [];
+}

src/lib/init/types.ts

@@ -1,3 +1,9 @@
+export type DirEntry = {
+  name: string;
+  path: string;
+  type: "file" | "directory";
+};
+
 export type WizardOptions = {
   directory: string;
   force: boolean;

src/lib/init/wizard-runner.ts

@@ -21,7 +21,7 @@ import {
 } from "./constants.js";
 import { formatError, formatResult } from "./formatters.js";
 import { handleInteractive } from "./interactive.js";
-import { handleLocalOp } from "./local-ops.js";
+import { handleLocalOp, precomputeDirListing } from "./local-ops.js";
 import type {
   InteractivePayload,
   LocalOpPayload,
@@ -150,13 +150,16 @@ export async function runWizard(options: WizardOptions): Promise<void> {
 
   const spin = spinner();
 
+  spin.start("Scanning project...");
+  const dirListing = precomputeDirListing(directory);
+
   let run: Awaited<ReturnType<typeof workflow.createRun>>;
   let result: WorkflowRunResult;
   try {
-    spin.start("Connecting to wizard...");
+    spin.message("Connecting to wizard...");
     run = await workflow.createRun();
     result = (await run.startAsync({
-      inputData: { directory, force, yes, dryRun, features },
+      inputData: { directory, force, yes, dryRun, features, dirListing },
       tracingOptions,
     })) as WorkflowRunResult;
   } catch (err) {

test/lib/init/local-ops.test.ts

@@ -3,6 +3,7 @@ import fs, { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import {
   handleLocalOp,
+  precomputeDirListing,
   validateCommand,
 } from "../../../src/lib/init/local-ops.js";
 import type {
@@ -768,3 +769,49 @@ describe("handleLocalOp", () => {
     });
   });
 });
+
+describe("precomputeDirListing", () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = mkdtempSync(join("/tmp", "precompute-test-"));
+  });
+
+  afterEach(() => {
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  test("returns DirEntry[] directly", () => {
+    writeFileSync(join(testDir, "app.ts"), "x");
+    mkdirSync(join(testDir, "src"));
+
+    const entries = precomputeDirListing(testDir);
+
+    expect(Array.isArray(entries)).toBe(true);
+    expect(entries.length).toBeGreaterThanOrEqual(2);
+
+    const names = entries.map((e) => e.name).sort();
+    expect(names).toContain("app.ts");
+    expect(names).toContain("src");
+
+    const file = entries.find((e) => e.name === "app.ts");
+    expect(file?.type).toBe("file");
+
+    const dir = entries.find((e) => e.name === "src");
+    expect(dir?.type).toBe("directory");
+  });
+
+  test("returns empty array for non-existent directory", () => {
+    const entries = precomputeDirListing(join(testDir, "nope"));
+    expect(entries).toEqual([]);
+  });
+
+  test("recursively lists nested entries", () => {
+    mkdirSync(join(testDir, "a"));
+    writeFileSync(join(testDir, "a", "nested.ts"), "x");
+
+    const entries = precomputeDirListing(testDir);
+    const paths = entries.map((e) => e.path);
+    expect(paths).toContain(join("a", "nested.ts"));
+  });
+});

test/lib/init/wizard-runner.test.ts

@@ -66,6 +66,7 @@ let formatBannerSpy: ReturnType<typeof spyOn>;
 let formatResultSpy: ReturnType<typeof spyOn>;
 let formatErrorSpy: ReturnType<typeof spyOn>;
 let handleLocalOpSpy: ReturnType<typeof spyOn>;
+let precomputeDirListingSpy: ReturnType<typeof spyOn>;
 let handleInteractiveSpy: ReturnType<typeof spyOn>;
 
 // MastraClient
@@ -143,6 +144,9 @@ beforeEach(() => {
     ok: true,
     data: { results: [] },
   });
+  precomputeDirListingSpy = spyOn(ops, "precomputeDirListing").mockReturnValue(
+    []
+  );
   handleInteractiveSpy = spyOn(inter, "handleInteractive").mockResolvedValue({
     action: "continue",
   });
@@ -169,6 +173,7 @@ afterEach(() => {
   formatResultSpy.mockRestore();
   formatErrorSpy.mockRestore();
   handleLocalOpSpy.mockRestore();
+  precomputeDirListingSpy.mockRestore();
   handleInteractiveSpy.mockRestore();
 
   stderrSpy.mockRestore();