@towles/tool 0.0.62 → 0.0.64

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

@@ -0,0 +1,139 @@
+import { rmSync } from "node:fs";
+import { join } from "node:path";
+
+import { Flags } from "@oclif/core";
+import consola from "consola";
+import { colors } from "consola/utils";
+import prompts from "prompts";
+
+import { BaseCommand } from "../base.js";
+import { initConfig } from "../../lib/auto-claude/index.js";
+import { LABELS, removeLabel, setLabel } from "../../lib/auto-claude/labels.js";
+import { getIssues, isGithubCliInstalled } from "../../utils/git/gh-cli-wrapper.js";
+import type { Issue } from "../../utils/git/gh-cli-wrapper.js";
+
+/**
+ * Core retry logic: swap labels on failed issues to re-trigger the pipeline.
+ * Extracted for testability.
+ */
+export async function retryIssues(
+  repo: string,
+  triggerLabel: string,
+  selected: Issue[],
+  clean: boolean,
+): Promise<number> {
+  for (const issue of selected) {
+    consola.info(`Retrying issue #${issue.number}: ${issue.title}`);
+
+    await removeLabel(repo, issue.number, LABELS.failed);
+    consola.success(`  Removed '${LABELS.failed}' label`);
+
+    await setLabel(repo, issue.number, triggerLabel);
+    consola.success(`  Added '${triggerLabel}' label`);
+
+    if (clean) {
+      const artifactDir = join(process.cwd(), `.auto-claude/issue-${issue.number}`);
+      try {
+        rmSync(artifactDir, { recursive: true, force: true });
+        consola.success(`  Cleaned artifacts: ${artifactDir}`);
+      } catch {
+        consola.warn(`  Could not clean artifacts: ${artifactDir}`);
+      }
+    }
+  }
+
+  return selected.length;
+}
+
+export default class AutoClaudeRetry extends BaseCommand {
+  static override description = "Retry failed auto-claude issues by swapping labels";
+
+  static override examples = [
+    {
+      description: "Interactively pick failed issues to retry",
+      command: "<%= config.bin %> auto-claude retry",
+    },
+    {
+      description: "Retry a specific issue",
+      command: "<%= config.bin %> auto-claude retry --issue 42",
+    },
+    {
+      description: "Retry and clean local artifacts",
+      command: "<%= config.bin %> auto-claude retry --issue 42 --clean",
+    },
+  ];
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+    issue: Flags.integer({
+      char: "i",
+      description: "Issue number to retry",
+    }),
+    clean: Flags.boolean({
+      description: "Delete local .auto-claude/issue-{N}/ artifacts",
+      default: false,
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(AutoClaudeRetry);
+
+    const cfg = await initConfig();
+
+    const cliInstalled = await isGithubCliInstalled();
+    if (!cliInstalled) {
+      this.error("GitHub CLI (gh) is not installed");
+    }
+
+    const failedIssues = await getIssues({ cwd: process.cwd(), label: LABELS.failed });
+
+    let selected: Issue[];
+
+    if (flags.issue) {
+      const match = failedIssues.find((i) => i.number === flags.issue);
+      if (!match) {
+        this.error(`Issue #${flags.issue} not found with '${LABELS.failed}' label`);
+      }
+      selected = [match];
+    } else {
+      if (failedIssues.length === 0) {
+        consola.info(`No open issues with '${LABELS.failed}' label`);
+        return;
+      }
+
+      consola.info(colors.yellow(`${failedIssues.length} failed issue(s) found`));
+
+      const choices = failedIssues.map((issue) => ({
+        title: `#${issue.number} ${issue.title}`,
+        value: issue.number,
+      }));
+
+      const result = await prompts(
+        {
+          name: "selected",
+          message: "Select issues to retry:",
+          type: "multiselect",
+          choices,
+          instructions: false,
+          hint: "- Space to select, Enter to confirm",
+        },
+        {
+          onCancel: () => {
+            consola.info(colors.dim("Canceled"));
+            this.exit(0);
+          },
+        },
+      );
+
+      if (!result.selected || result.selected.length === 0) {
+        consola.info(colors.dim("No issues selected"));
+        return;
+      }
+
+      selected = failedIssues.filter((i) => result.selected.includes(i.number));
+    }
+
+    const count = await retryIssues(cfg.repo, cfg.triggerLabel, selected, flags.clean);
+    consola.box(`Retried ${count} issue(s)`);
+  }
+}

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

@@ -0,0 +1,147 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+import type { Issue } from "../../utils/git/gh-cli-wrapper.js";
+import { LABELS } from "../../lib/auto-claude/labels.js";
+import { checkArtifacts, findAcLabel, formatIssueStatus } from "./status.js";
+
+// ── Test fixtures ──
+
+function makeIssue(overrides: Partial<Issue> = {}): Issue {
+  return {
+    number: 1,
+    title: "Test issue",
+    state: "open",
+    labels: [{ name: "auto-claude", color: "000000" }],
+    ...overrides,
+  };
+}
+
+// ── checkArtifacts ──
+
+describe("checkArtifacts", () => {
+  let tmpDir: string;
+
+  beforeAll(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "ac-status-test-"));
+  });
+
+  afterAll(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("returns all false when no artifacts exist", () => {
+    const result = checkArtifacts(99, tmpDir);
+    expect(result).toHaveLength(4);
+    for (const a of result) {
+      expect(a.exists).toBe(false);
+    }
+  });
+
+  it("detects existing artifacts", () => {
+    const issueDir = join(tmpDir, ".auto-claude/issue-42");
+    mkdirSync(issueDir, { recursive: true });
+    writeFileSync(join(issueDir, "plan.md"), "# Plan");
+    writeFileSync(join(issueDir, "review.md"), "# Review");
+
+    const result = checkArtifacts(42, tmpDir);
+    const planArtifact = result.find((a) => a.name === "plan.md");
+    const reviewArtifact = result.find((a) => a.name === "review.md");
+    const summaryArtifact = result.find((a) => a.name === "completed-summary.md");
+
+    expect(planArtifact?.exists).toBe(true);
+    expect(reviewArtifact?.exists).toBe(true);
+    expect(summaryArtifact?.exists).toBe(false);
+  });
+});
+
+// ── findAcLabel ──
+
+describe("findAcLabel", () => {
+  it("returns specific status label when present", () => {
+    const issue = makeIssue({
+      labels: [
+        { name: "auto-claude", color: "000000" },
+        { name: LABELS.inProgress, color: "ffff00" },
+      ],
+    });
+    expect(findAcLabel(issue)).toBe(LABELS.inProgress);
+  });
+
+  it("falls back to auto-claude when no status label", () => {
+    const issue = makeIssue({
+      labels: [{ name: "auto-claude", color: "000000" }],
+    });
+    expect(findAcLabel(issue)).toBe("auto-claude");
+  });
+
+  it("prefers in-progress over other labels", () => {
+    const issue = makeIssue({
+      labels: [
+        { name: LABELS.inProgress, color: "ffff00" },
+        { name: LABELS.success, color: "00ff00" },
+      ],
+    });
+    expect(findAcLabel(issue)).toBe(LABELS.inProgress);
+  });
+});
+
+// ── formatIssueStatus ──
+
+describe("formatIssueStatus", () => {
+  it("includes issue number and title", () => {
+    const issue = makeIssue({ number: 7, title: "Fix widget" });
+    const artifacts = [
+      { name: "plan.md", exists: false },
+      { name: "completed-summary.md", exists: false },
+      { name: "simplify-summary.md", exists: false },
+      { name: "review.md", exists: false },
+    ];
+    const output = formatIssueStatus(issue, artifacts);
+    expect(output).toContain("#7");
+    expect(output).toContain("Fix widget");
+  });
+
+  it("includes status tag", () => {
+    const issue = makeIssue({
+      labels: [{ name: LABELS.failed, color: "ff0000" }],
+    });
+    const artifacts = [
+      { name: "plan.md", exists: false },
+      { name: "completed-summary.md", exists: false },
+      { name: "simplify-summary.md", exists: false },
+      { name: "review.md", exists: false },
+    ];
+    const output = formatIssueStatus(issue, artifacts);
+    expect(output).toContain("failed");
+  });
+
+  it("shows completed artifacts", () => {
+    const issue = makeIssue();
+    const artifacts = [
+      { name: "plan.md", exists: true },
+      { name: "completed-summary.md", exists: true },
+      { name: "simplify-summary.md", exists: false },
+      { name: "review.md", exists: false },
+    ];
+    const output = formatIssueStatus(issue, artifacts);
+    expect(output).toContain("plan.md");
+    expect(output).toContain("completed-summary.md");
+    expect(output).not.toContain("simplify-summary.md");
+  });
+
+  it("omits artifacts line when none exist", () => {
+    const issue = makeIssue();
+    const artifacts = [
+      { name: "plan.md", exists: false },
+      { name: "completed-summary.md", exists: false },
+      { name: "simplify-summary.md", exists: false },
+      { name: "review.md", exists: false },
+    ];
+    const output = formatIssueStatus(issue, artifacts);
+    expect(output).not.toContain("artifacts:");
+  });
+});

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

