@ramarivera/coding-buddy 0.4.0-alpha.1

package/cli/pick.ts

@@ -0,0 +1,492 @@
+#!/usr/bin/env bun
+/**
+ * cli/pick.ts — interactive two-pane buddy picker
+ *
+ *  Left pane                    │  Right pane
+ *  ─────────────────────────    │  ──────────────────────
+ *  Saved:   list of slots       │  full companion card
+ *  Criteria: search form        │
+ *  Results: matched buddies     │  preview of highlighted
+ *  Naming:  name + save prompt  │  card with live name
+ *
+ * Keys — Saved:    ↑↓ navigate  [enter] summon  [r] random  [s] search  [q] quit
+ * Keys — Criteria: ↑↓ field     ←→ value        [enter] run  [esc] back
+ * Keys — Results:  ↑↓ navigate  [enter] pick     [esc] back  [q] quit
+ * Keys — Naming:   type name    [enter] save      [esc] cancel
+ */
+
+import {
+  loadActiveSlot, saveActiveSlot, listCompanionSlots,
+  loadCompanionSlot, saveCompanionSlot, slugify, unusedName, writeStatusState,
+} from "../server/state.ts";
+import {
+  generateBones, SPECIES, RARITIES, STAT_NAMES, RARITY_STARS,
+  type Species, type Rarity, type StatName, type BuddyBones, type Companion,
+} from "../server/engine.ts";
+import { renderCompanionCard } from "../server/art.ts";
+import { randomBytes } from "crypto";
+
+// ─── ANSI ─────────────────────────────────────────────────────────────────────
+
+const RARITY_CLR: Record<string, string> = {
+  common:    "\x1b[38;2;153;153;153m",
+  uncommon:  "\x1b[38;2;78;186;101m",
+  rare:      "\x1b[38;2;177;185;249m",
+  epic:      "\x1b[38;2;175;135;255m",
+  legendary: "\x1b[38;2;255;193;7m",
+};
+const B  = "\x1b[1m";
+const D  = "\x1b[2m";
+const RV = "\x1b[7m";
+const N  = "\x1b[0m";
+const CY = "\x1b[36m";
+const GR = "\x1b[90m";
+const YL = "\x1b[33m";
+const GN = "\x1b[32m";
+
+function stripAnsi(s: string): string { return s.replace(/\x1b\[[^m]*m/g, ""); }
+
+// Wide characters: emojis, some Unicode symbols take 2 display columns
+function charWidth(cp: number): number {
+  // Emoji modifiers, variation selectors, ZWJ
+  if (cp >= 0xFE00 && cp <= 0xFE0F) return 0;
+  if (cp === 0x200D) return 0;
+  // Common wide ranges: CJK, emoji, fullwidth, braille, box-drawing stars etc.
+  if (cp >= 0x1F000) return 2;  // Most emoji (sparkles ✨ = U+2728 is below this)
+  if (cp === 0x2728) return 2;  // ✨ Sparkles
+  if (cp >= 0x2600 && cp <= 0x27BF) return 1;  // Misc symbols (★ ☆ etc.) — typically 1 col
+  if (cp >= 0x2500 && cp <= 0x257F) return 1;  // Box drawing
+  if (cp >= 0x2580 && cp <= 0x259F) return 1;  // Block elements (█░)
+  if (cp >= 0x3000 && cp <= 0x9FFF) return 2;  // CJK
+  if (cp >= 0xF900 && cp <= 0xFAFF) return 2;  // CJK compat
+  if (cp >= 0xFF01 && cp <= 0xFF60) return 2;  // Fullwidth
+  return 1;
+}
+
+function vlen(s: string): number {
+  const clean = stripAnsi(s);
+  let w = 0;
+  for (const ch of clean) {
+    w += charWidth(ch.codePointAt(0)!);
+  }
+  return w;
+}
+
+function rpad(s: string, w: number): string {
+  const v = vlen(s);
+  return v < w ? s + " ".repeat(w - v) : s;
+}
+
+// ─── Option lists ─────────────────────────────────────────────────────────────
+
+const SP_OPTS = ["any", ...SPECIES]    as const;
+const RA_OPTS = ["any", ...RARITIES]   as const;
+const SH_OPTS = ["any", "yes", "no"]   as const;
+const ST_OPTS = ["any", ...STAT_NAMES] as const;
+
+const CRITERIA_ROWS: Array<{ label: string; opts: readonly string[] }> = [
+  { label: "Species", opts: SP_OPTS },
+  { label: "Rarity ", opts: RA_OPTS },
+  { label: "Shiny  ", opts: SH_OPTS },
+  { label: "Peak   ", opts: ST_OPTS },
+  { label: "Dump   ", opts: ST_OPTS },
+];
+
+// ─── State ────────────────────────────────────────────────────────────────────
+
+type Mode = "saved" | "criteria" | "results" | "naming";
+interface SlotEntry   { slot: string; companion: Companion; }
+interface BuddyResult { userId: string; bones: BuddyBones; }
+
+interface State {
+  mode:          Mode;
+  savedSlots:    SlotEntry[];
+  savedCursor:   number;
+  activeSlot:    string;
+  criteriaFocus: number;
+  ci:            number[];   // [speciesIdx, rarityIdx, shinyIdx, peakIdx, dumpIdx]
+  results:       BuddyResult[];
+  resultCursor:  number;
+  searchStatus:  string;
+  nameInput:     string;
+  pendingResult: BuddyResult | null;
+  message:       string;
+}
+
+function fresh(): State {
+  return {
+    mode:          "saved",
+    savedSlots:    listCompanionSlots(),
+    savedCursor:   0,
+    activeSlot:    loadActiveSlot(),
+    criteriaFocus: 0,
+    // Default criteria: legendary, any species
+    ci: [0, RA_OPTS.indexOf("legendary"), 0, 0, 0],
+    results:       [],
+    resultCursor:  0,
+    searchStatus:  "",
+    nameInput:     "",
+    pendingResult: null,
+    message:       "",
+  };
+}
+
+// ─── Pane builders ────────────────────────────────────────────────────────────
+
+const LEFT_W = 36;
+
+function savedPane(s: State): string[] {
+  const lines: string[] = [];
+  lines.push(`${B}  Your Menagerie${N}  ${GR}[s] search${N}`);
+  lines.push(GR + "  " + "─".repeat(LEFT_W - 2) + N);
+
+  if (s.savedSlots.length === 0) {
+    lines.push(`  ${GR}your menagerie is empty${N}`);
+    lines.push(`  ${GR}press [s] to search${N}`);
+  }
+
+  for (let i = 0; i < s.savedSlots.length; i++) {
+    const { slot, companion: c } = s.savedSlots[i];
+    const isActive = slot === s.activeSlot;
+    const isCursor = i === s.savedCursor;
+    const dot  = isActive ? `${GN}●${N}` : " ";
+    const clr  = RARITY_CLR[c.bones.rarity] ?? "";
+    const star = RARITY_STARS[c.bones.rarity];
+    const shiny = c.bones.shiny ? "✨" : "  ";
+    const name  = c.name.slice(0, 11).padEnd(11);
+    const sp    = c.bones.species.slice(0, 7).padEnd(7);
+    const row   = ` ${dot} ${clr}${name}${N} ${GR}${sp}${N} ${clr}${star}${N} ${shiny}`;
+    lines.push(isCursor ? RV + row + N : row);
+  }
+
+  lines.push(GR + "  " + "─".repeat(LEFT_W - 2) + N);
+  return lines;
+}
+
+function criteriaPane(s: State): string[] {
+  const lines: string[] = [];
+  lines.push(`${B}  Search Criteria${N}`);
+  lines.push(GR + "  " + "─".repeat(LEFT_W - 2) + N);
+
+  for (let i = 0; i < CRITERIA_ROWS.length; i++) {
+    const { label, opts } = CRITERIA_ROWS[i];
+    const val     = opts[s.ci[i]];
+    const focus   = i === s.criteriaFocus;
+    const clr     = RARITY_CLR[val] ?? "";
+    const arrow   = focus ? `${YL}>${N}` : " ";
+    const valDisp = focus
+      ? `${RV}${B} ${val.padEnd(11)} ${N}`
+      : `${D}${clr} ${val.padEnd(11)} ${N}`;
+    lines.push(`  ${arrow} ${GR}${label}${N}  ${valDisp}  ${GR}←→${N}`);
+  }
+
+  lines.push(GR + "  " + "─".repeat(LEFT_W - 2) + N);
+  if (s.searchStatus) lines.push(`  ${YL}${s.searchStatus}${N}`);
+  return lines;
+}
+
+function resultsPane(s: State): string[] {
+  const lines: string[] = [];
+  lines.push(`${B}  Results${N}  ${GR}${s.results.length} found${N}`);
+  lines.push(GR + "  " + "─".repeat(LEFT_W - 2) + N);
+
+  if (s.results.length === 0) {
+    lines.push(`  ${GR}no matches — try broader criteria${N}`);
+  }
+
+  // Scrolling window
+  const viewH  = 12;
+  const offset = Math.max(0, s.resultCursor - Math.floor(viewH / 2));
+  for (let i = offset; i < Math.min(s.results.length, offset + viewH); i++) {
+    const b      = s.results[i].bones;
+    const sel    = i === s.resultCursor;
+    const clr    = RARITY_CLR[b.rarity] ?? "";
+    const star   = RARITY_STARS[b.rarity];
+    const shiny  = b.shiny ? "✨" : "  ";
+    const ra     = b.rarity.slice(0, 3);
+    const sp     = b.species.padEnd(8);
+    const eye    = `e:${b.eye}`;
+    const hat    = `h:${b.hat.slice(0, 6).padEnd(6)}`;
+    const row    = `  ${clr}${ra}${N} ${sp} ${GR}${eye} ${hat}${N} ${shiny}`;
+    lines.push(sel ? RV + row + N : row);
+  }
+
+  lines.push(GR + "  " + "─".repeat(LEFT_W - 2) + N);
+  return lines;
+}
+
+function namingPane(s: State): string[] {
+  const b   = s.pendingResult?.bones;
+  const clr = b ? (RARITY_CLR[b.rarity] ?? "") : "";
+  const lines: string[] = [];
+  lines.push(`${B}  Name this buddy${N}`);
+  if (b) lines.push(`  ${clr}${b.rarity} ${b.species}${N}`);
+  lines.push(GR + "  " + "─".repeat(LEFT_W - 2) + N);
+  lines.push(`  ${B}Name:${N} ${s.nameInput}${YL}▌${N}`);
+  lines.push(`  ${GR}(type a name, or enter for random)${N}`);
+  return lines;
+}
+
+function previewPane(s: State): string[] {
+  let c: Companion | null = null;
+
+  if (s.mode === "saved") {
+    c = s.savedSlots[s.savedCursor]?.companion ?? null;
+  } else if (s.mode === "results") {
+    const r = s.results[s.resultCursor];
+    if (r) c = {
+      bones: r.bones, name: "???",
+      personality: `A ${r.bones.rarity} ${r.bones.species}`,
+      hatchedAt: Date.now(), userId: r.userId,
+    };
+  } else if (s.mode === "naming" && s.pendingResult) {
+    const r = s.pendingResult;
+    c = {
+      bones: r.bones, name: s.nameInput || "???",
+      personality: `A ${r.bones.rarity} ${r.bones.species} who watches code with quiet intensity.`,
+      hatchedAt: Date.now(), userId: r.userId,
+    };
+  }
+
+  if (!c) return [`  ${GR}no preview${N}`];
+  // Calculate available width for the right pane (total cols - left pane - separator)
+  const cols = Math.max(80, process.stdout.columns || 80);
+  const rightW = cols - LEFT_W - 3;
+  return renderCompanionCard(c.bones, c.name, c.personality, undefined, 0, rightW).split("\n");
+}
+
+// ─── Screen render ────────────────────────────────────────────────────────────
+
+function drawScreen(s: State): void {
+  const cols = Math.max(80, process.stdout.columns || 80);
+  const rows = Math.max(20, process.stdout.rows    || 24);
+
+  const leftLines  = s.mode === "saved"    ? savedPane(s)
+                   : s.mode === "criteria" ? criteriaPane(s)
+                   : s.mode === "results"  ? resultsPane(s)
+                   : namingPane(s);
+  const rightLines = previewPane(s);
+  const contentH   = rows - 2;
+
+  let out = "\x1b[2J\x1b[H"; // clear + home
+
+  // Title bar
+  const title    = ` claude-buddy pick `;
+  const fill     = "─".repeat(Math.max(0, cols - title.length - 2));
+  out += `${CY}─${B}${title}${N}${CY}${fill}─${N}\n`;
+
+  // Content rows
+  for (let i = 0; i < contentH; i++) {
+    const l = rpad(leftLines[i] ?? "", LEFT_W);
+    const r = rightLines[i] ?? "";
+    out += l + GR + "│" + N + " " + r + "\n";
+  }
+
+  // Footer — mode-specific help
+  const helpText =
+    s.mode === "saved"    ? "↑↓ navigate  enter summon  r random  s search  q quit" :
+    s.mode === "criteria" ? "↑↓ field  ←→ value  enter search  esc back" :
+    s.mode === "results"  ? "↑↓ navigate  enter name+save  esc back  q quit" :
+    s.mode === "naming"   ? "type name  enter save  esc cancel" : "";
+  out += `${GR}─${N} ${GR}${helpText}${N} ${GR}${"─".repeat(Math.max(0, cols - helpText.length - 4))}${N}`;
+
+  // Message overlay on last line
+  if (s.message) {
+    out += `\x1b[${rows};1H  ${GN}${B}${s.message}${N}`;
+  }
+
+  process.stdout.write(out);
+}
+
+// ─── Search ───────────────────────────────────────────────────────────────────
+
+function runSearch(s: State): void {
+  const wantSp    = SP_OPTS[s.ci[0]] !== "any" ? SP_OPTS[s.ci[0]] as Species  : null;
+  const wantRa    = RA_OPTS[s.ci[1]] !== "any" ? RA_OPTS[s.ci[1]] as Rarity   : null;
+  const wantShiny = SH_OPTS[s.ci[2]] === "yes" ? true
+                  : SH_OPTS[s.ci[2]] === "no"  ? false : null;
+  const wantPeak  = ST_OPTS[s.ci[3]] !== "any" ? ST_OPTS[s.ci[3]] as StatName : null;
+  const wantDump  = ST_OPTS[s.ci[4]] !== "any" ? ST_OPTS[s.ci[4]] as StatName : null;
+
+  // Scale attempt budget to rarity difficulty
+  const maxAttempts =
+    wantRa === "legendary" ? 200_000_000 :
+    wantRa === "epic"      ?  50_000_000 :
+    wantRa === "rare"      ?  20_000_000 : 10_000_000;
+
+  const results: BuddyResult[] = [];
+  const progressRow = (process.stdout.rows || 24) - 1;
+
+  for (let i = 0; i < maxAttempts && results.length < 20; i++) {
+    if (i > 0 && i % 1_000_000 === 0) {
+      s.searchStatus = `${(i / 1e6).toFixed(0)}M checked — ${results.length} found`;
+      process.stdout.write(
+        `\x1b[${progressRow};1H  ${YL}${s.searchStatus}${N}   \x1b[K`,
+      );
+    }
+
+    const userId = randomBytes(16).toString("hex");
+    const bones  = generateBones(userId);
+
+    if (wantSp    !== null && bones.species !== wantSp)    continue;
+    if (wantRa    !== null && bones.rarity  !== wantRa)    continue;
+    if (wantShiny !== null && bones.shiny   !== wantShiny) continue;
+    if (wantPeak  !== null && bones.peak    !== wantPeak)  continue;
+    if (wantDump  !== null && bones.dump    !== wantDump)  continue;
+
+    results.push({ userId, bones });
+  }
+
+  s.searchStatus = `${results.length} found`;
+  s.results      = results;
+  s.resultCursor = 0;
+  s.mode         = "results";
+}
+
+// ─── Key handlers ─────────────────────────────────────────────────────────────
+
+function clamp(v: number, lo: number, hi: number) { return Math.max(lo, Math.min(hi, v)); }
+
+/** Returns true if the TUI should exit. */
+function onKey(key: string, s: State): boolean {
+  if (key === "\x03") return true;  // Ctrl+C always quits
+
+  switch (s.mode) {
+    case "naming": {
+      if (key === "\x1b") {
+        s.mode = "results"; s.nameInput = ""; s.pendingResult = null;
+      } else if (key === "\r" || key === "\n") {
+        // Empty input → auto-pick a random unused name
+        const name = s.nameInput.trim() || unusedName();
+        const slot = slugify(name);
+        if (loadCompanionSlot(slot)) {
+          s.message = `"${slot}" already taken — type a different name`;
+          s.nameInput = "";
+          break;
+        }
+        const r    = s.pendingResult!;
+        const companion: Companion = {
+          bones: r.bones, name,
+          personality: `A ${r.bones.rarity} ${r.bones.species} who watches code with quiet intensity.`,
+          hatchedAt: Date.now(), userId: r.userId,
+        };
+        saveCompanionSlot(companion, slot);
+        saveActiveSlot(slot);
+        writeStatusState(companion, `*${name} arrives*`);
+        s.message = `✓ ${name} saved to slot "${slot}" and set as active!`;
+        return true;
+      } else if (key === "\u007f" || key === "\b") {
+        s.nameInput = s.nameInput.slice(0, -1);
+      } else if (key.length === 1 && key >= " " && s.nameInput.length < 14) {
+        s.nameInput += key;
+      }
+      break;
+    }
+
+    case "saved": {
+      if (key === "q")                          return true;
+      if (key === "s")                          { s.mode = "criteria"; break; }
+      if (key === "\x1b[A" || key === "k")      s.savedCursor = clamp(s.savedCursor - 1, 0, s.savedSlots.length - 1);
+      else if (key === "\x1b[B" || key === "j") s.savedCursor = clamp(s.savedCursor + 1, 0, s.savedSlots.length - 1);
+      else if (key === "r") {
+        // Random pick from menagerie
+        if (s.savedSlots.length > 0) {
+          const entry = s.savedSlots[Math.floor(Math.random() * s.savedSlots.length)];
+          s.savedCursor = s.savedSlots.indexOf(entry);
+          saveActiveSlot(entry.slot);
+          writeStatusState(entry.companion, `*${entry.companion.name} arrives*`);
+          s.message = `✓ ${entry.companion.name} summoned at random!`;
+          return true;
+        }
+      } else if (key === "\r" || key === "\n") {
+        const entry = s.savedSlots[s.savedCursor];
+        if (entry) {
+          saveActiveSlot(entry.slot);
+          writeStatusState(entry.companion, `*${entry.companion.name} arrives*`);
+          s.message = `✓ ${entry.companion.name} summoned!`;
+          return true;
+        }
+      }
+      break;
+    }
+
+    case "criteria": {
+      if (key === "q")                          return true;
+      if (key === "\x1b")                       { s.mode = "saved"; break; }
+      if (key === "\x1b[A" || key === "k")      s.criteriaFocus = clamp(s.criteriaFocus - 1, 0, CRITERIA_ROWS.length - 1);
+      else if (key === "\x1b[B" || key === "j") s.criteriaFocus = clamp(s.criteriaFocus + 1, 0, CRITERIA_ROWS.length - 1);
+      else if (key === "\x1b[C" || key === "l") {
+        const len = CRITERIA_ROWS[s.criteriaFocus].opts.length;
+        s.ci[s.criteriaFocus] = (s.ci[s.criteriaFocus] + 1) % len;
+      } else if (key === "\x1b[D" || key === "h") {
+        const len = CRITERIA_ROWS[s.criteriaFocus].opts.length;
+        s.ci[s.criteriaFocus] = (s.ci[s.criteriaFocus] - 1 + len) % len;
+      } else if (key === "\r" || key === "\n") {
+        s.searchStatus = "Starting search...";
+        drawScreen(s);
+        runSearch(s);
+      }
+      break;
+    }
+
+    case "results": {
+      if (key === "q")                          return true;
+      if (key === "\x1b")                       { s.mode = "criteria"; break; }
+      if (key === "\x1b[A" || key === "k")      s.resultCursor = clamp(s.resultCursor - 1, 0, s.results.length - 1);
+      else if (key === "\x1b[B" || key === "j") s.resultCursor = clamp(s.resultCursor + 1, 0, s.results.length - 1);
+      else if (key === "\r" || key === "\n") {
+        const r = s.results[s.resultCursor];
+        if (r) {
+          s.pendingResult = r;
+          s.nameInput    = "";  // empty — user types name or presses Enter for auto
+          s.mode         = "naming";
+        }
+      }
+      break;
+    }
+  }
+  return false;
+}
+
+// ─── Entry point ──────────────────────────────────────────────────────────────
+
+function cleanup(): void {
+  process.stdout.write("\x1b[?25h");  // show cursor
+  try { process.stdin.setRawMode(false); } catch {}
+  process.stdin.pause();
+}
+
+async function main(): Promise<void> {
+  if (!process.stdin.isTTY) {
+    console.error("buddy pick requires an interactive terminal (TTY)");
+    process.exit(1);
+  }
+
+  process.stdout.write("\x1b[?25l");  // hide cursor
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.setEncoding("utf8");
+
+  process.on("exit", cleanup);
+  process.on("SIGINT", () => { cleanup(); process.exit(0); });
+
+  const s = fresh();
+  drawScreen(s);
+
+  await new Promise<void>((resolve) => {
+    process.stdin.on("data", (key: string) => {
+      const quit = onKey(key, s);
+      drawScreen(s);
+      if (quit) {
+        cleanup();
+        process.stdout.write("\x1b[2J\x1b[H");
+        if (s.message) console.log(`\n  ${s.message}\n`);
+        resolve();
+      }
+    });
+  });
+
+  process.exit(0);
+}
+
+main();

package/cli/settings.ts

@@ -0,0 +1,68 @@
+#!/usr/bin/env bun
+/**
+ * cli/settings.ts — View and update buddy settings
+ *
+ * Usage:
+ *   bun run settings                Show current settings
+ *   bun run settings cooldown 0     Set comment cooldown (0-300 seconds)
+ */
+
+import { loadConfig, saveConfig } from "../server/state.ts";
+
+const args = process.argv.slice(2);
+const key = args[0];
+const value = args[1];
+
+if (!key) {
+  const cfg = loadConfig();
+  console.log(`
+  claude-buddy settings
+  ─────────────────────
+  Comment cooldown:  ${cfg.commentCooldown}s    (0 = no throttling, default 30)
+  Reaction TTL:      ${cfg.reactionTTL}s    (0 = permanent, default 0)
+
+  Change:  bun run settings cooldown <seconds>
+           bun run settings ttl <seconds>
+`);
+  process.exit(0);
+}
+
+if (key === "cooldown") {
+  if (value === undefined) {
+    const cfg = loadConfig();
+    console.log(`Comment cooldown: ${cfg.commentCooldown}s`);
+    process.exit(0);
+  }
+
+  const n = parseInt(value, 10);
+  if (isNaN(n) || n < 0 || n > 300) {
+    console.error("Error: cooldown must be 0-300 (seconds)");
+    process.exit(1);
+  }
+
+  const cfg = saveConfig({ commentCooldown: n });
+  console.log(`Updated: comment cooldown → ${cfg.commentCooldown}s`);
+  process.exit(0);
+}
+
+if (key === "ttl") {
+  if (value === undefined) {
+    const cfg = loadConfig();
+    console.log(`Reaction TTL: ${cfg.reactionTTL}s`);
+    process.exit(0);
+  }
+
+  const n = parseInt(value, 10);
+  if (isNaN(n) || n < 0 || n > 300) {
+    console.error("Error: ttl must be 0-300 (seconds, 0 = permanent)");
+    process.exit(1);
+  }
+
+  const cfg = saveConfig({ reactionTTL: n });
+  console.log(`Updated: reaction TTL → ${cfg.reactionTTL}s${n === 0 ? " (permanent)" : ""}`);
+  process.exit(0);
+}
+
+console.error(`Unknown setting: ${key}`);
+console.error("Available: cooldown, ttl");
+process.exit(1);

package/cli/show.ts

@@ -0,0 +1,31 @@
+/**
+ * claude-buddy show — display current companion in terminal
+ */
+
+import { renderBuddy, renderFace, RARITY_STARS } from "../server/engine.ts";
+import { loadCompanion, loadReaction } from "../server/state.ts";
+
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const NC = "\x1b[0m";
+
+const companion = loadCompanion();
+
+if (!companion) {
+  console.log("No companion found. Run 'claude-buddy install' first.");
+  process.exit(1);
+}
+
+console.log("");
+console.log(renderBuddy(companion.bones));
+console.log("");
+console.log(`  ${BOLD}${companion.name}${NC}`);
+console.log(`  ${DIM}${companion.personality}${NC}`);
+console.log("");
+
+const reaction = loadReaction();
+if (reaction) {
+  const face = renderFace(companion.bones.species, companion.bones.eye);
+  console.log(`  ${face} "${reaction.reaction}"`);
+  console.log("");
+}

package/cli/test-statusline.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+# claude-buddy diagnostic test status line
+# Outputs multiple padding strategies + multi-line check + width check
+
+cat > /dev/null  # drain stdin
+
+# ANSI colors
+NC=$'\033[0m'
+DIM=$'\033[2m'
+GOLD=$'\033[38;2;255;193;7m'
+GREEN=$'\033[38;2;78;186;101m'
+BLUE=$'\033[38;2;87;105;247m'
+
+# Header
+echo "${DIM}--- claude-buddy statusline test ---${NC}"
+
+# Multi-line check
+echo "LINE_1_top"
+echo "LINE_2_middle"
+echo "LINE_3_bottom"
+
+# Padding strategies (each marker should align if strategy works)
+PAD=30
+echo "$(printf '%*s' "$PAD" '')|SPACE_${PAD}_END"
+B=$'\xe2\xa0\x80'
+braille=""
+for ((i=0; i<PAD; i++)); do braille="${braille}${B}"; done
+echo "${braille}|BRAILLE_${PAD}_END"
+NBSP=$'\xc2\xa0'
+nbsp=""
+for ((i=0; i<PAD; i++)); do nbsp="${nbsp}${NBSP}"; done
+echo "${nbsp}|NBSP_${PAD}_END"
+
+# Mini buddy art (mushroom)
+echo "${GOLD}-o-OO-o-${NC}"
+echo "${GOLD}(________)${NC}"
+echo "${GOLD}  |° °|${NC}"
+echo "${GOLD}  |__|${NC}"
+echo "${DIM}MUSHROOM${NC}"
+
+exit 0