buddy-finder-by-userid 1.0.0

package/README.md

@@ -0,0 +1,79 @@
+# Buddy Finder by UserID
+
+Claude Code Buddy 宠物属性穷举工具 - 通过穷举 userID 找到理想的 buddy 属性。
+
+## 功能特点
+
+- 🎯 **穷举搜索** - 随机生成 userID 并计算对应的 buddy 属性
+- 🔍 **条件过滤** - 按稀有度、物种、帽子、闪光、属性值筛选
+- 📊 **评分系统** - 计算与目标的匹配分数
+- ⚡ **进度显示** - 实时显示搜索进度和速率
+- 💾 **结果导出** - 保存匹配结果到 JSON 文件
+
+## 安装
+
+```bash
+# 克隆仓库
+git clone https://github.com/YOUR_USERNAME/buddy-finder-by-userID.git
+cd buddy-finder-by-userID
+
+# 确保 Node.js >= 18
+node --version
+```
+
+## 使用方法
+
+### 命令行
+
+```bash
+# 显示帮助
+node cli.js --help
+
+# 列出所有可用选项
+node cli.js --list
+
+# 测试指定 userID
+node cli.js --test 3a36224b57ca29e7f91a973131a565289378e898bcaebfe397f88483b5ef45d0
+
+# 使用预设搜索
+node cli.js -p perfect -i 50000000
+
+# 自定义条件搜索
+node cli.js -r legendary -s dragon --shiny
+```
+
+### 预设列表
+
+| 预设名 | 说明 |
+|--------|------|
+| `legendary_dragon` | 传奇龙 |
+| `legendary_dragon_shiny` | 闪光传奇龙 |
+| `legendary_dragon_wizard` | 传奇龙 + 巫师帽 |
+| `perfect` | 完美搭配（闪光传奇龙+巫师帽+高DEBUGGING）|
+| `any_legendary` | 任意传奇宠物 |
+| `shiny_hunter` | 闪光传奇宠物 |
+
+### 可用选项
+
+- `-p, --preset <name>` - 使用预设配置
+- `-r, --rarity <rarity>` - 目标稀有度 (common/uncommon/rare/epic/legendary)
+- `-s, --species <name>` - 目标物种
+- `-h, --hat <hat>` - 目标帽子
+- `--shiny` - 要求闪光
+- `--min-stat <stat:value>` - 最低属性值
+- `--peak-stat <stat>` - 峰值属性
+- `-i, --iterations <n>` - 最大迭代次数 (默认: 10000000)
+- `-o, --output <file>` - 输出结果到文件
+
+## 技术实现
+
+本工具实现了与 Claude Code buddy 系统完全一致的算法：
+
+- **Mulberry32 PRNG** - 确定性伪随机数生成器
+- **FNV-1a hash** - 字符串转数字种子
+- **稀有度权重抽取** - 基于权重的稀有度计算
+- **属性值生成** - 峰值/垃圾属性分配逻辑
+
+## 许可证
+
+MIT

package/cli.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * Buddy Finder CLI
+ * 穷举 userID 以获得特定的 Claude Code buddy 宠物属性
+ */
+export {};

