any-buddy 1.0.4 → 1.0.6

package/README.md

@@ -202,14 +202,21 @@ When you choose to install the hook, it adds this to `~/.claude/settings.json`:
   "hooks": {
     "SessionStart": [
       {
-        "type": "command",
-        "command": "claude-code-any-buddy apply --silent"
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "claude-code-any-buddy apply --silent"
+          }
+        ]
       }
     ]
   }
 }
 ```
 
+The hook is **optional and defaults to No** — you'll be asked during the interactive flow. If you prefer, just run `any-buddy apply` manually after Claude Code updates.
+
 On every Claude Code session start, this runs `apply --silent` which:
 1. Reads your saved salt from `~/.claude-code-any-buddy.json`
 2. Checks if the current binary already has the correct salt (fast `Buffer.indexOf`)

package/lib/config.mjs

@@ -135,11 +135,17 @@ export function saveClaudeSettings(settings) {
 
 const HOOK_COMMAND = 'claude-code-any-buddy apply --silent';
 
+// Claude Code hooks schema: { "SessionStart": [{ "matcher": "", "hooks": [{ "type": "command", "command": "..." }] }] }
+function findHookEntry(matchers) {
+  if (!Array.isArray(matchers)) return null;
+  return matchers.find(m =>
+    Array.isArray(m.hooks) && m.hooks.some(h => h.command === HOOK_COMMAND)
+  ) ?? null;
+}
+
 export function isHookInstalled() {
   const settings = getClaudeSettings();
-  const hooks = settings.hooks?.SessionStart;
-  if (!Array.isArray(hooks)) return false;
-  return hooks.some(h => h.command === HOOK_COMMAND);
+  return findHookEntry(settings.hooks?.SessionStart) !== null;
 }
 
 export function installHook() {
@@ -147,10 +153,10 @@ export function installHook() {
   if (!settings.hooks) settings.hooks = {};
   if (!Array.isArray(settings.hooks.SessionStart)) settings.hooks.SessionStart = [];
 
-  if (!settings.hooks.SessionStart.some(h => h.command === HOOK_COMMAND)) {
+  if (!findHookEntry(settings.hooks.SessionStart)) {
     settings.hooks.SessionStart.push({
-      type: 'command',
-      command: HOOK_COMMAND,
+      matcher: '',
+      hooks: [{ type: 'command', command: HOOK_COMMAND }],
     });
   }
 
@@ -161,7 +167,7 @@ export function removeHook() {
   const settings = getClaudeSettings();
   if (!settings.hooks?.SessionStart) return;
   settings.hooks.SessionStart = settings.hooks.SessionStart.filter(
-    h => h.command !== HOOK_COMMAND
+    m => !Array.isArray(m.hooks) || !m.hooks.some(h => h.command === HOOK_COMMAND)
   );
   if (settings.hooks.SessionStart.length === 0) delete settings.hooks.SessionStart;
   if (Object.keys(settings.hooks).length === 0) delete settings.hooks;

package/lib/finder-worker.mjs

@@ -109,7 +109,7 @@ while (true) {
     process.exit(0);
   }
 
-  if (attempts % 500000 === 0) {
-    process.stderr.write(`${(attempts / 1000).toFixed(0)}k seeds tried...\n`);
+  if (attempts % 25000 === 0) {
+    process.stderr.write(JSON.stringify({ attempts, elapsed: Date.now() - start }) + '\n');
   }
 }

package/lib/finder.mjs

@@ -1,28 +1,105 @@
-import { execFileSync } from 'child_process';
+import { spawn } from 'child_process';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
+import { RARITY_WEIGHTS } from './constants.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const WORKER_PATH = join(__dirname, 'finder-worker.mjs');
 
+// Calculate expected attempts based on probability of matching all desired traits.
+export function estimateAttempts(desired) {
+  // Species: 1/18
+  let p = 1 / 18;
+
+  // Rarity: weight / 100
+  p *= RARITY_WEIGHTS[desired.rarity] / 100;
+
+  // Eye: 1/6
+  p *= 1 / 6;
+
+  // Hat: common is always 'none' (guaranteed), otherwise 1/8
+  if (desired.rarity !== 'common') {
+    p *= 1 / 8;
+  }
+
+  // Shiny: 1/100
+  if (desired.shiny) {
+    p *= 0.01;
+  }
+
+  // Peak stat: 1/5
+  if (desired.peak) {
+    p *= 1 / 5;
+  }
+
+  // Dump stat: ~1/4 (picked from remaining 4, but rerolls on collision)
+  if (desired.dump) {
+    p *= 1 / 4;
+  }
+
+  // Expected attempts = 1/p (geometric distribution)
+  return Math.round(1 / p);
+}
+
 // Spawns a Bun subprocess that brute-forces salts using native Bun.hash.
-// Returns { salt, attempts, elapsed }.
-export function findSalt(userId, desired) {
-  const result = execFileSync('bun', [
-    WORKER_PATH,
-    userId,
-    desired.species,
-    desired.rarity,
-    desired.eye,
-    desired.hat,
-    String(desired.shiny ?? false),
-    desired.peak ?? 'any',
-    desired.dump ?? 'any',
-  ], {
-    encoding: 'utf-8',
-    timeout: 120000, // 2 minute timeout
-    stdio: ['pipe', 'pipe', 'inherit'], // stderr passes through for progress
-  });
+// Calls onProgress with { attempts, elapsed, rate, expected, pct, eta } on each tick.
+// Returns a promise resolving to { salt, attempts, elapsed }.
+export function findSalt(userId, desired, { onProgress } = {}) {
+  const expected = estimateAttempts(desired);
+
+  return new Promise((resolve, reject) => {
+    const child = spawn('bun', [
+      WORKER_PATH,
+      userId,
+      desired.species,
+      desired.rarity,
+      desired.eye,
+      desired.hat,
+      String(desired.shiny ?? false),
+      desired.peak ?? 'any',
+      desired.dump ?? 'any',
+    ], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 300000,
+    });
+
+    let stdout = '';
 
-  return JSON.parse(result.trim());
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk.toString();
+    });
+
+    child.stderr.on('data', (chunk) => {
+      if (!onProgress) return;
+      // Worker writes JSON progress lines to stderr
+      const lines = chunk.toString().split('\n').filter(Boolean);
+      for (const line of lines) {
+        try {
+          const progress = JSON.parse(line);
+          const rate = progress.attempts / (progress.elapsed / 1000); // attempts/sec
+          const pct = Math.min(100, (progress.attempts / expected) * 100);
+          // ETA based on expected remaining attempts at current rate
+          const remaining = Math.max(0, expected - progress.attempts);
+          const eta = rate > 0 ? remaining / rate : Infinity;
+          onProgress({ ...progress, rate, expected, pct, eta });
+        } catch {
+          // Not JSON — ignore
+        }
+      }
+    });
+
+    child.on('close', (code) => {
+      if (code === 0 && stdout.trim()) {
+        try {
+          resolve(JSON.parse(stdout.trim()));
+        } catch (err) {
+          reject(new Error(`Failed to parse finder result: ${stdout.trim()}`));
+        }
+      } else {
+        reject(new Error(`Salt finder exited with code ${code}`));
+      }
+    });
+
+    child.on('error', reject);
+  });
 }

package/lib/tui.mjs

@@ -3,11 +3,23 @@ import chalk from 'chalk';
 import { SPECIES, EYES, HATS, RARITIES, RARITY_STARS, RARITY_WEIGHTS, STAT_NAMES, ORIGINAL_SALT } from './constants.mjs';
 import { roll } from './generation.mjs';
 import { renderSprite, renderFace } from './sprites.mjs';
-import { findSalt } from './finder.mjs';
+import { findSalt, estimateAttempts } from './finder.mjs';
 import { findClaudeBinary, getCurrentSalt, patchBinary, verifySalt, restoreBinary, isClaudeRunning } from './patcher.mjs';
 import { getClaudeUserId, savePetConfig, loadPetConfig, isHookInstalled, installHook, removeHook, getCompanionName, renameCompanion, getCompanionPersonality, setCompanionPersonality, deleteCompanion } from './config.mjs';
 import { DEFAULT_PERSONALITIES } from './personalities.mjs';
 
+function progressBar(pct, width) {
+  const filled = Math.min(width, Math.round((pct / 100) * width));
+  const empty = width - filled;
+  return chalk.cyan('█'.repeat(filled)) + chalk.dim('░'.repeat(empty));
+}
+
+function formatCount(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(0)}k`;
+  return String(n);
+}
+
 const RARITY_CHALK = {
   common: chalk.gray,
   uncommon: chalk.green,
@@ -272,15 +284,23 @@ export async function runInteractive(flags = {}) {
   }
 
   // ─── Find salt ───
-  console.log(chalk.dim('\n  Searching for matching salt...'));
-
-  const result = findSalt(userId, desired, {
-    onProgress: (attempts, ms) => {
-      process.stdout.write(chalk.dim(`\r  Tried ${(attempts / 1000).toFixed(0)}k seeds (${(ms / 1000).toFixed(1)}s)...`));
+  const expected = estimateAttempts(desired);
+  console.log(chalk.dim(`\n  Searching (~${formatCount(expected)} expected attempts)...`));
+
+  const result = await findSalt(userId, desired, {
+    onProgress: ({ attempts, elapsed, rate, pct, eta }) => {
+      const bar = progressBar(pct, 20);
+      const etaStr = eta < 1 ? '<1s' : eta < 60 ? `${Math.ceil(eta)}s` : `${(eta / 60).toFixed(1)}m`;
+      const rateStr = rate > 1e6 ? `${(rate / 1e6).toFixed(1)}M/s` : `${(rate / 1e3).toFixed(0)}k/s`;
+      process.stdout.write(
+        `\r  ${bar} ${chalk.dim(`${Math.min(99, Math.floor(pct))}%`)}  ${chalk.cyan(formatCount(attempts))} tried  ${chalk.dim(rateStr)}  ${chalk.dim(`ETA ${etaStr}`)}   `
+      );
     },
   });
 
-  console.log(chalk.green(`\r  Found salt "${result.salt}" in ${result.attempts.toLocaleString()} attempts (${(result.elapsed / 1000).toFixed(1)}s)`));
+  // Clear the progress line and show result
+  process.stdout.write('\r' + ' '.repeat(80) + '\r');
+  console.log(chalk.green(`  Found in ${result.attempts.toLocaleString()} attempts (${(result.elapsed / 1000).toFixed(1)}s)`));
   const foundBones = roll(userId, result.salt).bones;
   showPet(foundBones, 'Your new pet');
 
@@ -367,14 +387,20 @@ export async function runInteractive(flags = {}) {
 
   // ─── Hook setup ───
   if (!isHookInstalled() && !flags.noHook) {
-    const setupHook = flags.yes || await confirm({
-      message: 'Install SessionStart hook to auto-re-apply after updates?',
-      default: true,
+    console.log(chalk.dim('\n  Optional: install a SessionStart hook to auto-re-apply after Claude Code updates.'));
+    console.log(chalk.yellow('  Note: this modifies ~/.claude/settings.json. If you have issues, run:'));
+    console.log(chalk.yellow('  any-buddy restore'));
+
+    const setupHook = await confirm({
+      message: 'Install auto-patch hook?',
+      default: false,
     });
 
     if (setupHook) {
       installHook();
       console.log(chalk.green('  Hook installed in ~/.claude/settings.json'));
+    } else {
+      console.log(chalk.dim('  No hook installed. Run `any-buddy apply` manually after updates.'));
     }
   } else if (isHookInstalled()) {
     console.log(chalk.dim('  SessionStart hook already installed.'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "any-buddy",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Pick any Claude Code companion pet you want",
   "type": "module",
   "bin": {