@towles/tool 0.0.66 → 0.0.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@towles/tool",
-  "version": "0.0.66",
+  "version": "0.0.68",
   "description": "One off quality of life scripts that I use on a daily basis.",
   "homepage": "https://github.com/ChrisTowles/towles-tool#readme",
   "bugs": {

package/src/commands/auto-claude/index.ts

@@ -1,7 +1,8 @@
-import { rmSync } from "node:fs";
+import { rmSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-import { Flags } from "@oclif/core";
+import { Args, Flags } from "@oclif/core";
 import consola from "consola";
 
 import { BaseCommand } from "../base.js";
@@ -14,6 +15,7 @@ import {
   initConfig,
   log,
   logBanner,
+  runClaude,
   runPipeline,
   sleep,
 } from "../../lib/auto-claude/index.js";
@@ -24,7 +26,18 @@ export default class AutoClaude extends BaseCommand {
 
   static override description = "Automated issue-to-PR pipeline using Claude Code";
 
+  static override args = {
+    prompt: Args.string({
+      description: "Run a single prompt (skips issue pipeline)",
+      required: false,
+    }),
+  };
+
   static override examples = [
+    {
+      description: "Run a single prompt",
+      command: '<%= config.bin %> auto-claude "Fix the login bug in auth.ts"',
+    },
     {
       description: "Process a specific issue",
       command: "<%= config.bin %> auto-claude --issue 42",
@@ -49,6 +62,10 @@ export default class AutoClaude extends BaseCommand {
 
   static override flags = {
     ...BaseCommand.baseFlags,
+    "max-turns": Flags.integer({
+      description: "Maximum conversation turns for prompt mode (default: 10)",
+      default: 10,
+    }),
     issue: Flags.integer({
       char: "i",
       description: "Process a specific issue number",
@@ -88,8 +105,29 @@ export default class AutoClaude extends BaseCommand {
   };
 
   async run(): Promise<void> {
-    const { flags } = await this.parse(AutoClaude);
+    const { args, flags } = await this.parse(AutoClaude);
+
+    // Prompt mode: run a single prompt with structured output, skip issue pipeline
+    if (args.prompt) {
+      await initConfig({ model: flags.model });
+
+      const promptDir = join(tmpdir(), "tt-auto-claude");
+      mkdirSync(promptDir, { recursive: true });
+      const promptFile = join(promptDir, `prompt-${Date.now()}.md`);
+      writeFileSync(promptFile, args.prompt);
+
+      const result = await runClaude({
+        promptFile,
+        maxTurns: flags["max-turns"],
+      });
+
+      if (result.is_error) {
+        this.error("Claude reported an error", { exit: 1 });
+      }
+      return;
+    }
 
+    // Issue pipeline mode
     const cfg = await initConfig({
       triggerLabel: flags.label,
       mainBranch: flags["main-branch"],

package/src/commands/auto-claude/retry.test.ts

@@ -3,23 +3,20 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import consola from "consola";
-import { x } from "tinyexec";
 import { describe, it, expect, vi, beforeEach } from "vitest";
 
+import type { ExecSafeFn } from "../../lib/auto-claude/labels.js";
 import { LABELS } from "../../lib/auto-claude/labels.js";
 import { retryIssues } from "./retry.js";
 
 // Suppress consola output during tests
 consola.level = -999;
 
-// Mock tinyexec so setLabel/removeLabel (which use execSafe -> x) work
-vi.mock("tinyexec", () => ({
-  x: vi.fn().mockResolvedValue({ stdout: "", exitCode: 0, stderr: "" }),
-}));
+const mockExecSafe: ExecSafeFn = vi.fn().mockResolvedValue({ stdout: "", ok: true });
 
 function getGhEditCalls() {
   return vi
-    .mocked(x)
+    .mocked(mockExecSafe)
     .mock.calls.filter(
       ([cmd, args]) => cmd === "gh" && args?.[0] === "issue" && args?.[1] === "edit",
     )
@@ -41,7 +38,7 @@ describe("retryIssues", () => {
       },
     ];
 
-    const count = await retryIssues("owner/repo", "auto-claude", issues, false);
+    const count = await retryIssues("owner/repo", "auto-claude", issues, false, mockExecSafe);
 
     expect(count).toBe(1);
     const editCalls = getGhEditCalls();
@@ -70,7 +67,7 @@ describe("retryIssues", () => {
       },
     ];
 
-    const count = await retryIssues("owner/repo", "auto-claude", issues, false);
+    const count = await retryIssues("owner/repo", "auto-claude", issues, false, mockExecSafe);
 
     expect(count).toBe(2);
     const editCalls = getGhEditCalls();
@@ -79,7 +76,7 @@ describe("retryIssues", () => {
   });
 
   it("returns 0 when given empty selection", async () => {
-    const count = await retryIssues("owner/repo", "auto-claude", [], false);
+    const count = await retryIssues("owner/repo", "auto-claude", [], false, mockExecSafe);
     expect(count).toBe(0);
     expect(getGhEditCalls().length).toBe(0);
   });
@@ -103,7 +100,7 @@ describe("retryIssues", () => {
         },
       ];
 
-      await retryIssues("owner/repo", "auto-claude", issues, true);
+      await retryIssues("owner/repo", "auto-claude", issues, true, mockExecSafe);
       expect(existsSync(issueDir)).toBe(false);
     } finally {
       process.chdir(originalCwd);
@@ -129,7 +126,7 @@ describe("retryIssues", () => {
         },
       ];
 
-      await retryIssues("owner/repo", "auto-claude", issues, false);
+      await retryIssues("owner/repo", "auto-claude", issues, false, mockExecSafe);
       expect(existsSync(issueDir)).toBe(true);
     } finally {
       process.chdir(originalCwd);

package/src/commands/auto-claude/retry.ts

@@ -9,6 +9,7 @@ import prompts from "prompts";
 import { BaseCommand } from "../base.js";
 import { initConfig } from "../../lib/auto-claude/index.js";
 import { LABELS, removeLabel, setLabel } from "../../lib/auto-claude/labels.js";
+import type { ExecSafeFn } from "../../lib/auto-claude/labels.js";
 import { getIssues, isGithubCliInstalled } from "../../utils/git/gh-cli-wrapper.js";
 import type { Issue } from "../../utils/git/gh-cli-wrapper.js";
 
@@ -21,14 +22,15 @@ export async function retryIssues(
   triggerLabel: string,
   selected: Issue[],
   clean: boolean,
+  exec?: ExecSafeFn,
 ): Promise<number> {
   for (const issue of selected) {
     consola.info(`Retrying issue #${issue.number}: ${issue.title}`);
 
-    await removeLabel(repo, issue.number, LABELS.failed);
+    await removeLabel(repo, issue.number, LABELS.failed, exec);
     consola.success(`  Removed '${LABELS.failed}' label`);
 
-    await setLabel(repo, issue.number, triggerLabel);
+    await setLabel(repo, issue.number, triggerLabel, exec);
     consola.success(`  Added '${triggerLabel}' label`);
 
     if (clean) {

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

@@ -5,7 +5,8 @@ import pc from "picocolors";
 
 import { getConfig } from "./config.js";
 import { sleep } from "./shell.js";
-import { spawnClaude } from "./spawn-claude.js";
+import { spawnClaude as defaultSpawnClaude } from "./spawn-claude.js";
+import type { SpawnClaudeFn } from "./spawn-claude.js";
 
 // ── Claude CLI ──
 
@@ -16,14 +17,26 @@ export interface ClaudeResult {
   num_turns: number;
 }
 
+export interface ClaudeLogger {
+  info: (...args: unknown[]) => void;
+  warn: (...args: unknown[]) => void;
+  error: (...args: unknown[]) => void;
+  success: (...args: unknown[]) => void;
+  log: (...args: unknown[]) => void;
+}
+
 const PROCESS_RETRIES = 3;
 const PROCESS_RETRY_DELAY_MS = 5_000;
 
 export async function runClaude(opts: {
   promptFile: string;
   maxTurns?: number;
+  spawnFn?: SpawnClaudeFn;
+  logger?: ClaudeLogger;
 }): Promise<ClaudeResult> {
   const cfg = getConfig();
+  const spawnFn = opts.spawnFn ?? defaultSpawnClaude;
+  const log = opts.logger ?? consola;
   const args = [
     "-p",
     "--output-format",
@@ -37,23 +50,21 @@ export async function runClaude(opts: {
     `@${opts.promptFile}`,
   ];
 
-  consola.info(
-    `${pc.dim("▶")} Calling Claude${opts.maxTurns ? ` (max ${opts.maxTurns} turns)` : ""}…`,
-  );
+  log.info(`${pc.dim("▶")} Calling Claude${opts.maxTurns ? ` (max ${opts.maxTurns} turns)` : ""}…`);
 
   let lastError: Error | undefined;
   for (let attempt = 1; attempt <= PROCESS_RETRIES; attempt++) {
     try {
-      const result = await runClaudeStreaming(args);
-      consola.success(`Done — ${result.num_turns} turns, $${result.total_cost_usd.toFixed(4)}`);
+      const result = await runClaudeStreaming(args, spawnFn, log);
+      log.success(`Done — ${result.num_turns} turns, $${result.total_cost_usd.toFixed(4)}`);
       if (result.result) {
-        consola.log(result.result);
+        log.log(result.result);
       }
       return result;
     } catch (err) {
       lastError = err instanceof Error ? err : new Error(String(err));
       if (attempt < PROCESS_RETRIES) {
-        consola.warn(
+        log.warn(
           `Claude process failed (attempt ${attempt}/${PROCESS_RETRIES}), retrying in ${PROCESS_RETRY_DELAY_MS / 1000}s…`,
         );
         await sleep(PROCESS_RETRY_DELAY_MS);
@@ -63,9 +74,13 @@ export async function runClaude(opts: {
   throw lastError ?? new Error("runClaude failed after all retries");
 }
 
-function runClaudeStreaming(args: string[]): Promise<ClaudeResult> {
+function runClaudeStreaming(
+  args: string[],
+  spawnFn: SpawnClaudeFn,
+  log: ClaudeLogger,
+): Promise<ClaudeResult> {
   return new Promise((resolve, reject) => {
-    const proc = spawnClaude(args);
+    const proc = spawnFn(args);
     let capturedResult: ClaudeResult | null = null;
     let turnCount = 0;
 
@@ -80,7 +95,7 @@ function runClaudeStreaming(args: string[]): Promise<ClaudeResult> {
       if (!line.trim()) return;
       try {
         const event = JSON.parse(line) as Record<string, unknown>;
-        handleStreamEvent(event, (turns) => {
+        handleStreamEvent(event, log, (turns) => {
           turnCount = turns;
         });
 
@@ -146,14 +161,18 @@ function toolDetail(block: Record<string, unknown>): string {
   return "";
 }
 
-function logToolUse(block: Record<string, unknown>): void {
+function logToolUse(block: Record<string, unknown>, log: ClaudeLogger): void {
   const name = block.name;
   if (typeof name === "string") {
-    consola.info(`  ${pc.dim("\u21B3")} ${name}${toolDetail(block)}`);
+    log.info(`  ${pc.dim("\u21B3")} ${name}${toolDetail(block)}`);
   }
 }
 
-function handleStreamEvent(event: Record<string, unknown>, onTurn: (count: number) => void): void {
+function handleStreamEvent(
+  event: Record<string, unknown>,
+  log: ClaudeLogger,
+  onTurn: (count: number) => void,
+): void {
   // Only handle stream_event — assistant turn events duplicate the same tools
   if (event.type === "stream_event" && typeof event.event === "object" && event.event !== null) {
     const inner = event.event as Record<string, unknown>;
@@ -165,13 +184,13 @@ function handleStreamEvent(event: Record<string, unknown>, onTurn: (count: numbe
     ) {
       const block = inner.content_block as Record<string, unknown>;
       if (block.type === "tool_use") {
-        logToolUse(block);
+        logToolUse(block, log);
       } else if (block.type === "thinking") {
         const thinkingText =
           typeof block.thinking === "string" && block.thinking.length > 0
             ? pc.dim(` ${truncate(block.thinking.split("\n")[0].trim(), 60)}`)
             : "";
-        consola.info(`  ${pc.dim("\u21B3")} ${pc.italic("thinking")}${thinkingText}`);
+        log.info(`  ${pc.dim("\u21B3")} ${pc.italic("thinking")}${thinkingText}`);
       }
     }
   }

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

@@ -1,4 +1,5 @@
 export { type AutoClaudeConfig, AutoClaudeConfigSchema, getConfig, initConfig } from "./config.js";
+export { type ClaudeResult, runClaude } from "./claude-cli.js";
 export { STEP_NAMES, runPipeline } from "./pipeline.js";
 export type { StepName } from "./prompt-templates/index.js";
 export { git } from "../../utils/git/exec.js";

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

@@ -1,13 +1,9 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 
-import { execSafe } from "../../utils/git/exec.js";
+import type { ExecSafeFn } from "./labels";
 import { ensureLabelsExist, LABELS, removeLabel, setLabel } from "./labels";
 
-vi.mock("../../utils/git/exec.js", () => ({
-  execSafe: vi.fn().mockResolvedValue({ stdout: "", ok: true }),
-}));
-
-const mockedExecSafe = vi.mocked(execSafe);
+const mockExecSafe: ExecSafeFn = vi.fn().mockResolvedValue({ stdout: "", ok: true });
 
 describe("LABELS", () => {
   it("has expected label values", () => {
@@ -28,11 +24,11 @@ describe("ensureLabelsExist", () => {
   });
 
   it("creates all labels with --force", async () => {
-    await ensureLabelsExist("owner/repo");
+    await ensureLabelsExist("owner/repo", mockExecSafe);
 
-    expect(mockedExecSafe).toHaveBeenCalledTimes(4);
+    expect(mockExecSafe).toHaveBeenCalledTimes(4);
     for (const label of Object.values(LABELS)) {
-      expect(mockedExecSafe).toHaveBeenCalledWith("gh", [
+      expect(mockExecSafe).toHaveBeenCalledWith("gh", [
         "label",
         "create",
         label,
@@ -50,9 +46,9 @@ describe("setLabel", () => {
   });
 
   it("calls gh issue edit with --add-label", async () => {
-    await setLabel("owner/repo", 42, "auto-claude-in-progress");
+    await setLabel("owner/repo", 42, "auto-claude-in-progress", mockExecSafe);
 
-    expect(mockedExecSafe).toHaveBeenCalledWith("gh", [
+    expect(mockExecSafe).toHaveBeenCalledWith("gh", [
       "issue",
       "edit",
       "42",
@@ -70,9 +66,9 @@ describe("removeLabel", () => {
   });
 
   it("calls gh issue edit with --remove-label", async () => {
-    await removeLabel("owner/repo", 42, "auto-claude-failed");
+    await removeLabel("owner/repo", 42, "auto-claude-failed", mockExecSafe);
 
-    expect(mockedExecSafe).toHaveBeenCalledWith("gh", [
+    expect(mockExecSafe).toHaveBeenCalledWith("gh", [
       "issue",
       "edit",
       "42",

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

@@ -1,4 +1,4 @@
-import { execSafe } from "../../utils/git/exec.js";
+import { execSafe as defaultExecSafe } from "../../utils/git/exec.js";
 
 // ── Label helpers ──
 
@@ -9,34 +9,33 @@ export const LABELS = {
   success: "auto-claude-success",
 } as const;
 
-export async function ensureLabelsExist(repo: string): Promise<void> {
+export type ExecSafeFn = (cmd: string, args: string[]) => Promise<{ stdout: string; ok: boolean }>;
+
+export async function ensureLabelsExist(
+  repo: string,
+  exec: ExecSafeFn = defaultExecSafe,
+): Promise<void> {
   await Promise.all(
     Object.values(LABELS).map((label) =>
-      execSafe("gh", ["label", "create", label, "--repo", repo, "--force"]),
+      exec("gh", ["label", "create", label, "--repo", repo, "--force"]),
     ),
   );
 }
 
-export async function setLabel(repo: string, issueNumber: number, label: string): Promise<void> {
-  await execSafe("gh", [
-    "issue",
-    "edit",
-    String(issueNumber),
-    "--repo",
-    repo,
-    "--add-label",
-    label,
-  ]);
+export async function setLabel(
+  repo: string,
+  issueNumber: number,
+  label: string,
+  exec: ExecSafeFn = defaultExecSafe,
+): Promise<void> {
+  await exec("gh", ["issue", "edit", String(issueNumber), "--repo", repo, "--add-label", label]);
 }
 
-export async function removeLabel(repo: string, issueNumber: number, label: string): Promise<void> {
-  await execSafe("gh", [
-    "issue",
-    "edit",
-    String(issueNumber),
-    "--repo",
-    repo,
-    "--remove-label",
-    label,
-  ]);
+export async function removeLabel(
+  repo: string,
+  issueNumber: number,
+  label: string,
+  exec: ExecSafeFn = defaultExecSafe,
+): Promise<void> {
+  await exec("gh", ["issue", "edit", String(issueNumber), "--repo", repo, "--remove-label", label]);
 }

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

@@ -9,50 +9,26 @@ 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";
+import type { ExecSafeFn } from "./labels";
 
 consola.level = -999;
 
-let mockClaudeImpl: MockClaudeImpl = null;
-vi.mock("./spawn-claude", () => createSpawnClaudeMock(() => mockClaudeImpl));
-
-// Track gh calls for label assertions
-let ghCalls: string[][] = [];
-
-vi.mock("tinyexec", async (importOriginal) => {
-  const original = await importOriginal<typeof import("tinyexec")>();
-  return {
-    ...original,
-    x: vi.fn(
-      async (
-        cmd: string,
-        args: string[],
-        opts?: Record<string, unknown>,
-      ): Promise<{ stdout: string; exitCode: number }> => {
-        if (cmd === "gh") {
-          ghCalls.push(args);
-          // Return empty success for label/issue/pr commands
-          return { stdout: "[]", exitCode: 0 };
-        }
-        return original.x(cmd, args, opts as never) as unknown as Promise<{
-          stdout: string;
-          exitCode: number;
-        }>;
-      },
-    ),
-  };
-});
-
 describe("runPipeline", () => {
   let originalCwd: string;
   let repo: TestRepo;
   let ctx: IssueContext;
+  let mockClaudeImpl: MockClaudeImpl;
+  let ghCalls: string[][];
+  let mockSpawnFn: SpawnClaudeFn;
+  let mockExec: ExecSafeFn;
 
   beforeEach(async () => {
     originalCwd = process.cwd();
@@ -66,6 +42,24 @@ describe("runPipeline", () => {
     ctx = buildTestContext(repo.dir);
     mockClaudeImpl = null;
     ghCalls = [];
+
+    mockSpawnFn = vi.fn((args: string[]) => {
+      if (mockClaudeImpl) {
+        const { stdout, exitCode } = mockClaudeImpl(args);
+        return createMockClaudeProcess(stdout, exitCode);
+      }
+      throw new Error("Unexpected spawnClaude call -- set mockClaudeImpl");
+    }) as SpawnClaudeFn;
+
+    mockExec = vi.fn(async (cmd: string, args: string[]) => {
+      if (cmd === "gh") {
+        ghCalls.push(args);
+        return { stdout: "[]", ok: true };
+      }
+      // Pass through non-gh commands to real exec
+      const { execSafe } = await import("../../utils/git/exec");
+      return execSafe(cmd, args);
+    }) as ExecSafeFn;
   });
 
   afterEach(() => {
@@ -78,7 +72,7 @@ describe("runPipeline", () => {
 
     mockClaudeImpl = () => ({ stdout: errorClaudeJson(), exitCode: 0 });
 
-    await runPipeline(ctx);
+    await runPipeline(ctx, undefined, { spawnFn: mockSpawnFn, exec: mockExec });
 
     const ramblingsPath = join(ctx.issueDir, ARTIFACTS.initialRamblings);
     expect(existsSync(ramblingsPath)).toBe(true);
@@ -97,7 +91,7 @@ describe("runPipeline", () => {
 
     mockClaudeImpl = () => ({ stdout: errorClaudeJson(), exitCode: 0 });
 
-    await runPipeline(ctx);
+    await runPipeline(ctx, undefined, { spawnFn: mockSpawnFn, exec: mockExec });
 
     const content = readFileSync(ramblingsPath, "utf-8");
     expect(content).toBe("# Existing ramblings");
@@ -116,7 +110,7 @@ describe("runPipeline", () => {
       return { stdout: successClaudeJson(), exitCode: 0 };
     };
 
-    await runPipeline(ctx, "plan");
+    await runPipeline(ctx, "plan", { spawnFn: mockSpawnFn, exec: mockExec });
 
     expect(claudeCallCount).toBe(1);
   });
@@ -126,7 +120,7 @@ describe("runPipeline", () => {
 
     mockClaudeImpl = () => ({ stdout: errorClaudeJson(), exitCode: 0 });
 
-    await runPipeline(ctx);
+    await runPipeline(ctx, undefined, { spawnFn: mockSpawnFn, exec: mockExec });
 
     const currentBranch = execSync("git branch --show-current", {
       cwd: repo.dir,
@@ -160,7 +154,7 @@ describe("runPipeline", () => {
       return { stdout: successClaudeJson(), exitCode: 0 };
     };
 
-    await runPipeline(ctx);
+    await runPipeline(ctx, undefined, { spawnFn: mockSpawnFn, exec: mockExec });
 
     expect(claudeCallCount).toBe(4);
 
@@ -209,7 +203,7 @@ describe("runPipeline", () => {
       return { stdout: successClaudeJson(), exitCode: 0 };
     };
 
-    await runPipeline(ctx);
+    await runPipeline(ctx, undefined, { spawnFn: mockSpawnFn, exec: mockExec });
 
     // 1 plan + 3 steps * 2 attempts = 7
     expect(claudeCallCount).toBe(7);
@@ -245,7 +239,7 @@ describe("runPipeline", () => {
       return { stdout: successClaudeJson(), exitCode: 0 };
     };
 
-    await runPipeline(ctx);
+    await runPipeline(ctx, undefined, { spawnFn: mockSpawnFn, exec: mockExec });
 
     // 1 plan + 3 steps * 3 attempts (maxReviewRetries=2 → 3 total) = 10
     expect(claudeCallCount).toBe(10);
@@ -280,7 +274,7 @@ describe("runPipeline", () => {
       return { stdout: successClaudeJson(), exitCode: 0 };
     };
 
-    await runPipeline(ctx, "implement");
+    await runPipeline(ctx, "implement", { spawnFn: mockSpawnFn, exec: mockExec });
 
     expect(claudeCallCount).toBe(2);
   });