@towles/tool 0.0.62 → 0.0.64

package/package.json

@@ -1,16 +1,7 @@
 {
   "name": "@towles/tool",
-  "version": "0.0.62",
-  "description": "CLI tool with auto-claude pipeline, developer tools, and journaling via markdown.",
-  "keywords": [
-    "auto-claude",
-    "autonomic",
-    "claude",
-    "cli",
-    "git",
-    "journal",
-    "oclif"
-  ],
+  "version": "0.0.64",
+  "description": "One off quality of life scripts that I use on a daily basis.",
   "homepage": "https://github.com/ChrisTowles/towles-tool#readme",
   "bugs": {
     "url": "https://github.com/ChrisTowles/towles-tool/issues"
@@ -34,79 +25,81 @@
     "src"
   ],
   "type": "module",
-  "main": "bin/run.ts",
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
-    "start": "tsx ./bin/run.ts",
-    "typecheck": "tsc --noEmit",
+    "version:sync": "pnpm tsx scripts/sync-versions.ts",
+    "prepublishOnly": "pnpm run version:sync",
+    "dev": "tsx bin/run.ts",
+    "format": "oxfmt --write .",
+    "format:check": "oxfmt --check .",
     "lint": "oxlint",
     "lint:fix": "oxlint --fix",
-    "format": "oxfmt --write",
-    "format:check": "oxfmt --check",
     "test": "vitest run",
-    "test:watch": "vitest watch",
-    "prepare": "simple-git-hooks",
-    "version:sync": "tsx scripts/sync-versions.ts"
+    "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"
   },
   "dependencies": {
-    "@oclif/core": "^4.3.16",
+    "@anthropic-ai/claude-code": "^2.1.4",
+    "@anthropic-ai/sdk": "^0.56.0",
+    "@oclif/core": "^4.3.2",
     "consola": "^3.4.2",
     "d3-hierarchy": "^3.1.2",
     "fzf": "^0.5.2",
-    "globby": "^14.1.0",
-    "luxon": "^3.5.0",
-    "open": "^10.1.1",
+    "luxon": "^3.7.1",
+    "neverthrow": "^8.2.0",
     "picocolors": "^1.1.1",
     "prompts": "^2.4.2",
-    "strip-ansi": "^7.1.2",
-    "tinyexec": "^1.0.2",
-    "zod": "^3.25.67"
+    "strip-ansi": "^7.1.0",
+    "tinyexec": "^0.3.2",
+    "zod": "^4.0.5"
   },
   "devDependencies": {
-    "@oclif/test": "^4.1.13",
-    "@total-typescript/tsconfig": "^1.0.4",
-    "@tsconfig/strictest": "^2.0.5",
+    "@oclif/test": "^4.1.10",
     "@types/d3-hierarchy": "^3.1.7",
-    "@types/luxon": "^3.4.2",
-    "@types/node": "^22.10.10",
+    "@types/luxon": "^3.6.2",
+    "@types/node": "^22.16.3",
     "@types/prompts": "^2.4.9",
+    "@typescript/native-preview": "^7.0.0-dev.20260111.1",
     "bumpp": "^10.4.0",
-    "lint-staged": "^15.5.1",
     "oxfmt": "^0.24.0",
-    "oxlint": "^1.2.0",
-    "simple-git-hooks": "^2.11.1",
-    "tsx": "^4.19.2",
+    "oxlint": "^1.7.0",
+    "promptfoo": "^0.121.2",
+    "simple-git-hooks": "^2.13.0",
+    "tsx": "^4.19.4",
     "typescript": "^5.8.3",
-    "vitest": "^3.1.3"
+    "vitest": "^4.0.17"
   },
   "simple-git-hooks": {
-    "pre-commit": "pnpm lint-staged && pnpm format && pnpm typecheck"
-  },
-  "lint-staged": {
-    "package.json": "oxfmt --write",
-    "*.{ts,tsx,mts,cts,js,cjs,mjs}": [
-      "oxlint --fix"
-    ],
-    "*.*": [
-      "oxfmt --write"
-    ]
+    "pre-commit": "pnpm format && pnpm lint:fix && pnpm typecheck && claude plugin validate ."
   },
   "oclif": {
     "bin": "tt",
-    "commands": {
-      "strategy": "pattern",
-      "target": "./src/commands"
-    },
+    "commands": "./src/commands",
     "dirname": "towles-tool",
-    "plugins": [],
     "topicSeparator": " "
   },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "packageManager": "pnpm@10.11.0",