@@ -0,0 +1,123 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+import consola from "consola";
+import { colors } from "consola/utils";
+
+import type { Issue } from "../../utils/git/gh-cli-wrapper.js";
+import { getIssues, isGithubCliInstalled } from "../../utils/git/gh-cli-wrapper.js";
+import { ARTIFACTS } from "../../lib/auto-claude/prompt-templates/index.js";
+import { LABELS } from "../../lib/auto-claude/labels.js";
+import { BaseCommand } from "../base.js";
+
+/** All labels that indicate an issue is part of the auto-claude pipeline. */
+const ALL_AC_LABELS = ["auto-claude", ...Object.values(LABELS)] as const;
+
+/** Display config per label: short name + color function. */
+const LABEL_DISPLAY: Record<string, { status: string; color: (t: string) => string }> = {
+  [LABELS.inProgress]: { status: "in-progress", color: colors.yellow },
+  [LABELS.success]: { status: "success", color: colors.green },
+  [LABELS.failed]: { status: "failed", color: colors.red },
+  [LABELS.review]: { status: "review", color: colors.blue },
+};
+
+const DEFAULT_DISPLAY = { status: "queued", color: colors.dim };
+
+interface ArtifactStatus {
+  name: string;
+  exists: boolean;
+}
+
+/** Pipeline artifacts to check, in pipeline order. */
+const CHECKED_ARTIFACTS = [
+  ARTIFACTS.plan,
+  ARTIFACTS.completedSummary,
+  ARTIFACTS.simplifySummary,
+  ARTIFACTS.review,
+] as const;
+
+/** Check which pipeline artifacts exist locally for an issue. */
+export function checkArtifacts(issueNumber: number, cwd: string): ArtifactStatus[] {
+  const issueDir = join(cwd, `.auto-claude/issue-${issueNumber}`);
+  return CHECKED_ARTIFACTS.map((name) => ({ name, exists: existsSync(join(issueDir, name)) }));
+}
+
+/** Find the most specific auto-claude label on an issue. */
+export function findAcLabel(issue: Issue): string {
+  const labelNames = issue.labels.map((l) => l.name);
+  // Prefer the most specific status label; fall back to generic "auto-claude"
+  for (const label of Object.values(LABELS)) {
+    if (labelNames.includes(label)) return label;
+  }
+  return "auto-claude";
+}
+
+/** Format a single issue for display. */
+export function formatIssueStatus(issue: Issue, artifacts: ArtifactStatus[]): string {
+  const label = findAcLabel(issue);
+  const { status, color } = LABEL_DISPLAY[label] ?? DEFAULT_DISPLAY;
+  const statusTag = color(`[${status}]`);
+
+  const parts: string[] = [`#${issue.number} ${issue.title} ${statusTag}`];
+
+  const completedSteps = artifacts.filter((a) => a.exists).map((a) => a.name);
+  if (completedSteps.length > 0) {
+    parts.push(colors.dim(`  artifacts: ${completedSteps.join(", ")}`));
+  }
+
+  return parts.join("\n");
+}
+
+/** Fetch issues across all auto-claude labels, deduplicating by issue number. */
+export async function fetchAllAcIssues(cwd: string): Promise<Issue[]> {
+  const issueMap = new Map<number, Issue>();
+
+  const results = await Promise.all(ALL_AC_LABELS.map((label) => getIssues({ cwd, label })));
+
+  for (const issues of results) {
+    for (const issue of issues) {
+      if (!issueMap.has(issue.number)) {
+        issueMap.set(issue.number, issue);
+      }
+    }
+  }
+
+  // Sort by issue number ascending
+  return [...issueMap.values()].sort((a, b) => a.number - b.number);
+}
+
+export default class AutoClaudeStatus extends BaseCommand {
+  static override description = "Show pipeline status for auto-claude issues";
+
+  static override aliases = ["ac:status"];
+
+  static override examples = [
+    {
+      description: "Show status of all auto-claude issues",
+      command: "<%= config.bin %> auto-claude status",
+    },
+  ];
+
+  async run(): Promise<void> {
+    const cliInstalled = await isGithubCliInstalled();
+    if (!cliInstalled) {
+      this.error("GitHub CLI (gh) is not installed");
+    }
+
+    const cwd = process.cwd();
+    const issues = await fetchAllAcIssues(cwd);
+
+    if (issues.length === 0) {
+      consola.info("No auto-claude issues found");
+      return;
+    }
+
+    consola.info(colors.bold(`Auto-Claude Pipeline Status (${issues.length} issue(s))`));
+    consola.log("");
+
+    for (const issue of issues) {
+      const artifacts = checkArtifacts(issue.number, cwd);
+      consola.log(formatIssueStatus(issue, artifacts));
+    }
+  }
+}

