@towles/tool 0.0.95 → 0.0.103

package/bin/run.ts

@@ -1,5 +1,6 @@
-#!/usr/bin/env tsx
+#!/usr/bin/env bun
 
-import { execute } from "@oclif/core";
+import { runMain } from "citty";
+import { main } from "../src/cli.js";
 
-await execute({ dir: import.meta.url });
+runMain(main);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@towles/tool",
-  "version": "0.0.95",
+  "version": "0.0.103",
   "description": "One off quality of life scripts that I use on a daily basis.",
   "homepage": "https://github.com/ChrisTowles/towles-tool#readme",
   "bugs": {
@@ -29,19 +29,14 @@
     "access": "public"
   },
   "scripts": {
-    "version:sync": "pnpm tsx scripts/sync-versions.ts",
-    "prepublishOnly": "pnpm run version:sync",
-    "dev": "tsx bin/run.ts",
+    "version:sync": "bun run scripts/sync-versions.ts",
+    "prepublishOnly": "bun run version:sync",
+    "dev": "bun run bin/run.ts",
     "format": "oxfmt --write .",
     "format:check": "oxfmt --check .",
     "lint": "oxlint",
     "lint:fix": "oxlint --fix",
     "test": "vitest run",
-    "test:prompts": "promptfoo eval && promptfoo eval -c plugins/tt-core/promptfooconfig.yaml && promptfoo eval -c plugins/tt-auto-claude/promptfooconfig.yaml",
-    "test:prompts:root": "promptfoo eval",
-    "test:prompts:tt-core": "promptfoo eval -c plugins/tt-core/promptfooconfig.yaml",
-    "test:prompts:tt-core:llm": "promptfoo eval -c plugins/tt-core/promptfooconfig.llm.yaml",
-    "test:prompts:tt-auto-claude": "promptfoo eval -c plugins/tt-auto-claude/promptfooconfig.yaml",
     "test:watch": "CI=DisableCallingClaude vitest watch",
     "typecheck": "tsgo --noEmit --incremental",
     "prepare": "simple-git-hooks"
@@ -49,7 +44,7 @@
   "dependencies": {
     "@anthropic-ai/claude-code": "^2.1.4",
     "@anthropic-ai/sdk": "^0.56.0",
-    "@oclif/core": "^4.3.2",
+    "citty": "^0.1.6",
     "consola": "^3.4.2",
     "d3-hierarchy": "^3.1.2",
     "fzf": "^0.5.2",
@@ -62,7 +57,6 @@
     "zod": "^4.0.5"
   },
   "devDependencies": {
-    "@oclif/test": "^4.1.10",
     "@types/d3-hierarchy": "^3.1.7",
     "@types/luxon": "^3.6.2",
     "@types/node": "^22.16.3",
@@ -71,38 +65,15 @@
     "bumpp": "^10.4.0",
     "oxfmt": "^0.24.0",
     "oxlint": "^1.7.0",
-    "promptfoo": "^0.121.2",
     "simple-git-hooks": "^2.13.0",
-    "tsx": "^4.19.4",
     "typescript": "^5.8.3",
     "vitest": "^4.0.17"
   },
   "simple-git-hooks": {
-    "pre-commit": "pnpm format && pnpm lint:fix && pnpm typecheck && claude plugin validate ."
+    "pre-commit": "bun run format && bun run lint:fix && bun run typecheck && claude plugin validate ."
   },
-  "oclif": {
-    "bin": "tt",
-    "commands": "./src/commands",
-    "dirname": "towles-tool",
-    "topicSeparator": " "
-  },
-  "packageManager": "pnpm@10.27.0",
-  "pnpm": {
-    "patchedDependencies": {
-      "prompts@2.4.2": "patches/prompts.patch"
-    },
-    "onlyBuiltDependencies": [
-      "@anthropic-ai/claude-code",
-      "@parcel/watcher",
-      "@playwright/browser-chromium",
-      "@swc/core",
-      "better-sqlite3",
-      "esbuild",
-      "onnxruntime-node",
-      "protobufjs",
-      "sharp",
-      "simple-git-hooks"
-    ]
+  "patchedDependencies": {
+    "prompts@2.4.2": "patches/prompts.patch"
   },
   "trustedDependencies": [
     "@anthropic-ai/claude-code"

package/src/cli.ts

@@ -0,0 +1,19 @@
+import { defineCommand } from "citty";
+
+export const main = defineCommand({
+  meta: { name: "tt", description: "towles-tool — personal CLI utilities" },
+  subCommands: {
+    config: () => import("./commands/config.js").then((m) => m.default),
+    doctor: () => import("./commands/doctor.js").then((m) => m.default),
+    install: () => import("./commands/install.js").then((m) => m.default),
+    agentboard: () => import("./commands/agentboard.js").then((m) => m.default),
+    ag: () => import("./commands/agentboard.js").then((m) => m.default),
+    gh: () => import("./commands/gh/index.js").then((m) => m.default),
+    pr: () => import("./commands/gh/pr.js").then((m) => m.default),
+    journal: () => import("./commands/journal/index.js").then((m) => m.default),
+    today: () => import("./commands/journal/daily-notes.js").then((m) => m.default),
+    "auto-claude": () => import("./commands/auto-claude/index.js").then((m) => m.default),
+    ac: () => import("./commands/auto-claude/index.js").then((m) => m.default),
+    graph: () => import("./commands/graph/index.js").then((m) => m.default),
+  },
+});

package/src/commands/agentboard.ts

@@ -0,0 +1,327 @@
+import { defineCommand } from "citty";
+import { execSync, spawn, spawnSync } from "node:child_process";
+import { readFileSync, writeFileSync, existsSync, realpathSync } from "node:fs";
+import { resolve } from "node:path";
+import consola from "consola";
+import { colors } from "consola/utils";
+import { debugArg } from "./shared.js";
+
+const SERVER_HOST = "127.0.0.1";
+const SERVER_PORT = 4201;
+
+const PLUGIN_DIR = resolve(import.meta.dirname, "../../plugins/tt-agentboard");
+
+// Keybinding defaults
+const DEFAULT_KEY = "a";
+const TMUX_BINDINGS = { toggle: "t", focus: "s" } as const;
+const RUN_SHELL_LINE = `run-shell '${PLUGIN_DIR}/agentboard.tmux'`;
+const MARKER = "# agentboard";
+
+function findTmuxConf(): string | null {
+  const candidates = [
+    resolve(process.env.HOME ?? "~", ".tmux.conf"),
+    resolve(process.env.HOME ?? "~", ".config/tmux/tmux.conf"),
+  ];
+  for (const path of candidates) {
+    try {
+      const real = existsSync(path) ? path : null;
+      if (real) return real;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+function ensureDeps(): void {
+  try {
+    execSync("bun --version", { stdio: "pipe" });
+  } catch {
+    consola.error("bun is required but not found. Install: https://bun.sh");
+    process.exit(1);
+  }
+
+  const runtimeNodeModules = resolve(PLUGIN_DIR, "packages/runtime/node_modules");
+  if (!existsSync(runtimeNodeModules)) {
+    consola.info("Installing agentboard dependencies...");
+    execSync("bun install", { cwd: PLUGIN_DIR, stdio: "inherit" });
+  }
+}
+
+function reloadTmux(): void {
+  try {
+    execSync(
+      "tmux source-file ~/.config/tmux/tmux.conf 2>/dev/null || tmux source-file ~/.tmux.conf 2>/dev/null",
+      {
+        stdio: "pipe",
+      },
+    );
+    consola.success("tmux config reloaded");
+  } catch {
+    consola.info("Reload tmux manually: tmux source-file ~/.config/tmux/tmux.conf");
+  }
+}
+
+function showKeys(): void {
+  let prefix = "C-a";
+  let key = DEFAULT_KEY;
+  try {
+    prefix = execSync("tmux show-option -gv prefix", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    const abKey = execSync(
+      `tmux show-option -gv @agentboard-key 2>/dev/null || echo ${DEFAULT_KEY}`,
+      {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+      },
+    ).trim();
+    if (abKey) key = abKey;
+  } catch {
+    // use defaults
+  }
+
+  const { toggle, focus } = TMUX_BINDINGS;
+  consola.box(
+    [
+      `${colors.bold("AgentBoard Keybindings")}\n`,
+      `${colors.cyan(`tmux (prefix = ${prefix}, C = Ctrl):`)}`,
+      `  ${prefix} ${key} ${toggle}     toggle sidebar`,
+      `  ${prefix} ${key} ${focus}     focus sidebar`,
+      `  ${prefix} ${key} 1-9   jump to session\n`,
+      `${colors.cyan("In sidebar:")}`,
+      `  Tab         cycle sessions`,
+      `  j / ↓       move down`,
+      `  k / ↑       move up`,
+      `  Enter / l   switch to selected session`,
+      `  1-9         jump to session`,
+      `  d           hide session`,
+      `  x           kill session`,
+      `  r           refresh`,
+      `  ?           help`,
+      `  q           quit`,
+    ].join("\n"),
+  );
+}
+
+function setup(): void {
+  ensureDeps();
+
+  const confPath = findTmuxConf();
+  if (!confPath) {
+    consola.warn("No tmux.conf found. Add this line manually:");
+    consola.info(colors.cyan(`  ${RUN_SHELL_LINE}`));
+    return;
+  }
+
+  let editPath = confPath;
+  try {
+    editPath = realpathSync(confPath);
+  } catch {
+    // keep confPath
+  }
+
+  const content = readFileSync(editPath, "utf8");
+  if (content.includes("agentboard.tmux")) {
+    consola.success("Already installed in tmux.conf");
+    reloadTmux();
+    return;
+  }
+
+  const tpmLine = "run '~/.config/tmux/plugins/tpm/tpm'";
+  const altTpmLine = "run-shell '~/.tmux/plugins/tpm/tpm'";
+  const insertLines = `\n${MARKER}\n${RUN_SHELL_LINE}\n`;
+
+  let newContent: string;
+  if (content.includes(tpmLine)) {
+    newContent = content.replace(tpmLine, `${insertLines}\n${tpmLine}`);
+  } else if (content.includes(altTpmLine)) {
+    newContent = content.replace(altTpmLine, `${insertLines}\n${altTpmLine}`);
+  } else {
+    newContent = content + insertLines;
+  }
+
+  writeFileSync(editPath, newContent);
+  consola.success(`Added agentboard to ${editPath}`);
+
+  reloadTmux();
+  showKeys();
+}
+
+function uninstall(): void {
+  const confPath = findTmuxConf();
+  if (!confPath) {
+    consola.info("No tmux.conf found.");
+    return;
+  }
+
+  let editPath = confPath;
+  try {
+    editPath = realpathSync(confPath);
+  } catch {
+    // keep confPath
+  }
+
+  const content = readFileSync(editPath, "utf8");
+  if (!content.includes("agentboard")) {
+    consola.info("agentboard not found in tmux.conf");
+    return;
+  }
+
+  const newContent = content
+    .split("\n")
+    .filter((line) => !line.includes("agentboard"))
+    .join("\n")
+    .replace(/\n{3,}/g, "\n\n");
+
+  writeFileSync(editPath, newContent);
+  consola.success("Removed agentboard from tmux.conf");
+  reloadTmux();
+}
+
+function startServer(): void {
+  ensureDeps();
+
+  const serverEntry = resolve(PLUGIN_DIR, "apps/server/src/main.ts");
+  consola.info("Starting agentboard server (foreground, Ctrl+C to stop)...");
+
+  execSync(`bun run ${serverEntry}`, {
+    stdio: "inherit",
+    cwd: PLUGIN_DIR,
+    env: {
+      ...process.env,
+      AGENTBOARD_DIR: PLUGIN_DIR,
+    },
+  });
+}
+
+async function serverAlive(): Promise<boolean> {
+  try {
+    const res = await fetch(`http://${SERVER_HOST}:${SERVER_PORT}/`, {
+      signal: AbortSignal.timeout(500),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+async function ensureServerUp(): Promise<boolean> {
+  if (await serverAlive()) return true;
+
+  const serverEntry = resolve(PLUGIN_DIR, "apps/server/src/main.ts");
+  consola.info("Starting agentboard server...");
+  const child = spawn("bun", ["run", serverEntry], {
+    stdio: "ignore",
+    cwd: PLUGIN_DIR,
+    detached: true,
+    env: { ...process.env, AGENTBOARD_DIR: PLUGIN_DIR },
+  });
+  child.unref();
+
+  for (let i = 0; i < 30; i++) {
+    await new Promise((r) => setTimeout(r, 100));
+    if (await serverAlive()) return true;
+  }
+  return false;
+}
+
+async function restart(): Promise<void> {
+  ensureDeps();
+
+  // 1. Kill stash sessions left over from hidden sidebars
+  try {
+    const result = spawnSync("tmux", ["list-sessions", "-F", "#{session_name}"], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    const sessions = (result.stdout ?? "").trim().split("\n").filter(Boolean);
+    for (const name of sessions) {
+      if (name.startsWith("_ab_stash")) {
+        spawnSync("tmux", ["kill-session", "-t", name], { stdio: "pipe" });
+        consola.info(`Killed stash session: ${name}`);
+      }
+    }
+  } catch {
+    // no tmux or no sessions
+  }
+
+  // 2. Ensure server is running
+  if (!(await ensureServerUp())) {
+    consola.error("Failed to start agentboard server");
+    process.exit(1);
+  }
+  consola.success("Server is running");
+
+  // 3. Toggle sidebar on (the server spawns sidebars in all active windows)
+  try {
+    const res = await fetch(`http://${SERVER_HOST}:${SERVER_PORT}/toggle`, {
+      method: "POST",
+      body: "",
+      signal: AbortSignal.timeout(2000),
+    });
+    if (res.ok) {
+      consola.success("Sidebar toggled on for all sessions");
+    } else {
+      consola.warn(`Toggle returned: ${res.status}`);
+    }
+  } catch (err) {
+    consola.error("Failed to toggle sidebar:", err);
+  }
+}
+
+function startTui(): void {
+  ensureDeps();
+
+  const tuiEntry = resolve(PLUGIN_DIR, "apps/tui/src/index.tsx");
+
+  execSync(`bun run ${tuiEntry}`, {
+    stdio: "inherit",
+    cwd: resolve(PLUGIN_DIR, "apps/tui"),
+    env: {
+      ...process.env,
+      AGENTBOARD_DIR: PLUGIN_DIR,
+    },
+  });
+}
+
+export default defineCommand({
+  meta: { name: "agentboard", description: "AgentBoard — tmux TUI sidebar" },
+  args: {
+    debug: debugArg,
+    subcommand: {
+      type: "positional",
+      required: false,
+      description: "Subcommand: setup, uninstall, server, tui, start, restart, keys",
+    },
+  },
+  async run({ args }) {
+    switch (args.subcommand) {
+      case "setup":
+        setup();
+        break;
+      case "uninstall":
+        uninstall();
+        break;
+      case "server":
+        startServer();
+        break;
+      case "tui":
+        startTui();
+        break;
+      case "start":
+        startTui();
+        break;
+      case "restart":
+        await restart();
+        break;
+      case "keys":
+        showKeys();
+        break;
+      default:
+        showKeys();
+        break;
+    }
+  },
+});

package/src/commands/auto-claude/index.ts

@@ -2,10 +2,10 @@ import { rmSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { Args, Flags } from "@oclif/core";
+import { defineCommand } from "citty";
 import consola from "consola";
 
-import { BaseCommand } from "../base.js";
+import { debugArg } from "../shared.js";
 import {
   STEP_NAMES,
   fetchIssue,
@@ -21,95 +21,75 @@ import {
 } from "../../lib/auto-claude/index.js";
 import type { IssueContext, StepName } from "../../lib/auto-claude/index.js";
 
-export default class AutoClaude extends BaseCommand {
-  static override aliases = ["ac"];
-
-  static override description = "Automated issue-to-PR pipeline using Claude Code";
-
-  static override args = {
-    prompt: Args.string({
-      description: "Run a single prompt (skips issue pipeline)",
+export default defineCommand({
+  meta: { name: "auto-claude", description: "Automated issue-to-PR pipeline using Claude Code" },
+  args: {
+    prompt: {
+      type: "positional" as const,
       required: false,
-    }),
-  };
-
-  static override examples = [
-    {
-      description: "Run a single prompt",
-      command: '<%= config.bin %> auto-claude "Fix the login bug in auth.ts"',
-    },
-    {
-      description: "Process a specific issue",
-      command: "<%= config.bin %> auto-claude --issue 42",
-    },
-    {
-      description: "Run until plan step",
-      command: "<%= config.bin %> auto-claude --issue 42 --until plan",
-    },
-    {
-      description: "Reset local state for an issue",
-      command: "<%= config.bin %> auto-claude --reset 42",
-    },
-    {
-      description: "Loop mode: poll for labeled issues",
-      command: "<%= config.bin %> auto-claude --loop",
-    },
-    {
-      description: "Loop with custom interval",
-      command: "<%= config.bin %> auto-claude --loop --interval 45",
+      description: "Run a single prompt (skips issue pipeline)",
     },
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    "max-turns": Flags.integer({
+    debug: debugArg,
+    "max-turns": {
+      type: "string" as const,
       description: "Maximum conversation turns for prompt mode (default: 10)",
-      default: 10,
-    }),
-    issue: Flags.integer({
-      char: "i",
+      default: "10",
+    },
+    issue: {
+      type: "string" as const,
+      alias: "i",
       description: "Process a specific issue number",
-    }),
-    until: Flags.string({
-      char: "u",
+    },
+    until: {
+      type: "string" as const,
+      alias: "u",
       description: `Stop after this step (${STEP_NAMES.join(", ")})`,
-      options: [...STEP_NAMES],
-    }),
-    reset: Flags.integer({
+    },
+    reset: {
+      type: "string" as const,
       description: "Delete local state for an issue (force restart)",
-    }),
-    model: Flags.string({
+    },
+    model: {
+      type: "string" as const,
       description: "Claude model to use (default: opus)",
       default: "opus",
-    }),
-    loop: Flags.boolean({
+    },
+    loop: {
+      type: "boolean" as const,
       description: "Poll for labeled issues continuously",
       default: false,
-    }),
-    interval: Flags.integer({
+    },
+    interval: {
+      type: "string" as const,
       description: "Poll interval in minutes (default: 30)",
-    }),
-    limit: Flags.integer({
+    },
+    limit: {
+      type: "string" as const,
       description: "Max issues per iteration (default: 1)",
-      default: 1,
-    }),
-    label: Flags.string({
+      default: "1",
+    },
+    label: {
+      type: "string" as const,
       description: "Trigger label (default: auto-claude)",
-    }),
-    "main-branch": Flags.string({
+    },
+    "main-branch": {
+      type: "string" as const,
       description: "Override main branch detection",
-    }),
-    "scope-path": Flags.string({
+    },
+    "scope-path": {
+      type: "string" as const,
       description: "Path within repo to scope work (default: .)",
-    }),
-  };
-
-  async run(): Promise<void> {
-    const { args, flags } = await this.parse(AutoClaude);
-
+    },
+  },
+  subCommands: {
+    list: () => import("./list.js").then((m) => m.default),
+    status: () => import("./status.js").then((m) => m.default),
+    retry: () => import("./retry.js").then((m) => m.default),
+  },
+  async run({ args }) {
     // Prompt mode: run a single prompt with structured output, skip issue pipeline
     if (args.prompt) {
-      await initConfig({ model: flags.model });
+      await initConfig({ model: args.model });
 
       const promptDir = join(tmpdir(), "tt-auto-claude");
       mkdirSync(promptDir, { recursive: true });
@@ -118,41 +98,44 @@ export default class AutoClaude extends BaseCommand {
 
       const result = await runClaude({
         promptFile,
-        maxTurns: flags["max-turns"],
+        maxTurns: Number(args["max-turns"]),
       });
 
       if (result.is_error) {
-        this.error("Claude reported an error", { exit: 1 });
+        consola.error("Claude reported an error");
+        process.exit(1);
       }
       return;
     }
 
     // Issue pipeline mode
     const cfg = await initConfig({
-      triggerLabel: flags.label,
-      mainBranch: flags["main-branch"],
-      scopePath: flags["scope-path"],
-      model: flags.model,
+      triggerLabel: args.label,
+      mainBranch: args["main-branch"],
+      scopePath: args["scope-path"],
+      model: args.model,
     });
 
-    if (flags.reset) {
-      const issueDir = join(process.cwd(), `.auto-claude/issue-${flags.reset}`);
-      log(`Resetting state for issue-${flags.reset}...`);
+    const resetIssue = args.reset ? Number(args.reset) : undefined;
+    if (resetIssue) {
+      const issueDir = join(process.cwd(), `.auto-claude/issue-${resetIssue}`);
+      log(`Resetting state for issue-${resetIssue}...`);
       rmSync(issueDir, { recursive: true, force: true });
       log(`Cleaned ${issueDir}`);
       return;
     }
 
-    const untilStep = flags.until as StepName | undefined;
-    const loopMode = flags.loop;
-    const intervalMs = (flags.interval ?? cfg.loopIntervalMinutes) * 60_000;
-    const limit = flags.limit ?? 1;
+    const untilStep = args.until as StepName | undefined;
+    const loopMode = args.loop as boolean;
+    const intervalMs = (args.interval ? Number(args.interval) : cfg.loopIntervalMinutes) * 60_000;
+    const limit = Number(args.limit);
 
     if (loopMode) {
       registerShutdownHandlers();
       log(`Loop mode — interval: ${intervalMs / 60_000}min, limit: ${limit}`);
     }
 
+    const issueNumber = args.issue ? Number(args.issue) : undefined;
     let iteration = 0;
 
     do {
@@ -177,8 +160,8 @@ export default class AutoClaude extends BaseCommand {
 
       log("Fetching labeled issues…");
       let contexts: IssueContext[];
-      if (flags.issue) {
-        const ctx = await fetchIssue(flags.issue);
+      if (issueNumber) {
+        const ctx = await fetchIssue(issueNumber);
         contexts = ctx ? [ctx] : [];
       } else {
         contexts = await fetchIssues(limit);
@@ -212,8 +195,8 @@ export default class AutoClaude extends BaseCommand {
     } while (loopMode);
 
     log("Done.");
-  }
-}
+  },
+});
 
 async function syncWithRemote(): Promise<void> {
   const cfg = getConfig();