@towles/tool 0.0.65 → 0.0.67

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

@@ -2,15 +2,14 @@ import consola from "consola";
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { initConfig } from "./config";
-import { createSpawnClaudeMock, createTestRepo } from "./test-helpers";
-import type { MockClaudeImpl, TestRepo } from "./test-helpers";
+import { createMockClaudeProcess, createTestRepo } from "./test-helpers";
+import type { TestRepo } from "./test-helpers";
+import type { SpawnClaudeFn } from "./spawn-claude";
+import type { ClaudeLogger } from "./claude-cli";
 
 consola.level = -999;
 
-let mockSpawnImpl: MockClaudeImpl = null;
-vi.mock("./spawn-claude", () => createSpawnClaudeMock(() => mockSpawnImpl));
-
-describe("runClaude (mocked spawn-claude)", () => {
+describe("runClaude (injected spawnFn)", () => {
   let originalCwd: string;
   let repo: TestRepo;
 
@@ -26,19 +25,20 @@ describe("runClaude (mocked spawn-claude)", () => {
   });
 
   beforeEach(() => {
-    mockSpawnImpl = null;
     vi.clearAllMocks();
   });
 
   it("parses stream-json result event", async () => {
-    mockSpawnImpl = () => ({
-      stdout: JSON.stringify({
-        result: "All done",
-        is_error: false,
-        total_cost_usd: 0.05,
-        num_turns: 3,
-      }),
-      exitCode: 0,
+    const mockSpawnClaude: SpawnClaudeFn = vi.fn((args: string[]) => {
+      return createMockClaudeProcess(
+        JSON.stringify({
+          result: "All done",
+          is_error: false,
+          total_cost_usd: 0.05,
+          num_turns: 3,
+        }),
+        0,
+      );
     });
 
     await initConfig({ repo: "test/repo", mainBranch: "main" });
@@ -48,14 +48,14 @@ describe("runClaude (mocked spawn-claude)", () => {
     const result = await runClaude({
       promptFile: "test-prompt.md",
       maxTurns: 10,
+      spawnFn: mockSpawnClaude,
     });
 
     expect(result.result).toBe("All done");
     expect(result.is_error).toBe(false);
     expect(result.num_turns).toBe(3);
 
-    const { spawnClaude } = await import("./spawn-claude");
-    expect(spawnClaude).toHaveBeenCalledWith(
+    expect(mockSpawnClaude).toHaveBeenCalledWith(
       expect.arrayContaining([
         "-p",
         "--output-format",
@@ -71,7 +71,13 @@ describe("runClaude (mocked spawn-claude)", () => {
   });
 
   it("logs tool names from stream_event and shows thinking indicator", async () => {
-    const infoSpy = vi.spyOn(consola, "info");
+    const mockLogger: ClaudeLogger = {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      success: vi.fn(),
+      log: vi.fn(),
+    };
 
     const thinkingEvent = {
       type: "stream_event",
@@ -94,30 +100,35 @@ describe("runClaude (mocked spawn-claude)", () => {
       num_turns: 1,
     };
 
-    mockSpawnImpl = () => ({
-      stdout: [thinkingEvent, toolEvent, resultEvent].map((e) => JSON.stringify(e)).join("\n"),
-      exitCode: 0,
+    const mockSpawnClaude: SpawnClaudeFn = vi.fn(() => {
+      return createMockClaudeProcess(
+        [thinkingEvent, toolEvent, resultEvent].map((e) => JSON.stringify(e)).join("\n"),
+        0,
+      );
     });
 
     await initConfig({ repo: "test/repo", mainBranch: "main" });
 
     const { runClaude } = await import("./claude-cli");
-    const result = await runClaude({ promptFile: "test.md" });
+    const result = await runClaude({
+      promptFile: "test.md",
+      spawnFn: mockSpawnClaude,
+      logger: mockLogger,
+    });
 
     expect(result.result).toBe("Done");
     expect(result.num_turns).toBe(1);
 
-    const infoCalls = infoSpy.mock.calls.map((c) => String(c[0]));
+    const infoCalls = (mockLogger.info as ReturnType<typeof vi.fn>).mock.calls.map((c) =>
+      String(c[0]),
+    );
     expect(infoCalls.some((msg) => msg.includes("thinking"))).toBe(true);
     expect(infoCalls.some((msg) => msg.includes("Edit"))).toBe(true);
-
-    infoSpy.mockRestore();
   });
 
   it("returns fallback when no result event in stream", async () => {
-    mockSpawnImpl = () => ({
-      stdout: '{"type":"system","message":"starting"}',
-      exitCode: 0,
+    const mockSpawnClaude: SpawnClaudeFn = vi.fn(() => {
+      return createMockClaudeProcess('{"type":"system","message":"starting"}', 0);
     });
 
     await initConfig({ repo: "test/repo", mainBranch: "main" });
@@ -126,6 +137,7 @@ describe("runClaude (mocked spawn-claude)", () => {
 
     const result = await runClaude({
       promptFile: "test.md",
+      spawnFn: mockSpawnClaude,
     });
 
     expect(result.result).toBe("");

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

@@ -1,6 +1,8 @@
 import { spawn } from "node:child_process";
 import type { ChildProcess } from "node:child_process";
 
+export type SpawnClaudeFn = (args: string[]) => ChildProcess;
+
 /**
  * Spawns the Claude CLI as a child process.
  * Extracted into its own module so tests can mock it cleanly

package/src/lib/auto-claude/steps/create-pr.ts

@@ -9,11 +9,12 @@ import { getConfig } from "../config.js";
 import { ARTIFACTS } from "../prompt-templates/index.js";
 import { log } from "../utils.js";
 import type { IssueContext } from "../utils.js";
+import type { ExecSafeFn } from "../labels.js";
 
-export async function createPr(ctx: IssueContext): Promise<string> {
+export async function createPr(ctx: IssueContext, exec?: ExecSafeFn): Promise<string> {
   const cfg = getConfig();
 
-  const existingUrl = await getExistingPrUrl(ctx.branch);
+  const existingUrl = await getExistingPrUrl(ctx.branch, exec);
   if (existingUrl) {
     log(`PR already exists: ${existingUrl}`);
     return existingUrl;
@@ -48,18 +49,21 @@ export async function createPr(ctx: IssueContext): Promise<string> {
     "Generated by auto-claude pipeline",
   ].join("\n");
 
-  const prUrl = await ghRaw([
-    "pr",
-    "create",
-    "--repo",
-    cfg.repo,
-    "--head",
-    ctx.branch,
-    "--title",
-    ctx.title,
-    "--body",
-    body,
-  ]);
+  const prUrl = await ghRaw(
+    [
+      "pr",
+      "create",
+      "--repo",
+      cfg.repo,
+      "--head",
+      ctx.branch,
+      "--title",
+      ctx.title,
+      "--body",
+      body,
+    ],
+    exec,
+  );
 
   if (!prUrl) {
     throw new Error("Failed to create PR — gh returned empty output");
@@ -69,7 +73,7 @@ export async function createPr(ctx: IssueContext): Promise<string> {
   log(`PR created: ${prUrl}`);
 
   try {
-    await attachArtifacts(ctx, prUrl);
+    await attachArtifacts(ctx, prUrl, exec);
   } catch (e) {
     consola.warn(`Artifact upload failed (non-blocking): ${e}`);
   }
@@ -77,7 +81,7 @@ export async function createPr(ctx: IssueContext): Promise<string> {
   return prUrl;
 }
 
-async function attachArtifacts(ctx: IssueContext, prUrl: string): Promise<void> {
+async function attachArtifacts(ctx: IssueContext, prUrl: string, exec?: ExecSafeFn): Promise<void> {
   const archivePath = join(ctx.issueDir, "artifacts.tar.gz");
   const tag = `ac-issue-${ctx.number}`;
   const cfg = getConfig();
@@ -94,31 +98,27 @@ async function attachArtifacts(ctx: IssueContext, prUrl: string): Promise<void>
   ]);
 
   log("Uploading artifacts to GitHub release…");
-  await ghRaw(["release", "delete", tag, "--yes", "--repo", cfg.repo]);
-
-  await ghRaw([
-    "release",
-    "create",
-    tag,
-    "--prerelease",
-    "--title",
-    `Artifacts: #${ctx.number}`,
-    "--repo",
-    cfg.repo,
-    archivePath,
-  ]);
-
-  const assetUrl = await ghRaw([
-    "release",
-    "view",
-    tag,
-    "--json",
-    "assets",
-    "--jq",
-    ".assets[0].url",
-    "--repo",
-    cfg.repo,
-  ]);
+  await ghRaw(["release", "delete", tag, "--yes", "--repo", cfg.repo], exec);
+
+  await ghRaw(
+    [
+      "release",
+      "create",
+      tag,
+      "--prerelease",
+      "--title",
+      `Artifacts: #${ctx.number}`,
+      "--repo",
+      cfg.repo,
+      archivePath,
+    ],
+    exec,
+  );
+
+  const assetUrl = await ghRaw(
+    ["release", "view", tag, "--json", "assets", "--jq", ".assets[0].url", "--repo", cfg.repo],
+    exec,
+  );
 
   if (!assetUrl) {
     consola.warn("Could not get artifact download URL — skipping PR comment");
@@ -133,22 +133,25 @@ async function attachArtifacts(ctx: IssueContext, prUrl: string): Promise<void>
     "Contains: plan.md, completed-summary.md, simplify-summary.md, review.md",
   ].join("\n");
 
-  await ghRaw(["pr", "comment", prUrl, "--body", comment]);
+  await ghRaw(["pr", "comment", prUrl, "--body", comment], exec);
 }
 
-async function getExistingPrUrl(branch: string): Promise<string | null> {
-  const out = await ghRaw([
-    "pr",
-    "list",
-    "--repo",
-    getConfig().repo,
-    "--head",
-    branch,
-    "--state",
-    "open",
-    "--json",
-    "url",
-  ]);
+async function getExistingPrUrl(branch: string, exec?: ExecSafeFn): Promise<string | null> {
+  const out = await ghRaw(
+    [
+      "pr",
+      "list",
+      "--repo",
+      getConfig().repo,
+      "--head",
+      branch,
+      "--state",
+      "open",
+      "--json",
+      "url",
+    ],
+    exec,
+  );
   try {
     const prs = JSON.parse(out) as Array<{ url: string }>;
     return prs.length > 0 ? prs[0].url : null;

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

@@ -10,8 +10,9 @@ import { runClaude } from "../claude-cli.js";
 import { resolveTemplate } from "../templates.js";
 import { buildTokens, log, logStep } from "../utils.js";
 import type { IssueContext } from "../utils.js";
+import type { SpawnClaudeFn } from "../spawn-claude.js";
 
-export async function stepImplement(ctx: IssueContext): Promise<boolean> {
+export async function stepImplement(ctx: IssueContext, spawnFn?: SpawnClaudeFn): Promise<boolean> {
   const completedPath = join(ctx.issueDir, ARTIFACTS.completedSummary);
   const maxIterations = getConfig().maxImplementIterations;
 
@@ -36,6 +37,7 @@ export async function stepImplement(ctx: IssueContext): Promise<boolean> {
     const result = await runClaude({
       promptFile,
       maxTurns: getConfig().maxTurns,
+      spawnFn,
     });
 
     if (result.is_error) {

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

@@ -3,8 +3,9 @@ import { join } from "node:path";
 import { ARTIFACTS, STEP_LABELS, TEMPLATES } from "../prompt-templates/index.js";
 import { ensureBranch, runStepWithArtifact } from "../utils.js";
 import type { IssueContext } from "../utils.js";
+import type { SpawnClaudeFn } from "../spawn-claude.js";
 
-export async function stepPlan(ctx: IssueContext): Promise<boolean> {
+export async function stepPlan(ctx: IssueContext, spawnFn?: SpawnClaudeFn): Promise<boolean> {
   await ensureBranch(ctx.branch);
 
   return runStepWithArtifact({
@@ -12,23 +13,26 @@ export async function stepPlan(ctx: IssueContext): Promise<boolean> {
     ctx,
     artifactPath: join(ctx.issueDir, ARTIFACTS.plan),
     templateName: TEMPLATES.plan,
+    spawnFn,
   });
 }
 
-export async function stepSimplify(ctx: IssueContext): Promise<boolean> {
+export async function stepSimplify(ctx: IssueContext, spawnFn?: SpawnClaudeFn): Promise<boolean> {
   return runStepWithArtifact({
     stepName: STEP_LABELS.simplify,
     ctx,
     artifactPath: join(ctx.issueDir, ARTIFACTS.simplifySummary),
     templateName: TEMPLATES.simplify,
+    spawnFn,
   });
 }
 
-export async function stepReview(ctx: IssueContext): Promise<boolean> {
+export async function stepReview(ctx: IssueContext, spawnFn?: SpawnClaudeFn): Promise<boolean> {
   return runStepWithArtifact({
     stepName: STEP_LABELS.review,
     ctx,
     artifactPath: join(ctx.issueDir, ARTIFACTS.review),
     templateName: TEMPLATES.review,
+    spawnFn,
   });
 }

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);
   });