package/src/commands/base.ts

@@ -15,13 +15,18 @@ export abstract class BaseCommand extends Command {
     }),
   };
 
-  protected settings!: SettingsFile;
+  protected settingsFile!: SettingsFile;
+
+  /** Shortcut to avoid `this.settingsFile.settings.X` stutter */
+  protected get userSettings() {
+    return this.settingsFile.settings;
+  }
 
   /**
    * Called before run(). Loads user settings.
    */
   async init(): Promise<void> {
     await super.init();
-    this.settings = await loadSettings();
+    this.settingsFile = await loadSettings();
   }
 }

package/src/commands/config.ts

@@ -18,18 +18,16 @@ export default class Config extends BaseCommand {
     consola.info("Configuration");
     consola.log("");
 
-    consola.info(`Settings File: ${this.settings.path}`);
+    consola.info(`Settings File: ${this.settingsFile.path}`);
     consola.log("");
 
     consola.warn("User Config:");
+    consola.log(`  Daily Path Template: ${this.userSettings.journalSettings.dailyPathTemplate}`);
     consola.log(
-      `  Daily Path Template: ${this.settings.settings.journalSettings.dailyPathTemplate}`,
+      `  Meeting Path Template: ${this.userSettings.journalSettings.meetingPathTemplate}`,
     );
-    consola.log(
-      `  Meeting Path Template: ${this.settings.settings.journalSettings.meetingPathTemplate}`,
-    );
-    consola.log(`  Note Path Template: ${this.settings.settings.journalSettings.notePathTemplate}`);
-    consola.log(`  Editor: ${this.settings.settings.preferredEditor}`);
+    consola.log(`  Note Path Template: ${this.userSettings.journalSettings.notePathTemplate}`);
+    consola.log(`  Editor: ${this.userSettings.preferredEditor}`);
     consola.log("");
 
     consola.warn("Working Directory:");

package/src/commands/doctor.ts

@@ -1,5 +1,8 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve, join } from "node:path";
+import consola from "consola";
 import { x } from "tinyexec";