package/cli.js

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+/**
+ * Buddy Finder CLI
+ * 穷举 userID 以获得特定的 Claude Code buddy 宠物属性
+ */
+import { parseArgs } from 'util';
+import { search, PRESETS, formatResult, calculateScore } from './search.js';
+import { rollBuddy } from './core.js';
+import { RARITIES, SPECIES, HATS, STAT_NAMES } from './types.js';
+import { writeFileSync } from 'fs';
+const HELP = `
+Buddy Finder - Claude Code 宠物属性穷举工具
+
+用法:
+  buddy-finder [options]
+
+选项:
+  -p, --preset <name>     使用预设配置 (见下方预设列表)
+  -r, --rarity <rarity>   目标稀有度 (common|uncommon|rare|epic|legendary)
+  -s, --species <name>    目标物种 (duck|dragon|cat|...)
+  -h, --hat <hat>         目标帽子 (none|crown|tophat|wizard|...)
+  --shiny                 要求闪光
+  --min-stat <stat:value> 最低属性值 (例: --min-stat DEBUGGING:80)
+  --peak-stat <stat>      峰值属性
+  -i, --iterations <n>    最大迭代次数 (默认: 10000000)
+  -o, --output <file>     输出结果到文件
+  --test <userId>         测试指定 userId 并显示结果
+  --list                  列出所有可用选项
+  --help                  显示帮助信息
+
+预设:
+  legendary_dragon        传奇龙
+  legendary_dragon_shiny  闪光传奇龙
+  legendary_dragon_wizard 传奇龙 + 巫师帽
+  perfect                 完美搭配 (闪光传奇龙+巫师帽+高DEBUGGING)
+  any_legendary           任意传奇宠物
+  shiny_hunter            闪光传奇宠物
+
+示例:
+  buddy-finder -p perfect -i 50000000
+  buddy-finder -r legendary -s dragon --shiny
+  buddy-finder --test 3a36224b57ca29e7f91a973131a565289378e898bcaebfe397f88483b5ef45d0
+`;
+function listOptions() {
+    console.log('\n=== 可用选项 ===\n');
+    console.log('稀有度:', RARITIES.join(', '));
+    console.log('\n物种:', SPECIES.join(', '));
+    console.log('\n帽子:', HATS.join(', '));
+    console.log('\n属性:', STAT_NAMES.join(', '));
+    console.log('\n预设:');
+    for (const [name, preset] of Object.entries(PRESETS)) {
+        console.log(`  ${name}: ${preset.description}`);
+    }
+}
+function testUserId(userId) {
+    console.log(`\n测试 userID: ${userId}\n`);
+    const result = rollBuddy(userId);
+    console.log(formatResult(result));
+    // 计算各预设的分数
+    console.log('\n=== 各预设匹配分数 ===');
+    for (const [name, preset] of Object.entries(PRESETS)) {
+        const score = calculateScore(result, preset.criteria);
+        console.log(`${name}: ${score}/100`);
+    }
+}
+function runSearch(options) {
+    // 构建搜索条件
+    const criteria = {};
+    if (options.preset) {
+        const preset = PRESETS[options.preset];
+        if (!preset) {
+            console.error(`未知预设: ${options.preset}`);
+            console.log('可用预设:', Object.keys(PRESETS).join(', '));
+            process.exit(1);
+        }
+        Object.assign(criteria, preset.criteria);
+        console.log(`\n使用预设: ${options.preset} (${preset.description})`);
+    }
+    if (options.rarity) {
+        if (!RARITIES.includes(options.rarity)) {
+            console.error(`未知稀有度: ${options.rarity}`);
+            process.exit(1);
+        }
+        criteria.rarity = options.rarity;
+    }
+    if (options.species) {
+        if (!SPECIES.includes(options.species)) {
+            console.error(`未知物种: ${options.species}`);
+            process.exit(1);
+        }
+        criteria.species = options.species;
+    }
+    if (options.hat) {
+        if (!HATS.includes(options.hat)) {
+            console.error(`未知帽子: ${options.hat}`);
+            process.exit(1);
+        }
+        criteria.hat = options.hat;
+    }
+    if (options.shiny) {
+        criteria.shiny = true;
+    }
+    if (options.minStats.length > 0) {
+        criteria.minStats = {};
+        for (const spec of options.minStats) {
+            const [stat, value] = spec.split(':');
+            if (!STAT_NAMES.includes(stat)) {
+                console.error(`未知属性: ${stat}`);
+                process.exit(1);
+            }
+            criteria.minStats[stat] = parseInt(value, 10);
+        }
+    }
+    if (options.peakStat) {
+        if (!STAT_NAMES.includes(options.peakStat)) {
+            console.error(`未知属性: ${options.peakStat}`);
+            process.exit(1);
+        }
+        criteria.peakStat = options.peakStat;
+    }
+    console.log(`\n搜索条件:`);
+    console.log(JSON.stringify(criteria, null, 2));
+    console.log(`最大迭代: ${options.iterations.toLocaleString()}`);
+    console.log('');
+    const startTime = Date.now();
+    let lastUpdate = startTime;
+    const result = search({
+        maxIterations: options.iterations,
+        criteria,
+        onProgress: (iterations, bestScore) => {
+            const now = Date.now();
+            if (now - lastUpdate > 1000) { // 每秒更新一次
+                const elapsed = ((now - startTime) / 1000).toFixed(1);
+                const rate = (iterations / (now - startTime) * 1000).toFixed(0);
+                process.stdout.write(`\r已搜索 ${iterations.toLocaleString()} (${rate}/s) | 最佳分数: ${bestScore} | 耗时: ${elapsed}s`);
+                lastUpdate = now;
+            }
+        },
+        onMatch: (match, score) => {
+            console.log(`\n\n★ 找到匹配! (分数: ${score})`);
+            console.log(formatResult(match));
+            console.log('');
+        }
+    });
+    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+    console.log(`\n\n搜索完成! 耗时: ${elapsed}s`);
+    if (result) {
+        console.log('\n=== 最终最佳结果 ===');
+        console.log(formatResult(result));
+        if (options.output) {
+            const output = {
+                ...result,
+                searchedAt: new Date().toISOString(),
+                elapsedSeconds: parseFloat(elapsed)
+            };
+            writeFileSync(options.output, JSON.stringify(output, null, 2));
+            console.log(`\n结果已保存到: ${options.output}`);
+        }
+    }
+    else {
+        console.log('\n未找到匹配，尝试增加迭代次数');
+    }
+}
+// 解析命令行参数
+const { values } = parseArgs({
+    options: {
+        preset: { type: 'string', short: 'p' },
+        rarity: { type: 'string', short: 'r' },
+        species: { type: 'string', short: 's' },
+        hat: { type: 'string', short: 'h' },
+        shiny: { type: 'boolean' },
+        'min-stat': { type: 'string', multiple: true },
+        'peak-stat': { type: 'string' },
+        iterations: { type: 'string', short: 'i', default: '10000000' },
+        output: { type: 'string', short: 'o' },
+        test: { type: 'string' },
+        list: { type: 'boolean' },
+        help: { type: 'boolean' }
+    },
+    strict: true
+});
+if (values.help) {
+    console.log(HELP);
+    process.exit(0);
+}
+if (values.list) {
+    listOptions();
+    process.exit(0);
+}
+if (values.test) {
+    testUserId(values.test);
+    process.exit(0);
+}
+runSearch({
+    preset: values.preset,
+    rarity: values.rarity,
+    species: values.species,
+    hat: values.hat,
+    shiny: values.shiny,
+    minStats: values['min-stat'] || [],
+    peakStat: values['peak-stat'],
+    iterations: parseInt(values.iterations, 10),
+    output: values.output
+});

