buddy-reroll 0.2.0 → 0.3.0

package/lib/wyhash.js

@@ -0,0 +1,88 @@
+// Wyhash v4.2 — Pure JavaScript implementation
+// Ported from @pencroff-lab/wyhash-ts (Apache-2.0)
+// https://github.com/pencroff-lab/wyhash-ts
+//
+// Produces identical output to Bun.hash() for string inputs.
+
+const secret = [
+  0xa0761d6478bd642fn,
+  0xe7037ed1a0b428dbn,
+  0x8ebc6af09c88c6e3n,
+  0x589965cc75374cc3n,
+];
+
+function read(data, offset, bytes) {
+  let result = 0n;
+  for (let i = 0; i < bytes && offset + i < data.length; i++) {
+    result |= BigInt(data[offset + i]) << (BigInt(i) * 8n);
+  }
+  return BigInt.asUintN(64, result);
+}
+
+function mum(a, b) {
+  const x = a * b;
+  return [BigInt.asUintN(64, x), BigInt.asUintN(64, x >> 64n)];
+}
+
+function mix(a, b) {
+  const [aMul, bMul] = mum(a, b);
+  return aMul ^ bMul;
+}
+
+function sum64(seed, input) {
+  let a, b;
+  let state0 = seed ^ mix(seed ^ secret[0], secret[1]);
+  const len = input.length;
+
+  if (len <= 16) {
+    if (len >= 4) {
+      const end = len - 4;
+      const quarter = (len >> 3) << 2;
+      a = (read(input, 0, 4) << 32n) | read(input, quarter, 4);
+      b = (read(input, end, 4) << 32n) | read(input, end - quarter, 4);
+    } else if (len > 0) {
+      a = (BigInt(input[0]) << 16n) | (BigInt(input[len >> 1]) << 8n) | BigInt(input[len - 1]);
+      b = 0n;
+    } else {
+      a = 0n;
+      b = 0n;
+    }
+  } else {
+    const state = [state0, state0, state0];
+    let i = 0;
+
+    if (len >= 48) {
+      while (i + 48 < len) {
+        for (let j = 0; j < 3; j++) {
+          const aRound = read(input, i + 8 * (2 * j), 8);
+          const bRound = read(input, i + 8 * (2 * j + 1), 8);
+          state[j] = mix(aRound ^ secret[j + 1], bRound ^ state[j]);
+        }
+        i += 48;
+      }
+      state[0] ^= state[1] ^ state[2];
+    }
+
+    const remaining = input.subarray(i);
+    let k = 0;
+    while (k + 16 < remaining.length) {
+      state[0] = mix(read(remaining, k, 8) ^ secret[1], read(remaining, k + 8, 8) ^ state[0]);
+      k += 16;
+    }
+
+    a = read(input, len - 16, 8);
+    b = read(input, len - 8, 8);
+    state0 = state[0];
+  }
+
+  a ^= secret[1];
+  b ^= state0;
+  [a, b] = mum(a, b);
+  return mix(a ^ secret[0] ^ BigInt(len), b ^ secret[1]);
+}
+
+const encoder = new TextEncoder();
+
+export function wyhash(seed, key) {
+  return sum64(BigInt.asUintN(64, seed), encoder.encode(key));
+}

package/lib/wyhash.test.js

