buddy-reroll 0.3.6 → 0.3.8

package/README.md

@@ -12,16 +12,13 @@ Pick the perfect [Claude Code](https://docs.anthropic.com/en/docs/claude-code) `
 
 ```bash
 # Bun (recommended)
-bun install -g buddy-reroll
+bunx buddy-reroll
 
 # npm
-npm install -g buddy-reroll
-
-# No install needed
 npx buddy-reroll
 ```
 
-Bun gives the speediest experience, but Node.js >= 20 works just as well.
+Bun is faster, but Node.js >= 20 produces identical results — no Bun required.
 
 ## Usage
 
@@ -87,12 +84,12 @@ buddy-reroll --unhook  # remove whenever you want
 
 ## How fast is it?
 
-buddy-reroll uses all your CPU cores (up to 8) to find the right companion. Bun is a bit faster because of its native hashing, but both runtimes produce identical results.
+buddy-reroll uses all your CPU cores (up to 8) to find the right companion. Both runtimes use the same wyhash algorithm as Claude Code, so your buddy will always match `/buddy` exactly.
 
-| Runtime | Speed | Notes |
+| Runtime | Speed | Hash |
 |---|---|---|
-| Bun | Faster | Recommended |
-| Node.js >= 20 | Slightly slower | Works great too |
+| Bun | Faster (native `Bun.hash`) | wyhash ✓ |
+| Node.js >= 20 | Slightly slower (pure JS) | wyhash ✓ |
 
 ## Requirements
 

package/index.js

@@ -18,9 +18,10 @@ import {
   findCurrentSalt,
   matches,
   rollFrom,
+  setNodeHashMode,
 } from "./lib/companion.js";
 import { formatDoctorReport, getDoctorReport } from "./lib/doctor.js";
-import { findBinaryPath, findConfigPath, getClaudeBinaryOverride, getPatchability } from "./lib/runtime.js";
+import { findBinaryPath, findConfigPath, getClaudeBinaryOverride, getPatchability, isBunBinary } from "./lib/runtime.js";
 import { parallelBruteForce } from "./lib/finder.js";
 import { estimateAttempts, formatProgress } from "./lib/estimator.js";
 import { installHook, removeHook, storeSalt, readStoredSalt } from "./lib/hooks.js";
@@ -265,7 +266,7 @@ function formatCompanionCard(result) {
 
 // ── Interactive mode ─────────────────────────────────────────────────────
 
-async function interactiveMode(binaryPath, configPath, userId) {
+async function interactiveMode(binaryPath, configPath, userId, nodeHash) {
   const { currentSalt, currentRoll } = readCurrentCompanion(binaryPath, userId);
 
   const uiOpts = {
@@ -274,7 +275,7 @@ async function interactiveMode(binaryPath, configPath, userId) {
     binaryPath,
     configPath,
     userId,
-    bruteForce: parallelBruteForce,
+    bruteForce: (uid, tgt, onProg, sig) => parallelBruteForce(uid, tgt, onProg, sig, { nodeHash }),
     patchBinary,
     resignBinary,
     clearCompanion,
@@ -303,7 +304,7 @@ async function interactiveMode(binaryPath, configPath, userId) {
 
 // ── Non-interactive mode ─────────────────────────────────────────────────
 
-async function nonInteractiveMode(args, binaryPath, configPath, userId) {
+async function nonInteractiveMode(args, binaryPath, configPath, userId, nodeHash) {
   console.log(`  Binary:  ${binaryPath}`);
   console.log(`  Config:  ${configPath}`);
   console.log(`  User ID: ${userId.slice(0, 8)}...`);
@@ -357,7 +358,7 @@ async function nonInteractiveMode(args, binaryPath, configPath, userId) {
   try {
     found = await parallelBruteForce(userId, target, (attempts, elapsed, est, workers) => {
       process.stdout.write(`\r  ${formatProgress(attempts, elapsed, est, workers)}`);
-    });
+    }, undefined, { nodeHash });
   } catch (err) {
     fail(`\n  ✗ ${err.message}`);
   }
@@ -536,6 +537,9 @@ async function main() {
     fail("✗ Could not find Claude Code binary. Checked PATH and known install locations.");
   }
 
+  const nodeHash = !isBunBinary(binaryPath);
+  if (nodeHash) setNodeHashMode(true);
+
   const configPath = findConfigPath();
   if (!configPath) fail("✗ Could not find Claude Code config file. Checked ~/.claude/.config.json and ~/.claude.json.");
 
@@ -548,9 +552,9 @@ async function main() {
   const isCommand = args.restore || args.current || args.doctor || args.hook || args.unhook || args["apply-hook"];
 
   if (!hasTargetFlags && !isCommand) {
-    await interactiveMode(binaryPath, configPath, userId);
+    await interactiveMode(binaryPath, configPath, userId, nodeHash);
   } else {
-    await nonInteractiveMode(args, binaryPath, configPath, userId);
+    await nonInteractiveMode(args, binaryPath, configPath, userId, nodeHash);
   }
 }
 

package/lib/companion.js

@@ -37,7 +37,23 @@ function mulberry32(seed) {
 
 import { wyhash } from "./wyhash.js";
 
+let _nodeHash = false;
+
+export function setNodeHashMode(enabled) {
+  _nodeHash = enabled;
+}
+
+function fnv1a(str) {
+  let h = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+
 function hashString(value) {
+  if (_nodeHash) return fnv1a(value);
   if (typeof Bun !== "undefined") return Number(BigInt(Bun.hash(value)) & 0xffffffffn);
   return Number(wyhash(0n, value) & 0xffffffffn);
 }

package/lib/estimator.js

@@ -16,28 +16,27 @@ export function estimateAttempts(target) {
   return Math.round(1 / probability);
 }
 
+function formatTime(seconds) {
+  if (seconds < 60) return Math.round(seconds) + "s";
+  const minutes = Math.floor(seconds / 60);
+  const secs = Math.round(seconds % 60);
+  return minutes + "m " + secs + "s";
+}
+
+function formatRate(rate) {
+  if (rate >= 1_000_000) return (rate / 1_000_000).toFixed(1) + "M/s";
+  if (rate >= 1_000) return (rate / 1_000).toFixed(1) + "k/s";
+  return rate.toFixed(1) + "/s";
+}
+
 export function formatProgress(attempts, elapsed, expected, workers) {
-  const pct = Math.min(100, Math.round((attempts / expected) * 100));
-  const rate = attempts / (elapsed / 1000);
-
-  let rateStr;
-  if (rate >= 1_000_000) {
-    rateStr = (rate / 1_000_000).toFixed(1) + "M tries/s";
-  } else if (rate >= 1_000) {
-    rateStr = (rate / 1_000).toFixed(1) + "k tries/s";
-  } else {
-    rateStr = rate.toFixed(1) + " tries/s";
-  }
+  const elapsedSec = elapsed / 1000;
+  const rate = attempts / elapsedSec;
 
-  const remaining = Math.max(0, (expected - attempts) / rate);
-  let etaStr;
-  if (remaining < 60) {
-    etaStr = Math.round(remaining) + "s";
-  } else {
-    const minutes = Math.floor(remaining / 60);
-    const seconds = Math.round(remaining % 60);
-    etaStr = minutes + "m " + seconds + "s";
+  if (attempts >= expected) {
+    return `Still searching... ${formatTime(elapsedSec)} | ${formatRate(rate)} | taking longer than usual`;
   }
 
-  return `${pct}% | ${rateStr} | ~${etaStr} left | ${workers} cores`;
+  const remaining = (expected - attempts) / rate;
+  return `Searching... ${formatTime(elapsedSec)} | ${formatRate(rate)} | ~${formatTime(remaining)} left`;
 }

package/lib/estimator.test.js

@@ -59,39 +59,41 @@ describe("estimateAttempts", () => {
 });
 
 describe("formatProgress", () => {
-  it("formats progress with millions of salts per second", () => {
+  it("shows elapsed time and rate", () => {
     const result = formatProgress(5_000_000, 2000, 10_000_000, 8);
-    expect(result).toContain("50%");
-    expect(result).toContain("2.5M tries/s");
-    expect(result).toContain("8 cores");
+    expect(result).toContain("Searching...");
+    expect(result).toContain("2s");
+    expect(result).toContain("2.5M/s");
   });
 
-  it("formats progress with thousands of salts per second", () => {
+  it("shows ETA when under expected", () => {
     const result = formatProgress(50_000, 5000, 100_000, 4);
-    expect(result).toContain("50%");
-    expect(result).toContain("10.0k tries/s");
-    expect(result).toContain("4 cores");
-  });
-
-  it("formats ETA in seconds", () => {
-    const result = formatProgress(9_000_000, 1000, 10_000_000, 8);
+    expect(result).toContain("Searching...");
     expect(result).toContain("left");
-    expect(result).toContain("s");
   });
 
   it("formats ETA in minutes and seconds", () => {
     const result = formatProgress(1_000_000, 1000, 100_000_000, 8);
     expect(result).toContain("m");
+    expect(result).toContain("left");
+  });
+
+  it("shows 'taking longer than usual' past expected", () => {
+    const result = formatProgress(10_000_000, 2000, 10_000_000, 8);
+    expect(result).toContain("Still searching...");
+    expect(result).toContain("taking longer than usual");
+    expect(result).not.toContain("left");
   });
 
-  it("caps percentage at 100", () => {
-    const result = formatProgress(10_000_000, 1000, 10_000_000, 8);
-    expect(result).toContain("100%");
+  it("shows 'taking longer than usual' well past expected", () => {
+    const result = formatProgress(30_000_000, 6000, 10_000_000, 8);
+    expect(result).toContain("Still searching...");
+    expect(result).toContain("6s");
   });
 
-  it("handles zero elapsed time gracefully", () => {
+  it("handles very small elapsed time", () => {
     const result = formatProgress(1_000_000, 1, 10_000_000, 8);
-    expect(result).toContain("%");
-    expect(result).toContain("tries/s");
+    expect(result).toContain("Searching...");
+    expect(result).toContain("/s");
   });
 });

package/lib/finder.js

@@ -7,7 +7,7 @@ import { rollFrom } from "./companion.js";
 
 const WORKER_SCRIPT = join(dirname(fileURLToPath(import.meta.url)), "..", "scripts", "worker.js");
 
-export async function parallelBruteForce(userId, target, onProgress, signal) {
+export async function parallelBruteForce(userId, target, onProgress, signal, { nodeHash = false } = {}) {
   const numWorkers = Math.max(1, Math.min(cpus().length, 8));
   const expected = estimateAttempts(target);
 
@@ -42,7 +42,9 @@ export async function parallelBruteForce(userId, target, onProgress, signal) {
       workerStderr[i] = "";
       workerAttempts[i] = 0;
 
-      const child = spawn(process.execPath, [WORKER_SCRIPT, userId, JSON.stringify(target)], {
+      const args = [WORKER_SCRIPT, userId, JSON.stringify(target)];
+      if (nodeHash) args.push("--node-hash");
+      const child = spawn(process.execPath, args, {
         stdio: ["ignore", "pipe", "pipe"],
       });
       children.push(child);

package/lib/runtime.js

@@ -1,4 +1,4 @@
-import { accessSync, constants, existsSync, readFileSync, readdirSync, realpathSync, statSync } from "fs";
+import { accessSync, closeSync, constants, existsSync, openSync, readFileSync, readSync, readdirSync, realpathSync, statSync } from "fs";
 import { execFileSync } from "child_process";
 import { join, dirname, isAbsolute } from "path";
 import { homedir, platform } from "os";
@@ -17,6 +17,23 @@ function isRealBinary(candidatePath) {
   }
 }
 
+export function isBunBinary(binaryPath) {
+  let fd;
+  try {
+    fd = openSync(binaryPath, "r");
+    const buf = Buffer.alloc(4);
+    readSync(fd, buf, 0, 4, 0);
+    const h0 = buf[0], h1 = buf[1];
+    // Mach-O (LE/BE), ELF, PE → compiled Bun binary
+    return (h0 === 0xcf && h1 === 0xfa) || (h0 === 0xfe && h1 === 0xed) ||
+           (h0 === 0x7f && h1 === 0x45) || (h0 === 0x4d && h1 === 0x5a);
+  } catch {
+    return true; // default to Bun (most common install)
+  } finally {
+    if (fd !== undefined) try { closeSync(fd); } catch {}
+  }
+}
+
 export function getClaudeConfigDir() {
   return process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-reroll",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "Reroll your Claude Code buddy companion to any species/rarity/eye/hat/shiny combo",
   "type": "module",
   "bin": {

package/scripts/worker.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { rollFrom, matches } from "../lib/companion.js";
+import { rollFrom, matches, setNodeHashMode } from "../lib/companion.js";
 
 const SALT_LEN = 15;
 const CHARSET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
@@ -22,6 +22,8 @@ try {
   process.exit(1);
 }
 
+if (process.argv.includes("--node-hash")) setNodeHashMode(true);
+
 if (!userId || !target) {
   process.stderr.write("Usage: worker.js <userId> '<targetJSON>'\n");
   process.exit(1);

package/ui-fallback.js

@@ -155,11 +155,16 @@ export async function runInteractiveUI(opts) {
   let found;
   try {
     found = await bruteForce(userId, target, (attempts, elapsed, expected, workers) => {
-      const pct = Math.min(100, Math.round((attempts / expected) * 100));
-      const rate = attempts / (elapsed / 1000);
-      const rateStr = rate >= 1e6 ? `${(rate / 1e6).toFixed(1)}M` : `${(rate / 1e3).toFixed(1)}k`;
-      const eta = Math.max(0, (expected - attempts) / rate);
-      process.stdout.write(`\r  ${pct}% | ${rateStr} tries/s | ~${Math.round(eta)}s left | ${workers} cores`);
+      const elapsedSec = elapsed / 1000;
+      const rate = attempts / elapsedSec;
+      const rateStr = rate >= 1e6 ? `${(rate / 1e6).toFixed(1)}M/s` : `${(rate / 1e3).toFixed(1)}k/s`;
+      const fmtTime = (s) => s < 60 ? `${Math.round(s)}s` : `${Math.floor(s / 60)}m ${Math.round(s % 60)}s`;
+      if (attempts >= expected) {
+        process.stdout.write(`\r  Still searching... ${fmtTime(elapsedSec)} | ${rateStr} | taking longer than usual`);
+      } else {
+        const remaining = (expected - attempts) / rate;
+        process.stdout.write(`\r  Searching... ${fmtTime(elapsedSec)} | ${rateStr} | ~${fmtTime(remaining)} left`);
+      }
     });
   } catch (err) {
     console.log(chalk.red(`\n✗ ${err.message}`));

package/ui.jsx

@@ -213,11 +213,16 @@ function SearchStep({ userId, target, bruteForce, onFound, onFail, isActive }) {
       try {
         found = await bruteForce(userId, target, (attempts, elapsed, expected, workers) => {
           if (!ac.signal.aborted) {
-            const pct = Math.min(100, Math.round((attempts / expected) * 100));
-            const rate = attempts / (elapsed / 1000);
-            const rateStr = rate >= 1e6 ? `${(rate / 1e6).toFixed(1)}M` : `${(rate / 1e3).toFixed(1)}k`;
-            const eta = Math.max(0, (expected - attempts) / rate);
-            setProgress(`${pct}% | ${rateStr} tries/s | ~${Math.round(eta)}s left | ${workers} cores`);
+            const elapsedSec = elapsed / 1000;
+            const rate = attempts / elapsedSec;
+            const rateStr = rate >= 1e6 ? `${(rate / 1e6).toFixed(1)}M/s` : `${(rate / 1e3).toFixed(1)}k/s`;
+            const fmtTime = (s) => s < 60 ? `${Math.round(s)}s` : `${Math.floor(s / 60)}m ${Math.round(s % 60)}s`;
+            if (attempts >= expected) {
+              setProgress(`Still searching... ${fmtTime(elapsedSec)} | ${rateStr} | taking longer than usual`);
+            } else {
+              const remaining = (expected - attempts) / rate;
+              setProgress(`Searching... ${fmtTime(elapsedSec)} | ${rateStr} | ~${fmtTime(remaining)} left`);
+            }
           }
         }, ac.signal);
       } catch {