@towles/tool 0.0.62 → 0.0.64

package/src/utils/fs.ts

@@ -0,0 +1,19 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+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");
+}

package/src/utils/git/exec.ts

@@ -0,0 +1,18 @@
+import { x } from "tinyexec";
+
+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 git(args: string[]): Promise<string> {
+  return exec("git", args);
+}

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

@@ -1,14 +1,53 @@
-import { describe, expect, it } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { x } from "tinyexec";
 import { getIssues, isGithubCliInstalled } from "./gh-cli-wrapper";
 
-describe.skipIf(!!process.env.CI)("gh-cli-wrapper", () => {
-  it("should return true if gh is installed", async () => {
-    const result = await isGithubCliInstalled();
-    expect(result).toBe(true);
+vi.mock("tinyexec", () => ({
+  x: vi.fn().mockResolvedValue({ stdout: "[]" }),
+}));
+
+const mockX = vi.mocked(x);
+
+describe("gh-cli-wrapper", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockX.mockResolvedValue({ stdout: "[]" } as never);
+  });
+
+  describe("getIssues", () => {
+    it("passes --label flag when label provided", async () => {
+      await getIssues({ cwd: ".", label: "auto-claude" });
+
+      expect(mockX).toHaveBeenCalledWith("gh", expect.arrayContaining(["--label", "auto-claude"]));
+    });
+
+    it("does not pass --label flag when label not provided", async () => {
+      await getIssues({ cwd: "." });
+
+      const args = mockX.mock.calls[0]![1] as string[];
+      expect(args).not.toContain("--label");
+    });
+
+    it("passes --assignee @me flag when assignedToMe is true", async () => {
+      await getIssues({ cwd: ".", assignedToMe: true });
+
+      expect(mockX).toHaveBeenCalledWith("gh", expect.arrayContaining(["--assignee", "@me"]));
+    });
   });
 
-  it("get issues", async () => {
-    const issues = await getIssues({ assignedToMe: false, cwd: "." });
-    expect(issues.length).toBeGreaterThan(0);
+  describe("isGithubCliInstalled", () => {
+    it("returns true when gh CLI outputs expected string", async () => {
+      mockX.mockResolvedValue({ stdout: "gh version 2.0.0 (https://github.com/cli/cli)" } as never);
+
+      const result = await isGithubCliInstalled();
+      expect(result).toBe(true);
+    });
+
+    it("returns false when gh CLI is not available", async () => {
+      mockX.mockRejectedValue(new Error("command not found"));
+
+      const result = await isGithubCliInstalled();
+      expect(result).toBe(false);
+    });
   });
 });

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

@@ -1,14 +1,27 @@
 import stripAnsi from "strip-ansi";
 import { x } from "tinyexec";
 
-export const isGithubCliInstalled = async (): Promise<boolean> => {
+import { execSafe } from "./exec.js";
+
+export async function isGithubCliInstalled(): Promise<boolean> {
   try {
-    const proc = await x(`gh`, ["--version"]);
-    return proc.stdout.indexOf("https://github.com/cli/cli") > 0;
-  } catch (e) {
+    const proc = await x("gh", ["--version"]);
+    return proc.stdout.includes("https://github.com/cli/cli");
+  } catch {
+    // gh CLI not installed or not accessible
     return false;
   }
-};
+}
+
+export async function gh<T = unknown>(args: string[]): Promise<T> {
+  const result = await x("gh", args, { nodeOptions: { cwd: process.cwd() }, throwOnError: true });
+  return JSON.parse(result.stdout.trim()) as T;
+}
+
+export async function ghRaw(args: string[]): Promise<string> {
+  const result = await execSafe("gh", args);
+  return result.stdout;
+}
 
 export interface Issue {
   labels: {
@@ -20,35 +33,34 @@ export interface Issue {
   state: string;
 }
 
-export const getIssues = async ({
+export async function getIssues({
   assignedToMe,
   cwd,
+  label,
 }: {
-  assignedToMe: boolean;
+  assignedToMe?: boolean;
   cwd: string;
-}): Promise<Issue[]> => {
-  let issues: Issue[] = [];
-
-  const flags = ["issue", "list", "--json", "labels,number,title,state"];
+  label?: string;
+}): Promise<Issue[]> {
+  const args = ["issue", "list", "--json", "labels,number,title,state"];
 
   if (assignedToMe) {
-    flags.push("--assignee");
-    flags.push("@me");
+    args.push("--assignee", "@me");
   }
 
-  //console.log('Current working directory:', cwd.stdout.trim())
+  if (label) {
+    args.push("--label", label);
+  }
 
-  const result = await x(`gh`, flags);
+  const result = await x("gh", args);
   // Setting NO_COLOR=1 didn't remove colors so had to use stripAnsi
   const stripped = stripAnsi(result.stdout);
 
   try {
-    issues = JSON.parse(stripped);
+    return JSON.parse(stripped) as Issue[];
   } catch {
     throw new Error(
       `Failed to parse GitHub CLI output as JSON. Raw output: ${stripped.slice(0, 200)}${stripped.length > 200 ? "..." : ""}`,
     );
   }
-
-  return issues;
-};
+}

package/src/utils/render.ts

@@ -1,6 +1,8 @@
 import { colors } from "consola/utils";
 
-export const getTerminalColumns = () => process.stdout?.columns || 80;
+export function getTerminalColumns(): number {
+  return process.stdout?.columns || 80;
+}
 
 export const limitText = (text: string, maxWidth: number): string => {
   if (text.length <= maxWidth) return text;