@towles/tool 0.0.66 → 0.0.68

package/src/lib/auto-claude/steps/steps.test.ts

@@ -9,29 +9,44 @@ import { initConfig } from "../config";
 import { ARTIFACTS } from "../prompt-templates/index";
 import {
   buildTestContext,
-  createSpawnClaudeMock,
+  createMockClaudeProcess,
   createTestRepoWithRemote,
   errorClaudeJson,
   successClaudeJson,
 } from "../test-helpers";
 import type { MockClaudeImpl, TestRepo } from "../test-helpers";
 import type { IssueContext } from "../utils";
+import type { SpawnClaudeFn } from "../spawn-claude";
 
 consola.level = -999;
 
-let mockClaudeImpl: MockClaudeImpl = null;
-vi.mock("../spawn-claude", () => createSpawnClaudeMock(() => mockClaudeImpl));
-
 // ── Shared setup/teardown for all step tests ──
 
-function setupStepTest(): { originalCwd: string; repo: TestRepo; ctx: IssueContext } {
+function setupStepTest(): {
+  originalCwd: string;
+  repo: TestRepo;
+  ctx: IssueContext;
+  spawnFn: SpawnClaudeFn;
+  mockClaudeImpl: { current: MockClaudeImpl };
+} {
   const originalCwd = process.cwd();
   const repo = createTestRepoWithRemote();
   process.chdir(repo.dir);
   const ctx = buildTestContext(repo.dir);
   mkdirSync(ctx.issueDir, { recursive: true });
-  mockClaudeImpl = null;
-  return { originalCwd, repo, ctx };
+
+  const mockClaudeImpl = { current: null as MockClaudeImpl };
+
+  const spawnFn = vi.fn((args: string[]) => {
+    const impl = mockClaudeImpl.current;
+    if (impl) {
+      const { stdout, exitCode } = impl(args);
+      return createMockClaudeProcess(stdout, exitCode);
+    }
+    throw new Error("Unexpected spawnClaude call -- set mockClaudeImpl.current");
+  }) as SpawnClaudeFn;
+
+  return { originalCwd, repo, ctx, spawnFn, mockClaudeImpl };
 }
 
 function teardownStepTest(originalCwd: string, repo: TestRepo): void {
@@ -45,9 +60,11 @@ describe("runStepWithArtifact", () => {
   let originalCwd: string;
   let repo: TestRepo;
   let ctx: IssueContext;
+  let spawnFn: SpawnClaudeFn;
+  let mockClaudeImpl: { current: MockClaudeImpl };
 
   beforeEach(async () => {
-    ({ originalCwd, repo, ctx } = setupStepTest());
+    ({ originalCwd, repo, ctx, spawnFn, mockClaudeImpl } = setupStepTest());
     await initConfig({ repo: "test/repo", mainBranch: "main" });
   });
 
@@ -63,13 +80,14 @@ describe("runStepWithArtifact", () => {
       ctx,
       artifactPath,
       templateName: "01_plan.prompt.md",
+      spawnFn,
     });
 
     expect(result).toBe(true);
   });
 
   it("returns false when Claude returns is_error", async () => {
-    mockClaudeImpl = () => ({ stdout: errorClaudeJson(), exitCode: 0 });
+    mockClaudeImpl.current = () => ({ stdout: errorClaudeJson(), exitCode: 0 });
 
     const { runStepWithArtifact } = await import("../utils");
     const artifactPath = join(ctx.issueDir, "missing-artifact.md");
@@ -79,13 +97,14 @@ describe("runStepWithArtifact", () => {
       ctx,
       artifactPath,
       templateName: "01_plan.prompt.md",
+      spawnFn,
     });
 
     expect(result).toBe(false);
   });
 
   it("returns false when artifact not produced after Claude run", async () => {
-    mockClaudeImpl = () => ({ stdout: successClaudeJson(), exitCode: 0 });
+    mockClaudeImpl.current = () => ({ stdout: successClaudeJson(), exitCode: 0 });
 
     const { runStepWithArtifact } = await import("../utils");
     const artifactPath = join(ctx.issueDir, "never-created.md");
@@ -95,6 +114,7 @@ describe("runStepWithArtifact", () => {
       ctx,
       artifactPath,
       templateName: "01_plan.prompt.md",
+      spawnFn,
     });
 
     expect(result).toBe(false);
@@ -104,7 +124,7 @@ describe("runStepWithArtifact", () => {
     const { runStepWithArtifact } = await import("../utils");
     const artifactPath = join(ctx.issueDir, "plan.md");
 
-    mockClaudeImpl = () => {
+    mockClaudeImpl.current = () => {
       writeFileSync(artifactPath, "# Plan\n\nDetailed plan content here.");
       return { stdout: successClaudeJson(), exitCode: 0 };
     };
@@ -114,6 +134,7 @@ describe("runStepWithArtifact", () => {
       ctx,
       artifactPath,
       templateName: "01_plan.prompt.md",
+      spawnFn,
     });
 
     expect(result).toBe(true);
@@ -126,9 +147,11 @@ describe("stepPlan", () => {
   let originalCwd: string;
   let repo: TestRepo;
   let ctx: IssueContext;
+  let spawnFn: SpawnClaudeFn;
+  let mockClaudeImpl: { current: MockClaudeImpl };
 
   beforeEach(async () => {
-    ({ originalCwd, repo, ctx } = setupStepTest());
+    ({ originalCwd, repo, ctx, spawnFn, mockClaudeImpl } = setupStepTest());
     await initConfig({ repo: "test/repo", mainBranch: "main" });
   });
 
@@ -139,7 +162,7 @@ describe("stepPlan", () => {
 
     writeFileSync(join(ctx.issueDir, ARTIFACTS.plan), "# Existing plan");
 
-    const result = await stepPlan(ctx);
+    const result = await stepPlan(ctx, spawnFn);
     expect(result).toBe(true);
   });
 
@@ -147,12 +170,12 @@ describe("stepPlan", () => {
     const { stepPlan } = await import("./simple-steps");
     const planPath = join(ctx.issueDir, ARTIFACTS.plan);
 
-    mockClaudeImpl = () => {
+    mockClaudeImpl.current = () => {
       writeFileSync(planPath, "# Plan\n\nDetailed plan.");
       return { stdout: successClaudeJson(), exitCode: 0 };
     };
 
-    const result = await stepPlan(ctx);
+    const result = await stepPlan(ctx, spawnFn);
     expect(result).toBe(true);
 
     // Verify we ended up on the branch (ensureBranch was called)
@@ -165,9 +188,9 @@ describe("stepPlan", () => {
   it("returns false when Claude fails", async () => {
     const { stepPlan } = await import("./simple-steps");
 
-    mockClaudeImpl = () => ({ stdout: errorClaudeJson(), exitCode: 0 });
+    mockClaudeImpl.current = () => ({ stdout: errorClaudeJson(), exitCode: 0 });
 
-    const result = await stepPlan(ctx);
+    const result = await stepPlan(ctx, spawnFn);
     expect(result).toBe(false);
   });
 });
@@ -178,9 +201,11 @@ describe("stepSimplify", () => {
   let originalCwd: string;
   let repo: TestRepo;
   let ctx: IssueContext;
+  let spawnFn: SpawnClaudeFn;
+  let mockClaudeImpl: { current: MockClaudeImpl };
 
   beforeEach(async () => {
-    ({ originalCwd, repo, ctx } = setupStepTest());
+    ({ originalCwd, repo, ctx, spawnFn, mockClaudeImpl } = setupStepTest());
     await initConfig({ repo: "test/repo", mainBranch: "main" });
 
     // stepSimplify doesn't switch branches, but we need to be on one
@@ -194,7 +219,7 @@ describe("stepSimplify", () => {
 
     writeFileSync(join(ctx.issueDir, ARTIFACTS.simplifySummary), "# Simplified");
 
-    const result = await stepSimplify(ctx);
+    const result = await stepSimplify(ctx, spawnFn);
     expect(result).toBe(true);
   });
 
@@ -202,21 +227,21 @@ describe("stepSimplify", () => {
     const { stepSimplify } = await import("./simple-steps");
     const artifactPath = join(ctx.issueDir, ARTIFACTS.simplifySummary);
 
-    mockClaudeImpl = () => {
+    mockClaudeImpl.current = () => {
       writeFileSync(artifactPath, "# Simplify Summary\n\nCode simplified.");
       return { stdout: successClaudeJson(), exitCode: 0 };
     };
 
-    const result = await stepSimplify(ctx);
+    const result = await stepSimplify(ctx, spawnFn);
     expect(result).toBe(true);
   });
 
   it("returns false when Claude fails", async () => {
     const { stepSimplify } = await import("./simple-steps");
 
-    mockClaudeImpl = () => ({ stdout: errorClaudeJson(), exitCode: 0 });
+    mockClaudeImpl.current = () => ({ stdout: errorClaudeJson(), exitCode: 0 });
 
-    const result = await stepSimplify(ctx);
+    const result = await stepSimplify(ctx, spawnFn);
     expect(result).toBe(false);
   });
 });
@@ -227,9 +252,11 @@ describe("stepImplement", () => {
   let originalCwd: string;
   let repo: TestRepo;
   let ctx: IssueContext;
+  let spawnFn: SpawnClaudeFn;
+  let mockClaudeImpl: { current: MockClaudeImpl };
 
   beforeEach(async () => {
-    ({ originalCwd, repo, ctx } = setupStepTest());
+    ({ originalCwd, repo, ctx, spawnFn, mockClaudeImpl } = setupStepTest());
     await initConfig({
       repo: "test/repo",
       mainBranch: "main",
@@ -247,7 +274,7 @@ describe("stepImplement", () => {
 
     writeFileSync(join(ctx.issueDir, ARTIFACTS.completedSummary), "# Done");
 
-    const result = await stepImplement(ctx);
+    const result = await stepImplement(ctx, spawnFn);
     expect(result).toBe(true);
   });
 
@@ -255,12 +282,12 @@ describe("stepImplement", () => {
     const { stepImplement } = await import("./implement");
 
     let callCount = 0;
-    mockClaudeImpl = () => {
+    mockClaudeImpl.current = () => {
       callCount++;
       return { stdout: successClaudeJson(), exitCode: 0 };
     };
 
-    const result = await stepImplement(ctx);
+    const result = await stepImplement(ctx, spawnFn);
     expect(result).toBe(false);
     expect(callCount).toBe(3);
   });
@@ -272,12 +299,12 @@ describe("stepImplement", () => {
     writeFileSync(join(ctx.issueDir, ARTIFACTS.review), "# Review\n\nFix the tests.");
 
     const completedPath = join(ctx.issueDir, ARTIFACTS.completedSummary);
-    mockClaudeImpl = () => {
+    mockClaudeImpl.current = () => {
       writeFileSync(completedPath, "# Done");
       return { stdout: successClaudeJson(), exitCode: 0 };
     };
 
-    const result = await stepImplement(ctx);
+    const result = await stepImplement(ctx, spawnFn);
     expect(result).toBe(true);
   });
 
@@ -287,7 +314,7 @@ describe("stepImplement", () => {
     let callCount = 0;
     const completedPath = join(ctx.issueDir, ARTIFACTS.completedSummary);
 
-    mockClaudeImpl = () => {
+    mockClaudeImpl.current = () => {
       callCount++;
       if (callCount === 2) {
         writeFileSync(completedPath, "# Implementation Complete\n\nAll tasks done.");
@@ -295,7 +322,7 @@ describe("stepImplement", () => {
       return { stdout: successClaudeJson(), exitCode: 0 };
     };
 
-    const result = await stepImplement(ctx);
+    const result = await stepImplement(ctx, spawnFn);
     expect(result).toBe(true);
     expect(callCount).toBe(2);
   });

package/src/lib/auto-claude/templates.test.ts

@@ -1,22 +1,21 @@
-import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { describe, expect, it, vi, beforeEach } from "vitest";
 
 import { resolveTemplate } from "./templates";
-import type { TokenValues } from "./templates";
+import type { TemplateFsDeps, TokenValues } from "./templates";
 
-vi.mock("node:fs", () => ({
-  readFileSync: vi.fn(),
-  writeFileSync: vi.fn(),
-  mkdirSync: vi.fn(),
-}));
-
-const mockedReadFileSync = vi.mocked(readFileSync);
-const mockedWriteFileSync = vi.mocked(writeFileSync);
-const mockedMkdirSync = vi.mocked(mkdirSync);
+function createMockFs(): TemplateFsDeps {
+  return {
+    readFileSync: vi.fn().mockReturnValue(""),
+    writeFileSync: vi.fn(),
+    mkdirSync: vi.fn(),
+  };
+}
 
 describe("resolveTemplate", () => {
+  let mockFs: TemplateFsDeps;
+
   beforeEach(() => {
-    vi.clearAllMocks();
+    mockFs = createMockFs();
   });
 
   const tokens: TokenValues = {
@@ -26,13 +25,13 @@ describe("resolveTemplate", () => {
   };
 
   it("replaces all token placeholders in template", () => {
-    mockedReadFileSync.mockReturnValue(
+    vi.mocked(mockFs.readFileSync).mockReturnValue(
       "Scope: {{SCOPE_PATH}}\nDir: {{ISSUE_DIR}}\nBranch: {{MAIN_BRANCH}}",
     );
 
-    resolveTemplate("plan.md", tokens, "/tmp/issues/42");
+    resolveTemplate("plan.md", tokens, "/tmp/issues/42", mockFs);
 
-    const writtenContent = mockedWriteFileSync.mock.calls[0][1];
+    const writtenContent = vi.mocked(mockFs.writeFileSync).mock.calls[0][1];
     expect(writtenContent).toContain("/home/user/project");
     expect(writtenContent).toContain("/tmp/issues/42");
     expect(writtenContent).toContain("main");
@@ -44,28 +43,28 @@ describe("resolveTemplate", () => {
       ...tokens,
       REVIEW_FEEDBACK: "Needs more tests",
     };
-    mockedReadFileSync.mockReturnValue("Feedback: {{REVIEW_FEEDBACK}}");
+    vi.mocked(mockFs.readFileSync).mockReturnValue("Feedback: {{REVIEW_FEEDBACK}}");
 
-    resolveTemplate("review.md", tokensWithFeedback, "/tmp/issues/42");
+    resolveTemplate("review.md", tokensWithFeedback, "/tmp/issues/42", mockFs);
 
-    const writtenContent = mockedWriteFileSync.mock.calls[0][1];
+    const writtenContent = vi.mocked(mockFs.writeFileSync).mock.calls[0][1];
     expect(writtenContent).toContain("Needs more tests");
   });
 
   it("creates output directory recursively", () => {
-    mockedReadFileSync.mockReturnValue("template content");
+    vi.mocked(mockFs.readFileSync).mockReturnValue("template content");
 
-    resolveTemplate("plan.md", tokens, "/tmp/issues/42");
+    resolveTemplate("plan.md", tokens, "/tmp/issues/42", mockFs);
 
-    expect(mockedMkdirSync).toHaveBeenCalledWith("/tmp/issues/42", { recursive: true });
+    expect(mockFs.mkdirSync).toHaveBeenCalledWith("/tmp/issues/42", { recursive: true });
   });
 
   it("writes resolved template to issue dir", () => {
-    mockedReadFileSync.mockReturnValue("simple content");
+    vi.mocked(mockFs.readFileSync).mockReturnValue("simple content");
 
-    resolveTemplate("plan.md", tokens, "/tmp/issues/42");
+    resolveTemplate("plan.md", tokens, "/tmp/issues/42", mockFs);
 
-    expect(mockedWriteFileSync).toHaveBeenCalledWith(
+    expect(mockFs.writeFileSync).toHaveBeenCalledWith(
       "/tmp/issues/42/plan.md",
       "simple content",
       "utf-8",
@@ -73,19 +72,19 @@ describe("resolveTemplate", () => {
   });
 
   it("returns relative path from cwd", () => {
-    mockedReadFileSync.mockReturnValue("content");
+    vi.mocked(mockFs.readFileSync).mockReturnValue("content");
 
-    const result = resolveTemplate("plan.md", tokens, "/tmp/issues/42");
+    const result = resolveTemplate("plan.md", tokens, "/tmp/issues/42", mockFs);
     // Should be a relative path (not starting with /)
     expect(result).not.toMatch(/^\/tmp/);
   });
 
   it("handles multiple occurrences of the same token", () => {
-    mockedReadFileSync.mockReturnValue("{{MAIN_BRANCH}} and {{MAIN_BRANCH}} again");
+    vi.mocked(mockFs.readFileSync).mockReturnValue("{{MAIN_BRANCH}} and {{MAIN_BRANCH}} again");
 
-    resolveTemplate("plan.md", tokens, "/tmp/issues/42");
+    resolveTemplate("plan.md", tokens, "/tmp/issues/42", mockFs);
 
-    const writtenContent = mockedWriteFileSync.mock.calls[0][1];
+    const writtenContent = vi.mocked(mockFs.writeFileSync).mock.calls[0][1];
     expect(writtenContent).toBe("main and main again");
   });
 });

package/src/lib/auto-claude/templates.ts

@@ -1,4 +1,8 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import {
+  mkdirSync as defaultMkdirSync,
+  readFileSync as defaultReadFileSync,
+  writeFileSync as defaultWriteFileSync,
+} from "node:fs";
 import { dirname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -14,21 +18,34 @@ export interface TokenValues {
   REVIEW_FEEDBACK?: string;
 }
 
+export interface TemplateFsDeps {
+  readFileSync: typeof defaultReadFileSync;
+  writeFileSync: typeof defaultWriteFileSync;
+  mkdirSync: typeof defaultMkdirSync;
+}
+
+const defaultFsDeps: TemplateFsDeps = {
+  readFileSync: defaultReadFileSync,
+  writeFileSync: defaultWriteFileSync,
+  mkdirSync: defaultMkdirSync,
+};
+
 export function resolveTemplate(
   templateName: string,
   tokens: TokenValues,
   issueDir: string,
+  fs: TemplateFsDeps = defaultFsDeps,
 ): string {
   const templatePath = join(TEMPLATES_DIR, templateName);
-  let template = readFileSync(templatePath, "utf-8");
+  let template = fs.readFileSync(templatePath, "utf-8") as string;
 
   for (const [key, value] of Object.entries(tokens)) {
     template = template.replaceAll(`{{${key}}}`, value);
   }
 
   const resolvedPath = join(issueDir, templateName);
-  mkdirSync(dirname(resolvedPath), { recursive: true });
-  writeFileSync(resolvedPath, template, "utf-8");
+  fs.mkdirSync(dirname(resolvedPath), { recursive: true });
+  fs.writeFileSync(resolvedPath, template, "utf-8");
 
   return relative(process.cwd(), resolvedPath);
 }

package/src/lib/auto-claude/utils.ts

@@ -11,6 +11,7 @@ import { getConfig } from "./config.js";
 import { ARTIFACTS } from "./prompt-templates/index.js";
 import { resolveTemplate } from "./templates.js";
 
+import type { SpawnClaudeFn } from "./spawn-claude.js";
 import type { TokenValues } from "./templates.js";
 
 export { ensureDir, fileExists, readFile, writeFile } from "../../utils/fs.js";
@@ -157,6 +158,7 @@ export interface StepRunnerOptions {
   artifactPath: string;
   templateName: string;
   artifactValidator?: (path: string) => boolean;
+  spawnFn?: SpawnClaudeFn;
 }
 
 /**
@@ -167,7 +169,7 @@ export interface StepRunnerOptions {
  * the same pattern.
  */
 export async function runStepWithArtifact(opts: StepRunnerOptions): Promise<boolean> {
-  const { stepName, ctx, artifactPath, templateName, artifactValidator } = opts;
+  const { stepName, ctx, artifactPath, templateName, artifactValidator, spawnFn } = opts;
 
   const isValid = artifactValidator ?? fileExists;
   if (isValid(artifactPath)) {
@@ -183,6 +185,7 @@ export async function runStepWithArtifact(opts: StepRunnerOptions): Promise<bool
   const result = await runClaude({
     promptFile,
     maxTurns: getConfig().maxTurns,
+    spawnFn,
   });
 
   if (result.is_error) {

package/src/lib/graph/parser.test.ts

@@ -1,13 +1,9 @@
-import * as fs from "node:fs";
 import { describe, expect, it, vi } from "vitest";
 
+import type { ReadFileFn } from "./parser";
 import { calculateCutoffMs, filterByDays, parseJsonl, quickTokenCount } from "./parser";
 
-vi.mock("node:fs", () => ({
-  readFileSync: vi.fn(),
-}));
-
-const mockedReadFileSync = vi.mocked(fs.readFileSync);
+const mockReadFileSync: ReadFileFn = vi.fn();
 
 // ── Pure functions (no mocking needed) ──
 
@@ -67,38 +63,38 @@ describe("filterByDays", () => {
   });
 });
 
-// ── parseJsonl and quickTokenCount (require fs mock) ──
+// ── parseJsonl and quickTokenCount (use injected readFile) ──
 
 describe("parseJsonl", () => {
   it("parses valid JSONL lines", () => {
-    mockedReadFileSync.mockReturnValue(
+    vi.mocked(mockReadFileSync).mockReturnValue(
       '{"type":"user","sessionId":"s1","timestamp":"2025-01-01T00:00:00Z"}\n{"type":"assistant","sessionId":"s1","timestamp":"2025-01-01T00:01:00Z"}\n',
     );
-    const entries = parseJsonl("/fake/path.jsonl");
+    const entries = parseJsonl("/fake/path.jsonl", mockReadFileSync);
     expect(entries).toHaveLength(2);
     expect(entries[0].type).toBe("user");
     expect(entries[1].type).toBe("assistant");
   });
 
   it("skips empty lines", () => {
-    mockedReadFileSync.mockReturnValue(
+    vi.mocked(mockReadFileSync).mockReturnValue(
       '{"type":"user","sessionId":"s1","timestamp":"t"}\n\n\n{"type":"assistant","sessionId":"s1","timestamp":"t"}\n',
     );
-    const entries = parseJsonl("/fake/path.jsonl");
+    const entries = parseJsonl("/fake/path.jsonl", mockReadFileSync);
     expect(entries).toHaveLength(2);
   });
 
   it("skips invalid JSON lines", () => {
-    mockedReadFileSync.mockReturnValue(
+    vi.mocked(mockReadFileSync).mockReturnValue(
       '{"type":"user","sessionId":"s1","timestamp":"t"}\nnot-json\n{"type":"assistant","sessionId":"s1","timestamp":"t"}\n',
     );
-    const entries = parseJsonl("/fake/path.jsonl");
+    const entries = parseJsonl("/fake/path.jsonl", mockReadFileSync);
     expect(entries).toHaveLength(2);
   });
 
   it("returns empty array for empty file", () => {
-    mockedReadFileSync.mockReturnValue("");
-    const entries = parseJsonl("/fake/path.jsonl");
+    vi.mocked(mockReadFileSync).mockReturnValue("");
+    const entries = parseJsonl("/fake/path.jsonl", mockReadFileSync);
     expect(entries).toHaveLength(0);
   });
 });
@@ -113,8 +109,8 @@ describe("quickTokenCount", () => {
         message: { usage: { input_tokens: 200, output_tokens: 75 } },
       }),
     ].join("\n");
-    mockedReadFileSync.mockReturnValue(lines);
-    expect(quickTokenCount("/fake/path.jsonl")).toBe(425);
+    vi.mocked(mockReadFileSync).mockReturnValue(lines);
+    expect(quickTokenCount("/fake/path.jsonl", mockReadFileSync)).toBe(425);
   });
 
   it("skips entries without usage", () => {
@@ -122,29 +118,29 @@ describe("quickTokenCount", () => {
       JSON.stringify({ message: { content: "text" } }),
       JSON.stringify({ message: { usage: { input_tokens: 100, output_tokens: 50 } } }),
     ].join("\n");
-    mockedReadFileSync.mockReturnValue(lines);
-    expect(quickTokenCount("/fake/path.jsonl")).toBe(150);
+    vi.mocked(mockReadFileSync).mockReturnValue(lines);
+    expect(quickTokenCount("/fake/path.jsonl", mockReadFileSync)).toBe(150);
   });
 
   it("returns 0 for unreadable files", () => {
-    mockedReadFileSync.mockImplementation(() => {
+    vi.mocked(mockReadFileSync).mockImplementation(() => {
       throw new Error("ENOENT");
     });
-    expect(quickTokenCount("/missing/file.jsonl")).toBe(0);
+    expect(quickTokenCount("/missing/file.jsonl", mockReadFileSync)).toBe(0);
   });
 
   it("handles entries with partial usage (only input_tokens)", () => {
     const lines = JSON.stringify({
       message: { usage: { input_tokens: 100 } },
     });
-    mockedReadFileSync.mockReturnValue(lines);
-    expect(quickTokenCount("/fake/path.jsonl")).toBe(100);
+    vi.mocked(mockReadFileSync).mockReturnValue(lines);
+    expect(quickTokenCount("/fake/path.jsonl", mockReadFileSync)).toBe(100);
   });
 
   it("skips invalid JSON lines gracefully", () => {
-    mockedReadFileSync.mockReturnValue(
+    vi.mocked(mockReadFileSync).mockReturnValue(
       '{"message":{"usage":{"input_tokens":50,"output_tokens":50}}}\nbadline\n',
     );
-    expect(quickTokenCount("/fake/path.jsonl")).toBe(100);
+    expect(quickTokenCount("/fake/path.jsonl", mockReadFileSync)).toBe(100);
   });
 });

package/src/lib/graph/parser.ts

@@ -1,6 +1,9 @@
-import * as fs from "node:fs";
+import { readFileSync as defaultReadFileSync } from "node:fs";
+
 import type { JournalEntry } from "./types.js";
 
+export type ReadFileFn = (path: string, encoding: BufferEncoding) => string;
+
 /**
  * Calculate cutoff timestamp for days filtering.
  * Returns 0 if days <= 0 (no filtering).
@@ -22,8 +25,11 @@ export function filterByDays<T extends { mtime: number }>(items: T[], days: numb
 /**
  * Parse JSONL file into JournalEntry array.
  */
-export function parseJsonl(filePath: string): JournalEntry[] {
-  const content = fs.readFileSync(filePath, "utf-8");
+export function parseJsonl(
+  filePath: string,
+  readFile: ReadFileFn = defaultReadFileSync,
+): JournalEntry[] {
+  const content = readFile(filePath, "utf-8");
   const entries: JournalEntry[] = [];
 
   for (const line of content.split("\n")) {
@@ -41,9 +47,12 @@ export function parseJsonl(filePath: string): JournalEntry[] {
 /**
  * Quick token count from a JSONL file without full parsing.
  */
-export function quickTokenCount(filePath: string): number {
+export function quickTokenCount(
+  filePath: string,
+  readFile: ReadFileFn = defaultReadFileSync,
+): number {
   try {
-    const content = fs.readFileSync(filePath, "utf-8");
+    const content = readFile(filePath, "utf-8");
     let total = 0;
     for (const line of content.split("\n")) {
       if (!line.trim()) continue;