@towles/tool 0.0.20 → 0.0.41

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

@@ -0,0 +1,54 @@
+import stripAnsi from "strip-ansi";
+import { x } from "tinyexec";
+
+export const isGithubCliInstalled = async (): Promise<boolean> => {
+  try {
+    const proc = await x(`gh`, ["--version"]);
+    return proc.stdout.indexOf("https://github.com/cli/cli") > 0;
+  } catch (e) {
+    return false;
+  }
+};
+
+export interface Issue {
+  labels: {
+    name: string;
+    color: string;
+  }[];
+  number: number;
+  title: string;
+  state: string;
+}
+
+export const getIssues = async ({
+  assignedToMe,
+  cwd,
+}: {
+  assignedToMe: boolean;
+  cwd: string;
+}): Promise<Issue[]> => {
+  let issues: Issue[] = [];
+
+  const flags = ["issue", "list", "--json", "labels,number,title,state"];
+
+  if (assignedToMe) {
+    flags.push("--assignee");
+    flags.push("@me");
+  }
+
+  //console.log('Current working directory:', cwd.stdout.trim())
+
+  const result = await x(`gh`, flags);
+  // Setting NO_COLOR=1 didn't remove colors so had to use stripAnsi
+  const stripped = stripAnsi(result.stdout);
+
+  try {
+    issues = JSON.parse(stripped);
+  } 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/git/git-wrapper.test.ts

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,15 @@
+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;
+};

package/src/utils/git/git.ts

@@ -0,0 +1,25 @@
+// unJs/changelogen has some nice utilities for git
+import { execCommand } from "../exec";
+
+// using logic from https://github.com/unjs/changelogen/blob/main/src/git.ts
+
+export async function getGitDiff(cwd: string): Promise<string> {
+  // https://git-scm.com/docs/pretty-formats
+  let r = execCommand(
+    // `git --no-pager log "${from ? `${from}...` : ''}${to}"  `,
+    // using --cached because staged didn't work on MacOS
+    `git --no-pager diff --cached`,
+    // --name-status
+    // --pretty="----%n%s|%h|%an|%ae%n%b"
+    cwd,
+  );
+
+  // Limit output to 1000 lines maximum
+  const lines = r.split("\n");
+  if (lines.length > 1000) {
+    r = lines.slice(0, 1000).join("\n");
+    r += `\n\n[Output truncated to 1000 lines]`;
+  }
+
+  return r;
+}

package/src/utils/render.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from "vitest";
+import { printWithHexColor } from "./render";
+
+describe("printWithHexColor", () => {
+  it("should handle hex colors with # prefix", () => {
+    const result = printWithHexColor({ msg: "test", hex: "#ff0000" });
+    expect(result).toBe("\x1B[38;2;255;0;0mtest\x1B[0m");
+  });
+
+  it("should handle hex colors without # prefix", () => {
+    const result = printWithHexColor({ msg: "test", hex: "ff0000" });
+    expect(result).toBe("\x1B[38;2;255;0;0mtest\x1B[0m");
+  });
+
+  it("should handle green color correctly", () => {
+    const result = printWithHexColor({ msg: "green", hex: "#00ff00" });
+    expect(result).toBe("\x1B[38;2;0;255;0mgreen\x1B[0m");
+  });
+
+  it("should handle blue color correctly", () => {
+    const result = printWithHexColor({ msg: "blue", hex: "0000ff" });
+    expect(result).toBe("\x1B[38;2;0;0;255mblue\x1B[0m");
+  });
+
+  it("should handle mixed RGB values", () => {
+    const result = printWithHexColor({ msg: "purple", hex: "#800080" });
+    expect(result).toBe("\x1B[38;2;128;0;128mpurple\x1B[0m");
+  });
+
+  it("should handle GitHub-style label colors", () => {
+    // GitHub red label color
+    const result = printWithHexColor({ msg: "bug", hex: "d73a49" });
+    expect(result).toBe("\x1B[38;2;215;58;73mbug\x1B[0m");
+  });
+
+  it("should handle lowercase hex values", () => {
+    const result = printWithHexColor({ msg: "test", hex: "abc123" });
+    expect(result).toBe("\x1B[38;2;171;193;35mtest\x1B[0m");
+  });
+
+  it("should handle uppercase hex values", () => {
+    const result = printWithHexColor({ msg: "test", hex: "ABC123" });
+    expect(result).toBe("\x1B[38;2;171;193;35mtest\x1B[0m");
+  });
+
+  it("should handle empty message", () => {
+    const result = printWithHexColor({ msg: "", hex: "#ff0000" });
+    expect(result).toBe("\x1B[38;2;255;0;0m\x1B[0m");
+  });
+
+  it("should handle message with spaces", () => {
+    const result = printWithHexColor({ msg: "hello world", hex: "#ffffff" });
+    expect(result).toBe("\x1B[38;2;255;255;255mhello world\x1B[0m");
+  });
+
+  it("should handle black color (000000)", () => {
+    const result = printWithHexColor({ msg: "black", hex: "000000" });
+    expect(result).toBe("\x1B[38;2;0;0;0mblack\x1B[0m");
+  });
+
+  it("should handle white color (ffffff)", () => {
+    const result = printWithHexColor({ msg: "white", hex: "ffffff" });
+    expect(result).toBe("\x1B[38;2;255;255;255mwhite\x1B[0m");
+  });
+
+  it("should preserve message content exactly", () => {
+    const specialMessage = "special-chars_123!@#";
+    const result = printWithHexColor({ msg: specialMessage, hex: "#123456" });
+    expect(result).toBe(`\x1B[38;2;18;52;86m${specialMessage}\x1B[0m`);
+  });
+});

package/src/utils/render.ts

@@ -0,0 +1,34 @@
+import { colors } from "consola/utils";
+
+export const getTerminalColumns = () => process.stdout?.columns || 80;
+
+export const limitText = (text: string, maxWidth: number): string => {
+  if (text.length <= maxWidth) return text;
+  // subtract 1 so room for the ellipsis
+  return `${text.slice(0, maxWidth - 1)}${colors.dim("…")}`;
+};
+
+/**
+ * Convert hex color to RGB values
+ */
+function hexToRgb(hex: string): { r: number; g: number; b: number } {
+  const cleanHex = hex.replace("#", "");
+  const r = Number.parseInt(cleanHex.slice(0, 2), 16);
+  const g = Number.parseInt(cleanHex.slice(2, 4), 16);
+  const b = Number.parseInt(cleanHex.slice(4, 6), 16);
+  return { r, g, b };
+}
+
+/**
+ * Apply hex color to text using ANSI 24-bit color codes
+ */
+export function printWithHexColor({ msg, hex }: { msg: string; hex: string }): string {
+  const colorWithHex = hex.startsWith("#") ? hex : `#${hex}`;
+  const { r, g, b } = hexToRgb(colorWithHex);
+
+  // Use ANSI 24-bit color: \x1B[38;2;r;g;bm for foreground color
+  const colorStart = `\x1B[38;2;${r};${g};${b}m`;
+  const colorEnd = "\x1B[0m"; // Reset color
+
+  return `${colorStart}${msg}${colorEnd}`;
+}

package/dist/index.d.mts

@@ -1 +0,0 @@
-