@towles/tool 0.0.108 → 0.0.110

package/packages/shared/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@towles/shared",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "dependencies": {
+    "consola": "^3.4.2"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.8.3"
+  }
+}

package/packages/shared/src/git/exec.ts

@@ -0,0 +1,41 @@
+export interface XResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+export interface XOptions {
+  throwOnError?: boolean;
+  cwd?: string;
+}
+
+export async function run(cmd: string, args: string[] = [], options?: XOptions): Promise<XResult> {
+  const cwd = options?.cwd ?? process.cwd();
+  const proc = Bun.spawn([cmd, ...args], { cwd, stdout: "pipe", stderr: "pipe" });
+  const exitCode = await proc.exited;
+  const [stdout, stderr] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ]);
+  if (options?.throwOnError && exitCode !== 0) {
+    throw new Error(`Command failed (exit ${exitCode}): ${cmd} ${args.join(" ")}\n${stderr}`);
+  }
+  return { stdout, stderr, exitCode };
+}
+
+export async function exec(cmd: string, args: string[]): Promise<string> {
+  const result = await run(cmd, args, { throwOnError: true });
+  return result.stdout.trim();
+}
+
+export async function execSafe(
+  cmd: string,
+  args: string[],
+): Promise<{ stdout: string; ok: boolean }> {
+  const result = await run(cmd, args);
+  return { stdout: result.stdout.trim(), ok: result.exitCode === 0 };
+}
+
+export async function git(args: string[]): Promise<string> {
+  return exec("git", args);
+}

package/{src/utils → packages/shared/src}/git/gh-cli-wrapper.ts

@@ -1,36 +1,32 @@
-import stripAnsi from "strip-ansi";
-import { x } from "tinyexec";
-import type { Output } from "tinyexec";
-
-import { execSafe } from "./exec.js";
+import { exec, execSafe, run as defaultX } from "./exec.js";
+import type { XResult } from "./exec.js";
 
 export type XFn = (
   cmd: string,
   args?: string[],
   opts?: Record<string, unknown>,
-) => PromiseLike<Output>;
+) => PromiseLike<XResult>;
 