-import pc from "picocolors";
+import { colors } from "consola/utils";
 import { BaseCommand } from "./base.js";
 
 interface CheckResult {
@@ -31,25 +34,32 @@ export default class Doctor extends BaseCommand {
       this.checkCommand("node", ["--version"], /v?([\d.]+)/),
       this.checkCommand("bun", ["--version"], /([\d.]+)/),
       this.checkCommand("pnpm", ["--version"], /([\d.]+)/),
+      this.checkCommand("claude", ["--version"], /([\d.]+)/),
+      this.checkCommand("tmux", ["-V"], /tmux ([\d.]+)/),
+      this.checkCommand("ttyd", ["--version"], /ttyd version ([\d.]+)/, true),
     ]);
 
     // Display results
     for (const check of checks) {
-      const icon = check.ok ? pc.green("✓") : pc.red("✗");
+      const icon = check.ok
+        ? colors.green("✓")
+        : check.warning
+          ? colors.yellow("⚠")
+          : colors.red("✗");
       const version = check.version ?? "not found";
       this.log(`${icon} ${check.name}: ${version}`);
       if (check.warning) {
-        this.log(`  ${pc.yellow("⚠")} ${check.warning}`);
+        this.log(`  ${colors.yellow("⚠")} ${check.warning}`);
       }
     }
 
     // Check gh auth
     this.log("");
     const ghAuth = await this.checkGhAuth();
