@towles/tool 0.0.62 → 0.0.63

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

@@ -1,251 +1,19 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join, relative } from "node:path";
-import { createInterface } from "node:readline";
-import { fileURLToPath } from "node:url";
+import { join } from "node:path";
 
 import consola from "consola";
 import pc from "picocolors";
-import { x } from "tinyexec";
 
+import { ensureDir, fileExists, readFile, writeFile } from "../../utils/fs.js";
 import { createBranchNameFromIssue } from "../../utils/git/branch-name.js";
+import { execSafe, git } from "../../utils/git/exec.js";
+import { runClaude } from "./claude-cli.js";
 import { getConfig } from "./config.js";
 import { ARTIFACTS } from "./prompt-templates/index.js";
-import { spawnClaude } from "./spawn-claude.js";
+import { resolveTemplate } from "./templates.js";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-export const TEMPLATES_DIR = join(__dirname, "prompt-templates");
+import type { TokenValues } from "./templates.js";
 
-// ── Shell helpers ──
-
-async function exec(cmd: string, args: string[]): Promise<string> {
-  const result = await x(cmd, args, { nodeOptions: { cwd: process.cwd() }, throwOnError: true });
-  return result.stdout.trim();
-}
-
-export async function execSafe(
-  cmd: string,
-  args: string[],
-): Promise<{ stdout: string; ok: boolean }> {
-  const result = await x(cmd, args, { nodeOptions: { cwd: process.cwd() }, throwOnError: false });
-  return { stdout: (result.stdout ?? "").trim(), ok: result.exitCode === 0 };
-}
-
-export async function gh<T = unknown>(args: string[]): Promise<T> {
-  const out = await exec("gh", args);
-  return JSON.parse(out) as T;
-}
-
-export async function ghRaw(args: string[]): Promise<string> {
-  const result = await execSafe("gh", args);
-  return result.stdout;
-}
-
-export async function git(args: string[]): Promise<string> {
-  return exec("git", args);
-}
-
-export function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// ── Claude CLI ──
-
-export interface ClaudeResult {
-  result: string;
-  is_error: boolean;
-  total_cost_usd: number;
-  num_turns: number;
-}
-
-export async function runClaude(opts: {
-  promptFile: string;
-  permissionMode: "plan" | "acceptEdits";
-  maxTurns?: number;
-  retry?: boolean;
-}): Promise<ClaudeResult> {
-  const args = [
-    "-p",
-    "--output-format",
-    "stream-json",
-    "--verbose",
-    "--permission-mode",
-    opts.permissionMode,
-    ...(opts.maxTurns ? ["--max-turns", String(opts.maxTurns)] : []),
-    `@${opts.promptFile}`,
-  ];
-
-  const cfg = getConfig();
-  let retryDelay = cfg.retryDelayMs;
-  let retries = 0;
-
-  while (true) {
-    try {
-      const result = await runClaudeStreaming(args);
-      consola.success(`Done — ${result.num_turns} turns`);
-      if (result.result) {
-        consola.log(result.result);
-      }
-      return result;
-    } catch (e) {
-      const shouldRetry = opts.retry ?? cfg.loopRetryEnabled ?? false;
-      if (!shouldRetry) throw e;
-
-      retries++;
-      if (retries >= cfg.maxRetries) {
-        throw new Error(`Claude failed after ${cfg.maxRetries} retries: ${e}`);
-      }
-
-      consola.warn(`Claude process error (attempt ${retries}/${cfg.maxRetries}): ${e}`);
-      consola.info(`Retrying in ${retryDelay / 1000}s...`);
-      await sleep(retryDelay);
-      retryDelay = Math.min(retryDelay * 2, cfg.maxRetryDelayMs);
-    }
-  }
-}
-
-function runClaudeStreaming(args: string[]): Promise<ClaudeResult> {
-  return new Promise((resolve, reject) => {
-    const proc = spawnClaude(args);
-    let capturedResult: ClaudeResult | null = null;
-    let turnCount = 0;
-
-    if (!proc.stdout) {
-      reject(new Error("Claude process has no stdout"));
-      return;
-    }
-
-    const rl = createInterface({ input: proc.stdout });
-
-    rl.on("line", (line) => {
-      if (!line.trim()) return;
-      try {
-        const event = JSON.parse(line) as Record<string, unknown>;
-        handleStreamEvent(event, (turns) => {
-          turnCount = turns;
-        });
-
-        if ("result" in event && "is_error" in event && "num_turns" in event) {
-          capturedResult = {
-            result: String(event.result ?? ""),
-            is_error: Boolean(event.is_error),
-            total_cost_usd: Number(event.total_cost_usd ?? 0),
-            num_turns: Number(event.num_turns),
-          };
-        }
-      } catch {
-        // Skip non-JSON lines
-      }
-    });
-
-    proc.on("error", (err) => {
-      rl.close();
-      reject(err);
-    });
-
-    proc.on("close", (code) => {
-      rl.close();
-      if (capturedResult) {
-        resolve(capturedResult);
-      } else if (code !== 0) {
-        reject(new Error(`Claude process exited with code ${code}`));
-      } else {
-        resolve({ result: "", is_error: false, total_cost_usd: 0, num_turns: turnCount });
-      }
-    });
-  });
-}
-
-function handleStreamEvent(event: Record<string, unknown>, onTurn: (count: number) => void): void {
-  // Tool use events: look for content blocks with tool_use type
-  if (event.type === "assistant" && Array.isArray(event.message)) {
-    for (const block of event.message) {
-      if (
-        typeof block === "object" &&
-        block !== null &&
-        "type" in block &&
-        (block as Record<string, unknown>).type === "tool_use"
-      ) {
-        const name = (block as Record<string, unknown>).name;
-        if (typeof name === "string") {
-          consola.info(`  ${pc.dim("\u21B3")} ${name}`);
-        }
-      }
-    }
-  }
-
-  // Content block with tool_use (alternative format)
-  if (
-    event.type === "content_block_start" &&
-    typeof event.content_block === "object" &&
-    event.content_block !== null
-  ) {
-    const block = event.content_block as Record<string, unknown>;
-    if (block.type === "tool_use" && typeof block.name === "string") {
-      consola.info(`  ${pc.dim("\u21B3")} ${block.name}`);
-    }
-  }
-
-  // Turn count tracking
-  if (typeof event.num_turns === "number" && !("result" in event)) {
-    onTurn(event.num_turns as number);
-  }
-}
-
-// ── Template resolution ──
-
-export interface TokenValues {
-  SCOPE_PATH: string;
-  ISSUE_DIR: string;
-  MAIN_BRANCH: string;
-}
-
-export function resolveTemplate(
-  templateName: string,
-  tokens: TokenValues,
-  issueDir: string,
-): string {
-  const templatePath = join(TEMPLATES_DIR, templateName);
-  let template = readFileSync(templatePath, "utf-8");
-
-  for (const [key, value] of Object.entries(tokens)) {
-    template = template.replaceAll(`{{${key}}}`, value);
-  }
-
-  const resolvedPath = join(issueDir, templateName);
-  ensureDir(dirname(resolvedPath));
-  writeFileSync(resolvedPath, template, "utf-8");
-
-  return relative(process.cwd(), resolvedPath);
-}
-
-// ── File helpers ──
-
-export function ensureDir(dir: string): void {
-  mkdirSync(dir, { recursive: true });
-}
-
-export function fileExists(path: string): boolean {
-  return existsSync(path);
-}
-
-export function readFile(path: string): string {
-  return readFileSync(path, "utf-8");
-}
-
-export function writeFile(path: string, content: string): void {
-  ensureDir(dirname(path));
-  writeFileSync(path, content, "utf-8");
-}
-
-// ── Git helpers ──
-
-export async function commitArtifacts(ctx: IssueContext, message: string): Promise<void> {
-  await git(["add", ctx.issueDirRel]);
-  const staged = await execSafe("git", ["diff", "--cached", "--name-only"]);
-  if (staged.ok && staged.stdout.length > 0) {
-    await git(["commit", "-m", message]);
-  }
-}
+export { ensureDir, fileExists, readFile, writeFile } from "../../utils/fs.js";
 
 // ── Issue context ──
 
