buddy-battle 1.0.0

package/dist/app.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function App(): React.JSX.Element | null;

package/dist/app.js

@@ -0,0 +1,74 @@
+import React, { useEffect, useState } from 'react';
+import { Box, Text } from 'ink';
+import { readLocalBuddy, getHashedUserId } from './config/reader.js';
+import { sanitizeBuddyForNetwork, fetchCloudProfile, createCloudProfile } from './network/client.js';
+import { Menu } from './ui/Menu.js';
+import { Leaderboard } from './ui/Leaderboard.js';
+import { Matchmaking } from './ui/Matchmaking.js';
+import { Arena } from './ui/Arena.js';
+import { Setup } from './ui/Setup.js';
+export default function App() {
+    const [buddy, setBuddy] = useState(undefined);
+    const [trainerName, setTrainerName] = useState(null);
+    const [bunWarning, setBunWarning] = useState(false);
+    const [view, setView] = useState('loading');
+    const [setupError, setSetupError] = useState(undefined);
+    const [opponent, setOpponent] = useState(null);
+    const [battleId, setBattleId] = useState(null);
+    useEffect(() => {
+        async function boot() {
+            const { buddy: localBuddy, bunWarning: noBun } = readLocalBuddy();
+            setBunWarning(noBun);
+            const hashedId = getHashedUserId();
+            const cloudName = await fetchCloudProfile(hashedId);
+            if (cloudName) {
+                setTrainerName(cloudName);
+                setBuddy(localBuddy);
+                setView('menu');
+            }
+            else {
+                setBuddy(localBuddy);
+                setView('setup');
+            }
+        }
+        boot();
+    }, []);
+    if (!buddy) {
+        return React.createElement(Text, { color: "cyan" }, "Syncing Cloud Profile...");
+    }
+    if (view === 'exit') {
+        process.exit(0);
+        return null; // unreachable
+    }
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 1, flexDirection: "column" },
+            React.createElement(Text, { color: "gray" },
+                "Logged in as ",
+                trainerName ?? buddy.name,
+                " (",
+                buddy.rarity,
+                " ",
+                buddy.species,
+                ")"),
+            bunWarning && (React.createElement(Text, { color: "yellow" }, "\u26A0 Bun not found \u2014 buddy stats may be inaccurate. Install Bun: curl -fsSL https://bun.sh/install | bash"))),
+        view === 'loading' && (React.createElement(Text, { color: "cyan" }, "Authenticating profile...")),
+        view === 'setup' && (React.createElement(Setup, { errorMsg: setupError, onComplete: async (name) => {
+                setSetupError(undefined);
+                const success = await createCloudProfile(getHashedUserId(), name);
+                if (success) {
+                    setTrainerName(name);
+                    setView('menu');
+                }
+                else {
+                    setSetupError(`Trainer name '${name}' is already taken. Please try another!`);
+                }
+            } })),
+        view === 'menu' && (React.createElement(Menu, { onSelect: (opt) => setView(opt) })),
+        view === 'leaderboard' && (React.createElement(Leaderboard, { onBack: () => setView('menu') })),
+        view === 'matchmaking' && (React.createElement(Matchmaking, { myBuddy: sanitizeBuddyForNetwork(buddy, trainerName), onCancel: () => setView('menu'), onMatch: (opp, id) => {
+                setOpponent(opp);
+                setBattleId(id);
+                setView('battle');
+            } })),
+        view === 'battle' && opponent && battleId && (React.createElement(Arena, { myBuddy: buddy, myTrainerName: trainerName ?? buddy.name, opponent: opponent, battleId: battleId, onLeave: () => setView('menu') }))));
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import React from 'react';
+import { render } from 'ink';
+import App from './app.js';
+render(React.createElement(App, null));

package/dist/config/reader.d.ts

@@ -0,0 +1,8 @@
+import { type Companion } from '../engine/types.js';
+export declare function getClaudeConfigHomeDir(): string;
+export type BuddyLoadResult = {
+    buddy: Companion;
+    bunWarning: boolean;
+};
+export declare function readLocalBuddy(): BuddyLoadResult;
+export declare function getHashedUserId(): string;