+  "packageManager": "pnpm@10.27.0",
   "pnpm": {
     "patchedDependencies": {
       "prompts@2.4.2": "patches/prompts.patch"
-    }
-  }
+    },
+    "onlyBuiltDependencies": [
+      "@anthropic-ai/claude-code",
+      "better-sqlite3",
+      "esbuild",
+      "simple-git-hooks",
+      "@parcel/watcher"
+    ]
+  },
+  "trustedDependencies": [
+    "@anthropic-ai/claude-code"
+  ]
 }

package/src/commands/agentboard.ts

@@ -0,0 +1,176 @@
+import { Args, Flags } from "@oclif/core";
+import { execSync, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { networkInterfaces } from "node:os";
+import consola from "consola";
+import { BaseCommand } from "./base.js";
+
+function getLocalIp(): string {
+  const nets = networkInterfaces();
+  for (const ifaces of Object.values(nets)) {
+    if (!ifaces) continue;
+    for (const iface of ifaces) {
+      if (iface.family === "IPv4" && !iface.internal) {
+        return iface.address;
+      }
+    }
+  }
+  return "localhost";
+}
+
+export default class Agentboard extends BaseCommand {
+  static override aliases = ["ag"];
+  static override description = "Start AgentBoard — agentic workflow orchestration IDE";
+
+  static override examples = [
+    {
+      description: "Start AgentBoard on default port",
+      command: "<%= config.bin %> agentboard",
+    },
+    {
+      description: "Start on a custom port",
+      command: "<%= config.bin %> ag --port 3000",
+    },
+    {
+      description: "Start without opening browser",
+      command: "<%= config.bin %> ag --no-open",
+    },
+    {
+      description: "Attach to a running card tmux session",
+      command: "<%= config.bin %> ag attach 42",
+    },
+  ];
+
+  static override flags = {
+    port: Flags.string({
+      char: "p",
+      description: "Port to serve on",
+      default: "4200",
+    }),
+    open: Flags.boolean({
+      description: "Open browser after starting",
+      default: true,
+      allowNo: true,
+    }),
+    "data-dir": Flags.string({
+      char: "d",
+      description: "Directory for AgentBoard data (SQLite DB, artifacts)",
+      env: "AGENTBOARD_DATA_DIR",
+    }),
+    lan: Flags.boolean({
+      description: "Listen on all interfaces (0.0.0.0) for LAN access. Default: localhost only.",
+      default: false,
+    }),
+  };
+
+  static override args = {
+    subcommand: Args.string({
+      description: "Subcommand (attach, reset)",
+      required: false,
+    }),
+    cardId: Args.string({
+      description: "Card ID for attach subcommand",
+      required: false,
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Agentboard);
+
+    if (args.subcommand === "attach") {
+      if (!args.cardId) {
+        this.error("Card ID is required for attach subcommand");
+      }
+      execSync(`tmux attach-session -t card-${args.cardId}`, {
+        stdio: "inherit",
+      });
+      return;
+    }
+
+    if (args.subcommand === "reset") {
+      const defaultDataDir = resolve(
+        process.env.XDG_CONFIG_HOME ?? resolve(process.env.HOME ?? "~", ".config"),
+        "towles-tool",
+        "agentboard",
+      );
+      const dataDir = flags["data-dir"] ? resolve(flags["data-dir"]) : defaultDataDir;
+      const dbPath = join(dataDir, "agentboard.db");
+      const walPath = `${dbPath}-wal`;
+      const shmPath = `${dbPath}-shm`;
+
+      if (!existsSync(dbPath)) {
+        consola.info("No database found — nothing to reset.");
+        return;
+      }
+
+      consola.warn(`This will delete: ${dbPath}`);
+      for (const f of [dbPath, walPath, shmPath]) {
+        if (existsSync(f)) {
+          const { unlinkSync } = await import("node:fs");
+          unlinkSync(f);
+        }
+      }
+      consola.success("Database reset. Start AgentBoard to create a fresh DB.");
+      return;
+    }
+
+    const agentboardDir = resolve(import.meta.dirname, "../../plugins/tt-agentboard");
+    const port = flags.port;
+    const defaultDataDir = resolve(
+      process.env.XDG_CONFIG_HOME ?? resolve(process.env.HOME ?? "~", ".config"),
+      "towles-tool",
+      "agentboard",
+    );
+    const dataDir = flags["data-dir"] ? resolve(flags["data-dir"]) : defaultDataDir;
+    const localIp = getLocalIp();
+    const dbPath = join(dataDir, "agentboard.db");
+    const isFirstRun = !existsSync(dbPath);
+
+    const lanMode = flags.lan;
+    const host = lanMode ? "0.0.0.0" : "127.0.0.1";
+
+    const lines = [`AgentBoard\n\n  Local:   http://localhost:${port}`];
+    if (lanMode) {
+      lines.push(`  Network: http://${localIp}:${port}`);
+    } else {
+      lines.push(`  Network: disabled (use --lan to enable)`);
+    }
+    lines.push(`  Data:    ${dataDir}`);
+    consola.box(lines.join("\n"));
+
+    if (isFirstRun) {
+      consola.info("First run detected — a new database will be created at startup.");
+      consola.info(
+        "Setup checklist:\n" +
+          "  1. Ensure tmux is installed (sudo apt install tmux / brew install tmux)\n" +
+          "  2. Set GITHUB_TOKEN for GitHub features (optional)\n" +
+          "  3. Open the board → Workspaces → Add a workspace slot\n" +
+          "  4. Create your first card and drag it to In Progress",
+      );
+    }
+
+    const proc = spawn("pnpm", ["dev", "--port", port], {
+      cwd: agentboardDir,
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        NUXT_DEV_HOST: host,
+        AGENTBOARD_DATA_DIR: dataDir,
+        AGENTBOARD_LAN: lanMode ? "1" : "0",
+      },
+    });
+
+    if (flags.open) {
+      setTimeout(() => {
+        try {
+          execSync(`xdg-open http://localhost:${port}`, { stdio: "ignore" });
+        } catch {
+          consola.debug("Could not open browser automatically");
+        }
+      }, 2000);
+    }
+
+    proc.on("exit", (code) => process.exit(code ?? 0));
+  }
+}

package/src/commands/{auto-claude.ts → auto-claude/index.ts}

@@ -4,10 +4,9 @@ import { join } from "node:path";
 import { Flags } from "@oclif/core";
 import consola from "consola";
 
-import { BaseCommand } from "./base.js";
+import { BaseCommand } from "../base.js";
 import {
   STEP_NAMES,
-  buildIssueContext,
   fetchIssue,
   fetchIssues,
   getConfig,
@@ -17,9 +16,8 @@ import {
   logBanner,
   runPipeline,
   sleep,
-  stepRefresh,
-} from "../lib/auto-claude/index.js";
-import type { IssueContext, StepName } from "../lib/auto-claude/index.js";
+} 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"];
@@ -39,10 +37,6 @@ export default class AutoClaude extends BaseCommand {
       description: "Reset local state for an issue",
       command: "<%= config.bin %> auto-claude --reset 42",
     },
-    {
-      description: "Refresh a stale PR branch",
-      command: "<%= config.bin %> auto-claude --refresh --issue 42",
-    },
     {
       description: "Loop mode: poll for labeled issues",
       command: "<%= config.bin %> auto-claude --loop",
@@ -67,9 +61,9 @@ export default class AutoClaude extends BaseCommand {
     reset: Flags.integer({
       description: "Delete local state for an issue (force restart)",
     }),
-    refresh: Flags.boolean({
-      description: "Rebase a stale PR branch onto current main",
-      default: false,
+    model: Flags.string({
+      description: "Claude model to use (default: opus)",
+      default: "opus",
     }),
     loop: Flags.boolean({
       description: "Poll for labeled issues continuously",
@@ -100,7 +94,7 @@ export default class AutoClaude extends BaseCommand {
       triggerLabel: flags.label,
       mainBranch: flags["main-branch"],
       scopePath: flags["scope-path"],
-      loopRetryEnabled: flags.loop || undefined,
+      model: flags.model,
     });
 
     if (flags.reset) {
@@ -111,19 +105,6 @@ export default class AutoClaude extends BaseCommand {
       return;
     }
 
-    if (flags.refresh) {
-      if (!flags.issue) {
-        this.error("--refresh requires --issue <number>");
-      }
-      const ctx = buildIssueContext(
-        { number: flags.issue, title: `Issue #${flags.issue}`, body: "" },
-        cfg.repo,
-        cfg.scopePath,
-      );
-      await stepRefresh(ctx);
-      return;
-    }
-
     const untilStep = flags.until as StepName | undefined;
     const loopMode = flags.loop;
     const intervalMs = (flags.interval ?? cfg.loopIntervalMinutes) * 60_000;
@@ -156,6 +137,7 @@ export default class AutoClaude extends BaseCommand {
         throw e;
       }
 
+      log("Fetching labeled issues…");
       let contexts: IssueContext[];
       if (flags.issue) {
         const ctx = await fetchIssue(flags.issue);
@@ -170,10 +152,14 @@ export default class AutoClaude extends BaseCommand {
         log(`Processing ${contexts.length} issue(s)...\n`);
 
         for (const ctx of contexts) {
+          const issueStart = Date.now();
           try {
             await runPipeline(ctx, untilStep);
           } catch (e) {
             consola.error(`Pipeline error for ${ctx.repo}#${ctx.number}:`, e);
+          } finally {
+            const elapsed = ((Date.now() - issueStart) / 1000).toFixed(1);
+            log(`Completed ${ctx.repo}#${ctx.number} in ${elapsed}s`);
           }
         }
       }
@@ -198,7 +184,9 @@ async function syncWithRemote(): Promise<void> {
   const branch = await git(["rev-parse", "--abbrev-ref", "HEAD"]);
   if (branch !== cfg.mainBranch) {
     log(`Warning: on branch "${branch}", switching to ${cfg.mainBranch}...`);
-    await git(["checkout", cfg.mainBranch]).catch(() => {});
+    await git(["checkout", cfg.mainBranch]).catch(() => {
+      // Best-effort checkout — may fail if working tree is dirty
+    });
   }
   const status = await git(["status", "--porcelain"]);
   if (status.length > 0) {
@@ -217,7 +205,9 @@ function registerShutdownHandlers(): void {
       log(`Received ${signal}, shutting down...`);
       setTimeout(() => process.exit(1), 5_000).unref();
       git(["checkout", getConfig().mainBranch])
-        .catch(() => {})
+        .catch(() => {
+          // Best-effort cleanup on shutdown — ignore failures
+        })
         .then(() => process.exit(0));
     });
   }

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

@@ -0,0 +1,114 @@
+import { Flags } from "@oclif/core";
+import consola from "consola";
+import { colors } from "consola/utils";
+import { Fzf } from "fzf";
+import prompts from "prompts";
+import type { Choice } from "prompts";
+
+import { BaseCommand } from "../base.js";
+import { buildIssueChoices, computeColumnLayout } from "../gh/branch.js";
+import { STEP_NAMES, fetchIssue, initConfig, runPipeline } from "../../lib/auto-claude/index.js";
+import type { StepName } from "../../lib/auto-claude/index.js";
+import { getIssues, isGithubCliInstalled } from "../../utils/git/gh-cli-wrapper.js";
+import { getTerminalColumns } from "../../utils/render.js";
+
+export default class AutoClaudeList extends BaseCommand {
+  static override description = "Interactively pick an auto-claude issue to process";
+
+  static override examples = [
+    {
+      description: "Browse auto-claude labeled issues",
+      command: "<%= config.bin %> auto-claude list",
+    },
+    {
+      description: "Pick an issue and run until plan step",
+      command: "<%= config.bin %> auto-claude list --until plan",
+    },
+  ];
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+    until: Flags.string({
+      char: "u",
+      description: `Stop after this step (${STEP_NAMES.join(", ")})`,
+      options: [...STEP_NAMES],
+    }),
+    label: Flags.string({
+      description: "Trigger label (default: auto-claude)",
+    }),
+    "main-branch": Flags.string({
+      description: "Override main branch detection",
+    }),
+    "scope-path": Flags.string({
+      description: "Path within repo to scope work (default: .)",
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(AutoClaudeList);
+
+    const cfg = await initConfig({
+      triggerLabel: flags.label,
+      mainBranch: flags["main-branch"],
+      scopePath: flags["scope-path"],
+    });
+
+    const cliInstalled = await isGithubCliInstalled();
+    if (!cliInstalled) {
+      this.error("GitHub CLI (gh) is not installed");
+    }
+
+    const issues = await getIssues({ cwd: process.cwd(), label: cfg.triggerLabel });
+    if (issues.length === 0) {
+      consola.info(`No open issues with '${cfg.triggerLabel}' label`);
+      return;
+    }
+
+    consola.info(colors.green(`${issues.length} issue(s) with '${cfg.triggerLabel}' label`));
+
+    const layout = computeColumnLayout(issues, getTerminalColumns());
+    const choices = buildIssueChoices(issues, layout);
+
+    const fzf = new Fzf(choices, {
+      selector: (item) => `${item.value} ${item.description}`,
+      casing: "case-insensitive",
+    });
+
+    try {
+      const result = await prompts(
+        {
+          name: "issueNumber",
+          message: "Pick an issue to process:",
+          type: "autocomplete",
+          choices,
+          async suggest(input: string, choices: Choice[]) {
+            const results = fzf.find(input);
+            return results.map((r) => choices.find((c) => c.value === r.item.value));
+          },
+        },
+        {
+          onCancel: () => {
+            consola.info(colors.dim("Canceled"));
+            this.exit(0);
+          },
+        },
+      );
+
+      if (result.issueNumber === "cancel") {
+        consola.info(colors.dim("Canceled"));
+        return;
+      }
+
+      const ctx = await fetchIssue(result.issueNumber);
+      if (!ctx) {
+        this.error(`Could not fetch issue #${result.issueNumber}`);
+      }
+
+      const untilStep = flags.until as StepName | undefined;
+      await runPipeline(ctx, untilStep);
+    } catch (e) {
+      consola.error(e);
+      this.exit(1);
+    }
+  }
+}

package/src/commands/auto-claude/retry.test.ts

@@ -0,0 +1,138 @@
+import { mkdirSync, existsSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import consola from "consola";
+import { x } from "tinyexec";
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+import { LABELS } from "../../lib/auto-claude/labels.js";
+import { retryIssues } from "./retry.js";
+
+// Suppress consola output during tests
+consola.level = -999;
+
+// Mock tinyexec so setLabel/removeLabel (which use execSafe -> x) work
+vi.mock("tinyexec", () => ({
+  x: vi.fn().mockResolvedValue({ stdout: "", exitCode: 0, stderr: "" }),
+}));
+
+function getGhEditCalls() {
+  return vi
+    .mocked(x)
+    .mock.calls.filter(
+      ([cmd, args]) => cmd === "gh" && args?.[0] === "issue" && args?.[1] === "edit",
+    )
+    .map(([, args]) => args as string[]);
+}
+
+describe("retryIssues", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("removes failed label and adds trigger label for each issue", async () => {
+    const issues = [
+      {
+        number: 42,
+        title: "Fix bug",
+        state: "OPEN",
+        labels: [{ name: LABELS.failed, color: "red" }],
+      },
+    ];
+
+    const count = await retryIssues("owner/repo", "auto-claude", issues, false);
+
+    expect(count).toBe(1);
+    const editCalls = getGhEditCalls();
+    expect(editCalls.length).toBe(2);
+    expect(editCalls[0]).toEqual(
+      expect.arrayContaining(["42", "--repo", "owner/repo", "--remove-label", LABELS.failed]),
+    );
+    expect(editCalls[1]).toEqual(
+      expect.arrayContaining(["42", "--repo", "owner/repo", "--add-label", "auto-claude"]),
+    );
+  });
+
+  it("retries multiple issues", async () => {
+    const issues = [
+      {
+        number: 10,
+        title: "Issue A",
+        state: "OPEN",
+        labels: [{ name: LABELS.failed, color: "red" }],
+      },
+      {
+        number: 20,
+        title: "Issue B",
+        state: "OPEN",
+        labels: [{ name: LABELS.failed, color: "red" }],
+      },
+    ];
+
+    const count = await retryIssues("owner/repo", "auto-claude", issues, false);
+
+    expect(count).toBe(2);
+    const editCalls = getGhEditCalls();
+    // 2 issues * 2 label ops = 4
+    expect(editCalls.length).toBe(4);
+  });
+
+  it("returns 0 when given empty selection", async () => {
+    const count = await retryIssues("owner/repo", "auto-claude", [], false);
+    expect(count).toBe(0);
+    expect(getGhEditCalls().length).toBe(0);
+  });
+
+  it("cleans artifact directory when clean=true", async () => {
+    const tmpDir = join(tmpdir(), `retry-test-${Date.now()}`);
+    const issueDir = join(tmpDir, ".auto-claude", "issue-42");
+    mkdirSync(issueDir, { recursive: true });
+    writeFileSync(join(issueDir, "test.txt"), "data");
+
+    const originalCwd = process.cwd();
+    process.chdir(tmpDir);
+
+    try {
+      const issues = [
+        {
+          number: 42,
+          title: "Fix bug",
+          state: "OPEN",
+          labels: [{ name: LABELS.failed, color: "red" }],
+        },
+      ];
+
+      await retryIssues("owner/repo", "auto-claude", issues, true);
+      expect(existsSync(issueDir)).toBe(false);
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+
+  it("does not clean artifacts when clean=false", async () => {
+    const tmpDir = join(tmpdir(), `retry-test-${Date.now()}`);
+    const issueDir = join(tmpDir, ".auto-claude", "issue-42");
+    mkdirSync(issueDir, { recursive: true });
+    writeFileSync(join(issueDir, "test.txt"), "data");
+
+    const originalCwd = process.cwd();
+    process.chdir(tmpDir);
+
+    try {
+      const issues = [
+        {
+          number: 42,
+          title: "Fix bug",
+          state: "OPEN",
+          labels: [{ name: LABELS.failed, color: "red" }],
+        },
+      ];
+
+      await retryIssues("owner/repo", "auto-claude", issues, false);
+      expect(existsSync(issueDir)).toBe(true);
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+});