package/core.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 核心算法 - 与 Claude Code buddy 系统完全一致的实现
+ */
+import { Rarity, StatName, BuddyResult } from './types.js';
+export { RARITY_FLOOR } from './types.js';
+export declare const SALT = "friend-2026-401";
+/**
+ * Mulberry32 PRNG - 确定性伪随机数生成器
+ */
+export declare function mulberry32(seed: number): () => number;
+/**
+ * FNV-1a hash - 字符串转数字种子
+ */
+export declare function hashString(s: string): number;
+/**
+ * 根据权重抽取稀有度
+ */
+export declare function rollRarity(rng: () => number): Rarity;
+/**
+ * 生成属性值
+ */
+export declare function rollStats(rng: () => number, rarity: Rarity): Record<StatName, number>;
+/**
+ * 根据 userId 生成 buddy 属性
+ */
+export declare function rollBuddy(userId: string): BuddyResult;
+/**
+ * 生成随机 userId (64字符十六进制)
+ */
+export declare function generateRandomUserId(): string;

package/core.js

@@ -0,0 +1,97 @@
+/**
+ * 核心算法 - 与 Claude Code buddy 系统完全一致的实现
+ */
+import { RARITIES, SPECIES, EYES, HATS, STAT_NAMES, RARITY_WEIGHTS, RARITY_FLOOR } from './types.js';
+export { RARITY_FLOOR } from './types.js';
+export const SALT = 'friend-2026-401';
+/**
+ * Mulberry32 PRNG - 确定性伪随机数生成器
+ */
+export 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;
+    };
+}
+/**
+ * FNV-1a hash - 字符串转数字种子
+ */
+export function hashString(s) {
+    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)];
+}
+/**
+ * 根据权重抽取稀有度
+ */
+export 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';
+}
+/**
+ * 生成属性值
+ */
+export 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;
+}
+/**
+ * 根据 userId 生成 buddy 属性
+ */
+export function rollBuddy(userId) {
+    const key = userId + SALT;
+    const rng = mulberry32(hashString(key));
+    const rarity = rollRarity(rng);
+    const species = pick(rng, SPECIES);
+    const eye = pick(rng, EYES);
+    const hat = rarity === 'common' ? 'none' : pick(rng, HATS);
+    const shiny = rng() < 0.01;
+    const stats = rollStats(rng, rarity);
+    return { userId, rarity, species, eye, hat, shiny, stats };
+}
+/**
+ * 生成随机 userId (64字符十六进制)
+ */
+export function generateRandomUserId() {
+    const chars = '0123456789abcdef';
+    let userId = '';
+    for (let i = 0; i < 64; i++) {
+        userId += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return userId;
+}

package/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Buddy Finder - Claude Code 宠物属性穷举工具
+ */
+export * from './types.js';
+export * from './core.js';
+export * from './search.js';

package/index.js

@@ -0,0 +1,6 @@
+/**
+ * Buddy Finder - Claude Code 宠物属性穷举工具
+ */
+export * from './types.js';
+export * from './core.js';
+export * from './search.js';

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "buddy-finder-by-userid",
+  "version": "1.0.0",
+  "description": "Claude Code Buddy 宠物属性穷举工具 - 通过穷举 userID 找到理想的 buddy 属性",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "buddy-finder": "./cli.js"
+  },
+  "scripts": {
+    "start": "node cli.js",
+    "test": "node cli.js --test"
+  },
+  "keywords": [
+    "claude-code",
+    "buddy",
+    "pet",
+    "finder",
+    "userID",
+    "brute-force"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/search.d.ts

@@ -0,0 +1,73 @@
+/**
+ * 搜索策略
+ */
+import { BuddyResult, SearchCriteria, SearchOptions } from './types.js';
+/**
+ * 计算匹配分数
+ */
+export declare function calculateScore(result: BuddyResult, criteria: SearchCriteria): number;
+/**
+ * 检查是否满足最低要求
+ */
+export declare function meetsCriteria(result: BuddyResult, criteria: SearchCriteria): boolean;
+/**
+ * 随机穷举搜索
+ */
+export declare function search(options: SearchOptions): BuddyResult | null;
+/**
+ * 预设搜索配置
+ */
+export declare const PRESETS: {
+    readonly legendary_dragon: {
+        readonly criteria: {
+            readonly rarity: "legendary";
+            readonly species: "dragon";
+        };
+        readonly description: "传奇龙";
+    };
+    readonly legendary_dragon_shiny: {
+        readonly criteria: {
+            readonly rarity: "legendary";
+            readonly species: "dragon";
+            readonly shiny: true;
+        };
+        readonly description: "闪光传奇龙";
+    };
+    readonly legendary_dragon_wizard: {
+        readonly criteria: {
+            readonly rarity: "legendary";
+            readonly species: "dragon";
+            readonly hat: "wizard";
+        };
+        readonly description: "传奇龙 + 巫师帽";
+    };
+    readonly perfect: {
+        readonly criteria: {
+            readonly rarity: "legendary";
+            readonly species: "dragon";
+            readonly hat: "wizard";
+            readonly shiny: true;
+            readonly minStats: {
+                readonly DEBUGGING: 90;
+            };
+        };
+        readonly description: "完美搭配: 闪光传奇龙 + 巫师帽 + 高DEBUGGING";
+    };
+    readonly any_legendary: {
+        readonly criteria: {
+            readonly rarity: "legendary";
+        };
+        readonly description: "任意传奇宠物";
+    };
+    readonly shiny_hunter: {
+        readonly criteria: {
+            readonly shiny: true;
+            readonly rarity: "legendary";
+        };
+        readonly description: "闪光传奇宠物";
+    };
+};
+/**
+ * 格式化输出结果
+ */
+export declare function formatResult(result: BuddyResult): string;

package/search.js

@@ -0,0 +1,183 @@
+/**
+ * 搜索策略
+ */
+import { rollBuddy, generateRandomUserId, RARITY_FLOOR } from './core.js';
+/**
+ * 计算匹配分数
+ */
+export function calculateScore(result, criteria) {
+    let score = 0;
+    let maxScore = 0;
+    // 稀有度得分
+    maxScore += 100;
+    if (criteria.rarity && criteria.rarity !== 'any') {
+        if (result.rarity === criteria.rarity)
+            score += 100;
+    }
+    else {
+        score += RARITY_FLOOR[result.rarity];
+    }
+    // 物种得分
+    maxScore += 50;
+    if (criteria.species && criteria.species !== 'any') {
+        if (result.species === criteria.species)
+            score += 50;
+    }
+    else {
+        score += 25; // 任意物种给一半分
+    }
+    // 帽子得分
+    maxScore += 50;
+    if (criteria.hat && criteria.hat !== 'any') {
+        if (result.hat === criteria.hat)
+            score += 50;
+    }
+    else if (result.hat !== 'none') {
+        score += 25; // 有帽子但任意类型
+    }
+    // 闪光得分
+    maxScore += 30;
+    if (criteria.shiny === true) {
+        if (result.shiny)
+            score += 30;
+    }
+    else if (result.shiny) {
+        score += 15; // 闪光但不是必须
+    }
+    // 属性值得分
+    if (criteria.minStats) {
+        for (const [stat, min] of Object.entries(criteria.minStats)) {
+            maxScore += 50;
+            if (result.stats[stat] >= min) {
+                score += 50;
+            }
+            else {
+                score += (result.stats[stat] / min) * 50;
+            }
+        }
+    }
+    // 峰值属性奖励
+    if (criteria.peakStat) {
+        maxScore += 30;
+        const peak = findPeakStat(result);
+        if (peak === criteria.peakStat)
+            score += 30;
+    }
+    // 归一化得分 (0-100)
+    return Math.round((score / maxScore) * 100);
+}
+/**
+ * 找出峰值属性
+ */
+function findPeakStat(result) {
+    let max = 0;
+    let peak = 'DEBUGGING';
+    for (const [stat, value] of Object.entries(result.stats)) {
+        if (value > max) {
+            max = value;
+            peak = stat;
+        }
+    }
+    return peak;
+}
+/**
+ * 检查是否满足最低要求
+ */
+export function meetsCriteria(result, criteria) {
+    if (criteria.rarity && criteria.rarity !== 'any' && result.rarity !== criteria.rarity)
+        return false;
+    if (criteria.species && criteria.species !== 'any' && result.species !== criteria.species)
+        return false;
+    if (criteria.hat && criteria.hat !== 'any' && result.hat !== criteria.hat)
+        return false;
+    if (criteria.shiny !== undefined && result.shiny !== criteria.shiny)
+        return false;
+    if (criteria.minStats) {
+        for (const [stat, min] of Object.entries(criteria.minStats)) {
+            if (result.stats[stat] < min)
+                return false;
+        }
+    }
+    return true;
+}
+/**
+ * 随机穷举搜索
+ */
+export function search(options) {
+    const { maxIterations, criteria, onProgress, onMatch } = options;
+    let bestMatch = null;
+    let bestScore = 0;
+    for (let i = 0; i < maxIterations; i++) {
+        const userId = generateRandomUserId();
+        const result = rollBuddy(userId);
+        if (meetsCriteria(result, criteria)) {
+            const score = calculateScore(result, criteria);
+            if (score > bestScore) {
+                bestMatch = result;
+                bestScore = score;
+                onMatch?.(result, score);
+                // 完美匹配 (score >= 95) 可以提前结束
+                if (score >= 95) {
+                    onProgress?.(i + 1, score);
+                    return result;
+                }
+            }
+        }
+        if (i % 100000 === 0 && i > 0) {
+            onProgress?.(i, bestScore);
+        }
+    }
+    onProgress?.(maxIterations, bestScore);
+    return bestMatch;
+}
+/**
+ * 预设搜索配置
+ */
+export const PRESETS = {
+    legendary_dragon: {
+        criteria: { rarity: 'legendary', species: 'dragon' },
+        description: '传奇龙'
+    },
+    legendary_dragon_shiny: {
+        criteria: { rarity: 'legendary', species: 'dragon', shiny: true },
+        description: '闪光传奇龙'
+    },
+    legendary_dragon_wizard: {
+        criteria: { rarity: 'legendary', species: 'dragon', hat: 'wizard' },
+        description: '传奇龙 + 巫师帽'
+    },
+    perfect: {
+        criteria: {
+            rarity: 'legendary',
+            species: 'dragon',
+            hat: 'wizard',
+            shiny: true,
+            minStats: { DEBUGGING: 90 }
+        },
+        description: '完美搭配: 闪光传奇龙 + 巫师帽 + 高DEBUGGING'
+    },
+    any_legendary: {
+        criteria: { rarity: 'legendary' },
+        description: '任意传奇宠物'
+    },
+    shiny_hunter: {
+        criteria: { shiny: true, rarity: 'legendary' },
+        description: '闪光传奇宠物'
+    }
+};
+/**
+ * 格式化输出结果
+ */
+export function formatResult(result) {
+    const lines = [
+        `userID: ${result.userId}`,
+        `稀有度: ${result.rarity} (基础属性 ${RARITY_FLOOR[result.rarity]})`,
+        `物种: ${result.species}`,
+        `眼睛: ${result.eye}`,
+        `帽子: ${result.hat}`,
+        `闪光: ${result.shiny ? '是 ★' : '否'}`,
+        '属性:',
+        ...Object.entries(result.stats).map(([k, v]) => `  ${k}: ${v}`)
+    ];
+    return lines.join('\n');
+}

package/types.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 类型定义
+ */
+export declare const RARITIES: readonly ["common", "uncommon", "rare", "epic", "legendary"];
+export type Rarity = typeof RARITIES[number];
+export declare const SPECIES: readonly ["duck", "goose", "blob", "cat", "dragon", "octopus", "owl", "penguin", "turtle", "snail", "ghost", "axolotl", "capybara", "cactus", "robot", "rabbit", "mushroom", "chonk"];
+export type Species = typeof SPECIES[number];
+export declare const EYES: readonly ["·", "✦", "×", "◉", "@", "°"];
+export type Eye = typeof EYES[number];
+export declare const HATS: readonly ["none", "crown", "tophat", "propeller", "halo", "wizard", "beanie", "tinyduck"];
+export type Hat = typeof HATS[number];
+export declare const STAT_NAMES: readonly ["DEBUGGING", "PATIENCE", "CHAOS", "WISDOM", "SNACK"];
+export type StatName = typeof STAT_NAMES[number];
+export declare const RARITY_WEIGHTS: Record<Rarity, number>;
+export declare const RARITY_FLOOR: Record<Rarity, number>;
+export interface BuddyResult {
+    userId: string;
+    rarity: Rarity;
+    species: Species;
+    eye: Eye;
+    hat: Hat;
+    shiny: boolean;
+    stats: Record<StatName, number>;
+}
+export interface SearchCriteria {
+    rarity?: Rarity | 'any';
+    species?: Species | 'any';
+    hat?: Hat | 'any';
+    shiny?: boolean;
+    minStats?: Partial<Record<StatName, number>>;
+    peakStat?: StatName;
+}
+export interface SearchOptions {
+    maxIterations: number;
+    criteria: SearchCriteria;
+    onProgress?: (iterations: number, bestScore: number) => void;
+    onMatch?: (result: BuddyResult, score: number) => void;
+}

package/types.js

@@ -0,0 +1,27 @@
+/**
+ * 类型定义
+ */
+export const RARITIES = ['common', 'uncommon', 'rare', 'epic', 'legendary'];
+export const SPECIES = [
+    'duck', 'goose', 'blob', 'cat', 'dragon',
+    'octopus', 'owl', 'penguin', 'turtle', 'snail',
+    'ghost', 'axolotl', 'capybara', 'cactus', 'robot',
+    'rabbit', 'mushroom', 'chonk'
+];
+export const EYES = ['·', '✦', '×', '◉', '@', '°'];
+export const HATS = ['none', 'crown', 'tophat', 'propeller', 'halo', 'wizard', 'beanie', 'tinyduck'];
+export const STAT_NAMES = ['DEBUGGING', 'PATIENCE', 'CHAOS', 'WISDOM', 'SNACK'];
+export const RARITY_WEIGHTS = {
+    common: 60,
+    uncommon: 25,
+    rare: 10,
+    epic: 4,
+    legendary: 1
+};
+export const RARITY_FLOOR = {
+    common: 5,
+    uncommon: 15,
+    rare: 25,
+    epic: 35,
+    legendary: 50
+};