buddy-reroll 0.1.1 → 0.2.1

package/index.js

@@ -5,7 +5,8 @@ import { join } from "path";
 import { homedir, platform } from "os";
 import { execSync } from "child_process";
 import { parseArgs } from "util";
-import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { renderSprite, colorizeSprite, RARITY_STARS, RARITY_COLORS } from "./sprites.js";
 
 if (typeof Bun === "undefined") {
   console.error("buddy-reroll requires Bun runtime (uses Bun.hash).\nInstall: https://bun.sh");
@@ -99,8 +100,11 @@ function getClaudeConfigDir() {
 }
 
 function findBinaryPath() {
+  const isWin = platform() === "win32";
+
   try {
-    const allPaths = execSync("which -a claude 2>/dev/null", { encoding: "utf-8" }).trim().split("\n");
+    const cmd = isWin ? "where.exe claude 2>nul" : "which -a claude 2>/dev/null";
+    const allPaths = execSync(cmd, { encoding: "utf-8" }).trim().split("\n");
     for (const entry of allPaths) {
       try {
         const resolved = realpathSync(entry.trim());
@@ -109,10 +113,16 @@ function findBinaryPath() {
     }
   } catch {}
 
-  const versionsDir = join(homedir(), ".local", "share", "claude", "versions");
-  if (existsSync(versionsDir)) {
+  const versionsDirs = [
+    join(homedir(), ".local", "share", "claude", "versions"),
+    ...(isWin ? [join(process.env.LOCALAPPDATA || join(homedir(), "AppData", "Local"), "Claude", "versions")] : []),
+  ];
+  for (const versionsDir of versionsDirs) {
+    if (!existsSync(versionsDir)) continue;
     try {
-      const versions = readdirSync(versionsDir).sort();
+      const versions = readdirSync(versionsDir)
+        .filter((f) => !f.includes(".backup"))
+        .sort();
       if (versions.length > 0) return join(versionsDir, versions[versions.length - 1]);
     } catch {}
   }
@@ -130,6 +140,12 @@ function findConfigPath() {
   const defaultPath = join(home, ".claude.json");
   if (existsSync(defaultPath)) return defaultPath;
 
+  // Windows: check AppData\Roaming\Claude
+  if (platform() === "win32" && process.env.APPDATA) {
+    const appDataPath = join(process.env.APPDATA, "Claude", "config.json");
+    if (existsSync(appDataPath)) return appDataPath;
+  }
+
   return null;
 }
 
@@ -143,9 +159,9 @@ function getUserId(configPath) {
 function findCurrentSalt(binaryData, userId) {
   if (binaryData.includes(Buffer.from(ORIGINAL_SALT))) return ORIGINAL_SALT;
 
-  const text = binaryData.toString("utf-8");
+  const text = binaryData.toString("latin1");
 
-  // Scan for previously patched salts (our known patterns)
+  // Scan for previously patched salts
   const patterns = [
     new RegExp(`x{${SALT_LEN - 8}}\\d{8}`, "g"),
     new RegExp(`friend-\\d{4}-.{${SALT_LEN - 12}}`, "g"),
@@ -157,7 +173,6 @@ function findCurrentSalt(binaryData, userId) {
     }
   }
 
-  // Contextual scan near companion code markers
   const saltRegex = new RegExp(`"([a-zA-Z0-9_-]{${SALT_LEN}})"`, "g");
   const candidates = new Set();
   const markers = ["rollRarity", "CompanionBones", "inspirationSeed", "companionUserId"];
@@ -171,7 +186,6 @@ function findCurrentSalt(binaryData, userId) {
     }
   }
 
-  // Filter: real salts contain digits or hyphens (rules out "projectSettings" etc.)
   for (const c of candidates) {
     if (/[\d-]/.test(c)) return c;
   }
@@ -181,7 +195,7 @@ function findCurrentSalt(binaryData, userId) {
 
 // ── Brute-force ──────────────────────────────────────────────────────────
 
-function bruteForce(userId, target, spinner) {
+async function bruteForce(userId, target, onProgress) {
   const startTime = Date.now();
   let checked = 0;
 
@@ -206,9 +220,11 @@ function bruteForce(userId, target, spinner) {
     const r = rollFrom(salt, userId);
     if (matches(r, target)) return { salt, result: r, checked, elapsed: Date.now() - startTime };
 
+    if (checked % 100_000 === 0) {
+      await new Promise((r) => setTimeout(r, 0));
+    }
     if (checked % 5_000_000 === 0) {
-      const secs = ((Date.now() - startTime) / 1000).toFixed(1);
-      if (spinner) spinner.message(`${(checked / 1e6).toFixed(0)}M salts checked (${secs}s)`);
+      if (onProgress) onProgress(checked, Date.now() - startTime);
     }
   }
 
@@ -228,6 +244,10 @@ function matches(roll, target) {
 
 function isClaudeRunning() {
   try {
+    if (platform() === "win32") {
+      const out = execSync('tasklist /FI "IMAGENAME eq claude.exe" /FO CSV 2>nul', { encoding: "utf-8" });
+      return out.toLowerCase().includes("claude.exe");
+    }
     const out = execSync("pgrep -af claude 2>/dev/null", { encoding: "utf-8" });
     return out.split("\n").some((line) => !line.includes("buddy-reroll") && line.trim().length > 0);
   } catch {
@@ -256,8 +276,20 @@ function patchBinary(binaryPath, oldSalt, newSalt) {
 
   if (count === 0) throw new Error(`Salt "${oldSalt}" not found in binary`);
 
-  writeFileSync(binaryPath, data);
-  return count;
+  const isWin = platform() === "win32";
+  const maxRetries = isWin ? 3 : 1;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      writeFileSync(binaryPath, data);
+      return count;
+    } catch (err) {
+      if (isWin && (err.code === "EACCES" || err.code === "EPERM" || err.code === "EBUSY") && attempt < maxRetries - 1) {
+        execSync("timeout /t 2 /nobreak >nul 2>&1", { shell: true, stdio: "ignore" });
+        continue;
+      }
+      throw new Error(`Failed to write binary: ${err.message}${isWin ? " (ensure Claude Code is fully closed)" : ""}`);
+    }
+  }
 }
 
 function resignBinary(binaryPath) {
@@ -281,165 +313,69 @@ function clearCompanion(configPath) {
 
 // ── Display ──────────────────────────────────────────────────────────────
 
-function formatRoll(result) {
+function formatCompanionCard(result) {
+  const sprite = renderSprite({ species: result.species, eye: result.eye, hat: result.hat });
+  const colored = colorizeSprite(sprite, result.rarity);
+  const colorFn = chalk[RARITY_COLORS[result.rarity]] ?? chalk.white;
+  const stars = RARITY_STARS[result.rarity] ?? "";
+
+  const meta = [];
+  meta.push(`${result.species} / ${result.rarity}${result.shiny ? " / shiny" : ""}`);
+  meta.push(`eye:${result.eye} / hat:${result.hat}`);
+  meta.push(stars);
+
   const lines = [];
-  lines.push(`  ${result.species} / ${result.rarity} / eye:${result.eye} / hat:${result.hat}${result.shiny ? " / shiny" : ""}`);
+  const spriteWidth = 14;
+  for (let i = 0; i < colored.length; i++) {
+    const right = meta[i] ?? "";
+    lines.push(`  ${colored[i]}${" ".repeat(Math.max(0, spriteWidth - sprite[i].length))}${right}`);
+  }
+
   for (const [k, v] of Object.entries(result.stats)) {
-    const bar = "█".repeat(Math.round(v / 10)) + "░".repeat(10 - Math.round(v / 10));
+    const filled = Math.min(10, Math.max(0, Math.round(v / 10)));
+    const bar = colorFn("█".repeat(filled) + "░".repeat(10 - filled));
     lines.push(`  ${k.padEnd(10)} ${bar} ${String(v).padStart(3)}`);
   }
+
   return lines.join("\n");
 }
 
 // ── Interactive mode ─────────────────────────────────────────────────────
 
 async function interactiveMode(binaryPath, configPath, userId) {
-  p.intro("buddy-reroll");
-
   const binaryData = readFileSync(binaryPath);
   const currentSalt = findCurrentSalt(binaryData, userId);
   if (!currentSalt) {
-    p.cancel("Could not find companion salt in binary.");
+    console.error("✗ Could not find companion salt in binary.");
     process.exit(1);
   }
   const currentRoll = rollFrom(currentSalt, userId);
-  p.note(formatRoll(currentRoll), "Current companion");
-
-  const action = await p.select({
-    message: "What would you like to do?",
-    options: [
-      { value: "reroll", label: "Reroll companion", hint: "pick species, rarity, etc." },
-      { value: "restore", label: "Restore original", hint: "undo all patches" },
-      { value: "current", label: "Show current", hint: "just display info" },
-    ],
-  });
-  if (p.isCancel(action)) { p.cancel(); process.exit(0); }
-
-  if (action === "current") {
-    p.outro("Done!");
-    return;
-  }
-
-  if (action === "restore") {
-    const backupPath = binaryPath + ".backup";
-    if (!existsSync(backupPath)) {
-      p.cancel("No backup found. Nothing to restore.");
-      process.exit(1);
-    }
-    copyFileSync(backupPath, binaryPath);
-    resignBinary(binaryPath);
-    clearCompanion(configPath);
-    p.outro("Restored! Restart Claude Code and run /buddy.");
-    return;
-  }
-
-  const species = await p.select({
-    message: "Species",
-    options: SPECIES.map((s) => ({
-      value: s,
-      label: s,
-      hint: s === currentRoll.species ? "current" : undefined,
-    })),
-    initialValue: currentRoll.species,
-  });
-  if (p.isCancel(species)) { p.cancel(); process.exit(0); }
-
-  const rarity = await p.select({
-    message: "Rarity",
-    options: RARITIES.map((r) => ({
-      value: r,
-      label: RARITY_LABELS[r],
-      hint: r === currentRoll.rarity ? "current" : undefined,
-    })),
-    initialValue: currentRoll.rarity,
-  });
-  if (p.isCancel(rarity)) { p.cancel(); process.exit(0); }
-
-  const eye = await p.select({
-    message: "Eye",
-    options: EYES.map((e) => ({
-      value: e,
-      label: e,
-      hint: e === currentRoll.eye ? "current" : undefined,
-    })),
-    initialValue: currentRoll.eye,
-  });
-  if (p.isCancel(eye)) { p.cancel(); process.exit(0); }
 
-  let hat = "none";
-  if (rarity === "common") {
-    p.log.info("Common rarity always gets hat=none");
-  } else {
-    hat = await p.select({
-      message: "Hat",
-      options: HATS.map((h) => ({
-        value: h,
-        label: h,
-        hint: h === currentRoll.hat ? "current" : undefined,
-      })),
-      initialValue: currentRoll.hat === "none" ? "crown" : currentRoll.hat,
-    });
-    if (p.isCancel(hat)) { p.cancel(); process.exit(0); }
-  }
-
-  const shiny = await p.confirm({
-    message: "Shiny?",
-    initialValue: false,
+  const { runInteractiveUI } = await import("./ui.jsx");
+  await runInteractiveUI({
+    currentRoll,
+    currentSalt,
+    binaryPath,
+    configPath,
+    userId,
+    bruteForce,
+    patchBinary,
+    resignBinary,
+    clearCompanion,
+    isClaudeRunning,
+    rollFrom,
+    matches,
+    SPECIES,
+    RARITIES,
+    RARITY_LABELS,
+    EYES,
+    HATS,
   });
-  if (p.isCancel(shiny)) { p.cancel(); process.exit(0); }
-
-  const target = { species, rarity, eye, hat, shiny };
-
-  if (matches(currentRoll, target)) {
-    p.outro("Already matching! No changes needed.");
-    return;
-  }
-
-  p.log.info(`Target: ${species} / ${rarity} / eye:${eye} / hat:${hat}${shiny ? " / shiny" : ""}`);
-
-  const confirm = await p.confirm({ message: "Search and apply?" });
-  if (p.isCancel(confirm) || !confirm) { p.cancel(); process.exit(0); }
-
-  if (isClaudeRunning()) {
-    p.log.warn("Claude Code appears to be running. Quit it before patching to avoid issues.");
-    const proceed = await p.confirm({ message: "Patch anyway?" });
-    if (p.isCancel(proceed) || !proceed) { p.cancel(); process.exit(0); }
-  }
-
-  const spinner = p.spinner();
-  spinner.start("Searching for matching salt...");
-
-  const found = bruteForce(userId, target, spinner);
-  if (!found) {
-    spinner.stop("No matching salt found. Try relaxing constraints.");
-    process.exit(1);
-  }
-  spinner.stop(`Found in ${found.checked.toLocaleString()} attempts (${(found.elapsed / 1000).toFixed(1)}s)`);
-
-  p.note(formatRoll(found.result), "New companion");
-
-  const backupPath = binaryPath + ".backup";
-  if (!existsSync(backupPath)) {
-    copyFileSync(binaryPath, backupPath);
-    p.log.info(`Backup saved to ${backupPath}`);
-  }
-
-  const patchCount = patchBinary(binaryPath, currentSalt, found.salt);
-  p.log.success(`Patched ${patchCount} occurrence(s)`);
-
-  if (resignBinary(binaryPath)) {
-    p.log.success("Binary re-signed (ad-hoc codesign)");
-  }
-
-  clearCompanion(configPath);
-  p.log.success("Companion data cleared");
-
-  p.outro("Done! Restart Claude Code and run /buddy to hatch your new companion.");
 }
 
 // ── Non-interactive mode ─────────────────────────────────────────────────
 
-function nonInteractiveMode(args, binaryPath, configPath, userId) {
+async function nonInteractiveMode(args, binaryPath, configPath, userId) {
   console.log(`  Binary:  ${binaryPath}`);
   console.log(`  Config:  ${configPath}`);
   console.log(`  User ID: ${userId.slice(0, 8)}...`);
@@ -467,7 +403,7 @@ function nonInteractiveMode(args, binaryPath, configPath, userId) {
   if (args.current) {
     const result = rollFrom(currentSalt, userId);
     console.log(`\n  Current companion (salt: ${currentSalt}):`);
-    console.log(formatRoll(result));
+    console.log(formatCompanionCard(result));
     console.log();
     return;
   }
@@ -500,7 +436,7 @@ function nonInteractiveMode(args, binaryPath, configPath, userId) {
 
   const currentRoll = rollFrom(currentSalt, userId);
   if (matches(currentRoll, target)) {
-    console.log("  ✓ Already matches!\n" + formatRoll(currentRoll));
+    console.log("  ✓ Already matches!\n" + formatCompanionCard(currentRoll));
     return;
   }
 
@@ -509,13 +445,13 @@ function nonInteractiveMode(args, binaryPath, configPath, userId) {
   }
 
   console.log("  Searching...");
-  const found = bruteForce(userId, target, null);
+  const found = await bruteForce(userId, target, null);
   if (!found) {
     console.error("  ✗ No matching salt found. Try relaxing constraints.");
     process.exit(1);
   }
   console.log(`  ✓ Found in ${found.checked.toLocaleString()} attempts (${(found.elapsed / 1000).toFixed(1)}s)`);
-  console.log(formatRoll(found.result));
+  console.log(formatCompanionCard(found.result));
 
   const backupPath = binaryPath + ".backup";
   if (!existsSync(backupPath)) {
@@ -603,7 +539,7 @@ async function main() {
   if (!hasTargetFlags && !isCommand) {
     await interactiveMode(binaryPath, configPath, userId);
   } else {
-    nonInteractiveMode(args, binaryPath, configPath, userId);
+    await nonInteractiveMode(args, binaryPath, configPath, userId);
   }
 }
 

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "buddy-reroll",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Reroll your Claude Code buddy companion to any species/rarity/eye/hat/shiny combo",
   "type": "module",
   "bin": {
     "buddy-reroll": "index.js"
   },
   "files": [
-    "index.js"
+    "index.js",
+    "ui.jsx",
+    "sprites.js"
   ],
   "engines": {
     "bun": ">=1.0.0"
@@ -25,6 +27,8 @@
     "reroll"
   ],
   "dependencies": {
-    "@clack/prompts": "^1.2.0"
+    "chalk": "^5.6.2",
+    "ink": "^6.8.0",
+    "react": "^19.2.4"
   }
 }

package/sprites.js

@@ -0,0 +1,137 @@
+import chalk from "chalk";
+
+export const RARITY_STARS = {
+  common: "★",
+  uncommon: "★★",
+  rare: "★★★",
+  epic: "★★★★",
+  legendary: "★★★★★",
+};
+
+export const RARITY_COLORS = {
+  common: "white",
+  uncommon: "greenBright",
+  rare: "blueBright",
+  epic: "magentaBright",
+  legendary: "yellowBright",
+};
+
+export const HAT_LINES = {
+  none: "",
+  crown: "   \\^^^/    ",
+  tophat: "   [___]    ",
+  propeller: "    -+-     ",
+  halo: "   (   )    ",
+  wizard: "    /^\\     ",
+  beanie: "   (___)    ",
+  tinyduck: "    ,>      ",
+};
+
+export const BODIES = {
+  duck: [
+    ["            ", "    __      ", "  <({E} )___  ", "   (  ._>   ", "    `--´    "],
+    ["            ", "    __      ", "  <({E} )___  ", "   (  ._>   ", "    `--´~   "],
+    ["            ", "    __      ", "  <({E} )___  ", "   (  .__>  ", "    `--´    "],
+  ],
+  goose: [
+    ["            ", "     ({E}>    ", "     ||     ", "   _(__)_   ", "    ^^^^    "],
+    ["            ", "    ({E}>     ", "     ||     ", "   _(__)_   ", "    ^^^^    "],
+    ["            ", "     ({E}>>   ", "     ||     ", "   _(__)_   ", "    ^^^^    "],
+  ],
+  blob: [
+    ["            ", "   .----.   ", "  ( {E}  {E} )  ", "  (      )  ", "   `----´   "],
+    ["            ", "  .------.  ", " (  {E}  {E}  ) ", " (        ) ", "  `------´  "],
+    ["            ", "    .--.    ", "   ({E}  {E})   ", "   (    )   ", "    `--´    "],
+  ],
+  cat: [
+    ["            ", "   /\\_/\\    ", "  ( {E}   {E})  ", "  (  ω  )   ", '  (")_(")   '],
+    ["            ", "   /\\_/\\    ", "  ( {E}   {E})  ", "  (  ω  )   ", '  (")_(")~  '],
+    ["            ", "   /\\-/\\    ", "  ( {E}   {E})  ", "  (  ω  )   ", '  (")_(")   '],
+  ],
+  dragon: [
+    ["            ", "  /^\\  /^\\  ", " <  {E}  {E}  > ", " (   ~~   ) ", "  `-vvvv-´  "],
+    ["            ", "  /^\\  /^\\  ", " <  {E}  {E}  > ", " (        ) ", "  `-vvvv-´  "],
+    ["   ~    ~   ", "  /^\\  /^\\  ", " <  {E}  {E}  > ", " (   ~~   ) ", "  `-vvvv-´  "],
+  ],
+  octopus: [
+    ["            ", "   .----.   ", "  ( {E}  {E} )  ", "  (______)  ", "  /\\/\\/\\/\\  "],
+    ["            ", "   .----.   ", "  ( {E}  {E} )  ", "  (______)  ", "  \\/\\/\\/\\/  "],
+    ["     o      ", "   .----.   ", "  ( {E}  {E} )  ", "  (______)  ", "  /\\/\\/\\/\\  "],
+  ],
+  owl: [
+    ["            ", "   /\\  /\\   ", "  (({E})({E}))  ", "  (  ><  )  ", "   `----´   "],
+    ["            ", "   /\\  /\\   ", "  (({E})({E}))  ", "  (  ><  )  ", "   .----.   "],
+    ["            ", "   /\\  /\\   ", "  (({E})(-))  ", "  (  ><  )  ", "   `----´   "],
+  ],
+  penguin: [
+    ["            ", "  .---.     ", "  ({E}>{E})     ", " /(   )\\    ", "  `---´     "],
+    ["            ", "  .---.     ", "  ({E}>{E})     ", " |(   )|    ", "  `---´     "],
+    ["  .---.     ", "  ({E}>{E})     ", " /(   )\\    ", "  `---´     ", "   ~ ~      "],
+  ],
+  turtle: [
+    ["            ", "   _,--._   ", "  ( {E}  {E} )  ", " /[______]\\ ", "  ``    ``  "],
+    ["            ", "   _,--._   ", "  ( {E}  {E} )  ", " /[______]\\ ", "   ``  ``   "],
+    ["            ", "   _,--._   ", "  ( {E}  {E} )  ", " /[======]\\ ", "  ``    ``  "],
+  ],
+  snail: [
+    ["            ", " {E}    .--.  ", "  \\  ( @ )  ", "   \\_`--´   ", "  ~~~~~~~   "],
+    ["            ", "  {E}   .--.  ", "  |  ( @ )  ", "   \\_`--´   ", "  ~~~~~~~   "],
+    ["            ", " {E}    .--.  ", "  \\  ( @  ) ", "   \\_`--´   ", "   ~~~~~~   "],
+  ],
+  ghost: [
+    ["            ", "   .----.   ", "  / {E}  {E} \\  ", "  |      |  ", "  ~`~``~`~  "],
+    ["            ", "   .----.   ", "  / {E}  {E} \\  ", "  |      |  ", "  `~`~~`~`  "],
+    ["    ~  ~    ", "   .----.   ", "  / {E}  {E} \\  ", "  |      |  ", "  ~~`~~`~~  "],
+  ],
+  axolotl: [
+    ["            ", "}~(______)~{", "}~({E} .. {E})~{", "  ( .--. )  ", "  (_/  \\_)  "],
+    ["            ", "~}(______){~", "~}({E} .. {E}){~", "  ( .--. )  ", "  (_/  \\_)  "],
+    ["            ", "}~(______)~{", "}~({E} .. {E})~{", "  (  --  )  ", "  ~_/  \\_~  "],
+  ],
+  capybara: [
+    ["            ", "  n______n  ", " ( {E}    {E} ) ", " (   oo   ) ", "  `------´  "],
+    ["            ", "  n______n  ", " ( {E}    {E} ) ", " (   Oo   ) ", "  `------´  "],
+    ["    ~  ~    ", "  u______n  ", " ( {E}    {E} ) ", " (   oo   ) ", "  `------´  "],
+  ],
+  cactus: [
+    ["            ", " n  ____  n ", " | |{E}  {E}| | ", " |_|    |_| ", "   |    |   "],
+    ["            ", "    ____    ", " n |{E}  {E}| n ", " |_|    |_| ", "   |    |   "],
+    [" n        n ", " |  ____  | ", " | |{E}  {E}| | ", " |_|    |_| ", "   |    |   "],
+  ],
+  robot: [
+    ["            ", "   .[||].   ", "  [ {E}  {E} ]  ", "  [ ==== ]  ", "  `------´  "],
+    ["            ", "   .[||].   ", "  [ {E}  {E} ]  ", "  [ -==- ]  ", "  `------´  "],
+    ["     *      ", "   .[||].   ", "  [ {E}  {E} ]  ", "  [ ==== ]  ", "  `------´  "],
+  ],
+  rabbit: [
+    ["            ", "   (\\__/)   ", "  ( {E}  {E} )  ", " =(  ..  )= ", '  (")__(")  '],
+    ["            ", "   (|__/)   ", "  ( {E}  {E} )  ", " =(  ..  )= ", '  (")__(")  '],
+    ["            ", "   (\\__/)   ", "  ( {E}  {E} )  ", " =( .  . )= ", '  (")__(")  '],
+  ],
+  mushroom: [
+    ["            ", " .-o-OO-o-. ", "(__________)", "   |{E}  {E}|   ", "   |____|   "],
+    ["            ", " .-O-oo-O-. ", "(__________)", "   |{E}  {E}|   ", "   |____|   "],
+    ["   . o  .   ", " .-o-OO-o-. ", "(__________)", "   |{E}  {E}|   ", "   |____|   "],
+  ],
+  chonk: [
+    ["            ", "  /\\    /\\  ", " ( {E}    {E} ) ", " (   ..   ) ", "  `------´  "],
+    ["            ", "  /\\    /|  ", " ( {E}    {E} ) ", " (   ..   ) ", "  `------´  "],
+    ["            ", "  /\\    /\\  ", " ( {E}    {E} ) ", " (   ..   ) ", "  `------´~ "],
+  ],
+};
+
+export function renderSprite(bones, frame = 0) {
+  const frames = BODIES[bones.species];
+  const body = frames[frame % frames.length].map((line) => line.replaceAll("{E}", bones.eye));
+  const lines = [...body];
+  if (bones.hat !== "none" && !lines[0].trim()) {
+    lines[0] = HAT_LINES[bones.hat];
+  }
+  if (!lines[0].trim() && frames.every((f) => !f[0].trim())) lines.shift();
+  return lines;
+}
+
+export function colorizeSprite(lines, rarity) {
+  const colorFn = chalk[RARITY_COLORS[rarity]] ?? chalk.white;
+  return lines.map((line) => colorFn(line));
+}

package/ui.jsx

@@ -0,0 +1,458 @@
+import React, { useState, useEffect, useRef } from "react";
+import { render, Box, Text, useApp, useInput } from "ink";
+import { renderSprite, RARITY_STARS, RARITY_COLORS } from "./sprites.js";
+import { existsSync, copyFileSync } from "fs";
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+function Spinner({ label }) {
+  const [frame, setFrame] = useState(0);
+  useEffect(() => {
+    const timer = setInterval(() => setFrame((f) => (f + 1) % SPINNER_FRAMES.length), 80);
+    return () => clearInterval(timer);
+  }, []);
+  return <Text><Text color="cyan">{SPINNER_FRAMES[frame]}</Text> {label}</Text>;
+}
+
+// ── Components ──────────────────────────────────────────────────────────
+
+function KeyHint({ children }) {
+  return <Text italic dimColor>{children}</Text>;
+}
+
+function ListSelect({ label, options, defaultValue, onChange, onSubmit, onBack, isActive }) {
+  const [idx, setIdx] = useState(() => Math.max(0, options.findIndex((o) => o.value === defaultValue)));
+
+  useInput((input, key) => {
+    if (key.escape && onBack) { onBack(); return; }
+    if (key.upArrow || key.leftArrow) {
+      const next = (idx - 1 + options.length) % options.length;
+      setIdx(next);
+      if (onChange) onChange(options[next].value);
+    }
+    if (key.downArrow || key.rightArrow) {
+      const next = (idx + 1) % options.length;
+      setIdx(next);
+      if (onChange) onChange(options[next].value);
+    }
+    if (key.return) onSubmit(options[idx].value);
+  }, { isActive: isActive !== false });
+
+  return (
+    <Box flexDirection="column">
+      {label && <Text bold>{label}</Text>}
+      {options.map((opt, i) => (
+        <Text key={opt.value}>
+          <Text color={i === idx ? "cyan" : undefined}>
+            {i === idx ? "❯ " : "  "}{opt.label}
+          </Text>
+          {opt.hint && <Text dimColor> ({opt.hint})</Text>}
+        </Text>
+      ))}
+      <KeyHint>{onBack ? "↑↓ select · enter confirm · esc back" : "↑↓ select · enter confirm"}</KeyHint>
+    </Box>
+  );
+}
+
+function ConfirmSelect({ label, onConfirm, onCancel, onBack, isActive }) {
+  const [idx, setIdx] = useState(0);
+  const options = [
+    { label: "Yes", value: true },
+    { label: "No", value: false },
+  ];
+
+  useInput((input, key) => {
+    if (key.escape && onBack) { onBack(); return; }
+    if (key.upArrow || key.downArrow || key.leftArrow || key.rightArrow) {
+      setIdx(idx === 0 ? 1 : 0);
+    }
+    if (key.return) {
+      if (options[idx].value) onConfirm();
+      else onCancel();
+    }
+  }, { isActive: isActive !== false });
+
+  return (
+    <Box flexDirection="column">
+      <Text bold>{label}</Text>
+      <Box gap={2}>
+        {options.map((opt, i) => (
+          <Text key={opt.label} color={i === idx ? "cyan" : undefined}>
+            {i === idx ? "❯ " : "  "}{opt.label}
+          </Text>
+        ))}
+      </Box>
+      <KeyHint>{onBack ? "←→ select · enter confirm · esc back" : "←→ select · enter confirm"}</KeyHint>
+    </Box>
+  );
+}
+
+function PreviewCard({ species, rarity, eye, hat, shiny, stats }) {
+  const color = RARITY_COLORS[rarity] ?? "white";
+  const stars = RARITY_STARS[rarity] ?? "";
+  const sprite = renderSprite({ species, eye, hat });
+
+  return (
+    <Box flexDirection="column" borderStyle="round" borderColor={color} paddingX={1}>
+      <Box>
+        <Box flexDirection="column">
+          {sprite.map((line, i) => (
+            <Text key={i} color={color}>{line}</Text>
+          ))}
+        </Box>
+        <Box flexDirection="column" marginLeft={2}>
+          <Text bold>{species}</Text>
+          <Text color={color}>{rarity}{shiny ? " ✦shiny" : ""}</Text>
+          <Text dimColor>eye:{eye} hat:{hat}</Text>
+          <Text>{stars}</Text>
+        </Box>
+      </Box>
+      {stats && (
+        <Box flexDirection="column" marginTop={1}>
+          {Object.entries(stats).map(([k, v]) => {
+            const filled = Math.min(10, Math.max(0, Math.round(v / 10)));
+            return (
+              <Text key={k}>
+                <Text>{k.padEnd(10)} </Text>
+                <Text color={color}>{"█".repeat(filled)}</Text>
+                <Text dimColor>{"░".repeat(10 - filled)}</Text>
+                <Text> {String(v).padStart(3)}</Text>
+              </Text>
+            );
+          })}
+        </Box>
+      )}
+    </Box>
+  );
+}
+
+function ShowCurrentStep({ isActive }) {
+  const { exit } = useApp();
+
+  useInput(() => {
+    exit();
+  }, { isActive });
+
+  return (
+    <Box flexDirection="column">
+      <Text color="green">✓ Current companion shown above.</Text>
+      <KeyHint>Press any key to exit</KeyHint>
+    </Box>
+  );
+}
+
+function SpeciesStep({ speciesList, current, onChange, onSubmit, onBack, isActive }) {
+  const [idx, setIdx] = useState(Math.max(0, speciesList.indexOf(current)));
+
+  useInput((input, key) => {
+    if (key.escape && onBack) { onBack(); return; }
+    if (key.leftArrow || key.upArrow) {
+      const next = (idx - 1 + speciesList.length) % speciesList.length;
+      setIdx(next);
+      onChange(speciesList[next]);
+    }
+    if (key.rightArrow || key.downArrow) {
+      const next = (idx + 1) % speciesList.length;
+      setIdx(next);
+      onChange(speciesList[next]);
+    }
+    if (key.return) onSubmit();
+  }, { isActive });
+
+  return (
+    <Box flexDirection="column">
+      <Text bold>Species: <Text color="cyan">{speciesList[idx]}</Text> <Text dimColor>({idx + 1}/{speciesList.length})</Text></Text>
+      <KeyHint>←→ browse · enter select · esc back</KeyHint>
+    </Box>
+  );
+}
+
+function SearchStep({ userId, target, bruteForce, onFound, onFail, isActive }) {
+  const [progress, setProgress] = useState("");
+  const [error, setError] = useState(null);
+  const cancelRef = useRef(false);
+  const { exit } = useApp();
+
+  useInput((input, key) => {
+    if (key.escape) {
+      cancelRef.current = true;
+      exit();
+    }
+  }, { isActive });
+
+  useEffect(() => {
+    (async () => {
+      const found = await bruteForce(userId, target, (checked, elapsed) => {
+        if (!cancelRef.current) {
+          setProgress(`${(checked / 1e6).toFixed(0)}M salts checked (${(elapsed / 1000).toFixed(1)}s)`);
+        }
+      });
+      if (cancelRef.current) return;
+      if (found) onFound(found);
+      else setError("No matching salt found. Try relaxing constraints.");
+    })();
+  }, []);
+
+  if (error) {
+    return (
+      <Box flexDirection="column">
+        <Text color="red">✗ {error}</Text>
+        <KeyHint>Press esc to exit</KeyHint>
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column">
+      <Spinner label={progress || "Searching for matching salt..."} />
+      <KeyHint>esc to cancel</KeyHint>
+    </Box>
+  );
+}
+
+function DoneStep({ messages, isActive }) {
+  const { exit } = useApp();
+
+  useInput(() => {
+    exit();
+  }, { isActive });
+
+  return (
+    <Box flexDirection="column">
+      {messages.map((msg, i) => (
+        <Text key={i} color="green">✓ {msg}</Text>
+      ))}
+      <Box marginTop={1}>
+        <Text bold>Done! Restart Claude Code and run /buddy to hatch your new companion.</Text>
+      </Box>
+      <KeyHint>Press any key to exit</KeyHint>
+    </Box>
+  );
+}
+
+const STEP_ORDER = ["action", "species", "rarity", "eye", "hat", "shiny", "confirm"];
+
+function getPrevStep(current, rarity) {
+  const idx = STEP_ORDER.indexOf(current);
+  if (idx <= 0) return null;
+  let prev = STEP_ORDER[idx - 1];
+  if (prev === "hat" && rarity === "common") prev = "eye";
+  return prev;
+}
+
+function App({ opts }) {
+  const { exit } = useApp();
+  const {
+    currentRoll, currentSalt, binaryPath, configPath, userId,
+    bruteForce, patchBinary, resignBinary, clearCompanion, isClaudeRunning,
+    rollFrom, matches, SPECIES, RARITIES, RARITY_LABELS, EYES, HATS,
+  } = opts;
+
+  const [step, setStep] = useState("action");
+  const [species, setSpecies] = useState(currentRoll.species);
+  const [rarity, setRarity] = useState(currentRoll.rarity);
+  const [eye, setEye] = useState(currentRoll.eye);
+  const [hat, setHat] = useState(currentRoll.hat);
+  const [shiny, setShiny] = useState(currentRoll.shiny);
+  const [found, setFound] = useState(null);
+  const [doneMessages, setDoneMessages] = useState([]);
+
+  const showStats = step === "showCurrent" || step === "result" || step === "done";
+  const displayRoll = found ? found.result : { species, rarity, eye, hat, shiny, stats: currentRoll.stats };
+  const effectiveHat = rarity === "common" ? "none" : hat;
+  const buildTarget = (s = shiny) => ({ species, rarity, eye, hat: effectiveHat, shiny: s });
+
+  const goBack = (toStep) => {
+    const prev = toStep || getPrevStep(step, rarity);
+    if (prev) setStep(prev);
+    else exit();
+  };
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold dimColor>buddy-reroll</Text>
+
+      <PreviewCard
+        species={displayRoll.species}
+        rarity={displayRoll.rarity}
+        eye={displayRoll.eye}
+        hat={displayRoll.hat}
+        shiny={displayRoll.shiny}
+        stats={showStats ? displayRoll.stats : null}
+      />
+
+      <Box marginTop={1}>
+        {step === "action" && (
+          <ListSelect
+            label="What would you like to do?"
+            options={[
+              { label: "Reroll companion", value: "reroll" },
+              { label: "Restore original", value: "restore" },
+              { label: "Show current", value: "current" },
+            ]}
+            isActive={step === "action"}
+            onSubmit={(action) => {
+              if (action === "current") {
+                setStep("showCurrent");
+              } else if (action === "restore") {
+                const backupPath = binaryPath + ".backup";
+                if (!existsSync(backupPath)) {
+                  setDoneMessages(["No backup found. Nothing to restore."]);
+                  setStep("done");
+                  return;
+                }
+                copyFileSync(backupPath, binaryPath);
+                resignBinary(binaryPath);
+                clearCompanion(configPath);
+                setDoneMessages(["Restored! Restart Claude Code and run /buddy."]);
+                setStep("done");
+              } else {
+                setStep("species");
+              }
+            }}
+          />
+        )}
+
+        {step === "showCurrent" && (
+          <ShowCurrentStep isActive={step === "showCurrent"} />
+        )}
+
+        {step === "species" && (
+          <SpeciesStep
+            speciesList={SPECIES}
+            current={species}
+            onChange={setSpecies}
+            onSubmit={() => setStep("rarity")}
+            onBack={() => goBack("action")}
+            isActive={step === "species"}
+          />
+        )}
+
+        {step === "rarity" && (
+          <ListSelect
+            label="Rarity"
+            options={RARITIES.map((r) => ({ label: RARITY_LABELS[r], value: r }))}
+            defaultValue={rarity}
+            onChange={(r) => {
+              setRarity(r);
+              if (r === "common") setHat("none");
+            }}
+            onSubmit={() => setStep("eye")}
+            onBack={() => goBack()}
+            isActive={step === "rarity"}
+          />
+        )}
+
+        {step === "eye" && (
+          <ListSelect
+            label="Eye"
+            options={EYES.map((e) => ({ label: e, value: e }))}
+            defaultValue={eye}
+            onChange={setEye}
+            onSubmit={() => setStep(rarity === "common" ? "shiny" : "hat")}
+            onBack={() => goBack()}
+            isActive={step === "eye"}
+          />
+        )}
+
+        {step === "hat" && (
+          <ListSelect
+            label="Hat"
+            options={HATS.map((h) => ({ label: h, value: h }))}
+            defaultValue={hat === "none" ? "crown" : hat}
+            onChange={setHat}
+            onSubmit={() => setStep("shiny")}
+            onBack={() => goBack()}
+            isActive={step === "hat"}
+          />
+        )}
+
+        {step === "shiny" && (
+          <ConfirmSelect
+            label="Shiny?"
+            isActive={step === "shiny"}
+            onConfirm={() => {
+              setShiny(true);
+              if (matches(currentRoll, buildTarget(true))) {
+                setDoneMessages(["Already matching! No changes needed."]);
+                setStep("done");
+              } else {
+                setStep("confirm");
+              }
+            }}
+            onCancel={() => {
+              setShiny(false);
+              if (matches(currentRoll, buildTarget(false))) {
+                setDoneMessages(["Already matching! No changes needed."]);
+                setStep("done");
+              } else {
+                setStep("confirm");
+              }
+            }}
+            onBack={() => goBack()}
+          />
+        )}
+
+        {step === "confirm" && (
+          <Box flexDirection="column">
+            <Text>Target: <Text bold>{species}</Text> / <Text bold>{rarity}</Text> / eye:{eye} / hat:{effectiveHat}{shiny ? " / shiny" : ""}</Text>
+            {isClaudeRunning() && <Text color="yellow">⚠ Claude Code appears to be running. Quit it before patching.</Text>}
+            <ConfirmSelect
+              label="Search and apply?"
+              isActive={step === "confirm"}
+              onConfirm={() => setStep("search")}
+              onCancel={() => exit()}
+              onBack={() => goBack()}
+            />
+          </Box>
+        )}
+
+        {step === "search" && (
+          <SearchStep
+            userId={userId}
+            target={buildTarget()}
+            bruteForce={bruteForce}
+            onFound={(f) => { setFound(f); setStep("result"); }}
+            onFail={() => {
+              setDoneMessages(["No matching salt found. Try relaxing constraints."]);
+              setStep("done");
+            }}
+            isActive={step === "search"}
+          />
+        )}
+
+        {step === "result" && (
+          <Box flexDirection="column">
+            <Text bold color="green">✓ Found in {found.checked.toLocaleString()} attempts ({(found.elapsed / 1000).toFixed(1)}s)</Text>
+            <ConfirmSelect
+              label="Apply patch?"
+              isActive={step === "result"}
+              onConfirm={() => {
+                const msgs = [];
+                const backupPath = binaryPath + ".backup";
+                if (!existsSync(backupPath)) {
+                  copyFileSync(binaryPath, backupPath);
+                  msgs.push(`Backup saved to ${backupPath}`);
+                }
+                const count = patchBinary(binaryPath, currentSalt, found.salt);
+                msgs.push(`Patched ${count} occurrence(s)`);
+                if (resignBinary(binaryPath)) msgs.push("Binary re-signed (ad-hoc codesign)");
+                clearCompanion(configPath);
+                msgs.push("Companion data cleared");
+                setDoneMessages(msgs);
+                setStep("done");
+              }}
+              onCancel={() => exit()}
+            />
+          </Box>
+        )}
+
+        {step === "done" && <DoneStep messages={doneMessages} isActive={step === "done"} />}
+      </Box>
+    </Box>
+  );
+}
+
+export async function runInteractiveUI(opts) {
+  const { waitUntilExit } = render(<App opts={opts} />);
+  await waitUntilExit();
+}