buddydex 0.1.0

package/dist/buddydex.js

@@ -0,0 +1,450 @@
+#!/usr/bin/env bun
+// @bun
+
+// packages/engine/src/constants.ts
+var SPECIES = [
+  "duck",
+  "goose",
+  "blob",
+  "cat",
+  "dragon",
+  "octopus",
+  "owl",
+  "penguin",
+  "turtle",
+  "snail",
+  "ghost",
+  "axolotl",
+  "capybara",
+  "cactus",
+  "robot",
+  "rabbit",
+  "mushroom",
+  "chonk"
+];
+var RARITIES = ["common", "uncommon", "rare", "epic", "legendary"];
+var RARITY_WEIGHTS = [60, 25, 10, 4, 1];
+var EYES = ["\xB7", "\u2726", "\xD7", "\u25C9", "@", "\xB0"];
+var HATS = ["none", "crown", "tophat", "propeller", "halo", "wizard", "beanie", "tinyduck"];
+var STAT_FLOORS = { common: 5, uncommon: 15, rare: 25, epic: 35, legendary: 50 };
+var STAT_NAMES = ["debugging", "patience", "chaos", "wisdom", "snark"];
+var SALT = "friend-2026-401";
+
+// packages/cli/commands/hunt.ts
+import { parseArgs } from "util";
+
+// packages/engine/src/hash.ts
+var _wyhashSync = null;
+var _encoder = new TextEncoder;
+function wyhashFallback(str) {
+  const buf = _encoder.encode(str);
+  const raw = _wyhashSync(buf, 0n);
+  return Number(BigInt.asUintN(64, raw) & 0xffffffffn);
+}
+function hashString(str) {
+  if (typeof globalThis.Bun !== "undefined") {
+    return Number(BigInt(Bun.hash(str)) & 0xffffffffn);
+  }
+  if (!_wyhashSync) {
+    throw new Error("Hash not initialized. Call initHash() first.");
+  }
+  return wyhashFallback(str);
+}
+// packages/engine/src/prng.ts
+class Mulberry32 {
+  state;
+  constructor(seed) {
+    this.state = seed >>> 0;
+  }
+  nextU32() {
+    this.state = this.state + 1831565813 >>> 0;
+    let t = (this.state ^ this.state >>> 15) >>> 0;
+    t = Math.imul(t, 1 | this.state) >>> 0;
+    t = t + (Math.imul((t ^ t >>> 7) >>> 0, 61 | t) >>> 0) ^ t;
+    return (t ^ t >>> 14) >>> 0;
+  }
+  nextF64() {
+    return this.nextU32() / 4294967296;
+  }
+}
+// packages/engine/src/roll.ts
+function rollBones(userId) {
+  const seed = hashString(userId + SALT);
+  const rng = new Mulberry32(seed);
+  let roll = rng.nextF64() * 100;
+  let rarity = "common";
+  for (let i = 0;i < RARITY_WEIGHTS.length; i++) {
+    roll -= RARITY_WEIGHTS[i];
+    if (roll < 0) {
+      rarity = RARITIES[i];
+      break;
+    }
+  }
+  const species = SPECIES[Math.floor(rng.nextF64() * SPECIES.length) % SPECIES.length];
+  const eye = EYES[Math.floor(rng.nextF64() * EYES.length) % EYES.length];
+  const hat = rarity === "common" ? "none" : HATS[Math.floor(rng.nextF64() * HATS.length) % HATS.length];
+  const shiny = rng.nextF64() < 0.01;
+  const floor = STAT_FLOORS[rarity];
+  const peakIdx = Math.floor(rng.nextF64() * 5) % 5;
+  let dumpIdx = Math.floor(rng.nextF64() * 5) % 5;
+  if (dumpIdx === peakIdx)
+    dumpIdx = (dumpIdx + 1) % 5;
+  const stats = {};
+  for (let i = 0;i < 5; i++) {
+    const name = STAT_NAMES[i];
+    if (i === peakIdx) {
+      stats[name] = Math.min(100, Math.floor(floor + 50 + rng.nextF64() * 30));
+    } else if (i === dumpIdx) {
+      stats[name] = Math.max(1, Math.floor(floor - 10 + rng.nextF64() * 15));
+    } else {
+      stats[name] = Math.floor(floor + rng.nextF64() * 40);
+    }
+  }
+  const totalStats = Object.values(stats).reduce((a, b) => a + b, 0);
+  return { rarity, species, eye, hat, shiny, stats, totalStats };
+}
+// packages/engine/src/uuid.ts
+function generateUuid() {
+  const hex = () => Math.floor(Math.random() * 16).toString(16);
+  const h = (n) => Array.from({ length: n }, hex).join("");
+  return `${h(8)}-${h(4)}-${h(4)}-${h(4)}-${h(12)}`;
+}
+// packages/cli/lib/format.ts
+var isBun = typeof Bun !== "undefined";
+function printHeader(hashMode) {
+  const effectiveHash = hashMode === "fnv1a" ? "FNV-1a (forced)" : isBun ? "Bun.hash (Wyhash)" : "Wyhash (WASM)";
+  console.log(`
+  BuddyDex`);
+  console.log(`  Runtime: ${isBun ? "Bun" : "Node.js"}  Hash: ${effectiveHash}`);
+}
+function printBuddy(label, bones, userId) {
+  const shinyTag = bones.shiny ? " SHINY" : "";
+  const statBar = STAT_NAMES.map((s) => `${s.slice(0, 3).toUpperCase()}:${bones.stats[s]}`).join(" ");
+  console.log(`
+  ${label}`);
+  if (userId) {
+    const display = userId.length > 24 ? userId.slice(0, 12) + "..." : userId;
+    console.log(`  ID:     ${display}`);
+  }
+  console.log(`  Result: ${bones.rarity.toUpperCase()} ${bones.species}${shinyTag}`);
+  console.log(`  Eye: ${bones.eye}  Hat: ${bones.hat}  Total: ${bones.totalStats}`);
+  console.log(`  Stats:  ${statBar}`);
+}
+
+// packages/cli/commands/hunt.ts
+function cmdHunt(argv) {
+  const { values: args } = parseArgs({
+    args: argv,
+    options: {
+      species: { type: "string" },
+      rarity: { type: "string" },
+      shiny: { type: "boolean", default: false },
+      "min-stat": { type: "string" },
+      "min-total": { type: "string" },
+      perfect: { type: "string" },
+      tries: { type: "string", default: "1000000" },
+      limit: { type: "string", default: "10" }
+    }
+  });
+  const maxTries = parseInt(args.tries);
+  const maxResults = parseInt(args.limit);
+  const wantSpecies = args.species?.toLowerCase();
+  const wantRarity = args.rarity?.toLowerCase();
+  const wantShiny = args.shiny;
+  const wantMinStat = args["min-stat"]?.split(":");
+  const wantMinTotal = args["min-total"] ? parseInt(args["min-total"]) : null;
+  const wantPerfect = args.perfect ? parseInt(args.perfect) : null;
+  if (wantSpecies && !SPECIES.includes(wantSpecies)) {
+    console.error(`Unknown species: ${wantSpecies}
+Valid: ${SPECIES.join(", ")}`);
+    process.exit(1);
+  }
+  if (wantRarity && !RARITIES.includes(wantRarity)) {
+    console.error(`Unknown rarity: ${wantRarity}
+Valid: ${RARITIES.join(", ")}`);
+    process.exit(1);
+  }
+  printHeader();
+  const filters = [
+    `species=${wantSpecies || "any"}`,
+    `rarity=${wantRarity || "any"}`,
+    `shiny=${wantShiny}`,
+    wantMinStat ? `min-stat=${args["min-stat"]}` : null,
+    wantMinTotal ? `min-total=${wantMinTotal}` : null,
+    wantPerfect ? `perfect=${wantPerfect}` : null
+  ].filter(Boolean).join(" ");
+  console.log(`
+  Filters: ${filters}`);
+  console.log(`  Trying ${maxTries.toLocaleString()} random UUIDs, showing up to ${maxResults} results.
+`);
+  const results = [];
+  const startTime = Date.now();
+  for (let i = 0;i < maxTries && results.length < maxResults; i++) {
+    const fakeId = generateUuid();
+    const bones = rollBones(fakeId);
+    if (wantSpecies && bones.species !== wantSpecies)
+      continue;
+    if (wantRarity && bones.rarity !== wantRarity)
+      continue;
+    if (wantShiny && !bones.shiny)
+      continue;
+    if (wantMinStat) {
+      const [statName, minVal] = wantMinStat;
+      if (!bones.stats[statName] || bones.stats[statName] < parseInt(minVal))
+        continue;
+    }
+    if (wantMinTotal && bones.totalStats < wantMinTotal)
+      continue;
+    if (wantPerfect && !STAT_NAMES.every((s) => bones.stats[s] >= wantPerfect))
+      continue;
+    results.push({ fakeId, ...bones });
+  }
+  const elapsed = ((Date.now() - startTime) / 1000).toFixed(2);
+  if (results.length === 0) {
+    console.log(`  No matches found in ${maxTries.toLocaleString()} tries (${elapsed}s).`);
+    console.log(`  Try increasing --tries or relaxing filters.
+`);
+  } else {
+    console.log(`  Found ${results.length} match(es) in ${elapsed}s:
+`);
+    for (const r of results) {
+      const shinyTag = r.shiny ? " SHINY" : "";
+      const statBar = STAT_NAMES.map((s) => `${s.slice(0, 3).toUpperCase()}:${r.stats[s]}`).join(" ");
+      console.log(`  ${r.rarity.toUpperCase()} ${r.species}${shinyTag}  [${r.eye}]  hat:${r.hat}  total:${r.totalStats}`);
+      console.log(`    Stats: ${statBar}`);
+      console.log(`    Seed:  ${r.fakeId}`);
+      console.log();
+    }
+    console.log(`  To inject: buddydex inject <seed>
+`);
+  }
+}
+
+// packages/cli/commands/inject.ts
+import { parseArgs as parseArgs2 } from "util";
+
+// packages/cli/lib/config.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join, dirname } from "path";
+var CONFIG_PATH = join(homedir(), ".claude.json");
+var BACKUP_PATH = join(homedir(), ".claude", "buddy-backup.json");
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function isValidUuid(str) {
+  return /^[0-9a-f]{32}$/i.test(str.replace(/-/g, ""));
+}
+function getRealUserId() {
+  const backup = readJson(BACKUP_PATH);
+  if (backup?.originalAccountUuid)
+    return backup.originalAccountUuid;
+  if (backup?.originalUserID)
+    return backup.originalUserID;
+  const config = readJson(CONFIG_PATH);
+  return config?.oauthAccount?.accountUuid ?? config?.userID ?? "anon";
+}
+function getEffectiveUserId() {
+  const config = readJson(CONFIG_PATH);
+  return config?.oauthAccount?.accountUuid ?? config?.userID ?? "anon";
+}
+function backup(config) {
+  if (existsSync(BACKUP_PATH))
+    return;
+  const dir = dirname(BACKUP_PATH);
+  if (!existsSync(dir))
+    mkdirSync(dir, { recursive: true });
+  writeFileSync(BACKUP_PATH, JSON.stringify({
+    originalAccountUuid: config.oauthAccount?.accountUuid || null,
+    originalUserID: config.userID || null,
+    backedUpAt: new Date().toISOString()
+  }, null, 2) + `
+`);
+}
+function writeConfig(config) {
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + `
+`);
+}
+
+// packages/cli/commands/inject.ts
+function cmdInject(argv) {
+  const { values: args, positionals } = parseArgs2({
+    args: argv,
+    options: { preview: { type: "boolean", default: false } },
+    allowPositionals: true
+  });
+  const seed = positionals[0];
+  if (!seed) {
+    console.error(`
+  Usage: buddydex inject <seed> [--preview]
+`);
+    process.exit(1);
+  }
+  const config = readJson(CONFIG_PATH);
+  if (!config) {
+    console.error(`
+  Cannot read ${CONFIG_PATH}
+`);
+    process.exit(1);
+  }
+  const isOAuth = !!config.oauthAccount?.accountUuid;
+  printHeader();
+  console.log(`  Auth: ${isOAuth ? "OAuth (accountUuid)" : "Legacy (userID)"}`);
+  if (isOAuth && !isValidUuid(seed)) {
+    console.error(`
+  ERROR: Seed "${seed}" is not a valid UUID.`);
+    console.error(`  The binary expects 32 hex chars. Non-UUID values crash on launch.
+`);
+    process.exit(1);
+  }
+  const bones = rollBones(seed);
+  printBuddy("New buddy:", bones, seed);
+  if (args.preview) {
+    console.log(`
+  (preview only)
+`);
+    process.exit(0);
+  }
+  backup(config);
+  if (isOAuth) {
+    config.oauthAccount.accountUuid = seed;
+    console.log(`
+  Spoofed oauthAccount.accountUuid`);
+  } else {
+    config.userID = seed;
+    console.log(`
+  Spoofed userID`);
+  }
+  delete config.companion;
+  writeConfig(config);
+  console.log(`  Companion soul cleared.`);
+  console.log(`
+  Restart Claude Code to meet your new buddy!`);
+  console.log(`  Run: buddydex restore
+`);
+}
+
+// packages/cli/commands/restore.ts
+import { existsSync as existsSync2 } from "fs";
+function cmdRestore() {
+  if (!existsSync2(BACKUP_PATH)) {
+    console.error(`
+  No backup found at ${BACKUP_PATH}
+`);
+    process.exit(1);
+  }
+  const bk = readJson(BACKUP_PATH);
+  const config = readJson(CONFIG_PATH);
+  if (!config) {
+    console.error(`
+  Cannot read ${CONFIG_PATH}
+`);
+    process.exit(1);
+  }
+  printHeader();
+  if (bk?.originalAccountUuid && config.oauthAccount) {
+    config.oauthAccount.accountUuid = bk.originalAccountUuid;
+    console.log(`
+  Restored oauthAccount.accountUuid`);
+  }
+  if (bk?.originalUserID) {
+    config.userID = bk.originalUserID;
+    console.log(`  Restored userID`);
+  }
+  delete config.companion;
+  writeConfig(config);
+  const restoredId = getEffectiveUserId();
+  const bones = rollBones(restoredId);
+  printBuddy("Restored buddy:", bones, restoredId);
+  console.log(`
+  Restart Claude Code to get your original buddy back.
+`);
+}
+
+// packages/cli/commands/show.ts
+function cmdShow() {
+  printHeader();
+  const realId = getRealUserId();
+  const effectiveId = getEffectiveUserId();
+  const realBones = rollBones(realId);
+  printBuddy("Your buddy:", realBones, realId);
+  if (effectiveId !== realId) {
+    const currentBones = rollBones(effectiveId);
+    printBuddy("Currently active (spoofed):", currentBones, effectiveId);
+  }
+  console.log();
+}
+
+// packages/cli/commands/roll.ts
+import { parseArgs as parseArgs3 } from "util";
+function cmdRoll(argv) {
+  const { positionals } = parseArgs3({
+    args: argv,
+    options: {},
+    allowPositionals: true
+  });
+  const userId = positionals[0];
+  if (!userId) {
+    console.error(`
+  Usage: buddydex roll <uuid>
+`);
+    process.exit(1);
+  }
+  printHeader();
+  const bones = rollBones(userId);
+  printBuddy("Roll result:", bones, userId);
+  console.log();
+}
+
+// packages/cli/bin.ts
+var USAGE = `
+  BuddyDex CLI
+
+  Commands:
+    hunt      Search for buddies matching filters
+    inject    Inject a seed UUID into ~/.claude.json
+    restore   Restore your original UUID from backup
+    show      Show your current buddy
+    roll      Roll a specific UUID to see its buddy
+
+  Hunt options:
+    --species <name>       Filter by species
+    --rarity <level>       Filter by rarity (${RARITIES.join(", ")})
+    --shiny                Only shiny buddies
+    --min-stat <name:val>  Min value for a stat (e.g. chaos:80)
+    --min-total <val>      Min total stat points (e.g. 400)
+    --perfect <val>        ALL stats >= this value (e.g. 70)
+    --tries <n>            UUIDs to try (default: 1000000)
+    --limit <n>            Max results (default: 10)
+
+  Inject options:
+    --preview              Preview without saving
+
+  Examples:
+    buddydex hunt --species dragon --rarity legendary
+    buddydex hunt --rarity legendary --perfect 70
+    buddydex inject <seed>
+    buddydex show
+`;
+var [command, ...rest] = process.argv.slice(2);
+var commands = {
+  hunt: cmdHunt,
+  inject: cmdInject,
+  restore: cmdRestore,
+  show: cmdShow,
+  roll: cmdRoll
+};
+if (command && command in commands) {
+  commands[command](rest);
+} else {
+  console.log(USAGE);
+  if (command && command !== "--help" && command !== "-h") {
+    console.error(`  Unknown command: ${command}
+`);
+    process.exit(1);
+  }
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "buddydex",
+  "version": "0.1.0",
+  "description": "Hunt, browse, and inject Claude Code buddies",
+  "type": "module",
+  "bin": {
+    "buddydex": "dist/buddydex.js"
+  },
+  "files": ["dist"],
+  "keywords": ["claude", "claude-code", "buddy", "companion", "wyhash"],
+  "author": "iammatthias",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iammatthias/buddydex.git"
+  },
+  "dependencies": {
+    "@buddy/engine": "workspace:*"
+  }
+}