@towles/tool 0.0.109 → 0.0.111

package/{plugins/tt-agentboard → packages/agentboard}/packages/runtime/src/server/pane-scanner.ts

@@ -2,6 +2,7 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import type { AgentStatus } from "../contracts/agent";
+import { TERMINAL_STATUSES } from "../contracts/agent";
 import type { SidebarPane } from "../contracts/mux";
 import type { ServerContext, PaneAgentPresence } from "./context";
 import { shell } from "./git-info";
@@ -98,6 +99,11 @@ function resolveClaudeCodePaneInfo(
     const threadId: string | undefined = data.sessionId;
     if (!threadId) return {};
     const journalInfo = resolveClaudeCodeJournalInfo(threadId);
+    // Process is alive (found via process tree), so terminal journal status
+    // is a between-turn artifact — override to running.
+    if (journalInfo.status && TERMINAL_STATUSES.has(journalInfo.status)) {
+      journalInfo.status = "running";
+    }
     return { threadId, ...journalInfo };
   } catch {
     return {};

package/{plugins/tt-agentboard → packages/agentboard}/packages/runtime/src/shared.ts

@@ -1,10 +1,14 @@
 import type { AgentStatus, AgentEvent } from "./contracts/agent";
 
-export const SERVER_PORT = 4201;
-export const SERVER_HOST = "127.0.0.1";
+export const DEFAULT_SERVER_PORT = 4201;
+export const DEFAULT_SERVER_HOST = "127.0.0.1";
+
+export const SERVER_PORT: number = Number(process.env.TT_AGENTBOARD_PORT) || DEFAULT_SERVER_PORT;
+export const SERVER_HOST: string = process.env.TT_AGENTBOARD_HOST || DEFAULT_SERVER_HOST;
 export const PID_FILE = "/tmp/agentboard.pid";
 export const SERVER_IDLE_TIMEOUT_MS = 30_000;
 export const STUCK_RUNNING_TIMEOUT_MS = 3 * 60 * 1000;
+export const JOURNAL_IDLE_TIMEOUT_MS = 120_000;
 
 export interface SessionData {
   name: string;
@@ -35,6 +39,7 @@ export interface ServerState {
   currentSession: string | null;
   theme: string | undefined;
   sidebarWidth: number;
+  preferredEditor: string;
   ts: number;
 }
 

package/{plugins/tt-agentboard → packages/agentboard}/packages/runtime/tsconfig.json

@@ -9,5 +9,5 @@
     "noEmit": true,
     "types": ["bun-types"]
   },
-  "include": ["src/**/*", "test/**/*"]
+  "include": ["src/**/*"]
 }

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

@@ -4,7 +4,7 @@ import { version } from "../package.json";
 export const main = defineCommand({
   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

@@ -6,10 +6,8 @@ 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");
+const SERVER_HOST = process.env.TT_AGENTBOARD_HOST || "127.0.0.1";
+const SERVER_PORT = Number(process.env.TT_AGENTBOARD_PORT) || 4201;
 
 // Keybinding defaults
 const DEFAULT_KEY = "a";
@@ -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:");
@@ -169,14 +146,14 @@ function uninstall(): void {
   }
 
   const content = readFileSync(editPath, "utf8");
-  if (!content.includes("agentboard")) {
+  if (!content.includes(MARKER) && !content.includes(RUN_SHELL_LINE)) {
     consola.info("agentboard not found in tmux.conf");
     return;
   }
 
   const newContent = content
     .split("\n")
-    .filter((line) => !line.includes("agentboard"))
+    .filter((line) => !line.includes(MARKER) && !line.includes(RUN_SHELL_LINE))
     .join("\n")
     .replace(/\n{3,}/g, "\n\n");
 
@@ -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;
 }
 
@@ -360,12 +333,13 @@ async function runFocus(): Promise<void> {
     return;
   }
 
-  // Otherwise, ensure server + toggle sidebar on
+  // Otherwise, ensure server + open sidebar
   if (!(await ensureServerUp())) process.exit(0);
   const ctx = tmuxContext();
-  await fetch(`http://${SERVER_HOST}:${SERVER_PORT}/toggle`, { method: "POST", body: ctx }).catch(
-    () => {},
-  );
+  await fetch(`http://${SERVER_HOST}:${SERVER_PORT}/ensure-sidebar`, {
+    method: "POST",
+    body: ctx,
+  }).catch(() => {});
 
   // Wait for sidebar pane to appear
   for (let i = 0; i < 20; i++) {
@@ -381,7 +355,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 +381,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 +449,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"');
+  });
+});