@towles/tool 0.0.66 → 0.0.68

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

@@ -8,16 +8,29 @@ import { createPr } from "./steps/create-pr.js";
 import { stepImplement } from "./steps/implement.js";
 import { stepPlan, stepReview, stepSimplify } from "./steps/simple-steps.js";
 import { LABELS, ensureLabelsExist, removeLabel, setLabel } from "./labels.js";
+import type { ExecSafeFn } from "./labels.js";
 import { ensureDir, fileExists, readFile, writeFile } from "../../utils/fs.js";
 import { execSafe, git } from "../../utils/git/exec.js";
 import { ghRaw } from "../../utils/git/gh-cli-wrapper.js";
 import { log } from "./utils.js";
 import type { IssueContext } from "./utils.js";
+import type { SpawnClaudeFn } from "./spawn-claude.js";
 
 export { type StepName, STEP_NAMES } from "./prompt-templates/index.js";
 
-export async function runPipeline(ctx: IssueContext, untilStep?: StepName): Promise<void> {
+export interface PipelineDeps {
+  spawnFn?: SpawnClaudeFn;
+  exec?: ExecSafeFn;
+}
+
+export async function runPipeline(
+  ctx: IssueContext,
+  untilStep?: StepName,
+  deps?: PipelineDeps,
+): Promise<void> {
   const cfg = getConfig();
+  const exec = deps?.exec;
+  const spawnFn = deps?.spawnFn;
   log(`Pipeline starting for ${ctx.repo}#${ctx.number}: ${ctx.title}`);
 
   ensureDir(ctx.issueDir);
@@ -29,14 +42,14 @@ export async function runPipeline(ctx: IssueContext, untilStep?: StepName): Prom
   }
 
   // Label management
-  await ensureLabelsExist(ctx.repo);
-  await removeLabel(ctx.repo, ctx.number, cfg.triggerLabel);
-  await setLabel(ctx.repo, ctx.number, LABELS.inProgress);
+  await ensureLabelsExist(ctx.repo, exec);
+  await removeLabel(ctx.repo, ctx.number, cfg.triggerLabel, exec);
+  await setLabel(ctx.repo, ctx.number, LABELS.inProgress, exec);
 
   try {
     // Step 1: Plan (runs once)
-    if (!(await stepPlan(ctx))) {
-      await handleFailure(ctx, "plan");
+    if (!(await stepPlan(ctx, spawnFn))) {
+      await handleFailure(ctx, "plan", undefined, exec);
       return;
     }
     if (untilStep === "plan") {
@@ -55,8 +68,8 @@ export async function runPipeline(ctx: IssueContext, untilStep?: StepName): Prom
       }
 
       // Implement
-      if (!(await stepImplement(ctx))) {
-        await handleFailure(ctx, "implement");
+      if (!(await stepImplement(ctx, spawnFn))) {
+        await handleFailure(ctx, "implement", undefined, exec);
         return;
       }
       if (untilStep === "implement") {
@@ -65,8 +78,8 @@ export async function runPipeline(ctx: IssueContext, untilStep?: StepName): Prom
       }
 
       // Simplify
-      if (!(await stepSimplify(ctx))) {
-        await handleFailure(ctx, "simplify");
+      if (!(await stepSimplify(ctx, spawnFn))) {
+        await handleFailure(ctx, "simplify", undefined, exec);
         return;
       }
       if (untilStep === "simplify") {
@@ -75,8 +88,8 @@ export async function runPipeline(ctx: IssueContext, untilStep?: StepName): Prom
       }
 
       // Review
-      if (!(await stepReview(ctx))) {
-        await handleFailure(ctx, "review");
+      if (!(await stepReview(ctx, spawnFn))) {
+        await handleFailure(ctx, "review", undefined, exec);
         return;
       }
       if (untilStep === "review") {
@@ -86,10 +99,10 @@ export async function runPipeline(ctx: IssueContext, untilStep?: StepName): Prom
 
       // Check review result
       if (isReviewPass(ctx)) {
-        const prUrl = await createPr(ctx);
-        await removeLabel(ctx.repo, ctx.number, LABELS.inProgress);
-        await setLabel(ctx.repo, ctx.number, LABELS.success);
-        await setLabel(ctx.repo, ctx.number, LABELS.review);
+        const prUrl = await createPr(ctx, exec);
+        await removeLabel(ctx.repo, ctx.number, LABELS.inProgress, exec);
+        await setLabel(ctx.repo, ctx.number, LABELS.success, exec);
+        await setLabel(ctx.repo, ctx.number, LABELS.review, exec);
         log(`Pipeline complete for ${ctx.repo}#${ctx.number} — ${prUrl}`);
         return;
       }
@@ -107,6 +120,7 @@ export async function runPipeline(ctx: IssueContext, untilStep?: StepName): Prom
       ctx,
       "review",
       `auto-claude: review did not pass after ${maxRetries + 1} attempts. Labelled \`${LABELS.failed}\`.`,
+      exec,
     );
   } finally {
     await checkoutMain();
@@ -125,11 +139,19 @@ function isReviewPass(ctx: IssueContext): boolean {
   return firstLine === "PASS";
 }
 
-async function handleFailure(ctx: IssueContext, stepName: string, comment?: string): Promise<void> {
-  await removeLabel(ctx.repo, ctx.number, LABELS.inProgress);
-  await setLabel(ctx.repo, ctx.number, LABELS.failed);
+async function handleFailure(
+  ctx: IssueContext,
+  stepName: string,
+  comment?: string,
+  exec?: ExecSafeFn,
+): Promise<void> {
+  await removeLabel(ctx.repo, ctx.number, LABELS.inProgress, exec);
+  await setLabel(ctx.repo, ctx.number, LABELS.failed, exec);
   if (comment) {
-    await ghRaw(["issue", "comment", String(ctx.number), "--repo", ctx.repo, "--body", comment]);
+    await ghRaw(
+      ["issue", "comment", String(ctx.number), "--repo", ctx.repo, "--body", comment],
+      exec,
+    );
   }
   log(`Pipeline stopped at "${stepName}" for ${ctx.repo}#${ctx.number}`);
 }

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