fix: load snapshot-style fixture subdirectories on boot

The recorder (v1.19.0, #155) writes fixtures to
<fixturePath>/<testId>/<provider>.json, but loadFixturesFromDir
skipped all subdirectories with a warning. Recorded fixtures could
never be replayed.

Recurse one level into subdirectories so the read path matches the
write path. Top-level JSON files load first, then subdirectory
fixtures in alphabetical order. Deeper nesting is ignored.

Closes #161

Author: jpr5

CHANGELOG.md

@@ -1,5 +1,12 @@
 # @copilotkit/aimock
 
+## [Unreleased]
+
+### Fixed
+
+- **Fixture loader: snapshot-style subdirectories skipped on boot** — `loadFixturesFromDir` now recurses one level into subdirectories to load `<testId>/<provider>.json` files written by the snapshot recorder. Previously the loader skipped all subdirectories with a warning, so recorded fixtures could never be replayed. (Issue #161, reported by @jantimon)
+- **CLI: immediate exit on npx/bunx** — Entry-point guard now matches the `aimock` bin name (not just `aimock-cli.js`), fixing silent exit when invoked via `npx aimock` or `bunx aimock`. (Issue #160)
+
 ## [1.19.0] - 2026-05-06
 
 ### Added

src/__tests__/fixture-loader.test.ts

@@ -455,22 +455,102 @@ describe("loadFixturesFromDir", () => {
     expect(fixtures[0].match.userMessage).toBe("nested");
   });
 
-  it("warns and skips subdirectories, still loads sibling JSON files", () => {
+  it("recurses one level into subdirectories (snapshot-style layout)", () => {
     writeJson(tmpDir, "a-valid.json", {
       fixtures: [{ match: { userMessage: "top" }, response: { content: "yes" } }],
     });
-    const subDir = join(tmpDir, "nested");
+    const subDir = join(tmpDir, "greeting--hello-world");
     mkdirSync(subDir);
-    writeJson(subDir, "inner.json", {
-      fixtures: [{ match: { userMessage: "deep" }, response: { content: "nope" } }],
+    writeJson(subDir, "openai.json", {
+      fixtures: [{ match: { userMessage: "deep" }, response: { content: "found" } }],
+    });
+
+    const fixtures = loadFixturesFromDir(tmpDir);
+    expect(fixtures).toHaveLength(2);
+    expect(fixtures[0].match.userMessage).toBe("top");
+    expect(fixtures[1].match.userMessage).toBe("deep");
+  });
+
+  it("loads multiple provider files from one snapshot subdirectory", () => {
+    const subDir = join(tmpDir, "test-greeting");
+    mkdirSync(subDir);
+    writeJson(subDir, "anthropic.json", {
+      fixtures: [{ match: { userMessage: "hi anthropic" }, response: { content: "A" } }],
+    });
+    writeJson(subDir, "openai.json", {
+      fixtures: [{ match: { userMessage: "hi openai" }, response: { content: "O" } }],
+    });
+
+    const fixtures = loadFixturesFromDir(tmpDir);
+    expect(fixtures).toHaveLength(2);
+    // Alphabetical order within subdirectory
+    expect(fixtures[0].match.userMessage).toBe("hi anthropic");
+    expect(fixtures[1].match.userMessage).toBe("hi openai");
+  });
+
+  it("loads fixtures from multiple snapshot subdirectories in alphabetical order", () => {
+    const subA = join(tmpDir, "a-test");
+    const subB = join(tmpDir, "b-test");
+    mkdirSync(subA);
+    mkdirSync(subB);
+    writeJson(subA, "openai.json", {
+      fixtures: [{ match: { userMessage: "a" }, response: { content: "A" } }],
+    });
+    writeJson(subB, "openai.json", {
+      fixtures: [{ match: { userMessage: "b" }, response: { content: "B" } }],
+    });
+
+    const fixtures = loadFixturesFromDir(tmpDir);
+    expect(fixtures).toHaveLength(2);
+    expect(fixtures[0].match.userMessage).toBe("a");
+    expect(fixtures[1].match.userMessage).toBe("b");
+  });
+
+  it("does not recurse deeper than one level", () => {
+    const subDir = join(tmpDir, "level1");
+    const deepDir = join(subDir, "level2");
+    mkdirSync(subDir);
+    mkdirSync(deepDir);
+    writeJson(subDir, "openai.json", {
+      fixtures: [{ match: { userMessage: "one" }, response: { content: "1" } }],
+    });
+    writeJson(deepDir, "openai.json", {
+      fixtures: [{ match: { userMessage: "two" }, response: { content: "2" } }],
     });
 
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
     const fixtures = loadFixturesFromDir(tmpDir);
     expect(fixtures).toHaveLength(1);
+    expect(fixtures[0].match.userMessage).toBe("one");
+  });
+
+  it("top-level JSON files come before subdirectory fixtures", () => {
+    writeJson(tmpDir, "z-top.json", {
+      fixtures: [{ match: { userMessage: "top" }, response: { content: "T" } }],
+    });
+    const subDir = join(tmpDir, "a-sub");
+    mkdirSync(subDir);
+    writeJson(subDir, "openai.json", {
+      fixtures: [{ match: { userMessage: "sub" }, response: { content: "S" } }],
+    });
+
+    const fixtures = loadFixturesFromDir(tmpDir);
+    expect(fixtures).toHaveLength(2);
+    // Top-level files load first (regardless of sort order vs subdirectory names)
     expect(fixtures[0].match.userMessage).toBe("top");
-    expect(warn).toHaveBeenCalledWith(expect.stringContaining("Skipping subdirectory"));
-    warn.mockRestore();
+    expect(fixtures[1].match.userMessage).toBe("sub");
+  });
+
+  it("ignores non-.json files inside subdirectories", () => {
+    const subDir = join(tmpDir, "test-sub");
+    mkdirSync(subDir);
+    writeFileSync(join(subDir, "readme.txt"), "ignore me", "utf-8");
+    writeJson(subDir, "openai.json", {
+      fixtures: [{ match: { userMessage: "real" }, response: { content: "yes" } }],
+    });
+
+    const fixtures = loadFixturesFromDir(tmpDir);
+    expect(fixtures).toHaveLength(1);
+    expect(fixtures[0].match.userMessage).toBe("real");
   });
 });
 

src/fixture-loader.ts

@@ -127,11 +127,12 @@ export function loadFixturesFromDir(dirPath: string, logger?: Logger): Fixture[]
   }
 
   const jsonFiles: string[] = [];
+  const subdirs: string[] = [];
   for (const name of entries) {
     const fullPath = join(dirPath, name);
     try {
       if (statSync(fullPath).isDirectory()) {
-        warn(logger, `Skipping subdirectory ${fullPath} (fixtures are not loaded recursively)`);
+        subdirs.push(name);
         continue;
       }
     } catch (err) {
@@ -153,6 +154,44 @@ export function loadFixturesFromDir(dirPath: string, logger?: Logger): Fixture[]
     fixtures.push(...loadFixtureFile(filePath, logger));
   }
 
+  // Recurse one level into subdirectories to support snapshot-style layouts
+  // where the recorder writes to <fixturePath>/<testId>/<provider>.json.
+  subdirs.sort();
+  for (const sub of subdirs) {
+    const subPath = join(dirPath, sub);
+    let subEntries: string[];
+    try {
+      subEntries = readdirSync(subPath);
+    } catch (err) {
+      warn(logger, `Could not read subdirectory ${subPath}:`, err);
+      continue;
+    }
+    const subJsonFiles: string[] = [];
+    for (const subName of subEntries) {
+      const subFullPath = join(subPath, subName);
+      try {
+        if (statSync(subFullPath).isDirectory()) {
+          // Only one level of recursion — skip deeper nesting
+          continue;
+        }
+      } catch (err) {
+        const code = (err as NodeJS.ErrnoException).code;
+        if (code !== "ENOENT") {
+          warn(logger, `Could not stat ${subFullPath}:`, err);
+        }
+        continue;
+      }
+      if (subName.endsWith(".json")) {
+        subJsonFiles.push(subName);
+      }
+    }
+    subJsonFiles.sort();
+    for (const subName of subJsonFiles) {
+      const filePath = join(subPath, subName);
+      fixtures.push(...loadFixtureFile(filePath, logger));
+    }
+  }
+
   return fixtures;
 }