-    const authIcon = ghAuth.ok ? pc.green("✓") : pc.yellow("⚠");
+    const authIcon = ghAuth.ok ? colors.green("✓") : colors.yellow("⚠");
     this.log(`${authIcon} gh auth: ${ghAuth.ok ? "authenticated" : "not authenticated"}`);
     if (!ghAuth.ok) {
-      this.log(`  ${pc.dim("Run: gh auth login")}`);
+      this.log(`  ${colors.dim("Run: gh auth login")}`);
     }
 
     // Node version check
@@ -58,7 +68,7 @@ export default class Doctor extends BaseCommand {
       const major = Number.parseInt(nodeCheck.version.split(".")[0], 10);
       if (major < 18) {
         this.log("");
-        this.log(`${pc.yellow("⚠")} Node.js 18+ recommended (found ${nodeCheck.version})`);
+        this.log(`${colors.yellow("⚠")} Node.js 18+ recommended (found ${nodeCheck.version})`);
       }
     }
 
@@ -66,21 +76,41 @@ export default class Doctor extends BaseCommand {
     this.log("");
     const pluginChecks = await this.checkClaudePlugins();
     for (const check of pluginChecks) {
-      const icon = check.ok ? pc.green("✓") : pc.red("✗");
+      const icon = check.ok ? colors.green("✓") : colors.red("✗");
       const status = check.ok ? "installed" : "not installed";
       this.log(`${icon} claude plugin ${check.name}: ${status}`);
       if (!check.ok && check.installHint) {
-        this.log(`  ${pc.dim(check.installHint)}`);
+        this.log(`  ${colors.dim(check.installHint)}`);
+      }
+    }
+
+    // AgentBoard checks
+    this.log("");
+    this.log(colors.bold("AgentBoard:"));
+    const agentboardChecks = this.checkAgentBoard();
+    for (const check of agentboardChecks) {
+      const icon = check.ok
+        ? colors.green("✓")
+        : check.warning
+          ? colors.yellow("⚠")
+          : colors.red("✗");
+      this.log(`${icon} ${check.name}: ${check.value}`);
+      if (check.hint) {
+        this.log(`  ${colors.dim(check.hint)}`);
       }
     }
 
     // Summary
-    const allOk = checks.every((c) => c.ok) && ghAuth.ok && pluginChecks.every((c) => c.ok);
+    const allOk =
+      checks.every((c) => c.ok || !!c.warning) &&
+      ghAuth.ok &&
+      pluginChecks.every((c) => c.ok) &&
+      agentboardChecks.every((c) => c.ok || !!c.warning);
     this.log("");
     if (allOk) {
-      this.log(pc.green("All checks passed!"));
+      this.log(colors.green("All checks passed!"));
     } else {
-      this.log(pc.yellow("Some checks failed. See above for details."));
+      this.log(colors.yellow("Some checks failed. See above for details."));
     }
   }
 