-export async function isGithubCliInstalled(exec: XFn = x as XFn): Promise<boolean> {
+export async function isGithubCliInstalled(execFn: XFn = defaultX): Promise<boolean> {
   try {
-    const proc = await exec("gh", ["--version"]);
+    const proc = await execFn("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;
+  const stdout = await exec("gh", args);
+  return JSON.parse(stdout) as T;
 }
 
 export async function ghRaw(
   args: string[],
-  exec?: (cmd: string, args: string[]) => Promise<{ stdout: string; ok: boolean }>,
+  execFn?: (cmd: string, args: string[]) => Promise<{ stdout: string; ok: boolean }>,
 ): Promise<string> {
-  const execFn = exec ?? execSafe;
-  const result = await execFn("gh", args);
+  const fn = execFn ?? execSafe;
+  const result = await fn("gh", args);
   return result.stdout;
 }
 
@@ -48,7 +44,7 @@ export async function getIssues({
   assignedToMe,
   cwd,
   label,
-  exec = x as XFn,
+  exec: execFn = defaultX,
 }: {
   assignedToMe?: boolean;
   cwd: string;
@@ -65,9 +61,8 @@ export async function getIssues({
     args.push("--label", label);
   }
 
-  const result = await exec("gh", args);
-  // Setting NO_COLOR=1 didn't remove colors so had to use stripAnsi
-  const stripped = stripAnsi(result.stdout);
+  const result = await execFn("gh", args);
+  const stripped = Bun.stripANSI(result.stdout);
 
   try {
     return JSON.parse(stripped) as Issue[];

package/packages/shared/src/index.ts

@@ -0,0 +1,8 @@
+export { ensureDir, fileExists, readFile, writeFile } from "./fs.js";
+export { getTerminalColumns, limitText, printWithHexColor } from "./render.js";
+export { formatDate, generateJournalFilename, getMondayOfWeek, getWeekInfo } from "./date-utils.js";
+export { exec, execSafe, git, run } from "./git/exec.js";
+export type { XResult, XOptions } from "./git/exec.js";
+export { gh, ghRaw, getIssues, isGithubCliInstalled } from "./git/gh-cli-wrapper.js";
+export type { Issue, XFn } from "./git/gh-cli-wrapper.js";
+export { createBranchNameFromIssue } from "./git/branch-name.js";

package/packages/shared/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
+    "strict": true,
+    "strictNullChecks": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/src/cli.ts

@@ -1,9 +1,10 @@
 import { defineCommand } from "citty";
+import { version } from "../package.json";
 
 export const main = defineCommand({
-  meta: { name: "tt", description: "towles-tool — personal CLI utilities" },
+  meta: { name: "tt", version, description: "towles-tool — personal CLI utilities" },
   subCommands: {
-    config: () => import("./commands/config.js").then((m) => m.default),
+    config: () => import("./commands/config/index.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),

package/src/commands/agentboard.ts

@@ -9,8 +9,6 @@ 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;
@@ -20,37 +18,18 @@ const MARKER = "# agentboard";
 function findTmuxConf(): string | null {
   const candidates = [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;
-    }
+    if (existsSync(path)) return path;
   }
   return null;
 }
 
-function ensureDeps(): void {
+function ensureBun(): void {
   try {
     execSync("bun --version", { stdio: "pipe" });
   } catch {
     consola.error("bun is required but not found. Install: https://bun.sh");
     process.exit(1);
   }
-
-  if (!existsSync(PLUGIN_DIR)) {
-    consola.error(`Agentboard plugin directory not found: ${PLUGIN_DIR}`);
-    consola.error(
-      "If installed globally, ensure the 'plugins' directory is included in the package.",
-    );
-    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 {
@@ -111,8 +90,6 @@ function showKeys(): void {
 }
 
 function setup(): void {
-  ensureDeps();
-
   const confPath = findTmuxConf();
   if (!confPath) {
     consola.warn("No tmux.conf found. Add this line manually:");
@@ -186,18 +163,15 @@ function uninstall(): void {
 }
 
 function startServer(): void {
-  ensureDeps();
+  ensureBun();
 
-  const serverEntry = resolve(PLUGIN_DIR, "apps/server/src/main.ts");
+  const agentboardDir = resolve(import.meta.dirname, "../../packages/agentboard");
+  const serverEntry = resolve(agentboardDir, "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,
-    },
+    cwd: agentboardDir,
   });
 }
 
@@ -215,13 +189,10 @@ async function serverAlive(): Promise<boolean> {
 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], {
+  const child = spawn("tt", ["agentboard", "server"], {
     stdio: "ignore",
-    cwd: PLUGIN_DIR,
     detached: true,
-    env: { ...process.env, AGENTBOARD_DIR: PLUGIN_DIR },
   });
   child.unref();
 
@@ -262,7 +233,9 @@ function findSidebarPane(windowId: string): string | null {
       const [paneId, title] = line.split(" ", 2);
       if (title === "agentboard-sidebar" && paneId) return paneId;
     }
-  } catch {}
+  } catch (err) {
+    consola.debug(`findSidebarPane failed for window ${windowId}:`, err);
+  }
   return null;
 }
 
@@ -381,7 +354,7 @@ async function runFocus(): Promise<void> {
 }
 
 async function restart(): Promise<void> {
-  ensureDeps();
+  ensureBun();
 
   // 1. Kill stash sessions left over from hidden sidebars
   try {
@@ -407,35 +380,47 @@ async function restart(): Promise<void> {
   }
   consola.success("Server is running");
 
-  // 3. Toggle sidebar on (the server spawns sidebars in all active windows)
+  // 3. Bootstrap sidebars — refresh session list, then ensure-sidebar for
+  //    each active client's window so sidebars appear without interaction.
+  const base = `http://${SERVER_HOST}:${SERVER_PORT}`;
+  await fetch(`${base}/refresh`, { method: "POST", signal: AbortSignal.timeout(2000) }).catch(
+    () => {},
+  );
+
   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}`);
-    }
+    const clients = spawnSync(
+      "tmux",
+      ["list-clients", "-F", "#{client_tty}|#{session_name}|#{window_id}"],
+      {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+      },
+    );
+    const lines = (clients.stdout ?? "").trim().split("\n").filter(Boolean);
+    await Promise.allSettled(
+      lines.map((ctx) =>
+        fetch(`${base}/ensure-sidebar`, {
+          method: "POST",
+          body: ctx,
+          signal: AbortSignal.timeout(2000),
+        }),
+      ),
+    );
+    consola.success(`Sidebars ensured for ${lines.length} client(s)`);
   } catch (err) {
-    consola.error("Failed to toggle sidebar:", err);
+    consola.error("Failed to bootstrap sidebars:", err);
   }
 }
 
 function startTui(): void {
-  ensureDeps();
+  ensureBun();
 
-  const tuiEntry = resolve(PLUGIN_DIR, "apps/tui/src/index.tsx");
+  const agentboardDir = resolve(import.meta.dirname, "../../packages/agentboard");
+  const tuiEntry = resolve(agentboardDir, "apps/tui/src/index.tsx");
 
   execSync(`bun run ${tuiEntry}`, {
     stdio: "inherit",
-    cwd: resolve(PLUGIN_DIR, "apps/tui"),
-    env: {
-      ...process.env,
-      AGENTBOARD_DIR: PLUGIN_DIR,
-    },
+    cwd: resolve(agentboardDir, "apps/tui"),
   });
 }
 
@@ -463,8 +448,6 @@ export default defineCommand({
         startServer();
         break;
       case "tui":
-        startTui();
-        break;
       case "start":
         startTui();
         break;

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

@@ -4,7 +4,7 @@ import { join } from "node:path";
 import consola from "consola";
 import pc from "picocolors";
 
-import { readFile } from "../../utils/fs.js";
+import { readFile } from "@towles/shared";
 import { getConfig } from "./config.js";
 import { sleep } from "./shell.js";
 import { spawnClaude as defaultSpawnClaude } from "./spawn-claude.js";

package/src/commands/auto-claude/config-init-helpers.ts

@@ -0,0 +1,79 @@
+import { AutoClaudeConfigSchema } from "./config.js";
+import type { AutoClaudeConfig } from "./config.js";
+
+export const CONFIG_DIR = ".auto-claude";
+export const CONFIG_FILENAME = "config.json";
+export const CONFIG_PATH = `${CONFIG_DIR}/${CONFIG_FILENAME}`;
+
+export interface ConfigInitInput {
+  triggerLabel: string;
+  mainBranch: string;
+  scopePath: string;
+  model: string;
+  repo: string;
+}
+
+/**
+ * Build a full AutoClaudeConfig from user inputs, applying schema defaults.
+ */
+export function buildConfig(input: ConfigInitInput): AutoClaudeConfig {
+  return AutoClaudeConfigSchema.parse({
+    triggerLabel: input.triggerLabel,
+    mainBranch: input.mainBranch,
+    scopePath: input.scopePath,
+    model: input.model,
+    repo: input.repo,
+  });
+}
+
+/**
+ * Validate that a trigger label is non-empty and contains no spaces.
+ */
+export function validateTriggerLabel(label: string): string | true {
+  const trimmed = label.trim();
+  if (trimmed.length === 0) return "Trigger label cannot be empty";
+  if (/\s/.test(trimmed)) return "Trigger label cannot contain spaces";
+  return true;
+}
+
+/**
+ * Validate that a branch name is non-empty.
+ */
+export function validateBranchName(name: string): string | true {
+  const trimmed = name.trim();
+  if (trimmed.length === 0) return "Branch name cannot be empty";
+  return true;
+}
+
+/**
+ * Validate that a scope path is non-empty.
+ */
+export function validateScopePath(path: string): string | true {
+  const trimmed = path.trim();
+  if (trimmed.length === 0) return "Scope path cannot be empty";
+  return true;
+}
+
+/**
+ * Format the config as a human-readable summary for confirmation.
+ */
+export function formatConfigSummary(config: AutoClaudeConfig): string {
+  return [
+    `  repo:           ${config.repo}`,
+    `  triggerLabel:   ${config.triggerLabel}`,
+    `  mainBranch:     ${config.mainBranch}`,
+    `  scopePath:      ${config.scopePath}`,
+    `  model:          ${config.model}`,
+    `  remote:         ${config.remote}`,
+    `  maxIterations:  ${config.maxImplementIterations}`,
+    `  maxReviewRetries: ${config.maxReviewRetries}`,
+    `  loopInterval:   ${config.loopIntervalMinutes}min`,
+  ].join("\n");
+}
+
+/**
+ * Serialize config to JSON for writing to disk.
+ */
+export function serializeConfig(config: AutoClaudeConfig): string {
+  return JSON.stringify(config, null, 2) + "\n";
+}

package/src/commands/auto-claude/config-init.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  buildConfig,
+  formatConfigSummary,
+  serializeConfig,
+  validateBranchName,
+  validateScopePath,
+  validateTriggerLabel,
+} from "./config-init-helpers";
+
+describe("validateTriggerLabel", () => {
+  it("accepts a valid label", () => {
+    expect(validateTriggerLabel("auto-claude")).toBe(true);
+  });
+
+  it("rejects empty string", () => {
+    expect(validateTriggerLabel("")).toBe("Trigger label cannot be empty");
+  });
+
+  it("rejects whitespace-only", () => {
+    expect(validateTriggerLabel("   ")).toBe("Trigger label cannot be empty");
+  });
+
+  it("rejects label with spaces", () => {
+    expect(validateTriggerLabel("auto claude")).toBe("Trigger label cannot contain spaces");
+  });
+});
+
+describe("validateBranchName", () => {
+  it("accepts a valid branch name", () => {
+    expect(validateBranchName("main")).toBe(true);
+  });
+
+  it("rejects empty string", () => {
+    expect(validateBranchName("")).toBe("Branch name cannot be empty");
+  });
+});
+
+describe("validateScopePath", () => {
+  it("accepts a valid path", () => {
+    expect(validateScopePath(".")).toBe(true);
+  });
+
+  it("accepts a subdirectory", () => {
+    expect(validateScopePath("src/lib")).toBe(true);
+  });
+
+  it("rejects empty string", () => {
+    expect(validateScopePath("")).toBe("Scope path cannot be empty");
+  });
+});
+
+describe("buildConfig", () => {
+  it("builds config with provided values", () => {
+    const config = buildConfig({
+      triggerLabel: "my-label",
+      mainBranch: "develop",
+      scopePath: "src/",
+      model: "sonnet",
+      repo: "owner/repo",
+    });
+
+    expect(config.triggerLabel).toBe("my-label");
+    expect(config.mainBranch).toBe("develop");
+    expect(config.scopePath).toBe("src/");
+    expect(config.model).toBe("sonnet");
+    expect(config.repo).toBe("owner/repo");
+  });
+
+  it("applies schema defaults for fields not in input", () => {
+    const config = buildConfig({
+      triggerLabel: "auto-claude",
+      mainBranch: "main",
+      scopePath: ".",
+      model: "opus",
+      repo: "owner/repo",
+    });
+
+    expect(config.remote).toBe("origin");
+    expect(config.maxImplementIterations).toBe(5);
+    expect(config.maxReviewRetries).toBe(2);
+    expect(config.loopIntervalMinutes).toBe(30);
+  });
+});
+
+describe("formatConfigSummary", () => {
+  it("includes all key fields", () => {
+    const config = buildConfig({
+      triggerLabel: "auto-claude",
+      mainBranch: "main",
+      scopePath: ".",
+      model: "opus",
+      repo: "owner/repo",
+    });
+
+    const summary = formatConfigSummary(config);
+    expect(summary).toContain("owner/repo");
+    expect(summary).toContain("auto-claude");
+    expect(summary).toContain("main");
+    expect(summary).toContain("opus");
+    expect(summary).toContain("origin");
+    expect(summary).toContain("30min");
+  });
+});
+
+describe("serializeConfig", () => {
+  it("returns valid JSON with trailing newline", () => {
+    const config = buildConfig({
+      triggerLabel: "auto-claude",
+      mainBranch: "main",
+      scopePath: ".",
+      model: "opus",
+      repo: "owner/repo",
+    });
+
+    const json = serializeConfig(config);
+    expect(json.endsWith("\n")).toBe(true);
+
+    const parsed = JSON.parse(json);
+    expect(parsed.repo).toBe("owner/repo");
+    expect(parsed.triggerLabel).toBe("auto-claude");
+  });
+
+  it("is pretty-printed with 2-space indent", () => {
+    const config = buildConfig({
+      triggerLabel: "test",
+      mainBranch: "main",
+      scopePath: ".",
+      model: "opus",
+      repo: "o/r",
+    });
+
+    const json = serializeConfig(config);
+    expect(json).toContain('  "repo"');
+  });
+});