@towles/tool 0.0.60 → 0.0.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@towles/tool",
-  "version": "0.0.60",
+  "version": "0.0.61",
   "description": "CLI tool with auto-claude pipeline, developer tools, and journaling via markdown.",
   "keywords": [
     "auto-claude",

package/src/commands/auto-claude.ts

@@ -202,7 +202,11 @@ async function syncWithRemote(): Promise<void> {
   }
   const status = await git(["status", "--porcelain"]);
   if (status.length > 0) {
-    throw new Error("Working tree has uncommitted changes. Commit or stash them first.");
+    const files = status.trim().split("\n");
+    consola.warn(`Working tree has ${files.length} uncommitted change(s):`);
+    for (const file of files) {
+      consola.warn(`  ${file.trim()}`);
+    }
   }
   await git(["pull", cfg.remote, cfg.mainBranch]);
 }

package/src/commands/gh/branch.ts

@@ -5,10 +5,11 @@ import { colors } from "consola/utils";
 import { Fzf } from "fzf";
 import consola from "consola";
 
+import { exec } from "tinyexec";
+
 import { BaseCommand } from "../base.js";
 import type { Issue } from "../../utils/git/gh-cli-wrapper.js";
 import { getIssues, isGithubCliInstalled } from "../../utils/git/gh-cli-wrapper.js";
-import { createBranch } from "../../utils/git/git-wrapper.js";
 import { createBranchNameFromIssue } from "../../utils/git/branch-name.js";
 import { getTerminalColumns, limitText, printWithHexColor } from "../../utils/render.js";
 
@@ -130,7 +131,7 @@ export default class GhBranch extends BaseCommand {
       );
 
       const branchName = createBranchNameFromIssue(selectedIssue);
-      createBranch({ branchName });
+      await exec("git", ["checkout", "-b", branchName]);
     } catch {
       this.exit(1);
     }

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

@@ -9,19 +9,21 @@ import { initConfig } from "./config";
 import { ARTIFACTS } from "./prompt-templates/index";
 import {
   buildTestContext,
+  createSpawnClaudeMock,
   createTestRepoWithRemote,
   errorClaudeJson,
   successClaudeJson,
 } from "./test-helpers";
-import type { TestRepo } from "./test-helpers";
+import type { MockClaudeImpl, TestRepo } from "./test-helpers";
 import type { IssueContext } from "./utils";
 
 consola.level = -999;
 
-// ── Mock tinyexec: intercept "claude" and "gh" calls, pass through git ──
+let mockClaudeImpl: MockClaudeImpl = null;
+vi.mock("./spawn-claude", () => createSpawnClaudeMock(() => mockClaudeImpl));
+
+// ── Mock tinyexec: intercept "gh" calls, pass through git ──
 