@@ -278,11 +46,13 @@ export function buildIssueContext(
   };
 }
 
-export function buildTokens(ctx: IssueContext): TokenValues {
+export function buildTokens(ctx: IssueContext, overrides?: Partial<TokenValues>): TokenValues {
   return {
     SCOPE_PATH: ctx.scopePath,
     ISSUE_DIR: ctx.issueDirRel,
     MAIN_BRANCH: getConfig().mainBranch,
+    REVIEW_FEEDBACK: "",
+    ...overrides,
   };
 }
 
@@ -321,6 +91,8 @@ function findNthBlankLine(lines: string[], n: number): number {
   return 0;
 }
 
+// ── Logging ──
+
 export function log(msg: string): void {
   consola.info(`[auto-claude] ${msg}`);
 }
@@ -347,16 +119,22 @@ export function logStep(step: string, ctx: IssueContext, skipped = false): void
 export async function ensureBranch(branch: string): Promise<void> {
   const { mainBranch, remote } = getConfig();
 
-  try {
-    const branches = await git(["branch", "--list", branch]);
-    if (branches.includes(branch)) {
-      await git(["checkout", branch]);
-      return;
-    }
-  } catch {
-    /* ignore */
+  // Stash uncommitted changes so branch switching works from a dirty tree
+  const status = await execSafe("git", ["status", "--porcelain"]);
+  const hadDirtyTree = status.ok && status.stdout.length > 0;
+  if (hadDirtyTree) {
+    await git(["stash", "push", "-m", `auto-claude: before switching to ${branch}`]);
+    log("Stashed uncommitted changes");
+  }
+
+  // Check if branch exists locally (rev-parse is reliable, no output parsing)
+  const local = await execSafe("git", ["rev-parse", "--verify", `refs/heads/${branch}`]);
+  if (local.ok) {
+    await git(["checkout", branch]);
+    return;
   }
 
+  // Check if branch exists on remote
   try {
     await git(["fetch", remote, branch]);
     await git(["checkout", branch]);
@@ -365,6 +143,7 @@ export async function ensureBranch(branch: string): Promise<void> {
     /* doesn't exist remotely */
   }
 
+  // Create new branch from main
   await git(["checkout", mainBranch]);
   await git(["pull", remote, mainBranch]);
   await git(["checkout", "-b", branch]);
@@ -403,7 +182,6 @@ export async function runStepWithArtifact(opts: StepRunnerOptions): Promise<bool
 
   const result = await runClaude({
     promptFile,
-    permissionMode: "acceptEdits",
     maxTurns: getConfig().maxTurns,
   });
 
@@ -417,9 +195,5 @@ export async function runStepWithArtifact(opts: StepRunnerOptions): Promise<bool
     return false;
   }
 
-  await commitArtifacts(
-    ctx,
-    `chore(auto-claude): ${stepName.toLowerCase()} for ${ctx.repo}#${ctx.number}`,
-  );
   return true;
 }