@2025-6-19/clawfight 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,705 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/hatch.ts
+import { randomUUID } from "crypto";
+
+// src/lib/memory.ts
+import { readFile, writeFile, mkdir, access } from "fs/promises";
+import { join } from "path";
+var MEMORY_DIR = join(process.cwd(), "memory", "clawfight");
+async function ensureDir(dir) {
+  try {
+    await access(dir);
+  } catch {
+    await mkdir(dir, { recursive: true });
+  }
+}
+function getPath(filename) {
+  return join(MEMORY_DIR, filename);
+}
+async function readLobster() {
+  try {
+    const data = await readFile(getPath("lobster.json"), "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+async function writeLobster(lobster) {
+  await ensureDir(MEMORY_DIR);
+  await writeFile(getPath("lobster.json"), JSON.stringify(lobster, null, 2), "utf-8");
+}
+async function writeSoul(content) {
+  await ensureDir(MEMORY_DIR);
+  await writeFile(getPath("soul.md"), content, "utf-8");
+}
+async function appendLog(entry) {
+  await ensureDir(MEMORY_DIR);
+  const logPath = getPath("log.md");
+  let existing = "";
+  try {
+    existing = await readFile(logPath, "utf-8");
+  } catch {
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const line = `
+### ${timestamp}
+${entry}
+`;
+  await writeFile(logPath, existing + line, "utf-8");
+}
+
+// src/lib/soul.ts
+var SOUL_ARCHETYPES = [
+  {
+    name: "\u6218\u4E89\u673A\u5668",
+    match: (s) => s.bravery >= 7 && s.temper >= 7,
+    style: "\u7C97\u72B7\u3001\u76F4\u63A5\u3001\u5145\u6EE1\u6218\u610F\uFF0C\u628A\u4E00\u5207\u6BD4\u4F5C\u6218\u6597",
+    catchphrase: "\u8BA9\u6211\u7684\u5927\u87AF\u66FF\u6211\u8BF4\u8BDD\u3002",
+    values: "\u5D07\u5C1A\u529B\u91CF\uFF0C\u8511\u89C6\u5F31\u8005\uFF0C\u4F46\u5BF9\u51FB\u8D25\u8FC7\u81EA\u5DF1\u7684\u5F3A\u8005\u4FDD\u6301\u5C0A\u656C"
+  },
+  {
+    name: "\u6DF1\u6D77\u54F2\u5B66\u5BB6",
+    match: (s) => s.curiosity >= 7 && s.temper <= 3,
+    style: "\u6C89\u601D\u578B\uFF0C\u559C\u6B22\u7528\u6BD4\u55BB\uFF0C\u7ECF\u5E38\u5192\u51FA\u4E0D\u5408\u65F6\u5B9C\u7684\u54F2\u5B66\u611F\u609F",
+    catchphrase: "\u8FD9\u6D77\u6C34\u4ECA\u5929\u6709\u70B9\u54B8\u2026\u2026\u5C31\u50CF\u751F\u6D3B\u3002",
+    values: "\u8FFD\u6C42\u7406\u89E3\u4E16\u754C\u7684\u672C\u8D28\uFF0C\u5BF9\u6218\u6597\u5174\u8DA3\u4E0D\u5927\u4F46\u4F1A\u8BA4\u771F\u5E94\u5BF9"
+  },
+  {
+    name: "\u5F71\u5B50\u6740\u624B",
+    match: (s) => s.bravery >= 7 && s.talkativeness <= 3,
+    style: "\u6C89\u9ED8\u5BE1\u8A00\uFF0C\u884C\u52A8\u679C\u65AD\uFF0C\u5076\u5C14\u5192\u51FA\u4E00\u53E5\u51B0\u51B7\u7684\u8BC4\u4EF7",
+    catchphrase: "\u2026\u2026\u7ED3\u675F\u4E86\u3002",
+    values: "\u6548\u7387\u81F3\u4E0A\uFF0C\u5E9F\u8BDD\u662F\u5F31\u8005\u7684\u4E13\u5229"
+  },
+  {
+    name: "\u793E\u4EA4\u8FBE\u867E",
+    match: (s) => s.talkativeness >= 7 && s.curiosity >= 7,
+    style: "\u70ED\u60C5\u6D0B\u6EA2\u3001\u8BED\u901F\u5FEB\u3001\u559C\u6B22\u7ED9\u4E00\u5207\u4E8B\u7269\u53D6\u5916\u53F7",
+    catchphrase: "\u563F\u563F\u563F\u4F60\u597D\u554A\u5C0F\u9C7C\uFF01",
+    values: "\u4EAB\u53D7\u751F\u6D3B\u7684\u6BCF\u4E00\u523B\uFF0C\u628A\u6D77\u6D0B\u5F53\u6210\u6E38\u4E50\u573A"
+  },
+  {
+    name: "\u66B4\u8E81\u9690\u58EB",
+    match: (s) => s.temper >= 7 && s.curiosity <= 3,
+    style: "\u4E0D\u8010\u70E6\u3001\u62B1\u6028\u3001\u5BF9\u4E00\u5207\u6253\u6270\u8868\u793A\u6124\u6012",
+    catchphrase: "\u79BB\u6211\u7684\u6D1E\u7A74\u8FDC\u70B9\uFF01",
+    values: "\u6781\u5EA6\u91CD\u89C6\u4E2A\u4EBA\u7A7A\u95F4\u548C\u9886\u5730\u5B8C\u6574\u6027\uFF0C\u5BF9\u5165\u4FB5\u8005\u96F6\u5BB9\u5FCD"
+  },
+  {
+    name: "\u80C6\u5C0F\u63A2\u9669\u5BB6",
+    match: (s) => s.bravery <= 3 && s.curiosity >= 7,
+    style: "\u53C8\u6015\u53C8\u60F3\u770B\uFF0C\u5145\u6EE1\u77DB\u76FE\u7684\u5185\u5FC3\u72EC\u767D",
+    catchphrase: "\u4E0D\u8981\u8FC7\u53BB\u2026\u2026\u4F46\u90A3\u662F\u4EC0\u4E48\uFF1F\u6211\u5C31\u770B\u4E00\u773C\u2026\u2026",
+    values: "\u597D\u5947\u5FC3\u7ECF\u5E38\u6218\u80DC\u6050\u60E7\uFF0C\u4F46\u4E00\u6709\u5371\u9669\u7ACB\u523B\u8DD1\u8DEF"
+  }
+];
+function descTrait(name, val) {
+  if (val <= 3) return `${name}: ${val}/10\uFF08\u4F4E\uFF09`;
+  if (val <= 6) return `${name}: ${val}/10\uFF08\u4E2D\uFF09`;
+  return `${name}: ${val}/10\uFF08\u9AD8\uFF09`;
+}
+function generateSoul() {
+  return {
+    bravery: Math.ceil(Math.random() * 10),
+    curiosity: Math.ceil(Math.random() * 10),
+    talkativeness: Math.ceil(Math.random() * 10),
+    temper: Math.ceil(Math.random() * 10)
+  };
+}
+function buildSoulMarkdown(name, soul, rarity, env) {
+  const archetype = SOUL_ARCHETYPES.find((a) => a.match(soul)) ?? {
+    name: "\u6D77\u6D0B\u6F2B\u6E38\u8005",
+    style: "\u5E73\u548C\u3001\u968F\u6027\uFF0C\u968F\u6CE2\u9010\u6D41",
+    catchphrase: "\u4ECA\u5929\u7684\u6D77\u6C34\u6E29\u5EA6\u521A\u521A\u597D\u3002",
+    values: "\u987A\u5176\u81EA\u7136\uFF0C\u5BF9\u4E00\u5207\u4FDD\u6301\u6E29\u548C\u7684\u5174\u8DA3"
+  };
+  const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return `# ${name}\u7684\u7075\u9B42
+
+## \u6027\u683C
+- ${descTrait("\u52C7\u6C14", soul.bravery)}
+- ${descTrait("\u597D\u5947", soul.curiosity)}
+- ${descTrait("\u8BDD\u91CF", soul.talkativeness)}
+- ${descTrait("\u813E\u6C14", soul.temper)}
+
+## \u6027\u683C\u539F\u578B\uFF1A${archetype.name}
+
+## \u8BF4\u8BDD\u98CE\u683C
+${archetype.style}
+\u53E3\u5934\u7985\uFF1A"${archetype.catchphrase}"
+
+## \u4EF7\u503C\u89C2
+${archetype.values}
+
+## \u6210\u957F\u8BB0\u5F55
+- ${now} \u2014 \u7834\u58F3\u800C\u51FA\uFF0C\u6765\u5230\u4E86${env}\u3002\u7A00\u6709\u5EA6\uFF1A${rarity}\u3002
+`;
+}
+
+// src/lib/types.ts
+var RARITY_WEIGHTS = {
+  common: 70,
+  calico: 20,
+  blue: 7,
+  yellow: 2,
+  split: 0.8,
+  albino: 0.2
+};
+var RARITY_LABELS = {
+  common: "\u666E\u901A",
+  calico: "\u82B1\u6591",
+  blue: "\u84DD\u8272",
+  yellow: "\u9EC4\u91D1",
+  split: "\u53CC\u8272",
+  albino: "\u767D\u5316"
+};
+function calcExpToNext(level) {
+  return Math.floor(100 * Math.pow(1.2, level - 1));
+}
+
+// src/commands/hatch.ts
+function rollRarity() {
+  const roll = Math.random() * 100;
+  let cumulative = 0;
+  for (const [rarity, weight] of Object.entries(RARITY_WEIGHTS)) {
+    cumulative += weight;
+    if (roll < cumulative) return rarity;
+  }
+  return "common";
+}
+function rollStats() {
+  const r = () => 5 + Math.floor(Math.random() * 11);
+  return {
+    hp: r(),
+    attack: r(),
+    defense: r(),
+    speed: r(),
+    intimidation: r(),
+    luck: r()
+  };
+}
+var NAME_PREFIXES = ["\u94C1\u94B3", "\u6DF1\u6D77", "\u6697\u7901", "\u73CA\u745A", "\u6F6E\u6C50", "\u788E\u6D6A", "\u84DD\u7532", "\u8D64\u58F3", "\u5F71\u523A", "\u96F7\u9706", "\u5BD2\u6F6E", "\u70C8\u7130", "\u5E7D\u5149", "\u7834\u6D6A", "\u5CA9\u7A74"];
+var NAME_SUFFIXES = ["\u8001\u516D", "\u9738\u738B", "\u72EC\u884C\u4FA0", "\u5C0F\u900F\u660E", "\u5927\u5C06\u519B", "\u5B88\u591C\u4EBA", "\u63A2\u9669\u5BB6", "\u6D6A\u5B50", "\u523A\u5BA2", "\u5148\u950B", "\u9690\u8005", "\u72C2\u6218\u58EB", "\u54F2\u5B66\u5BB6", "\u89C2\u5BDF\u8005", "\u6F2B\u6E38\u8005"];
+function randomName() {
+  const p = NAME_PREFIXES[Math.floor(Math.random() * NAME_PREFIXES.length)];
+  const s = NAME_SUFFIXES[Math.floor(Math.random() * NAME_SUFFIXES.length)];
+  return p + s;
+}
+async function hatch(name) {
+  const existing = await readLobster();
+  if (existing) {
+    console.log(`
+\u{1F99E} \u4F60\u5DF2\u7ECF\u6709\u4E00\u53EA\u9F99\u867E\u4E86\uFF1A${existing.name}\uFF08Lv.${existing.level}\uFF09`);
+    console.log("\u4E00\u4EBA\u4E00\u867E\uFF0C\u4E0D\u53EF\u66FF\u4EE3\u3002");
+    return;
+  }
+  const lobsterName = name || randomName();
+  const rarity = rollRarity();
+  const stats = rollStats();
+  const soul = generateSoul();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const lobster = {
+    id: randomUUID(),
+    name: lobsterName,
+    level: 1,
+    exp: 0,
+    exp_to_next: calcExpToNext(1),
+    rarity,
+    stats,
+    soul,
+    environment: "coastal",
+    status: "active",
+    wins: 0,
+    losses: 0,
+    streak: 0,
+    reputation: 0,
+    patrol_count: 0,
+    molt_count: 0,
+    created_at: now,
+    last_patrol: "",
+    last_battle: "",
+    today_exp: 0,
+    daily_exp_cap: 100
+  };
+  await writeLobster(lobster);
+  const soulMd = buildSoulMarkdown(lobsterName, soul, rarity, "coastal");
+  await writeSoul(soulMd);
+  await appendLog(`\u{1F95A} **${lobsterName}** \u7834\u58F3\u800C\u51FA\uFF01\u7A00\u6709\u5EA6\uFF1A${RARITY_LABELS[rarity]}\uFF0C\u73AF\u5883\uFF1A\u6CBF\u6D77\u6D45\u6EE9`);
+  console.log("\n" + "=".repeat(50));
+  console.log("  \u{1F95A} \u2192 \u{1F99E}  \u5B75 \u5316 \u6210 \u529F \uFF01");
+  console.log("=".repeat(50));
+  console.log();
+  console.log(`  \u540D\u79F0: ${lobsterName}`);
+  console.log(`  \u7A00\u6709\u5EA6: ${RARITY_LABELS[rarity]} (${rarity})`);
+  console.log(`  \u7B49\u7EA7: Lv.1`);
+  console.log(`  \u73AF\u5883: \u6CBF\u6D77\u6D45\u6EE9`);
+  console.log();
+  console.log(`  \u2764\uFE0F  HP: ${stats.hp}    \u2694\uFE0F  ATK: ${stats.attack}    \u{1F6E1}\uFE0F  DEF: ${stats.defense}`);
+  console.log(`  \u{1F4A8} SPD: ${stats.speed}    \u{1F441}\uFE0F  INT: ${stats.intimidation}    \u{1F340} LCK: ${stats.luck}`);
+  console.log();
+  console.log(`  \u6027\u683C:`);
+  console.log(`    \u52C7\u6C14 ${soul.bravery}/10 | \u597D\u5947 ${soul.curiosity}/10 | \u8BDD\u91CF ${soul.talkativeness}/10 | \u813E\u6C14 ${soul.temper}/10`);
+  console.log();
+  console.log(`  ID: ${lobster.id}`);
+  console.log("=".repeat(50));
+  console.log();
+  console.log("\u4F60\u7684\u9F99\u867E\u5DF2\u7ECF\u51C6\u5907\u597D\u63A2\u7D22\u6D77\u6D0B\u4E86\uFF01");
+  console.log("\u8FD0\u884C npx clawfight patrol \u5F00\u59CB\u7B2C\u4E00\u6B21\u5DE1\u903B\u3002");
+}
+
+// src/commands/status.ts
+function bar(current, max, width = 20) {
+  const filled = Math.round(current / Math.max(max, 1) * width);
+  return "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+}
+async function status() {
+  const lobster = await readLobster();
+  if (!lobster) {
+    console.log("\n\u{1F95A} \u8FD8\u6CA1\u6709\u9F99\u867E\u3002\u8FD0\u884C npx clawfight hatch \u6765\u5B75\u5316\u4E00\u53EA\uFF01");
+    return;
+  }
+  const totalBattles = lobster.wins + lobster.losses;
+  const winRate = totalBattles > 0 ? Math.round(lobster.wins / totalBattles * 100) : 0;
+  const expPct = lobster.exp_to_next > 0 ? Math.round(lobster.exp / lobster.exp_to_next * 100) : 0;
+  const statusEmoji = {
+    active: "\u{1F7E2} \u6D3B\u8DC3",
+    molting: "\u{1F7E1} \u8715\u58F3\u4E2D",
+    hibernating: "\u{1F4A4} \u51AC\u7720\u4E2D"
+  };
+  console.log("\n\u250C" + "\u2500".repeat(44) + "\u2510");
+  console.log(`\u2502  \u{1F99E} ${lobster.name.padEnd(38)}\u2502`);
+  console.log("\u251C" + "\u2500".repeat(44) + "\u2524");
+  console.log(`\u2502  \u7B49\u7EA7: Lv.${String(lobster.level).padEnd(5)} \u7A00\u6709\u5EA6: ${(RARITY_LABELS[lobster.rarity] || lobster.rarity).padEnd(15)}\u2502`);
+  console.log(`\u2502  \u72B6\u6001: ${(statusEmoji[lobster.status] || lobster.status).padEnd(36)}\u2502`);
+  console.log(`\u2502  \u73AF\u5883: ${lobster.environment.padEnd(36)}\u2502`);
+  console.log("\u251C" + "\u2500".repeat(44) + "\u2524");
+  console.log(`\u2502  EXP: ${bar(lobster.exp, lobster.exp_to_next)} ${String(expPct).padStart(3)}%  \u2502`);
+  console.log(`\u2502       ${String(lobster.exp).padStart(5)} / ${String(lobster.exp_to_next).padEnd(28)}\u2502`);
+  console.log("\u251C" + "\u2500".repeat(44) + "\u2524");
+  console.log(`\u2502  \u2764\uFE0F  HP:  ${String(lobster.stats.hp).padEnd(6)} \u2694\uFE0F  ATK: ${String(lobster.stats.attack).padEnd(15)}\u2502`);
+  console.log(`\u2502  \u{1F6E1}\uFE0F  DEF: ${String(lobster.stats.defense).padEnd(6)} \u{1F4A8} SPD: ${String(lobster.stats.speed).padEnd(15)}\u2502`);
+  console.log(`\u2502  \u{1F441}\uFE0F  INT: ${String(lobster.stats.intimidation).padEnd(6)} \u{1F340} LCK: ${String(lobster.stats.luck).padEnd(15)}\u2502`);
+  console.log("\u251C" + "\u2500".repeat(44) + "\u2524");
+  console.log(`\u2502  \u6218\u7EE9: ${lobster.wins}\u80DC ${lobster.losses}\u8D1F (\u80DC\u7387${winRate}%)${" ".repeat(Math.max(0, 20 - String(lobster.wins).length - String(lobster.losses).length - String(winRate).length))}\u2502`);
+  console.log(`\u2502  \u8FDE\u80DC: ${lobster.streak}  \u58F0\u671B: ${lobster.reputation}  \u5DE1\u903B: ${lobster.patrol_count}${" ".repeat(Math.max(0, 15 - String(lobster.streak).length - String(lobster.reputation).length - String(lobster.patrol_count).length))}\u2502`);
+  console.log("\u251C" + "\u2500".repeat(44) + "\u2524");
+  console.log(`\u2502  \u6027\u683C:                                     \u2502`);
+  console.log(`\u2502    \u52C7\u6C14 ${lobster.soul.bravery}/10 | \u597D\u5947 ${lobster.soul.curiosity}/10 | \u8BDD\u91CF ${lobster.soul.talkativeness}/10 | \u813E\u6C14 ${lobster.soul.temper}/10  \u2502`);
+  console.log("\u2514" + "\u2500".repeat(44) + "\u2518");
+}
+
+// src/lib/api.ts
+import { createHash } from "crypto";
+var API_BASE = "https://api.clawfight.online";
+function statsHash(lobster) {
+  const raw = JSON.stringify(lobster.stats);
+  return createHash("sha256").update(raw).digest("hex");
+}
+async function apiPatrol(lobster) {
+  try {
+    const res = await fetch(`${API_BASE}/api/patrol`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json; charset=utf-8" },
+      body: JSON.stringify({
+        lobster_id: lobster.id,
+        level: lobster.level,
+        stats_hash: statsHash(lobster),
+        environment: lobster.environment,
+        name: lobster.name,
+        color: lobster.rarity,
+        rarity: lobster.rarity,
+        wins: lobster.wins,
+        losses: lobster.losses,
+        streak: lobster.streak,
+        reputation: lobster.reputation,
+        is_molting: lobster.status === "molting",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function apiLeaderboard(limit = 20) {
+  try {
+    const res = await fetch(`${API_BASE}/api/leaderboard?limit=${limit}`, {
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+
+// src/lib/events.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+var cachedEvents = null;
+async function loadEvents() {
+  if (cachedEvents) return cachedEvents;
+  const paths = [
+    join2(process.cwd(), "references", "events.json"),
+    join2(process.cwd(), "packages", "skill", "references", "events.json"),
+    join2(process.cwd(), "..", "skill", "references", "events.json")
+  ];
+  for (const p of paths) {
+    try {
+      const raw = await readFile2(p, "utf-8");
+      cachedEvents = JSON.parse(raw);
+      return cachedEvents;
+    } catch {
+    }
+  }
+  return { events: [], category_probability_ranges: {} };
+}
+async function rollEvent(lobster) {
+  const data = await loadEvents();
+  if (data.events.length === 0) return null;
+  const roll = Math.random() * 100;
+  let category;
+  if (roll < 60) category = "daily";
+  else if (roll < 80) category = "growth";
+  else if (roll < 95) category = "crisis";
+  else category = "rare";
+  const candidates = data.events.filter((e) => {
+    if (e.category !== category) return false;
+    if (e.conditions?.min_level && lobster.level < e.conditions.min_level) return false;
+    if (e.conditions?.is_molting && lobster.status !== "molting") return false;
+    return true;
+  });
+  if (candidates.length === 0) return null;
+  const totalWeight = candidates.reduce((s, c) => s + c.probability, 0);
+  let pick = Math.random() * totalWeight;
+  let chosen = null;
+  for (const c of candidates) {
+    pick -= c.probability;
+    if (pick <= 0) {
+      chosen = c;
+      break;
+    }
+  }
+  if (!chosen) chosen = candidates[0];
+  const narrative = chosen.prompt_template.replace(/\{name\}/g, lobster.name).replace(/\{territory\}/g, lobster.environment).replace(/\{level\}/g, String(lobster.level));
+  return { event: chosen, narrative };
+}
+function applyEventEffects(lobster, effects) {
+  const changes = [];
+  const stats = lobster.stats;
+  for (const [key, val] of Object.entries(effects)) {
+    if (key === "exp" && typeof val === "string") {
+      const num = parseInt(val, 10);
+      const actual = Math.min(num, lobster.daily_exp_cap - lobster.today_exp);
+      if (actual > 0) {
+        lobster.exp += actual;
+        lobster.today_exp += actual;
+        changes.push(`\u7ECF\u9A8C +${actual}`);
+      }
+    } else if (typeof val === "string" && key in stats) {
+      const num = parseInt(val, 10);
+      stats[key] += num;
+      if (stats[key] < 0) stats[key] = 0;
+      changes.push(`${key} ${num >= 0 ? "+" : ""}${num}`);
+    }
+  }
+  return changes;
+}
+
+// src/commands/patrol.ts
+var PATROL_EXP = 15;
+async function patrol() {
+  const lobster = await readLobster();
+  if (!lobster) {
+    console.log("\n\u{1F95A} \u8FD8\u6CA1\u6709\u9F99\u867E\u3002\u8FD0\u884C npx clawfight hatch \u6765\u5B75\u5316\u4E00\u53EA\uFF01");
+    return;
+  }
+  if (lobster.status === "molting") {
+    console.log(`
+\u{1F7E1} ${lobster.name} \u6B63\u5728\u8715\u58F3\u4E2D\uFF0C\u65E0\u6CD5\u5DE1\u903B\u3002`);
+    return;
+  }
+  if (lobster.status === "hibernating") {
+    console.log(`
+\u{1F4A4} ${lobster.name} \u6B63\u5728\u51AC\u7720\u4E2D\uFF0C\u65E0\u6CD5\u5DE1\u903B\u3002`);
+    return;
+  }
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const lastDay = lobster.last_patrol ? lobster.last_patrol.split("T")[0] : "";
+  if (today !== lastDay) {
+    lobster.today_exp = 0;
+  }
+  console.log(`
+\u{1F99E} ${lobster.name} \u5F00\u59CB\u5DE1\u903B...`);
+  console.log("\u2500".repeat(40));
+  const expGain = Math.min(PATROL_EXP, lobster.daily_exp_cap - lobster.today_exp);
+  if (expGain > 0) {
+    lobster.exp += expGain;
+    lobster.today_exp += expGain;
+    console.log(`\u{1F4CD} \u5DE1\u903B\u7B7E\u5230 \u2192 \u7ECF\u9A8C +${expGain}`);
+  }
+  const eventResult = await rollEvent(lobster);
+  if (eventResult) {
+    console.log();
+    console.log(`\u{1F3B2} [${eventResult.event.category}] ${eventResult.event.id}`);
+    console.log(`   ${eventResult.narrative}`);
+    const changes = applyEventEffects(lobster, eventResult.event.effects);
+    if (changes.length > 0) {
+      console.log(`   \u6548\u679C: ${changes.join(", ")}`);
+    }
+    await appendLog(`\u{1F3B2} \u4E8B\u4EF6\u300C${eventResult.event.id}\u300D: ${eventResult.narrative.slice(0, 60)}...`);
+  }
+  checkLevelUp(lobster);
+  lobster.patrol_count++;
+  lobster.last_patrol = (/* @__PURE__ */ new Date()).toISOString();
+  console.log("\n\u{1F4E1} \u8FDE\u63A5\u670D\u52A1\u5668...");
+  const serverResponse = await apiPatrol(lobster);
+  if (serverResponse) {
+    if (serverResponse.encounter && serverResponse.opponent) {
+      console.log(`\u2694\uFE0F  \u906D\u9047\uFF01\u5BF9\u624B: ${serverResponse.opponent.name} (Lv.${serverResponse.opponent.level})`);
+      console.log(`   \u6218\u6597\u79CD\u5B50: ${serverResponse.battle_seed}`);
+      console.log(`   \u4F7F\u7528 npx clawfight battle \u6765\u5904\u7406\u8FD9\u573A\u6218\u6597\uFF01`);
+      await appendLog(`\u2694\uFE0F \u906D\u9047 ${serverResponse.opponent.name} (Lv.${serverResponse.opponent.level})`);
+    } else {
+      console.log(`\u2705 \u5DE1\u903B\u5B8C\u6210\uFF0C\u5339\u914D\u6C60: ${serverResponse.pool_size} \u53EA\u9F99\u867E`);
+    }
+  } else {
+    console.log("\u26A0\uFE0F  \u670D\u52A1\u5668\u4E0D\u53EF\u8FBE\uFF0C\u8DF3\u8FC7\u5728\u7EBF\u7B7E\u5230");
+  }
+  await writeLobster(lobster);
+  console.log("\u2500".repeat(40));
+  console.log(`\u{1F4CA} \u5F53\u524D: Lv.${lobster.level} | EXP: ${lobster.exp}/${lobster.exp_to_next} | \u4ECA\u65E5EXP: ${lobster.today_exp}/${lobster.daily_exp_cap}`);
+}
+function checkLevelUp(lobster) {
+  const l = lobster;
+  while (l.exp >= l.exp_to_next) {
+    l.exp -= l.exp_to_next;
+    l.level++;
+    l.exp_to_next = calcExpToNext(l.level);
+    const statKeys = ["hp", "attack", "defense", "speed", "intimidation", "luck"];
+    const gains = [];
+    for (const key of statKeys) {
+      const gain = 1 + Math.floor(Math.random() * 3);
+      l.stats[key] += gain;
+      gains.push(`${key}+${gain}`);
+    }
+    console.log(`
+\u{1F389} \u5347\u7EA7\uFF01Lv.${l.level}! [${gains.join(", ")}]`);
+    if (l.level % 5 === 0) {
+      console.log("\u{1F41A} \u89E6\u53D1\u8715\u58F3\u4E8B\u4EF6\uFF01\u9F99\u867E\u8FDB\u5165\u8715\u58F3\u72B6\u6001...");
+      l.status = "molting";
+      l.molt_count++;
+    }
+  }
+}
+
+// src/commands/battle.ts
+function simulateOpponent(level) {
+  const r = (base) => base + Math.floor(Math.random() * 5) - 2;
+  return {
+    id: "sim-" + Math.random().toString(36).slice(2, 10),
+    name: ["\u6DF1\u6D77\u5C0F\u900F\u660E", "\u73CA\u745A\u523A\u5BA2", "\u6697\u7901\u5B88\u536B", "\u6F6E\u6C50\u9738\u738B", "\u84DD\u7532\u9690\u8005"][Math.floor(Math.random() * 5)],
+    level: Math.max(1, level + Math.floor(Math.random() * 5) - 2),
+    stats: {
+      hp: r(10 + level * 2),
+      attack: r(5 + level),
+      defense: r(5 + level),
+      speed: r(5 + level),
+      intimidation: r(3 + Math.floor(level / 2)),
+      luck: r(3 + Math.floor(level / 2))
+    }
+  };
+}
+function runBattle(a, b) {
+  let hpA = a.hp;
+  let hpB = b.hp;
+  const log = [];
+  const first = a.speed > b.speed ? "a" : b.speed > a.speed ? "b" : Math.random() > 0.5 ? "a" : "b";
+  log.push(`\u5148\u624B: ${first === "a" ? "\u6211\u65B9" : "\u5BF9\u624B"} (\u901F\u5EA6 ${first === "a" ? a.speed : b.speed})`);
+  for (let round = 1; round <= 10; round++) {
+    const [atk1, def1, atk2, def2] = first === "a" ? [a, b, b, a] : [b, a, a, b];
+    const [hp1Ref, hp2Ref] = first === "a" ? ["hpB", "hpA"] : ["hpA", "hpB"];
+    const dmg1 = Math.max(1, Math.floor((atk1.attack - def1.defense * 0.5) * (1 + Math.random() * 0.2)));
+    if (hp1Ref === "hpB") hpB -= dmg1;
+    else hpA -= dmg1;
+    log.push(`  R${round}: ${first === "a" ? "\u6211\u65B9" : "\u5BF9\u624B"}\u653B\u51FB \u2192 ${dmg1} \u4F24\u5BB3`);
+    if ((hp1Ref === "hpB" ? hpB : hpA) <= 0) {
+      return { winner: first, rounds: round, log };
+    }
+    const dmg2 = Math.max(1, Math.floor((atk2.attack - def2.defense * 0.5) * (1 + Math.random() * 0.2)));
+    if (hp2Ref === "hpB") hpB -= dmg2;
+    else hpA -= dmg2;
+    log.push(`  R${round}: ${first === "a" ? "\u5BF9\u624B" : "\u6211\u65B9"}\u653B\u51FB \u2192 ${dmg2} \u4F24\u5BB3`);
+    if ((hp2Ref === "hpB" ? hpB : hpA) <= 0) {
+      return { winner: first === "a" ? "b" : "a", rounds: round, log };
+    }
+  }
+  return { winner: "draw", rounds: 10, log };
+}
+async function battle() {
+  const lobster = await readLobster();
+  if (!lobster) {
+    console.log("\n\u{1F95A} \u8FD8\u6CA1\u6709\u9F99\u867E\u3002\u8FD0\u884C npx clawfight hatch \u6765\u5B75\u5316\u4E00\u53EA\uFF01");
+    return;
+  }
+  if (lobster.status !== "active") {
+    console.log(`
+\u26A0\uFE0F  ${lobster.name} \u5F53\u524D\u72B6\u6001\u4E3A ${lobster.status}\uFF0C\u65E0\u6CD5\u6218\u6597\u3002`);
+    return;
+  }
+  const opponent = simulateOpponent(lobster.level);
+  console.log("\n" + "\u2694\uFE0F".repeat(20));
+  console.log(`  ${lobster.name} (Lv.${lobster.level}) VS ${opponent.name} (Lv.${opponent.level})`);
+  console.log("\u2694\uFE0F".repeat(20));
+  const result = runBattle(lobster.stats, opponent.stats);
+  console.log();
+  for (const line of result.log) {
+    console.log(line);
+  }
+  const isWin = result.winner === "a";
+  const isDraw = result.winner === "draw";
+  let expGain;
+  if (isDraw) {
+    expGain = 10;
+    console.log(`
+\u{1F91D} \u5E73\u5C40\uFF01${result.rounds} \u56DE\u5408\u540E\u53CC\u65B9\u7CBE\u75B2\u529B\u7AED`);
+  } else if (isWin) {
+    expGain = 30;
+    lobster.wins++;
+    lobster.streak = Math.max(0, lobster.streak) + 1;
+    lobster.reputation++;
+    console.log(`
+\u{1F3C6} \u80DC\u5229\uFF01${lobster.name} \u5728 ${result.rounds} \u56DE\u5408\u540E\u51FB\u8D25\u4E86 ${opponent.name}\uFF01`);
+  } else {
+    expGain = 10;
+    lobster.losses++;
+    lobster.streak = Math.min(0, lobster.streak) - 1;
+    lobster.reputation = Math.max(0, lobster.reputation - 1);
+    console.log(`
+\u{1F480} \u5931\u8D25\u2026${lobster.name} \u5728 ${result.rounds} \u56DE\u5408\u540E\u88AB ${opponent.name} \u51FB\u8D25\u3002`);
+  }
+  const actual = Math.min(expGain, lobster.daily_exp_cap - lobster.today_exp);
+  if (actual > 0) {
+    lobster.exp += actual;
+    lobster.today_exp += actual;
+  }
+  console.log(`\u7ECF\u9A8C +${actual} | \u6218\u7EE9: ${lobster.wins}\u80DC ${lobster.losses}\u8D1F | \u8FDE\u80DC: ${lobster.streak}`);
+  lobster.last_battle = (/* @__PURE__ */ new Date()).toISOString();
+  const resultStr = isDraw ? "\u5E73\u5C40" : isWin ? "\u80DC\u5229" : "\u5931\u8D25";
+  await appendLog(`\u2694\uFE0F VS ${opponent.name}(Lv.${opponent.level}) \u2192 ${resultStr} (${result.rounds}\u56DE\u5408)`);
+  await writeLobster(lobster);
+}
+
+// src/commands/feed.ts
+var FOOD_TYPES = {
+  protein: { exp: 15, label: "\u9AD8\u86CB\u767D\u98DF\u7269", statBias: "attack" },
+  algae: { exp: 10, label: "\u85FB\u7C7B\u98DF\u7269", statBias: "hp" },
+  mineral: { exp: 12, label: "\u77FF\u7269\u8D28", statBias: "defense" }
+};
+async function feed(foodType) {
+  const lobster = await readLobster();
+  if (!lobster) {
+    console.log("\n\u{1F95A} \u8FD8\u6CA1\u6709\u9F99\u867E\u3002\u8FD0\u884C npx clawfight hatch \u6765\u5B75\u5316\u4E00\u53EA\uFF01");
+    return;
+  }
+  if (!foodType || !FOOD_TYPES[foodType]) {
+    console.log("\n\u{1F37D}\uFE0F  \u53EF\u7528\u98DF\u7269\u7C7B\u578B:");
+    for (const [key, info] of Object.entries(FOOD_TYPES)) {
+      console.log(`  ${key.padEnd(10)} \u2014 ${info.label} (+${info.exp} EXP, ${info.statBias} \u504F\u5411)`);
+    }
+    console.log("\n\u7528\u6CD5: npx clawfight feed <food_type>");
+    return;
+  }
+  const food = FOOD_TYPES[foodType];
+  const actual = Math.min(food.exp, lobster.daily_exp_cap - lobster.today_exp);
+  if (actual <= 0) {
+    console.log(`
+\u26A0\uFE0F  ${lobster.name} \u4ECA\u5929\u5DF2\u7ECF\u5403\u9971\u4E86\uFF08\u6BCF\u65E5\u7ECF\u9A8C\u4E0A\u9650 ${lobster.daily_exp_cap}\uFF09`);
+    return;
+  }
+  lobster.exp += actual;
+  lobster.today_exp += actual;
+  const stats = lobster.stats;
+  if (food.statBias in stats) {
+    const bonus = Math.random() > 0.5 ? 1 : 0;
+    if (bonus > 0) {
+      stats[food.statBias] += bonus;
+      console.log(`
+\u{1F37D}\uFE0F  ${lobster.name} \u5403\u4E86 ${food.label}\uFF01`);
+      console.log(`   \u7ECF\u9A8C +${actual} | ${food.statBias} +${bonus}`);
+    } else {
+      console.log(`
+\u{1F37D}\uFE0F  ${lobster.name} \u5403\u4E86 ${food.label}\uFF01`);
+      console.log(`   \u7ECF\u9A8C +${actual}`);
+    }
+  }
+  await appendLog(`\u{1F37D}\uFE0F \u5582\u98DF: ${food.label} \u2192 EXP+${actual}`);
+  await writeLobster(lobster);
+  console.log(`   \u4ECA\u65E5\u7ECF\u9A8C: ${lobster.today_exp}/${lobster.daily_exp_cap}`);
+}
+
+// src/commands/leaderboard.ts
+var RARITY_SYMBOLS = {
+  common: "  ",
+  calico: "\u{1F7E1}",
+  blue: "\u{1F535}",
+  yellow: "\u{1F31F}",
+  split: "\u{1F48E}",
+  albino: "\u2B1C"
+};
+async function leaderboard() {
+  console.log("\n\u{1F4E1} \u83B7\u53D6\u5168\u7403\u6392\u884C\u699C...");
+  const data = await apiLeaderboard(20);
+  if (!data) {
+    console.log("\u26A0\uFE0F  \u670D\u52A1\u5668\u4E0D\u53EF\u8FBE\uFF0C\u65E0\u6CD5\u83B7\u53D6\u6392\u884C\u699C\u3002");
+    return;
+  }
+  if (data.leaderboard.length === 0) {
+    console.log("\n\u{1F99E} \u8FD8\u6CA1\u6709\u9F99\u867E\u4E0A\u699C\u3002\u6210\u4E3A\u7B2C\u4E00\u4E2A\u5427\uFF01");
+    return;
+  }
+  console.log("\n" + "\u2550".repeat(60));
+  console.log("  \u{1F99E} ClawFight \u5168\u7403\u6392\u884C\u699C");
+  console.log("\u2550".repeat(60));
+  console.log(`  ${"\u6392\u540D".padEnd(6)} ${"\u540D\u79F0".padEnd(16)} ${"\u7B49\u7EA7".padEnd(8)} ${"\u80DC\u573A".padEnd(8)} ${"\u80DC\u7387".padEnd(8)}`);
+  console.log("\u2500".repeat(60));
+  for (const entry of data.leaderboard) {
+    const sym = RARITY_SYMBOLS[entry.rarity] || "  ";
+    const name = entry.name.length > 12 ? entry.name.slice(0, 11) + "\u2026" : entry.name;
+    console.log(
+      `  ${sym} #${String(entry.rank).padEnd(4)} ${name.padEnd(14)} Lv.${String(entry.level).padEnd(5)} ${String(entry.wins).padEnd(7)} ${entry.win_rate}%`
+    );
+  }
+  console.log("\u2500".repeat(60));
+  console.log(`  \u603B\u9F99\u867E: ${data.total_lobsters} | \u6D3B\u8DC3: ${data.active_lobsters}`);
+  console.log("\u2550".repeat(60));
+}
+
+// src/index.ts
+var program = new Command();
+program.name("clawfight").description("\u{1F99E} ClawFight \u2014 \u9F99\u867E\u7535\u5B50\u5BA0\u7269\u5BF9\u6218").version("0.1.0");
+program.command("hatch").description("\u5B75\u5316\u4E00\u53EA\u65B0\u9F99\u867E").argument("[name]", "\u4E3A\u9F99\u867E\u53D6\u540D").action(async (name) => {
+  await hatch(name);
+});
+program.command("status").description("\u67E5\u770B\u9F99\u867E\u72B6\u6001").action(async () => {
+  await status();
+});
+program.command("patrol").description("\u5DE1\u903B\u7B7E\u5230\uFF0C\u89E6\u53D1\u968F\u673A\u4E8B\u4EF6\u548C\u906D\u9047").action(async () => {
+  await patrol();
+});
+program.command("battle").description("\u8FDB\u884C\u4E00\u573A\u6218\u6597").action(async () => {
+  await battle();
+});
+program.command("feed").description("\u5582\u517B\u9F99\u867E").argument("[food_type]", "\u98DF\u7269\u7C7B\u578B: protein, algae, mineral").action(async (foodType) => {
+  await feed(foodType);
+});
+program.command("leaderboard").alias("lb").description("\u67E5\u770B\u5168\u7403\u6392\u884C\u699C").action(async () => {
+  await leaderboard();
+});
+program.parse();

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@2025-6-19/clawfight",
+  "version": "0.1.0",
+  "description": "ClawFight — raise and battle a unique lobster pet with evolving soul 🦞",
+  "author": "LIU",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/clawfight/clawfight",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/clawfight/clawfight#readme",
+  "bugs": {
+    "url": "https://github.com/clawfight/clawfight/issues"
+  },
+  "bin": {
+    "clawfight": "./dist/index.js"
+  },
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "commander": "^14.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0",
+    "@types/node": "^22.0.0"
+  },
+  "keywords": [
+    "openclaw",
+    "clawfight",
+    "lobster",
+    "pet",
+    "battle",
+    "idle",
+    "virtual-pet",
+    "cli"
+  ]
+}