@@ -88,6 +118,7 @@ export default class Doctor extends BaseCommand {
     name: string,
     args: string[],
     versionPattern: RegExp,
+    optional = false,
   ): Promise<CheckResult> {
     try {
       // tinyexec is safe - uses execFile internally, no shell injection risk
@@ -100,7 +131,13 @@ export default class Doctor extends BaseCommand {
         ok: true,
       };
     } catch {
-      return { name, version: null, ok: false };
+      consola.debug(`Tool check failed for "${name}"`);
+      return {
+        name,
+        version: null,
+        ok: optional,
+        warning: optional ? "optional, not installed" : undefined,
+      };
     }
   }
 
@@ -110,10 +147,71 @@ export default class Doctor extends BaseCommand {
       const result = await x("gh", ["auth", "status"]);
       return { ok: result.exitCode === 0 };
     } catch {
+      consola.debug("GitHub CLI auth check failed");
       return { ok: false };
     }
   }
 
+  private checkAgentBoard(): {
+    name: string;
+    value: string;
+    ok: boolean;
+    warning?: string;
+    hint?: string;
+  }[] {
+    const results: { name: string; value: string; ok: boolean; warning?: string; hint?: string }[] =
+      [];
+
+    const defaultDataDir = resolve(
+      process.env.XDG_CONFIG_HOME ?? resolve(process.env.HOME ?? "~", ".config"),
+      "towles-tool",
+      "agentboard",
+    );
+    const dataDir = process.env.AGENTBOARD_DATA_DIR ?? defaultDataDir;
+    const dbPath = join(dataDir, "agentboard.db");
+    const configPath = join(dataDir, "config.json");
+
+    // DB exists
+    const dbExists = existsSync(dbPath);
+    results.push({
+      name: "database",
+      value: dbExists ? dbPath : "not found",
+      ok: dbExists,
+      hint: dbExists ? undefined : "Run: tt ag (starts server and creates DB automatically)",
+    });
+
+    // Config exists with repoPaths
+    let repoPaths: string[] = [];
+    if (existsSync(configPath)) {
+      try {
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        repoPaths = config.repoPaths ?? [];
+      } catch {
+        // Corrupted config
+      }
+    }
+
+    results.push({
+      name: "scan paths",
+      value: repoPaths.length > 0 ? repoPaths.join(", ") : "none configured",
+      ok: repoPaths.length > 0,
+      warning: repoPaths.length === 0 ? "no scan paths" : undefined,
+      hint:
+        repoPaths.length === 0
+          ? "Run: tt ag → open Workspaces → run the onboarding wizard"
+          : undefined,
+    });
+
+    // Data directory
+    results.push({
+      name: "data dir",
+      value: dataDir,
+      ok: true,
+    });
+
+    return results;
+  }
+
   private async checkClaudePlugins(): Promise<
     { name: string; ok: boolean; installHint?: string }[]
   > {
@@ -136,6 +234,7 @@ export default class Doctor extends BaseCommand {
         installHint: installedIds.has(p.id) ? undefined : `Run: ${p.installCmd}`,
       }));
     } catch {
+      consola.debug("Failed to list Claude plugins");
       return requiredPlugins.map((p) => ({
         name: p.name,
         ok: false,

package/src/commands/gh/branch.ts

@@ -1,15 +1,14 @@
 import { Flags } from "@oclif/core";
+import consola from "consola";
 import prompts from "prompts";
 import type { Choice } from "prompts";
 import { colors } from "consola/utils";
 import { Fzf } from "fzf";
-import consola from "consola";
-
-import { exec } from "tinyexec";
 
 import { BaseCommand } from "../base.js";
 import type { Issue } from "../../utils/git/gh-cli-wrapper.js";
 import { getIssues, isGithubCliInstalled } from "../../utils/git/gh-cli-wrapper.js";
+import { git } from "../../utils/git/exec.js";
 import { createBranchNameFromIssue } from "../../utils/git/branch-name.js";
 import { getTerminalColumns, limitText, printWithHexColor } from "../../utils/render.js";
 
@@ -131,8 +130,9 @@ export default class GhBranch extends BaseCommand {
       );
 
       const branchName = createBranchNameFromIssue(selectedIssue);
-      await exec("git", ["checkout", "-b", branchName]);
+      await git(["checkout", "-b", branchName]);
     } catch {
+      consola.debug("Branch checkout failed");
       this.exit(1);
     }
   }