@towles/tool 0.0.65 → 0.0.67

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;

package/src/utils/git/gh-cli-wrapper.test.ts

@@ -1,35 +1,32 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { x } from "tinyexec";
-import { getIssues, isGithubCliInstalled } from "./gh-cli-wrapper";
 
-vi.mock("tinyexec", () => ({
-  x: vi.fn().mockResolvedValue({ stdout: "[]" }),
-}));
+import type { XFn } from "./gh-cli-wrapper";
+import { getIssues, isGithubCliInstalled } from "./gh-cli-wrapper";
 
-const mockX = vi.mocked(x);
+const mockX: XFn = vi.fn().mockResolvedValue({ stdout: "[]", stderr: "", exitCode: 0 });
 
 describe("gh-cli-wrapper", () => {
   beforeEach(() => {
     vi.clearAllMocks();
-    mockX.mockResolvedValue({ stdout: "[]" } as never);
+    vi.mocked(mockX).mockResolvedValue({ stdout: "[]", stderr: "", exitCode: 0 });
   });
 
   describe("getIssues", () => {
     it("passes --label flag when label provided", async () => {
-      await getIssues({ cwd: ".", label: "auto-claude" });
+      await getIssues({ cwd: ".", label: "auto-claude", exec: mockX });
 
       expect(mockX).toHaveBeenCalledWith("gh", expect.arrayContaining(["--label", "auto-claude"]));
     });
 
     it("does not pass --label flag when label not provided", async () => {
-      await getIssues({ cwd: "." });
+      await getIssues({ cwd: ".", exec: mockX });
 
-      const args = mockX.mock.calls[0]![1] as string[];
+      const args = vi.mocked(mockX).mock.calls[0]![1] as string[];
       expect(args).not.toContain("--label");
     });
 
     it("passes --assignee @me flag when assignedToMe is true", async () => {
-      await getIssues({ cwd: ".", assignedToMe: true });
+      await getIssues({ cwd: ".", assignedToMe: true, exec: mockX });
 
       expect(mockX).toHaveBeenCalledWith("gh", expect.arrayContaining(["--assignee", "@me"]));
     });
@@ -37,16 +34,20 @@ describe("gh-cli-wrapper", () => {
 
   describe("isGithubCliInstalled", () => {
     it("returns true when gh CLI outputs expected string", async () => {
-      mockX.mockResolvedValue({ stdout: "gh version 2.0.0 (https://github.com/cli/cli)" } as never);
+      vi.mocked(mockX).mockResolvedValue({
+        stdout: "gh version 2.0.0 (https://github.com/cli/cli)",
+        stderr: "",
+        exitCode: 0,
+      });
 
-      const result = await isGithubCliInstalled();
+      const result = await isGithubCliInstalled(mockX);
       expect(result).toBe(true);
     });
 
     it("returns false when gh CLI is not available", async () => {
-      mockX.mockRejectedValue(new Error("command not found"));
+      vi.mocked(mockX).mockRejectedValue(new Error("command not found"));
 
-      const result = await isGithubCliInstalled();
+      const result = await isGithubCliInstalled(mockX);
       expect(result).toBe(false);
     });
   });

package/src/utils/git/gh-cli-wrapper.ts

@@ -1,11 +1,18 @@
 import stripAnsi from "strip-ansi";
 import { x } from "tinyexec";
+import type { Output } from "tinyexec";
 
 import { execSafe } from "./exec.js";
 
-export async function isGithubCliInstalled(): Promise<boolean> {
+export type XFn = (
+  cmd: string,
+  args?: string[],
+  opts?: Record<string, unknown>,
+) => PromiseLike<Output>;
+
+export async function isGithubCliInstalled(exec: XFn = x as XFn): Promise<boolean> {
   try {
-    const proc = await x("gh", ["--version"]);
+    const proc = await exec("gh", ["--version"]);
     return proc.stdout.includes("https://github.com/cli/cli");
   } catch {
     // gh CLI not installed or not accessible
@@ -18,8 +25,12 @@ export async function gh<T = unknown>(args: string[]): Promise<T> {
   return JSON.parse(result.stdout.trim()) as T;
 }
 
-export async function ghRaw(args: string[]): Promise<string> {
-  const result = await execSafe("gh", args);
+export async function ghRaw(
+  args: string[],
+  exec?: (cmd: string, args: string[]) => Promise<{ stdout: string; ok: boolean }>,
+): Promise<string> {
+  const execFn = exec ?? execSafe;
+  const result = await execFn("gh", args);
   return result.stdout;
 }
 
@@ -37,9 +48,11 @@ export async function getIssues({
   assignedToMe,
   cwd,
   label,
+  exec = x as XFn,
 }: {
   assignedToMe?: boolean;
   cwd: string;
+  exec?: XFn;
   label?: string;
 }): Promise<Issue[]> {
   const args = ["issue", "list", "--json", "labels,number,title,state"];
@@ -52,7 +65,7 @@ export async function getIssues({
     args.push("--label", label);
   }
 
-  const result = await x("gh", args);
+  const result = await exec("gh", args);
   // Setting NO_COLOR=1 didn't remove colors so had to use stripAnsi
   const stripped = stripAnsi(result.stdout);