-let mockClaudeImpl: ((args: string[]) => Promise<{ stdout: string; exitCode: number }>) | null =
-  null;
 let mockGhImpl: ((args: string[]) => Promise<{ stdout: string; exitCode: number }>) | null = null;
 
 vi.mock("tinyexec", async (importOriginal) => {
@@ -34,12 +36,6 @@ vi.mock("tinyexec", async (importOriginal) => {
         args: string[],
         opts?: Record<string, unknown>,
       ): Promise<{ stdout: string; exitCode: number }> => {
-        if (cmd === "claude" && mockClaudeImpl) {
-          return mockClaudeImpl(args);
-        }
-        if (cmd === "claude") {
-          throw new Error("Unexpected claude call -- set mockClaudeImpl");
-        }
         if (cmd === "gh" && mockGhImpl) {
           return mockGhImpl(args);
         }
@@ -82,7 +78,7 @@ describe("runPipeline", () => {
   it("writes initial-ramblings.md on first run", async () => {
     const { runPipeline } = await import("./pipeline");
 
-    mockClaudeImpl = async () => ({ stdout: errorClaudeJson(), exitCode: 0 });
+    mockClaudeImpl = () => ({ stdout: errorClaudeJson(), exitCode: 0 });
 
     await runPipeline(ctx);
 
@@ -101,7 +97,7 @@ describe("runPipeline", () => {
     const ramblingsPath = join(ctx.issueDir, ARTIFACTS.initialRamblings);
     writeFileSync(ramblingsPath, "# Existing ramblings");
 
-    mockClaudeImpl = async () => ({ stdout: errorClaudeJson(), exitCode: 0 });
+    mockClaudeImpl = () => ({ stdout: errorClaudeJson(), exitCode: 0 });
 
     await runPipeline(ctx);
 
@@ -115,7 +111,7 @@ describe("runPipeline", () => {
     let claudeCallCount = 0;
     const researchPath = join(ctx.issueDir, ARTIFACTS.research);
 
-    mockClaudeImpl = async () => {
+    mockClaudeImpl = () => {
       claudeCallCount++;
       mkdirSync(ctx.issueDir, { recursive: true });
       writeFileSync(researchPath, "x".repeat(250));
@@ -130,7 +126,7 @@ describe("runPipeline", () => {
   it("stops and checks out main on step failure", async () => {
     const { runPipeline } = await import("./pipeline");
 
-    mockClaudeImpl = async () => ({ stdout: errorClaudeJson(), exitCode: 0 });
+    mockClaudeImpl = () => ({ stdout: errorClaudeJson(), exitCode: 0 });
 
     await runPipeline(ctx);
 
@@ -145,7 +141,7 @@ describe("runPipeline", () => {
     const { runPipeline } = await import("./pipeline");
 
     let claudeCallCount = 0;
-    mockClaudeImpl = async () => {
+    mockClaudeImpl = () => {
       claudeCallCount++;
       mkdirSync(ctx.issueDir, { recursive: true });
 

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

@@ -2,23 +2,15 @@ import consola from "consola";
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { initConfig } from "./config";
-import { createTestRepo } from "./test-helpers";
-import type { TestRepo } from "./test-helpers";
+import { createSpawnClaudeMock, createTestRepo } from "./test-helpers";
+import type { MockClaudeImpl, TestRepo } from "./test-helpers";
 
 consola.level = -999;
 
-// ── File-level tinyexec mock -- intercepts all x() calls ──
+let mockSpawnImpl: MockClaudeImpl = null;
+vi.mock("./spawn-claude", () => createSpawnClaudeMock(() => mockSpawnImpl));
 
-let mockXImpl: ((...args: unknown[]) => unknown) | null = null;
-
-vi.mock("tinyexec", () => ({
-  x: vi.fn((...args: unknown[]) => {
-    if (mockXImpl) return mockXImpl(...args);
-    throw new Error("mockXImpl not set");
-  }),
-}));
-
-describe("runClaude (mocked tinyexec)", () => {
+describe("runClaude (mocked spawn-claude)", () => {
   let originalCwd: string;
   let repo: TestRepo;
 
@@ -34,12 +26,12 @@ describe("runClaude (mocked tinyexec)", () => {
   });
 
   beforeEach(() => {
-    mockXImpl = null;
+    mockSpawnImpl = null;
     vi.clearAllMocks();
   });
 
-  it("constructs correct args and parses JSON result", async () => {
-    mockXImpl = vi.fn().mockResolvedValue({
+  it("parses stream-json result event", async () => {
+    mockSpawnImpl = () => ({
       stdout: JSON.stringify({
         result: "All done",
         is_error: false,
@@ -63,24 +55,27 @@ describe("runClaude (mocked tinyexec)", () => {
     expect(result.is_error).toBe(false);
     expect(result.num_turns).toBe(3);
 
-    expect(mockXImpl).toHaveBeenCalledWith(
-      "claude",
+    const { spawnClaude } = await import("./spawn-claude");
+    expect(spawnClaude).toHaveBeenCalledWith(
       expect.arrayContaining([
         "-p",
         "--output-format",
-        "json",
+        "stream-json",
+        "--verbose",
         "--permission-mode",
         "plan",
         "--max-turns",
         "10",
         "@test-prompt.md",
       ]),
-      expect.any(Object),
     );
   });
 
-  it("returns fallback when JSON parsing fails", async () => {
-    mockXImpl = vi.fn().mockResolvedValue({ stdout: "not json output", exitCode: 0 });
+  it("returns fallback when no result event in stream", async () => {
+    mockSpawnImpl = () => ({
+      stdout: '{"type":"system","message":"starting"}',
+      exitCode: 0,
+    });
 
     await initConfig({ repo: "test/repo", mainBranch: "main" });
 
@@ -91,19 +86,19 @@ describe("runClaude (mocked tinyexec)", () => {
       permissionMode: "acceptEdits",
     });
 
-    expect(result.result).toBe("not json output");
+    expect(result.result).toBe("");
     expect(result.is_error).toBe(false);
     expect(result.total_cost_usd).toBe(0);
   });
 
   it("retries on failure when retry is enabled", async () => {
     let callCount = 0;
-    mockXImpl = vi.fn().mockImplementation(() => {
+    mockSpawnImpl = () => {
       callCount++;
       if (callCount < 3) {
-        throw new Error("Claude process failed");
+        return { stdout: "", exitCode: 1 };
       }
-      return Promise.resolve({
+      return {
         stdout: JSON.stringify({
           result: "ok",
           is_error: false,
@@ -111,8 +106,8 @@ describe("runClaude (mocked tinyexec)", () => {
           num_turns: 1,
         }),
         exitCode: 0,
-      });
-    });
+      };
+    };
 
     await initConfig({
       repo: "test/repo",
@@ -136,7 +131,7 @@ describe("runClaude (mocked tinyexec)", () => {
   }, 10_000);
 
   it("throws after max retries exhausted", async () => {
-    mockXImpl = vi.fn().mockRejectedValue(new Error("Claude crash"));
+    mockSpawnImpl = () => ({ stdout: "", exitCode: 1 });
 
     await initConfig({
       repo: "test/repo",

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

@@ -0,0 +1,14 @@
+import { spawn } from "node:child_process";
+import type { ChildProcess } from "node:child_process";
+
+/**
+ * Spawns the Claude CLI as a child process.
+ * Extracted into its own module so tests can mock it cleanly
+ * without affecting other exec/spawn usage.
+ */
+export function spawnClaude(args: string[]): ChildProcess {
+  return spawn("claude", args, {
+    cwd: process.cwd(),
+    stdio: ["ignore", "pipe", "inherit"],
+  });
+}

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

@@ -9,44 +9,18 @@ import { initConfig } from "../config";
 import { ARTIFACTS } from "../prompt-templates/index";
 import {
   buildTestContext,
+  createSpawnClaudeMock,
   createTestRepoWithRemote,
   errorClaudeJson,
   successClaudeJson,
 } from "../test-helpers";
-import type { TestRepo } from "../test-helpers";
+import type { MockClaudeImpl, TestRepo } from "../test-helpers";
 import type { IssueContext } from "../utils";
 
 consola.level = -999;
 
-// ── Mock tinyexec: intercept "claude" calls, pass through everything else ──
-
-let mockClaudeImpl: ((args: string[]) => Promise<{ stdout: string; exitCode: number }>) | null =
-  null;
-
-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 === "claude" && mockClaudeImpl) {
-          return mockClaudeImpl(args);
-        }
-        if (cmd === "claude") {
-          throw new Error("Unexpected claude call -- set mockClaudeImpl before running");
-        }
-        return original.x(cmd, args, opts as never) as unknown as Promise<{
-          stdout: string;
-          exitCode: number;
-        }>;
-      },
-    ),
-  };
-});
+let mockClaudeImpl: MockClaudeImpl = null;
+vi.mock("../spawn-claude", () => createSpawnClaudeMock(() => mockClaudeImpl));
 
 // ── Shared setup/teardown for all step tests ──
 
@@ -95,7 +69,7 @@ describe("runStepWithArtifact", () => {
   });
 
   it("returns false when Claude returns is_error", async () => {
-    mockClaudeImpl = async () => ({ stdout: errorClaudeJson(), exitCode: 0 });
+    mockClaudeImpl = () => ({ stdout: errorClaudeJson(), exitCode: 0 });
 
     const { runStepWithArtifact } = await import("../utils");
     const artifactPath = join(ctx.issueDir, "missing-artifact.md");
@@ -111,7 +85,7 @@ describe("runStepWithArtifact", () => {
   });
 
   it("returns false when artifact not produced after Claude run", async () => {
-    mockClaudeImpl = async () => ({ stdout: successClaudeJson(), exitCode: 0 });
+    mockClaudeImpl = () => ({ stdout: successClaudeJson(), exitCode: 0 });
 
     const { runStepWithArtifact } = await import("../utils");
     const artifactPath = join(ctx.issueDir, "never-created.md");
@@ -130,7 +104,7 @@ describe("runStepWithArtifact", () => {
     const { runStepWithArtifact } = await import("../utils");
     const artifactPath = join(ctx.issueDir, "plan.md");
 
-    mockClaudeImpl = async () => {
+    mockClaudeImpl = () => {
       writeFileSync(artifactPath, "# Plan\n\nDetailed plan content here.");
       return { stdout: successClaudeJson(), exitCode: 0 };
     };
@@ -179,7 +153,7 @@ describe("stepResearch", () => {
     writeFileSync(researchPath, "short");
 
     let claudeCalled = false;
-    mockClaudeImpl = async () => {
+    mockClaudeImpl = () => {
       claudeCalled = true;
       writeFileSync(researchPath, "x".repeat(250));
       return { stdout: successClaudeJson(), exitCode: 0 };
@@ -194,7 +168,7 @@ describe("stepResearch", () => {
     const { stepResearch } = await import("./research");
 
     const researchPath = join(ctx.issueDir, ARTIFACTS.research);
-    mockClaudeImpl = async () => {
+    mockClaudeImpl = () => {
       writeFileSync(researchPath, "x".repeat(250));
       return { stdout: successClaudeJson(), exitCode: 0 };
     };
@@ -244,7 +218,7 @@ describe("stepPlanAnnotations", () => {
     const addressedPath = join(ctx.issueDir, ARTIFACTS.planAnnotationsAddressed);
     writeFileSync(annotationsPath, "# Annotations\n\nSome feedback here.");
 
-    mockClaudeImpl = async () => ({ stdout: successClaudeJson(), exitCode: 0 });
+    mockClaudeImpl = () => ({ stdout: successClaudeJson(), exitCode: 0 });
 
     const result = await stepPlanAnnotations(ctx);
 
@@ -288,7 +262,7 @@ describe("stepImplement", () => {
     const { stepImplement } = await import("./implement");
 
     let callCount = 0;
-    mockClaudeImpl = async () => {
+    mockClaudeImpl = () => {
       callCount++;
       return { stdout: successClaudeJson(), exitCode: 0 };
     };
@@ -304,7 +278,7 @@ describe("stepImplement", () => {
     let callCount = 0;
     const completedPath = join(ctx.issueDir, ARTIFACTS.completedSummary);
 
-    mockClaudeImpl = async () => {
+    mockClaudeImpl = () => {
       callCount++;
       if (callCount === 2) {
         writeFileSync(completedPath, "# Implementation Complete\n\nAll tasks done.");

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

@@ -1,7 +1,12 @@
+import type { ChildProcess } from "node:child_process";
 import { execSync } from "node:child_process";
+import { EventEmitter } from "node:events";
 import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { PassThrough } from "node:stream";
+
+import { vi } from "vitest";
 
 import type { ClaudeResult, IssueContext } from "./utils";
 
@@ -62,7 +67,7 @@ export function buildTestContext(dir: string, issueNumber = 1): IssueContext {
 }
 
 /**
- * Returns a JSON string matching a successful ClaudeResult.
+ * Returns a stream-json result line for a successful ClaudeResult.
  */
 export function successClaudeJson(result = "done"): string {
   return JSON.stringify({
@@ -74,7 +79,7 @@ export function successClaudeJson(result = "done"): string {
 }
 
 /**
- * Returns a JSON string matching a failed ClaudeResult.
+ * Returns a stream-json result line for a failed ClaudeResult.
  */
 export function errorClaudeJson(result = "failed"): string {
   return JSON.stringify({
@@ -84,3 +89,51 @@ export function errorClaudeJson(result = "failed"): string {
     num_turns: 0,
   } satisfies ClaudeResult);
 }
+
+/**
+ * Creates a fake ChildProcess with PassThrough stdout for testing
+ * the streaming runClaude implementation.
+ *
+ * Writes `stdout` content to the stream, then emits `close` with `exitCode`.
+ */
+export function createMockClaudeProcess(stdout: string, exitCode = 0): ChildProcess {
+  const proc = new EventEmitter() as ChildProcess;
+  const stdoutStream = new PassThrough();
+  (proc as unknown as { stdout: PassThrough }).stdout = stdoutStream;
+  (proc as unknown as { stderr: null }).stderr = null;
+  (proc as unknown as { stdin: null }).stdin = null;
+
+  // Write and close asynchronously so listeners can attach first
+  queueMicrotask(() => {
+    if (stdout) {
+      stdoutStream.write(`${stdout}\n`);
+    }
+    stdoutStream.end();
+    proc.emit("close", exitCode);
+  });
+
+  return proc;
+}
+
+export type MockClaudeImpl = ((args: string[]) => { stdout: string; exitCode: number }) | null;
+
+/**
+ * Creates the mock object for vi.mock("./spawn-claude").
+ * Must be called inside the vi.mock factory arrow (lazy) to avoid hoisting issues.
+ *
+ * Usage:
+ *   let mockClaudeImpl: MockClaudeImpl = null;
+ *   vi.mock("./spawn-claude", () => createSpawnClaudeMock(() => mockClaudeImpl));
+ */
+export function createSpawnClaudeMock(getImpl: () => MockClaudeImpl) {
+  return {
+    spawnClaude: vi.fn((args: string[]) => {
+      const impl = getImpl();
+      if (impl) {
+        const { stdout, exitCode } = impl(args);
+        return createMockClaudeProcess(stdout, exitCode);
+      }
+      throw new Error("Unexpected spawnClaude call -- set mockClaudeImpl");
+    }),
+  };
+}

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

@@ -1,5 +1,6 @@
 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 consola from "consola";
@@ -9,6 +10,7 @@ import { x } from "tinyexec";
 import { createBranchNameFromIssue } from "../../utils/git/branch-name.js";
 import { getConfig } from "./config.js";
 import { ARTIFACTS } from "./prompt-templates/index.js";
+import { spawnClaude } from "./spawn-claude.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 export const TEMPLATES_DIR = join(__dirname, "prompt-templates");
@@ -64,7 +66,8 @@ export async function runClaude(opts: {
   const args = [
     "-p",
     "--output-format",
-    "json",
+    "stream-json",
+    "--verbose",
     "--permission-mode",
     opts.permissionMode,
     ...(opts.maxTurns ? ["--max-turns", String(opts.maxTurns)] : []),
@@ -77,26 +80,12 @@ export async function runClaude(opts: {
 
   while (true) {
     try {
-      const proc = await x("claude", args, {
-        nodeOptions: { cwd: process.cwd(), stdio: ["ignore", "pipe", "inherit"] },
-        throwOnError: true,
-      });
-      const stdout = proc.stdout;
-
-      try {
-        const parsed = JSON.parse(stdout) as ClaudeResult;
-        consola.success(`Done — ${parsed.num_turns} turns`);
-        if (parsed.result) {
-          consola.log(parsed.result);
-        }
-        return parsed;
-      } catch {
-        consola.warn("Done — failed to parse Claude output");
-        if (stdout.trim()) {
-          consola.log(stdout.trim());
-        }
-        return { result: stdout.trim(), is_error: false, total_cost_usd: 0, num_turns: 0 };
+      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;
@@ -114,6 +103,94 @@ export async function runClaude(opts: {
   }
 }
 
+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 {

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

@@ -1,26 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { isGitDirectory } from "./git-wrapper";
-
-describe.skip("git-wrapper", () => {
-  it("isGitDirectory", async () => {
-    const result = await isGitDirectory();
-    expect(result).toBe(true);
-  });
-
-  // it('getMergedBranches', async () => {
-  //   const result = await getMergedBranches()
-
-  //   if (result.length > 0) // may not have branches to cleanup so just check for no errors
-  //     expect(result[0].trim()).toBe(result[0])
-  // })
-
-  // it('getLocalBranchNames', async () => {
-  //   const result = await getLocalBranchNames()
-  //   expect(result.includes('main')).toBeDefined()
-  // })
-
-  // it('getDefaultMainBranchName', async () => {
-  //   const result = await getDefaultMainBranchName()
-  //   expect(result).toBe('main')
-  // })
-});

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

@@ -1,15 +0,0 @@
-import { exec } from "tinyexec";
-
-export const isGitDirectory = async (): Promise<boolean> => {
-  try {
-    const result = await exec(`git`, ["status"]);
-    return result.stdout.includes("On branch");
-  } catch (e) {
-    return false;
-  }
-};
-
-export const createBranch = async ({ branchName }: { branchName: string }): Promise<string> => {
-  const result = await exec(`git`, ["checkout", "-b", branchName]);
-  return result.stdout;
-};