@towles/tool 0.0.18 → 0.0.41

package/src/commands/ralph/task/list.ts

@@ -0,0 +1,110 @@
+import { Flags } from "@oclif/core";
+import pc from "picocolors";
+import { BaseCommand } from "../../base.js";
+import { DEFAULT_STATE_FILE, loadState, resolveRalphPath } from "../lib/state.js";
+import { formatTasksAsMarkdown } from "../lib/formatter.js";
+
+/**
+ * List all ralph tasks
+ */
+export default class TaskList extends BaseCommand {
+  static override description = "List all tasks";
+
+  static override examples = [
+    "<%= config.bin %> ralph task list",
+    "<%= config.bin %> ralph task list --format markdown",
+    "<%= config.bin %> ralph task list --label backend",
+  ];
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+    stateFile: Flags.string({
+      char: "s",
+      description: `State file path (default: ${DEFAULT_STATE_FILE})`,
+    }),
+    format: Flags.string({
+      char: "f",
+      description: "Output format: default, markdown",
+      default: "default",
+      options: ["default", "markdown"],
+    }),
+    label: Flags.string({
+      char: "l",
+      description: "Filter tasks by label",
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(TaskList);
+    const ralphSettings = this.settings.settingsFile.settings.ralphSettings;
+    const stateFile = resolveRalphPath(flags.stateFile, "stateFile", ralphSettings);
+
+    const state = loadState(stateFile);
+
+    if (!state) {
+      this.log(pc.yellow(`No state file found at: ${stateFile}`));
+      return;
+    }
+
+    // Filter by label if specified
+    let tasks = state.tasks;
+    if (flags.label) {
+      tasks = tasks.filter((t) => t.label === flags.label);
+      if (tasks.length === 0) {
+        this.log(pc.yellow(`No tasks with label: ${flags.label}`));
+        return;
+      }
+    }
+
+    if (tasks.length === 0) {
+      this.log(pc.yellow("No tasks in state file."));
+      this.log(pc.dim('Use: tt ralph task add "description"'));
+      return;
+    }
+
+    if (flags.format === "markdown") {
+      this.log(formatTasksAsMarkdown(tasks));
+      return;
+    }
+
+    // Default format output - compact with truncation
+    const ready = tasks.filter((t) => t.status === "ready");
+    const done = tasks.filter((t) => t.status === "done");
+
+    const truncate = (s: string, len: number) => (s.length > len ? s.slice(0, len - 1) + "…" : s);
+    const termWidth = process.stdout.columns || 120;
+
+    // Summary header
+    const labelInfo = flags.label ? ` [${flags.label}]` : "";
+    this.log(
+      pc.bold(`\nTasks${labelInfo}: `) +
+        pc.green(`${done.length} done`) +
+        pc.dim(" / ") +
+        pc.yellow(`${ready.length} ready`),
+    );
+    this.log();
+
+    // Show ready tasks first (these are actionable)
+    // Reserve ~10 chars for "  ○ #XX " prefix
+    const descWidth = Math.max(40, termWidth - 12);
+
+    if (ready.length > 0) {
+      for (const task of ready) {
+        const icon = pc.dim("○");
+        const id = pc.cyan(`#${task.id}`);
+        const desc = truncate(task.description, descWidth);
+        this.log(`  ${icon} ${id} ${desc}`);
+      }
+    }
+
+    // Show done tasks collapsed
+    if (done.length > 0) {
+      this.log(pc.dim(`  ─── ${done.length} completed ───`));
+      for (const task of done) {
+        const desc = truncate(task.description, descWidth - 5);
+        this.log(pc.dim(`  ✓ #${task.id} ${desc}`));
+      }
+    }
+    this.log();
+  }
+}

package/src/commands/ralph/task/remove.ts

@@ -0,0 +1,62 @@
+import { Args, Flags } from "@oclif/core";
+import pc from "picocolors";
+import { BaseCommand } from "../../base.js";
+import { DEFAULT_STATE_FILE, loadState, saveState, resolveRalphPath } from "../lib/state.js";
+
+/**
+ * Remove a ralph task by ID
+ */
+export default class TaskRemove extends BaseCommand {
+  static override description = "Remove a task by ID";
+
+  static override examples = [
+    "<%= config.bin %> ralph task remove 1",
+    "<%= config.bin %> ralph task remove 5 --stateFile custom-state.json",
+  ];
+
+  static override args = {
+    id: Args.integer({
+      description: "Task ID to remove",
+      required: true,
+    }),
+  };
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+    stateFile: Flags.string({
+      char: "s",
+      description: `State file path (default: ${DEFAULT_STATE_FILE})`,
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(TaskRemove);
+    const ralphSettings = this.settings.settingsFile.settings.ralphSettings;
+    const stateFile = resolveRalphPath(flags.stateFile, "stateFile", ralphSettings);
+
+    const taskId = args.id;
+
+    if (taskId < 1) {
+      this.error("Invalid task ID");
+    }
+
+    const state = loadState(stateFile);
+
+    if (!state) {
+      this.error(`No state file found at: ${stateFile}`);
+    }
+
+    const taskIndex = state.tasks.findIndex((t) => t.id === taskId);
+
+    if (taskIndex === -1) {
+      this.error(`Task #${taskId} not found. Use: tt ralph task list`);
+    }
+
+    const removedTask = state.tasks[taskIndex];
+    state.tasks.splice(taskIndex, 1);
+    saveState(state, stateFile);
+
+    console.log(pc.green(`✓ Removed task #${taskId}: ${removedTask.description}`));
+    console.log(pc.dim(`Remaining tasks: ${state.tasks.length}`));
+  }
+}

package/src/config/context.ts

@@ -0,0 +1,7 @@
+import type { SettingsFile } from "./settings";
+
+export interface Context {
+  cwd: string;
+  settingsFile: SettingsFile;
+  debug: boolean;
+}

package/src/config/settings.ts

@@ -0,0 +1,155 @@
+import { z } from "zod/v4";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+import { AppInfo } from "../constants";
+import consola from "consola";
+import { colors } from "consola/utils";
+
+/** Default config directory */
+export const DEFAULT_CONFIG_DIR = path.join(homedir(), ".config", AppInfo.toolName);
+
+/** User settings file path */
+export const USER_SETTINGS_PATH = path.join(
+  DEFAULT_CONFIG_DIR,
+  `${AppInfo.toolName}.settings.json`,
+);
+
+/** Settings filename used within configDir */
+export const SETTINGS_FILENAME = `${AppInfo.toolName}.settings.json`;
+
+/** Get settings file path for a given configDir */
+export function getSettingsPath(configDir: string): string {
+  return path.join(configDir, SETTINGS_FILENAME);
+}
+
+export const RalphSettingsSchema = z.object({
+  // Base directory for ralph files (relative to cwd or absolute)
+  stateDir: z.string().default("./.claude/.ralph"),
+});
+
+export type RalphSettings = z.infer<typeof RalphSettingsSchema>;
+
+export const JournalSettingsSchema = z.object({
+  // Base folder where all journal files are stored
+  baseFolder: z.string().default(path.join(homedir())),
+  // https://moment.github.io/luxon/#/formatting?id=table-of-tokens
+  dailyPathTemplate: z
+    .string()
+    .default(
+      path.join(
+        "journal/{monday:yyyy}/{monday:MM}/daily-notes/{monday:yyyy}-{monday:MM}-{monday:dd}-daily-notes.md",
+      ),
+    ),
+  meetingPathTemplate: z
+    .string()
+    .default(path.join("journal/{yyyy}/{MM}/meetings/{yyyy}-{MM}-{dd}-{title}.md")),
+  notePathTemplate: z
+    .string()
+    .default(path.join("journal/{yyyy}/{MM}/notes/{yyyy}-{MM}-{dd}-{title}.md")),
+  // Directory for external templates (fallback to hardcoded if not found)
+  templateDir: z.string().default(path.join(homedir(), ".config", AppInfo.toolName, "templates")),
+});
+
+export type JournalSettings = z.infer<typeof JournalSettingsSchema>;
+
+export const UserSettingsSchema = z.object({
+  preferredEditor: z.string().default("code"),
+  journalSettings: JournalSettingsSchema.optional().transform(
+    (v) => v ?? JournalSettingsSchema.parse({}),
+  ),
+  ralphSettings: RalphSettingsSchema.optional().transform(
+    (v) => v ?? RalphSettingsSchema.parse({}),
+  ),
+});
+
+type UserSettings = z.infer<typeof UserSettingsSchema>;
+
+export interface SettingsFile {
+  settings: UserSettings;
+  path: string;
+}
+
+// TODO refactor this.
+export class LoadedSettings {
+  constructor(settingsFile: SettingsFile) {
+    this.settingsFile = settingsFile;
+  }
+
+  readonly settingsFile: SettingsFile;
+}
+
+function createDefaultSettings(): UserSettings {
+  return UserSettingsSchema.parse({});
+}
+
+function createAndSaveDefaultSettings(): UserSettings {
+  const userSettings = createDefaultSettings();
+  saveSettings({
+    path: USER_SETTINGS_PATH,
+    settings: userSettings,
+  });
+  return userSettings;
+}
+
+export function saveSettings(settingsFile: SettingsFile): void {
+  try {
+    // Ensure the directory exists
+    const dirPath = path.dirname(settingsFile.path);
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+
+    fs.writeFileSync(settingsFile.path, JSON.stringify(settingsFile.settings, null, 2), "utf-8");
+  } catch (error) {
+    consola.error("Error saving user settings file:", error);
+  }
+}
+
+export async function loadSettings(): Promise<LoadedSettings> {
+  let userSettings: UserSettings | null = null;
+
+  // Load user settings
+  if (fs.existsSync(USER_SETTINGS_PATH)) {
+    const userContent = fs.readFileSync(USER_SETTINGS_PATH, "utf-8");
+    const parsedUserSettings: unknown = JSON.parse(userContent);
+
+    userSettings = UserSettingsSchema.parse(parsedUserSettings);
+    // made add a save here if the default values differ from the current values
+    if (JSON.stringify(parsedUserSettings) !== JSON.stringify(userSettings)) {
+      consola.warn(`Settings file ${USER_SETTINGS_PATH} has been updated with default values.`);
+      const tempSettingsFile: SettingsFile = {
+        path: USER_SETTINGS_PATH,
+        settings: userSettings,
+      };
+
+      saveSettings(tempSettingsFile);
+    }
+  } else {
+    // Settings file doesn't exist
+    const isNonInteractive = process.env.CI || !process.stdout.isTTY;
+
+    if (isNonInteractive) {
+      // Auto-create in CI/non-TTY environments
+      consola.info(`Creating settings file: ${USER_SETTINGS_PATH}`);
+      userSettings = createAndSaveDefaultSettings();
+    } else {
+      // Interactive: ask user if they want to create it
+      const confirmed = await consola.prompt(
+        `Settings file not found. Create ${colors.cyan(USER_SETTINGS_PATH)}?`,
+        {
+          type: "confirm",
+        },
+      );
+      if (!confirmed) {
+        throw new Error(`Settings file not found and user chose not to create it.`);
+      }
+      userSettings = createAndSaveDefaultSettings();
+    }
+  }
+
+  return new LoadedSettings({
+    path: USER_SETTINGS_PATH,
+    settings: userSettings!,
+  });
+}

package/src/constants.ts

@@ -0,0 +1,3 @@
+export const AppInfo = {
+  toolName: "towles-tool",
+} as const;

package/src/types/journal.ts

@@ -0,0 +1,16 @@
+/**
+ * Journal types and constants
+ */
+
+export const JOURNAL_TYPES = {
+  DAILY_NOTES: "daily-notes",
+  MEETING: "meeting",
+  NOTE: "note",
+} as const;
+
+export type JournalType = (typeof JOURNAL_TYPES)[keyof typeof JOURNAL_TYPES];
+
+export interface JournalArgs {
+  title?: string;
+  journalType: JournalType;
+}

package/src/utils/anthropic/types.ts

@@ -0,0 +1,158 @@
+import type {
+  ContentBlock,
+  ContentBlockParam,
+  Message,
+  MessageParam,
+} from "@anthropic-ai/sdk/resources"; // only used for types
+import { z } from "zod/v4";
+
+// This file defines types and interfaces for Claude SDK messages and related structures.
+// copied from https://github.com/tuanemuy/cc-jsonl/blob/main/src/core/domain/claude/types.ts
+// which is also using the Anthropic claude-code package.
+
+export const sendMessageInputSchema = z.object({
+  message: z.string().min(1),
+  sessionId: z.string().optional(),
+  cwd: z.string().optional(),
+  allowedTools: z.array(z.string()).optional(),
+  bypassPermissions: z.boolean().optional(),
+});
+export type SendMessageInput = z.infer<typeof sendMessageInputSchema>;
+
+export type AssistantContent = ContentBlock[];
+export type UserContent = string | ContentBlockParam[];
+
+export interface AssistantMessage {
+  type: "assistant";
+  message: Message; // From Anthropic SDK
+  session_id: string;
+}
+
+export function isAssistantMessage(message: SDKMessage): message is AssistantMessage {
+  return message.type === "assistant";
+}
+
+export interface UserMessage {
+  type: "user";
+  message: MessageParam; // Anthropic SDK
+  session_id: string;
+}
+
+export function isUserMessage(message: SDKMessage): message is UserMessage {
+  return message.type === "user";
+}
+
+export interface ResultMessage {
+  type: "result";
+  subtype: "success" | "error_max_turns" | "error_during_execution";
+  duration_ms: number;
+  duration_api_ms: number;
+  is_error: boolean;
+  num_turns: number;
+  result?: string; // Only on success
+  session_id: string;
+  total_cost_usd: number;
+}
+
+export function isResultMessage(message: SDKMessage): message is ResultMessage {
+  return message.type === "result";
+}
+
+export interface SystemMessage {
+  type: "system";
+  subtype: "init";
+  apiKeySource: string;
+  cwd: string;
+  session_id: string;
+  tools: string[];
+  mcp_servers: {
+    name: string;
+    status: string;
+  }[];
+  model: string;
+  permissionMode: "default" | "acceptEdits" | "bypassPermissions" | "plan";
+}
+
+export function isSystemMessage(message: SDKMessage): message is SystemMessage {
+  return message.type === "system";
+}
+
+export type SDKMessage = AssistantMessage | UserMessage | ResultMessage | SystemMessage;
+
+// ChunkData is simply an SDKMessage
+// The SDK already provides messages in the appropriate granularity for streaming
+export type ChunkData = SDKMessage;
+
+// Tool result type for handling tool execution results
+export interface ToolResult {
+  type: "tool_result";
+  tool_use_id: string;
+  content?: string | Record<string, unknown>[];
+  is_error?: boolean;
+}
+
+export function isToolResult(obj: unknown): obj is ToolResult {
+  return (
+    typeof obj === "object" &&
+    obj !== null &&
+    "type" in obj &&
+    obj.type === "tool_result" &&
+    "tool_use_id" in obj &&
+    typeof (obj as ToolResult).tool_use_id === "string"
+  );
+}
+
+// Type guard helpers for parseSDKMessage - use unknown input to allow type narrowing
+function isValidAssistantMessage(obj: unknown): obj is AssistantMessage {
+  if (typeof obj !== "object" || obj === null) return false;
+  const o = obj as Record<string, unknown>;
+  return (
+    o.type === "assistant" &&
+    o.message !== null &&
+    typeof o.message === "object" &&
+    typeof o.session_id === "string"
+  );
+}
+
+function isValidUserMessage(obj: unknown): obj is UserMessage {
+  if (typeof obj !== "object" || obj === null) return false;
+  const o = obj as Record<string, unknown>;
+  return (
+    o.type === "user" &&
+    o.message !== null &&
+    typeof o.message === "object" &&
+    typeof o.session_id === "string"
+  );
+}
+
+function isValidResultMessage(obj: unknown): obj is ResultMessage {
+  if (typeof obj !== "object" || obj === null) return false;
+  const o = obj as Record<string, unknown>;
+  return (
+    o.type === "result" &&
+    typeof o.session_id === "string" &&
+    typeof o.subtype === "string" &&
+    typeof o.duration_ms === "number" &&
+    typeof o.is_error === "boolean"
+  );
+}
+
+function isValidSystemMessage(obj: unknown): obj is SystemMessage {
+  if (typeof obj !== "object" || obj === null) return false;
+  const o = obj as Record<string, unknown>;
+  return (
+    o.type === "system" &&
+    typeof o.session_id === "string" &&
+    typeof o.subtype === "string" &&
+    typeof o.cwd === "string"
+  );
+}
+
+// Helper function to safely parse SDKMessage
+export function parseSDKMessage(data: unknown): SDKMessage | null {
+  if (isValidAssistantMessage(data)) return data;
+  if (isValidUserMessage(data)) return data;
+  if (isValidResultMessage(data)) return data;
+  if (isValidSystemMessage(data)) return data;
+  return null;
+}

package/src/utils/date-utils.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from "vitest";
+import { formatDate, generateJournalFilename, getMondayOfWeek, getWeekInfo } from "./date-utils";
+
+describe("date utilities", () => {
+  it("should get Monday of the week correctly", () => {
+    // Test with a Wednesday (July 9, 2025)
+    const wednesday = new Date(2025, 6, 9); // July 9, 2025
+    const monday = getMondayOfWeek(wednesday);
+    expect(formatDate(monday)).toBe("2025-07-07");
+
+    // Test with a Friday (July 11, 2025)
+    const friday = new Date(2025, 6, 11); // July 11, 2025
+    const mondayFromFriday = getMondayOfWeek(friday);
+    expect(formatDate(mondayFromFriday)).toBe("2025-07-07");
+
+    // Test with a Sunday (July 13, 2025) - should return Monday of previous week
+    const sunday = new Date(2025, 6, 13); // July 13, 2025
+    const mondayFromSunday = getMondayOfWeek(sunday);
+    expect(formatDate(mondayFromSunday)).toBe("2025-07-07");
+
+    // Test with a Monday (July 7, 2025)
+    const actualMonday = new Date(2025, 6, 7); // July 7, 2025
+    const mondayFromMonday = getMondayOfWeek(actualMonday);
+    expect(formatDate(mondayFromMonday)).toBe("2025-07-07");
+  });
+
+  it("should generate correct journal filename", () => {
+    // Test with different days in the same week
+    const wednesday = new Date(2025, 6, 9); // July 9, 2025
+    const filename = generateJournalFilename(wednesday);
+    expect(filename).toBe("2025-07-07-week.md");
+
+    const friday = new Date(2025, 6, 11); // July 11, 2025
+    const filenameFromFriday = generateJournalFilename(friday);
+    expect(filenameFromFriday).toBe("2025-07-07-week.md");
+  });
+
+  it("should format date correctly", () => {
+    const date = new Date("2025-07-07");
+    expect(formatDate(date)).toBe("2025-07-07");
+  });
+
+  it("should get week info correctly", () => {
+    // Test with Monday July 7, 2025
+    const monday = new Date(2025, 6, 7);
+    const weekInfo = getWeekInfo(monday);
+
+    expect(formatDate(weekInfo.mondayDate)).toBe("2025-07-07");
+    expect(formatDate(weekInfo.tuesdayDate)).toBe("2025-07-08");
+    expect(formatDate(weekInfo.wednesdayDate)).toBe("2025-07-09");
+    expect(formatDate(weekInfo.thursdayDate)).toBe("2025-07-10");
+    expect(formatDate(weekInfo.fridayDate)).toBe("2025-07-11");
+  });
+
+  it("should handle edge cases correctly", () => {
+    // Test with year boundary - Monday December 30, 2024
+    const mondayEndOfYear = new Date(2024, 11, 30);
+    const weekInfo = getWeekInfo(mondayEndOfYear);
+
+    expect(formatDate(weekInfo.mondayDate)).toBe("2024-12-30");
+    expect(formatDate(weekInfo.tuesdayDate)).toBe("2024-12-31");
+    expect(formatDate(weekInfo.wednesdayDate)).toBe("2025-01-01");
+    expect(formatDate(weekInfo.thursdayDate)).toBe("2025-01-02");
+    expect(formatDate(weekInfo.fridayDate)).toBe("2025-01-03");
+  });
+
+  it("should handle month boundary correctly", () => {
+    // Test with month boundary - Monday January 29, 2025
+    const mondayEndOfMonth = new Date(2025, 0, 27);
+    const weekInfo = getWeekInfo(mondayEndOfMonth);
+
+    expect(formatDate(weekInfo.mondayDate)).toBe("2025-01-27");
+    expect(formatDate(weekInfo.tuesdayDate)).toBe("2025-01-28");
+    expect(formatDate(weekInfo.wednesdayDate)).toBe("2025-01-29");
+    expect(formatDate(weekInfo.thursdayDate)).toBe("2025-01-30");
+    expect(formatDate(weekInfo.fridayDate)).toBe("2025-01-31");
+  });
+
+  it("should handle getMondayOfWeek with different timezones", () => {
+    // Test with a specific time to ensure hours are reset
+    const dateWithTime = new Date(2025, 6, 9, 15, 30, 45); // July 9, 2025 at 3:30:45 PM
+    const monday = getMondayOfWeek(dateWithTime);
+
+    expect(formatDate(monday)).toBe("2025-07-07");
+    expect(monday.getHours()).toBe(0);
+    expect(monday.getMinutes()).toBe(0);
+    expect(monday.getSeconds()).toBe(0);
+    expect(monday.getMilliseconds()).toBe(0);
+  });
+
+  it("should handle formatDate with different times", () => {
+    // Test that formatDate only considers the date part
+    const dateWithTime = new Date(2025, 6, 7, 10, 30, 45); // July 7, 2025 at 10:30:45 AM
+    expect(formatDate(dateWithTime)).toBe("2025-07-07");
+  });
+});

package/src/utils/date-utils.ts

@@ -0,0 +1,54 @@
+/**
+ * Get the Monday of the week for a given date
+ */
+export function getMondayOfWeek(date: Date): Date {
+  const newDate = new Date(date);
+  const day = newDate.getDay();
+  const diff = newDate.getDate() - day + (day === 0 ? -6 : 1);
+  newDate.setDate(diff);
+  newDate.setHours(0, 0, 0, 0);
+  return newDate;
+}
+
+interface weekInfo {
+  mondayDate: Date;
+  tuesdayDate: Date;
+  wednesdayDate: Date;
+  thursdayDate: Date;
+  fridayDate: Date;
+}
+
+export function getWeekInfo(mondayDate: Date): weekInfo {
+  const tuesdayDate = new Date(mondayDate);
+  tuesdayDate.setDate(mondayDate.getDate() + 1);
+  const wednesdayDate = new Date(mondayDate);
+  wednesdayDate.setDate(mondayDate.getDate() + 2);
+  const thursdayDate = new Date(mondayDate);
+  thursdayDate.setDate(mondayDate.getDate() + 3);
+  const fridayDate = new Date(mondayDate);
+  fridayDate.setDate(mondayDate.getDate() + 4);
+
+  return {
+    mondayDate,
+    tuesdayDate,
+    wednesdayDate,
+    thursdayDate,
+    fridayDate,
+  };
+}
+
+/**
+ * Format date as YYYY-MM-DD
+ */
+export function formatDate(date: Date): string {
+  return date.toISOString().split("T")[0];
+}
+
+/**
+ * Generate journal filename based on Monday of the current week
+ * Format: YYYY-MM-DD-week.md (always uses Monday's date)
+ */
+export function generateJournalFilename(date: Date = new Date()): string {
+  const monday = getMondayOfWeek(new Date(date));
+  return `${formatDate(monday)}-week.md`;
+}

package/src/utils/exec.ts

@@ -0,0 +1,8 @@
+import { execSync } from "node:child_process";
+
+// TODO change to use tinyexec or similar for better error handling
+export function execCommand(cmd: string, cwd?: string) {
+  // Note about execSync, if the command fails or times out, it might not throw an error,
+  // if the child process intercepts the SIGTERM signal, we might not get an error.
+  return execSync(cmd, { encoding: "utf8", cwd }).trim();
+}

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

@@ -0,0 +1,14 @@
+import { describe, expect, it } from "vitest";
+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);
+  });
+
+  it("get issues", async () => {
+    const issues = await getIssues({ assignedToMe: false, cwd: "." });
+    expect(issues.length).toBeGreaterThan(0);
+  });
+});