buddy-reroll 0.3.5 → 0.3.7

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/lib/companion.js

@@ -35,17 +35,11 @@ function mulberry32(seed) {
   };
 }
 
-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;
-}
+import { wyhash } from "./wyhash.js";
 
 function hashString(value) {
-  return fnv1a(value);
+  if (typeof Bun !== "undefined") return Number(BigInt(Bun.hash(value)) & 0xffffffffn);
+  return Number(wyhash(0n, value) & 0xffffffffn);
 }
 
 function pick(rng, items) {
@@ -119,6 +113,8 @@ function findCurrentSalt(binaryData) {
   for (const candidate of candidates) {
     if (/[\d-]/.test(candidate)) return candidate;
   }
+  // Brute-forced salts can be purely alphabetic — accept any candidate
+  if (candidates.size > 0) return candidates.values().next().value;
 
   return null;
 }

package/lib/companion.test.js

@@ -127,6 +127,12 @@ describe("findCurrentSalt", () => {
     expect(findCurrentSalt(data)).toBe(patchedSalt);
   });
 
+  it("finds purely-alphabetic patched salt via context markers", () => {
+    const alphaSalt = "zaxZaEwKsjWqmfz";
+    const data = Buffer.from(`some data "${alphaSalt}" inspirationSeed more data`);
+    expect(findCurrentSalt(data)).toBe(alphaSalt);
+  });
+
   it("returns null when no salt found", () => {
     const data = Buffer.from("no salt here at all");
     expect(findCurrentSalt(data)).toBeNull();

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/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,6 +1,6 @@
 {
   "name": "buddy-reroll",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "Reroll your Claude Code buddy companion to any species/rarity/eye/hat/shiny combo",
   "type": "module",
   "bin": {

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 {