@@ -0,0 +1,50 @@
+import { describe, it, expect } from "bun:test";
+import { wyhash } from "./wyhash.js";
+
+describe("wyhash", () => {
+  it("matches Bun.hash for empty string", () => {
+    expect(wyhash(0n, "")).toBe(BigInt(Bun.hash("")));
+  });
+
+  it("matches Bun.hash for short strings", () => {
+    const cases = ["a", "ab", "abc", "hello", "hello world"];
+    for (const s of cases) {
+      expect(wyhash(0n, s)).toBe(BigInt(Bun.hash(s)));
+    }
+  });
+
+  it("matches Bun.hash for companion-realistic inputs", () => {
+    const salts = ["friend-2026-401", "friend-2026-abc", "xxxxxxxxxxxxxxx"];
+    const userIds = ["anon", "fd50b3fd-1234-5678-9abc-def012345678"];
+    for (const uid of userIds) {
+      for (const salt of salts) {
+        const key = uid + salt;
+        expect(wyhash(0n, key)).toBe(BigInt(Bun.hash(key)));
+      }
+    }
+  });
+
+  it("matches Bun.hash for long strings (>48 bytes)", () => {
+    const long = "a".repeat(100);
+    expect(wyhash(0n, long)).toBe(BigInt(Bun.hash(long)));
+  });
+
+  it("matches Bun.hash for unicode strings", () => {
+    const cases = ["한글", "αβγδ", "🎮🐉✨"];
+    for (const s of cases) {
+      expect(wyhash(0n, s)).toBe(BigInt(Bun.hash(s)));
+    }
+  });
+
+  it("returns bigint", () => {
+    expect(typeof wyhash(0n, "test")).toBe("bigint");
+  });
+
+  it("is deterministic", () => {
+    expect(wyhash(0n, "test")).toBe(wyhash(0n, "test"));
+  });
+
+  it("produces different output for different inputs", () => {
+    expect(wyhash(0n, "hello")).not.toBe(wyhash(0n, "world"));
+  });
+});

package/package.json