package/dist/config/reader.js

@@ -0,0 +1,102 @@
+import fs from 'fs';
+import os from 'os';
+import crypto from 'crypto';
+import path from 'path';
+import { execSync } from 'child_process';
+import { z } from 'zod';
+import { getCompanion } from '../engine/companion.js';
+// Try to resolve exactly where claude.json lives
+export function getClaudeConfigHomeDir() {
+    const baseDir = process.env['CLAUDE_CONFIG_DIR'] ?? path.join(os.homedir(), '.claude');
+    return baseDir.normalize('NFC');
+}
+const ClaudeConfigSchema = z.object({
+    userID: z.string().optional(),
+    oauthAccount: z.object({
+        accountUuid: z.string()
+    }).optional(),
+    companion: z.object({
+        name: z.string(),
+        personality: z.string(),
+        hatchedAt: z.number()
+    }).optional()
+}).passthrough();
+const GUEST_BUDDY = {
+    name: 'Stranger',
+    personality: 'Mysterious and ready to battle',
+    hatchedAt: Date.now()
+};
+// Check if Bun is available in PATH
+function isBunAvailable() {
+    try {
+        execSync('bun --version', { timeout: 3000, stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Shell out to Bun to extract the real buddy bones using Bun.hash (wyhash).
+// Claude Code runs on Bun, so the deterministic RNG seed differs from Node's
+// FNV hash. Since Claude Code users already have Bun installed, we leverage it.
+function extractRealBones() {
+    if (!isBunAvailable())
+        return null;
+    try {
+        // Try common locations relative to the project root
+        const candidates = [
+            path.resolve(process.cwd(), 'source', 'extract-bones.ts'),
+            path.resolve(path.dirname(process.argv[1] || ''), '..', 'source', 'extract-bones.ts'),
+        ];
+        for (const candidate of candidates) {
+            if (fs.existsSync(candidate)) {
+                const result = execSync(`bun "${candidate}"`, { timeout: 5000, encoding: 'utf-8' });
+                const parsed = JSON.parse(result.trim());
+                if (!parsed.error)
+                    return parsed;
+            }
+        }
+    }
+    catch (e) { }
+    return null;
+}
+export function readLocalBuddy() {
+    const configPath = path.join(os.homedir(), '.claude.json');
+    if (!fs.existsSync(configPath)) {
+        return { buddy: getCompanion('guest-123', GUEST_BUDDY), bunWarning: false };
+    }
+    try {
+        const fileContent = fs.readFileSync(configPath, 'utf-8');
+        const parsed = ClaudeConfigSchema.parse(JSON.parse(fileContent));
+        const userId = parsed.oauthAccount?.accountUuid ?? parsed.userID ?? 'guest-123';
+        const stored = parsed.companion;
+        const buddy = getCompanion(userId, stored ?? GUEST_BUDDY);
+        // Overlay the real bones from Bun.hash if available
+        const realBones = extractRealBones();
+        if (realBones) {
+            buddy.species = realBones.species;
+            buddy.rarity = realBones.rarity;
+            buddy.eye = realBones.eye;
+            buddy.hat = realBones.hat;
+            buddy.shiny = realBones.shiny;
+            buddy.stats = realBones.stats;
+        }
+        return { buddy, bunWarning: !realBones && !!stored };
+    }
+    catch (error) {
+        return { buddy: getCompanion('guest-123', GUEST_BUDDY), bunWarning: false };
+    }
+}
+export function getHashedUserId() {
+    const configPath = path.join(os.homedir(), '.claude.json');
+    let rawId = 'guest-123';
+    if (fs.existsSync(configPath)) {
+        try {
+            const fileContent = fs.readFileSync(configPath, 'utf-8');
+            const parsed = ClaudeConfigSchema.parse(JSON.parse(fileContent));
+            rawId = parsed.oauthAccount?.accountUuid ?? parsed.userID ?? 'guest-123';
+        }
+        catch (error) { }
+    }
+    return crypto.createHash('sha256').update(rawId + "buddy-battle-secret-salt").digest('hex');
+}

package/dist/engine/companion.d.ts

@@ -0,0 +1,8 @@
+import { type Companion, type CompanionBones, type StoredCompanion } from './types.js';
+export type Roll = {
+    bones: CompanionBones;
+    inspirationSeed: number;
+};
+export declare function roll(userId: string): Roll;
+export declare function rollWithSeed(seed: string): Roll;
+export declare function getCompanion(userId: string | undefined, stored: StoredCompanion | undefined): Companion | undefined;

package/dist/engine/companion.js

@@ -0,0 +1,97 @@
+import { EYES, HATS, RARITIES, RARITY_WEIGHTS, SPECIES, STAT_NAMES } from './types.js';
+// Mulberry32 — tiny seeded PRNG, good enough for picking ducks
+function mulberry32(seed) {
+    let a = seed >>> 0;
+    return function () {
+        a |= 0;
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+function hashString(s) {
+    if (typeof Bun !== 'undefined') {
+        return Number(BigInt(Bun.hash(s)) & 0xffffffffn);
+    }
+    let h = 2166136261;
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return h >>> 0;
+}
+function pick(rng, arr) {
+    return arr[Math.floor(rng() * arr.length)];
+}
+function rollRarity(rng) {
+    const total = Object.values(RARITY_WEIGHTS).reduce((a, b) => a + b, 0);
+    let roll = rng() * total;
+    for (const rarity of RARITIES) {
+        roll -= RARITY_WEIGHTS[rarity];
+        if (roll < 0)
+            return rarity;
+    }
+    return 'common';
+}
+const RARITY_FLOOR = {
+    common: 5,
+    uncommon: 15,
+    rare: 25,
+    epic: 35,
+    legendary: 50,
+};
+// One peak stat, one dump stat, rest scattered. Rarity bumps the floor.
+function rollStats(rng, rarity) {
+    const floor = RARITY_FLOOR[rarity];
+    const peak = pick(rng, STAT_NAMES);
+    let dump = pick(rng, STAT_NAMES);
+    while (dump === peak)
+        dump = pick(rng, STAT_NAMES);
+    const stats = {};
+    for (const name of STAT_NAMES) {
+        if (name === peak) {
+            stats[name] = Math.min(100, floor + 50 + Math.floor(rng() * 30));
+        }
+        else if (name === dump) {
+            stats[name] = Math.max(1, floor - 10 + Math.floor(rng() * 15));
+        }
+        else {
+            stats[name] = floor + Math.floor(rng() * 40);
+        }
+    }
+    return stats;
+}
+const SALT = 'friend-2026-401';
+function rollFrom(rng) {
+    const rarity = rollRarity(rng);
+    const bones = {
+        rarity,
+        species: pick(rng, SPECIES),
+        eye: pick(rng, EYES),
+        hat: rarity === 'common' ? 'none' : pick(rng, HATS),
+        shiny: rng() < 0.01,
+        stats: rollStats(rng, rarity),
+    };
+    return { bones, inspirationSeed: Math.floor(rng() * 1e9) };
+}
+// Called from three hot paths (500ms sprite tick, per-keystroke PromptInput,
+// per-turn observer) with the same userId → cache the deterministic result.
+let rollCache;
+export function roll(userId) {
+    const key = userId + SALT;
+    if (rollCache?.key === key)
+        return rollCache.value;
+    const value = rollFrom(mulberry32(hashString(key)));
+    rollCache = { key, value };
+    return value;
+}
+export function rollWithSeed(seed) {
+    return rollFrom(mulberry32(hashString(seed)));
+}
+export function getCompanion(userId, stored) {
+    if (!stored || !userId)
+        return undefined;
+    const { bones } = roll(userId);
+    return { ...stored, ...bones };
+}

package/dist/engine/sprites.d.ts

@@ -0,0 +1,4 @@
+import type { CompanionBones, Species } from './types.js';
+export declare function renderSprite(bones: CompanionBones, frame?: number): string[];
+export declare function spriteFrameCount(species: Species): number;
+export declare function renderFace(bones: CompanionBones): string;