@@ -1,18 +1,28 @@
 {
   "name": "buddy-reroll",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Reroll your Claude Code buddy companion to any species/rarity/eye/hat/shiny combo",
   "type": "module",
   "bin": {
     "buddy-reroll": "index.js"
   },
+  "scripts": {
+    "test": "bun test lib/",
+    "help": "bun run index.js --help",
+    "list": "bun run index.js --list",
+    "verify:runtime": "bun run scripts/verify-runtime.js",
+    "verify": "bun run test && bun run help && bun run list && bun run verify:runtime && npm pack --dry-run"
+  },
   "files": [
     "index.js",
+    "lib",
+    "scripts",
     "ui.jsx",
+    "ui-fallback.js",
     "sprites.js"
   ],
   "engines": {
-    "bun": ">=1.0.0"
+    "node": ">=20.0.0"
   },
   "license": "MIT",
   "repository": {
@@ -27,6 +37,7 @@
     "reroll"
   ],
   "dependencies": {
+    "@inquirer/prompts": "^8.3.2",
     "chalk": "^5.6.2",
     "ink": "^6.8.0",
     "react": "^19.2.4"

package/scripts/verify-runtime.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env bun
+
+import { execFileSync } from "child_process";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { formatDoctorReport, getDoctorReport } from "../lib/doctor.js";
+
+const rootDir = dirname(dirname(fileURLToPath(import.meta.url)));
+const entrypoint = join(rootDir, "index.js");
+
+function log(message) {
+  process.stdout.write(`${message}\n`);
+}
+
+function runCurrentSmokeCheck() {
+  execFileSync("bun", [entrypoint, "--current"], {
+    cwd: rootDir,
+    stdio: "inherit",
+  });
+}
+
+function main() {
+  const report = getDoctorReport();
+  log(formatDoctorReport(report, "Runtime verification"));
+
+  if (!report.canRunCurrent) {
+    log("  Skipping --current smoke check because Claude Code runtime was not fully discovered on this machine.");
+    process.exit(0);
+  }
+
+  runCurrentSmokeCheck();
+}
+
+main();

package/scripts/worker.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { rollFrom, matches } from "../lib/companion.js";
+
+const SALT_LEN = 15;
+const CHARSET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
+const REPORT_INTERVAL = 100_000;
+
+function randomSalt() {
+  let s = "";
+  for (let i = 0; i < SALT_LEN; i++) {
+    s += CHARSET[(Math.random() * CHARSET.length) | 0];
+  }
+  return s;
+}
+
+const userId = process.argv[2];
+const target = JSON.parse(process.argv[3]);
+
+if (!userId || !target) {
+  process.stderr.write("Usage: worker.js <userId> '<targetJSON>'\n");
+  process.exit(1);
+}
+
+const start = Date.now();
+let attempts = 0;
+
+for (;;) {
+  attempts++;
+  const salt = randomSalt();
+  const result = rollFrom(salt, userId);
+
+  if (matches(result, target)) {
+    process.stdout.write(JSON.stringify({ salt, attempts, elapsed: Date.now() - start }));
+    process.exit(0);
+  }
+
+  if (attempts % REPORT_INTERVAL === 0) {
+    process.stderr.write(JSON.stringify({ attempts, elapsed: Date.now() - start }) + "\n");
+  }
+}

package/ui-fallback.js

@@ -0,0 +1,181 @@
+import { select, confirm } from "@inquirer/prompts";
+import { existsSync, copyFileSync } from "fs";
+import chalk from "chalk";
+import { renderSprite, colorizeSprite, RARITY_STARS, RARITY_COLORS } from "./sprites.js";
+
+function printSprite(roll) {
+  const sprite = renderSprite({ species: roll.species, eye: roll.eye, hat: roll.hat });
+  const colored = colorizeSprite(sprite, roll.rarity);
+  const colorFn = chalk[RARITY_COLORS[roll.rarity]] ?? chalk.white;
+  const stars = RARITY_STARS[roll.rarity] ?? "";
+
+  console.log("");
+  for (const line of colored) console.log(`  ${line}`);
+  console.log(`  ${chalk.bold(roll.species)} / ${colorFn(roll.rarity)}${roll.shiny ? " / ✦shiny" : ""}`);
+  console.log(`  eye:${roll.eye} hat:${roll.hat}  ${stars}`);
+
+  if (roll.stats) {
+    console.log("");
+    for (const [k, v] of Object.entries(roll.stats)) {
+      const filled = Math.min(10, Math.max(0, Math.round(v / 10)));
+      const bar = colorFn("█".repeat(filled)) + chalk.dim("░".repeat(10 - filled));
+      console.log(`  ${k.padEnd(10)} ${bar} ${String(v).padStart(3)}`);
+    }
+  }
+  console.log("");
+}
+
+export async function runInteractiveUI(opts) {
+  const {
+    currentRoll, currentSalt, binaryPath, configPath, userId,
+    bruteForce, patchBinary, resignBinary, clearCompanion, getPatchability, isClaudeRunning,
+    rollFrom, matches, SPECIES, RARITIES, RARITY_LABELS, EYES, HATS, STAT_NAMES,
+  } = opts;
+
+  console.log(chalk.bold.dim("\n  buddy-reroll\n"));
+  printSprite(currentRoll);
+
+  const action = await select({
+    message: "What would you like to do?",
+    choices: [
+      { name: "Pick a new buddy", value: "reroll" },
+      { name: "Go back to default", value: "restore" },
+      { name: "See my buddy", value: "current" },
+    ],
+  });
+
+  if (action === "current") {
+    console.log(chalk.green("✓ That's your buddy!"));
+    return;
+  }
+
+  if (action === "restore") {
+    const patchability = getPatchability(binaryPath);
+    if (!patchability.ok) {
+      console.log(chalk.red(`✗ ${patchability.message}`));
+      return;
+    }
+    const { backupPath } = patchability;
+    if (!existsSync(backupPath)) {
+      console.log(chalk.yellow("No backup found. Nothing to restore."));
+      return;
+    }
+    try {
+      copyFileSync(backupPath, binaryPath);
+      resignBinary(binaryPath);
+      clearCompanion(configPath);
+      console.log(chalk.green("✓ Restored! Restart Claude Code and say /buddy to see your original friend."));
+    } catch (err) {
+      console.log(chalk.red(`✗ ${err.message}`));
+    }
+    return;
+  }
+
+  const species = await select({
+    message: "Species",
+    choices: SPECIES.map((s) => ({ name: s, value: s })),
+    default: currentRoll.species,
+  });
+
+  const rarity = await select({
+    message: "Rarity",
+    choices: RARITIES.map((r) => ({ name: RARITY_LABELS[r], value: r })),
+    default: currentRoll.rarity,
+  });
+
+  const eye = await select({
+    message: "Eye",
+    choices: EYES.map((e) => ({ name: e, value: e })),
+    default: currentRoll.eye,
+  });
+
+  let hat = "none";
+  if (rarity !== "common") {
+    hat = await select({
+      message: "Hat",
+      choices: HATS.map((h) => ({ name: h, value: h })),
+      default: currentRoll.hat === "none" ? "crown" : currentRoll.hat,
+    });
+  }
+
+  const shiny = await confirm({ message: "Shiny?", default: false });
+
+  let peak = null;
+  let dump = null;
+  if (STAT_NAMES) {
+    const wantStats = await confirm({ message: "Choose your buddy's strong and weak stats?", default: false });
+    if (wantStats) {
+      peak = await select({
+        message: "Best at",
+        choices: [
+          { name: "Surprise me!", value: null },
+          ...STAT_NAMES.map((s) => ({ name: s, value: s })),
+        ],
+      });
+      if (peak) {
+        dump = await select({
+          message: "Worst at",
+          choices: [
+            { name: "Surprise me!", value: null },
+            ...STAT_NAMES.filter((s) => s !== peak).map((s) => ({ name: s, value: s })),
+          ],
+        });
+      }
+    }
+  }
+
+  const preview = { species, rarity, eye, hat, shiny, stats: null };
+  printSprite(preview);
+
+  const target = { species, rarity, eye, hat: rarity === "common" ? "none" : hat };
+  if (shiny) target.shiny = true;
+  if (peak) target.peak = peak;
+  if (dump) target.dump = dump;
+
+  if (matches(currentRoll, target)) {
+    console.log(chalk.green("✓ Your buddy already looks like that!"));
+    return;
+  }
+
+  const patchability = getPatchability(binaryPath);
+  if (!patchability.ok) {
+    console.log(chalk.red(`✗ ${patchability.message}`));
+    return;
+  }
+
+  if (isClaudeRunning()) {
+    console.log(chalk.yellow("⚠ Claude Code is still running — close it first so the changes stick."));
+  }
+
+  const proceed = await confirm({ message: "Let's go?", default: true });
+  if (!proceed) return;
+
+  console.log("  Looking for your buddy...");
+  const found = await bruteForce(userId, target, (checked, elapsed) => {
+    process.stdout.write(`\r  ${(checked / 1e6).toFixed(1)}M tries (${(elapsed / 1000).toFixed(1)}s)`);
+  });
+
+  if (!found) {
+    console.log(chalk.red("\n✗ Couldn't find a match. Try being less picky!"));
+    return;
+  }
+
+  console.log(chalk.green(`\n✓ Found your buddy! (${found.checked.toLocaleString()} tries, ${(found.elapsed / 1000).toFixed(1)}s)`));
+  printSprite(found.result);
+
+  const { backupPath } = patchability;
+  try {
+    if (!existsSync(backupPath)) {
+      copyFileSync(binaryPath, backupPath);
+      console.log(`  Backup saved to ${backupPath}`);
+    }
+    patchBinary(binaryPath, currentSalt, found.salt);
+    console.log("  Applied ✓");
+    if (resignBinary(binaryPath)) console.log("  Re-signed for macOS ✓");
+    clearCompanion(configPath);
+    console.log("  Cleaned up old buddy data ✓");
+    console.log(chalk.bold("\n  All set! Restart Claude Code and say /buddy to meet your new friend.\n"));
+  } catch (err) {
+    console.log(chalk.red(`\n✗ ${err.message}`));
+  }
+}