@umang-boss/claudemon 1.0.0

package/src/server/tools/party.ts

@@ -0,0 +1,251 @@
+/**
+ * buddy_party tool — Manage your party of up to 6 Pokemon.
+ * Supports listing, switching active, depositing to PC, and withdrawing from PC.
+ */
+
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { POKEMON_BY_ID } from "../../engine/pokemon-data.js";
+import { MAX_PARTY_SIZE } from "../../engine/constants.js";
+import { StateManager } from "../../state/state-manager.js";
+import { formatTypes, pad } from "./display-helpers.js";
+
+/** Registers the buddy_party tool on the MCP server. */
+export function registerPartyTool(server: McpServer): void {
+  server.tool(
+    "buddy_party",
+    "Manage your Pokemon party: list members, switch active, deposit to PC, or withdraw from PC.",
+    {
+      action: z.enum(["list", "switch", "deposit", "withdraw"]).optional(),
+      slot: z.number().int().optional(),
+    },
+    async (params) => {
+      const stateManager = StateManager.getInstance();
+      const state = await stateManager.load();
+
+      if (!state || state.party.length === 0) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: "You don't have a Pokemon yet! Use buddy_starter to pick your first partner.",
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      const action = params.action ?? "list";
+
+      // ── LIST ────────────────────────────────────────────────
+      if (action === "list") {
+        const W = 42;
+        const border = "\u2500".repeat(W);
+        const lines: string[] = [];
+
+        lines.push(`\u250c${border}\u2510`);
+        lines.push(`\u2502  ${pad("YOUR PARTY", W - 2)}\u2502`);
+        lines.push(`\u2502${" ".repeat(W)}\u2502`);
+
+        for (let i = 0; i < state.party.length; i++) {
+          const pokemon = state.party[i]!;
+          const species = POKEMON_BY_ID.get(pokemon.pokemonId);
+          if (!species) continue;
+
+          const displayName = pokemon.nickname ?? species.name;
+          const typeStr = formatTypes(species.types);
+          const marker = pokemon.isActive ? " \u2605" : "";
+          const entry = `${i + 1}. ${displayName}  Lv.${pokemon.level}  ${typeStr}${marker}`;
+          lines.push(`\u2502  ${pad(entry, W - 2)}\u2502`);
+        }
+
+        lines.push(`\u2502${" ".repeat(W)}\u2502`);
+        lines.push(`\u2502  ${pad(`Party: ${state.party.length}/${MAX_PARTY_SIZE}`, W - 2)}\u2502`);
+
+        if (state.pcBox.length > 0) {
+          lines.push(`\u2502  ${pad(`PC Box: ${state.pcBox.length} Pokemon`, W - 2)}\u2502`);
+        }
+
+        lines.push(`\u2514${border}\u2518`);
+
+        return {
+          content: [{ type: "text" as const, text: lines.join("\n") }],
+        };
+      }
+
+      // ── SWITCH ──────────────────────────────────────────────
+      if (action === "switch") {
+        const slot = params.slot;
+        if (slot === undefined || slot < 1 || slot > state.party.length) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: `Invalid slot. Choose a number between 1 and ${state.party.length}.`,
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        const target = state.party[slot - 1]!;
+        if (target.isActive) {
+          const species = POKEMON_BY_ID.get(target.pokemonId);
+          const displayName = target.nickname ?? species?.name ?? "???";
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: `${displayName} is already your active Pokemon!`,
+              },
+            ],
+          };
+        }
+
+        // Deactivate all, activate target
+        for (const pokemon of state.party) {
+          pokemon.isActive = false;
+        }
+        target.isActive = true;
+
+        await stateManager.save();
+        await stateManager.writeStatus();
+
+        const species = POKEMON_BY_ID.get(target.pokemonId);
+        const displayName = target.nickname ?? species?.name ?? "???";
+        const typeStr = species ? formatTypes(species.types) : "";
+
+        const lines: string[] = [];
+        lines.push(`Go, ${displayName}!`);
+        lines.push(`Lv.${target.level} ${typeStr}`);
+
+        return {
+          content: [{ type: "text" as const, text: lines.join("\n") }],
+        };
+      }
+
+      // ── DEPOSIT ─────────────────────────────────────────────
+      if (action === "deposit") {
+        const slot = params.slot;
+        if (slot === undefined || slot < 1 || slot > state.party.length) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: `Invalid slot. Choose a number between 1 and ${state.party.length}.`,
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        if (state.party.length <= 1) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: "You can't deposit your last Pokemon! You need at least one in your party.",
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        const deposited = state.party.splice(slot - 1, 1)[0]!;
+        const wasActive = deposited.isActive;
+        deposited.isActive = false;
+        state.pcBox.push(deposited);
+
+        // If the deposited Pokemon was active, set the first party member as active
+        if (wasActive && state.party.length > 0) {
+          state.party[0]!.isActive = true;
+        }
+
+        await stateManager.save();
+        await stateManager.writeStatus();
+
+        const species = POKEMON_BY_ID.get(deposited.pokemonId);
+        const displayName = deposited.nickname ?? species?.name ?? "???";
+
+        const lines: string[] = [];
+        lines.push(`${displayName} was deposited in the PC Box.`);
+        lines.push(
+          `Party: ${state.party.length}/${MAX_PARTY_SIZE}  |  PC Box: ${state.pcBox.length}`,
+        );
+
+        if (wasActive) {
+          const newActive = state.party[0]!;
+          const newSpecies = POKEMON_BY_ID.get(newActive.pokemonId);
+          const newName = newActive.nickname ?? newSpecies?.name ?? "???";
+          lines.push(`${newName} is now your active Pokemon.`);
+        }
+
+        return {
+          content: [{ type: "text" as const, text: lines.join("\n") }],
+        };
+      }
+
+      // ── WITHDRAW ────────────────────────────────────────────
+      if (action === "withdraw") {
+        const slot = params.slot;
+        if (slot === undefined || slot < 1 || slot > state.pcBox.length) {
+          if (state.pcBox.length === 0) {
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: "Your PC Box is empty! Catch more Pokemon to fill it.",
+                },
+              ],
+            };
+          }
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: `Invalid slot. Choose a number between 1 and ${state.pcBox.length}.`,
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        if (state.party.length >= MAX_PARTY_SIZE) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: `Your party is full (${MAX_PARTY_SIZE}/${MAX_PARTY_SIZE}). Deposit a Pokemon first.`,
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        const withdrawn = state.pcBox.splice(slot - 1, 1)[0]!;
+        state.party.push(withdrawn);
+
+        await stateManager.save();
+
+        const species = POKEMON_BY_ID.get(withdrawn.pokemonId);
+        const displayName = withdrawn.nickname ?? species?.name ?? "???";
+
+        const lines: string[] = [];
+        lines.push(`${displayName} was withdrawn from the PC Box!`);
+        lines.push(
+          `Party: ${state.party.length}/${MAX_PARTY_SIZE}  |  PC Box: ${state.pcBox.length}`,
+        );
+
+        return {
+          content: [{ type: "text" as const, text: lines.join("\n") }],
+        };
+      }
+
+      // Should not reach here, but TypeScript exhaustiveness
+      return {
+        content: [{ type: "text" as const, text: "Unknown party action." }],
+        isError: true,
+      };
+    },
+  );
+}

package/src/server/tools/pet.ts

@@ -0,0 +1,124 @@
+/**
+ * buddy_pet tool — Pet your active Pokemon for a small happiness/XP boost.
+ * Returns a type-flavored reaction message.
+ */
+
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { PokemonType, Pokemon, OwnedPokemon } from "../../engine/types.js";
+import { POKEMON_BY_ID } from "../../engine/pokemon-data.js";
+import { MAX_HAPPINESS } from "../../engine/constants.js";
+import { addXp, createXpEvent } from "../../engine/xp.js";
+import { applyStatBoost } from "../../engine/stats.js";
+import { StateManager } from "../../state/state-manager.js";
+
+/** Pet reactions keyed by primary Pokemon type. */
+const PET_REACTIONS: Record<PokemonType, (name: string) => string> = {
+  Normal: (n) => `*${n} nuzzles against your hand contentedly*`,
+  Fire: (n) => `*${n}'s tail flame flickers happily*`,
+  Water: (n) => `*${n} splashes with joy*`,
+  Electric: (n) => `*${n}'s cheeks spark warmly*`,
+  Grass: (n) => `*${n}'s leaves rustle with delight*`,
+  Ice: (n) => `*${n} breathes a cool, contented mist*`,
+  Fighting: (n) => `*${n} flexes proudly and grins*`,
+  Poison: (n) => `*${n} oozes happily... you wash your hands*`,
+  Ground: (n) => `*${n} stomps the ground with glee*`,
+  Flying: (n) => `*${n} flutters around you in circles*`,
+  Psychic: (n) => `*${n}'s eyes glow softly with gratitude*`,
+  Bug: (n) => `*${n}'s antennae twitch happily*`,
+  Rock: (n) => `*${n} rumbles warmly, solid as ever*`,
+  Ghost: (n) => `*${n} phases through your hand... then comes back for more*`,
+  Dragon: (n) => `*${n} lets out a low, pleased growl*`,
+};
+
+/** Get a pet reaction based on the Pokemon's primary type. */
+function getPetReaction(species: Pokemon, displayName: string): string {
+  const primaryType = species.types[0];
+  const reactionFn = PET_REACTIONS[primaryType];
+  return reactionFn(displayName);
+}
+
+/** Registers the buddy_pet tool on the MCP server. */
+export function registerPetTool(server: McpServer): void {
+  server.tool(
+    "buddy_pet",
+    "Pet your active Pokemon to increase happiness and earn a small XP bonus.",
+    {},
+    async () => {
+      const stateManager = StateManager.getInstance();
+      const state = await stateManager.load();
+
+      if (!state || state.party.length === 0) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: "You don't have a Pokemon yet! Use buddy_starter to pick your first partner.",
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      const active = stateManager.getActivePokemon();
+      if (!active) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: "No active Pokemon found in your party.",
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      const species = POKEMON_BY_ID.get(active.pokemonId);
+      if (!species) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Could not find species data for Pokemon ID ${active.pokemonId}.`,
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      const displayName = active.nickname ?? species.name;
+
+      // Increase happiness (cap at 255)
+      const previousHappiness = active.happiness;
+      active.happiness = Math.min(MAX_HAPPINESS, active.happiness + 5);
+
+      // Award small XP via pet event
+      const xpEvent = createXpEvent("pet");
+      const levelUp = addXp(active, xpEvent.xp, species);
+
+      // Apply stat boost if the event has one
+      if (xpEvent.statBoost !== null && xpEvent.boostAmount > 0) {
+        applyStatBoost(active, xpEvent.statBoost, xpEvent.boostAmount);
+      }
+
+      // Save state and update status line
+      await stateManager.save();
+      await stateManager.writeStatus();
+
+      // Build response
+      const reaction = getPetReaction(species, displayName);
+      const lines: string[] = [reaction, ""];
+
+      lines.push(`Happiness: ${previousHappiness} -> ${active.happiness}`);
+      lines.push(`+${xpEvent.xp} XP`);
+
+      if (levelUp) {
+        lines.push("");
+        lines.push(`*** ${displayName} grew to Lv.${levelUp.newLevel}! ***`);
+      }
+
+      return {
+        content: [{ type: "text" as const, text: lines.join("\n") }],
+      };
+    },
+  );
+}

package/src/server/tools/pokedex.ts

@@ -0,0 +1,286 @@
+/**
+ * buddy_pokedex tool — Browse the Pokedex: view all 151, filter by caught/seen,
+ * or inspect a specific Pokemon's details.
+ */
+
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CodingStat } from "../../engine/types.js";
+import { CODING_STATS } from "../../engine/types.js";
+import { POKEDEX, POKEMON_BY_ID } from "../../engine/pokemon-data.js";
+import { STAT_DISPLAY_NAMES, TOTAL_POKEMON } from "../../engine/constants.js";
+import { renderStatBar } from "../../engine/stats.js";
+import { findEvolutionChain } from "../../engine/evolution.js";
+import { StateManager } from "../../state/state-manager.js";
+import { formatTypes, pad, CODING_TO_BASE } from "./display-helpers.js";
+
+/** Registers the buddy_pokedex tool on the MCP server. */
+export function registerPokedexTool(server: McpServer): void {
+  server.tool(
+    "buddy_pokedex",
+    "Browse the Pokedex: view all 151 Pokemon, filter by caught/seen, or look up a specific Pokemon.",
+    {
+      filter: z.enum(["all", "caught", "seen"]).optional(),
+      pokemon: z.string().optional(),
+    },
+    async (params) => {
+      const stateManager = StateManager.getInstance();
+      const state = await stateManager.load();
+
+      if (!state) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: "You don't have a Pokemon yet! Use buddy_starter to begin your journey.",
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      // ── Specific Pokemon lookup ────────────────────────────
+      if (params.pokemon) {
+        return handlePokemonDetail(params.pokemon, state, stateManager);
+      }
+
+      const filter = params.filter ?? "all";
+
+      // ── ALL: Grid of 151 with symbols ──────────────────────
+      if (filter === "all") {
+        const lines: string[] = [];
+        lines.push("P O K E D E X");
+        lines.push(
+          `Caught: ${state.pokedex.totalCaught}/${TOTAL_POKEMON}  |  Seen: ${state.pokedex.totalSeen}/${TOTAL_POKEMON}`,
+        );
+        lines.push("");
+
+        // Render grid: 10 per row
+        const COLS = 10;
+        let row: string[] = [];
+
+        for (let i = 1; i <= TOTAL_POKEMON; i++) {
+          const entry = state.pokedex.entries[i];
+          let symbol: string;
+
+          if (entry?.caught) {
+            symbol = "\u25cf"; // ● caught
+          } else if (entry?.seen) {
+            symbol = "\u25d0"; // ◐ seen
+          } else {
+            symbol = "\u25cb"; // ○ unknown
+          }
+
+          const num = String(i).padStart(3, "0");
+          row.push(`${num}${symbol}`);
+
+          if (i % COLS === 0 || i === TOTAL_POKEMON) {
+            lines.push(row.join("  "));
+            row = [];
+          }
+        }
+
+        lines.push("");
+        lines.push("\u25cf = caught  |  \u25d0 = seen  |  \u25cb = unknown");
+
+        return {
+          content: [{ type: "text" as const, text: lines.join("\n") }],
+        };
+      }
+
+      // ── CAUGHT: Show only caught Pokemon ───────────────────
+      if (filter === "caught") {
+        if (state.pokedex.totalCaught === 0) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: "You haven't caught any Pokemon yet! Keep coding and encounter wild Pokemon.",
+              },
+            ],
+          };
+        }
+
+        const lines: string[] = [];
+        lines.push(`CAUGHT POKEMON (${state.pokedex.totalCaught}/${TOTAL_POKEMON})`);
+        lines.push("");
+
+        for (const [idStr, entry] of Object.entries(state.pokedex.entries)) {
+          if (!entry.caught) continue;
+          const pokemonId = Number(idStr);
+          const species = POKEMON_BY_ID.get(pokemonId);
+          if (!species) continue;
+
+          // Find the owned instance for level info
+          const allOwned = [...state.party, ...state.pcBox];
+          const owned = allOwned.find((p) => p.pokemonId === pokemonId);
+          const levelStr = owned ? `Lv.${owned.level}` : "";
+          const typeStr = formatTypes(species.types);
+          const num = String(pokemonId).padStart(3, "0");
+
+          lines.push(`#${num} ${species.name.padEnd(12)} ${typeStr.padEnd(16)} ${levelStr}`);
+        }
+
+        return {
+          content: [{ type: "text" as const, text: lines.join("\n") }],
+        };
+      }
+
+      // ── SEEN: Show only seen (not caught) Pokemon ──────────
+      if (filter === "seen") {
+        const seenOnly: { id: number; name: string; type: string }[] = [];
+        for (const [idStr, entry] of Object.entries(state.pokedex.entries)) {
+          if (entry.seen && !entry.caught) {
+            const pokemonId = Number(idStr);
+            const species = POKEMON_BY_ID.get(pokemonId);
+            if (species) {
+              seenOnly.push({
+                id: pokemonId,
+                name: species.name,
+                type: formatTypes(species.types),
+              });
+            }
+          }
+        }
+
+        if (seenOnly.length === 0) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: "No seen-but-uncaught Pokemon. Either you've caught them all or haven't encountered any!",
+              },
+            ],
+          };
+        }
+
+        const lines: string[] = [];
+        lines.push(`SEEN POKEMON (not yet caught: ${seenOnly.length})`);
+        lines.push("");
+
+        for (const entry of seenOnly) {
+          const num = String(entry.id).padStart(3, "0");
+          lines.push(`#${num} ${entry.name.padEnd(12)} ${entry.type}`);
+        }
+
+        return {
+          content: [{ type: "text" as const, text: lines.join("\n") }],
+        };
+      }
+
+      return {
+        content: [{ type: "text" as const, text: "Unknown filter. Use all, caught, or seen." }],
+        isError: true,
+      };
+    },
+  );
+}
+
+/** Handle detailed view for a specific Pokemon by name or number. */
+function handlePokemonDetail(
+  query: string,
+  state: import("../../engine/types.js").PlayerState,
+  _stateManager: StateManager,
+): { content: { type: "text"; text: string }[] } {
+  // Find by number or name
+  let species: import("../../engine/types.js").Pokemon | undefined;
+
+  const asNumber = parseInt(query, 10);
+  if (!isNaN(asNumber) && asNumber >= 1 && asNumber <= TOTAL_POKEMON) {
+    species = POKEMON_BY_ID.get(asNumber);
+  }
+
+  if (!species) {
+    const lowerQuery = query.toLowerCase();
+    species = POKEDEX.find((p) => p.name.toLowerCase() === lowerQuery);
+  }
+
+  if (!species) {
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `Pokemon "${query}" not found. Try a name (e.g., "Pikachu") or number (1-151).`,
+        },
+      ],
+    };
+  }
+
+  const entry = state.pokedex.entries[species.id];
+  const caught = entry?.caught ?? false;
+  const seen = entry?.seen ?? false;
+
+  const typeStr = formatTypes(species.types);
+  const num = String(species.id).padStart(3, "0");
+
+  const W = 42;
+  const border = "\u2500".repeat(W);
+  const lines: string[] = [];
+
+  lines.push(`\u250c${border}\u2510`);
+  lines.push(`\u2502  ${pad(`#${num} ${species.name}`, W - 2)}\u2502`);
+  lines.push(`\u2502  ${pad(`Type: ${typeStr}`, W - 2)}\u2502`);
+  lines.push(`\u2502  ${pad(`Rarity: ${species.rarity}`, W - 2)}\u2502`);
+  lines.push(`\u2502${" ".repeat(W)}\u2502`);
+
+  // Status
+  const statusStr = caught ? "\u25cf Caught" : seen ? "\u25d0 Seen" : "\u25cb Unknown";
+  lines.push(`\u2502  ${pad(`Status: ${statusStr}`, W - 2)}\u2502`);
+
+  if (entry?.firstSeen) {
+    lines.push(`\u2502  ${pad(`First seen: ${entry.firstSeen.slice(0, 10)}`, W - 2)}\u2502`);
+  }
+  if (entry?.firstCaught) {
+    lines.push(`\u2502  ${pad(`First caught: ${entry.firstCaught.slice(0, 10)}`, W - 2)}\u2502`);
+  }
+
+  lines.push(`\u2502${" ".repeat(W)}\u2502`);
+  lines.push(`\u2502  ${pad(`"${species.description}"`, W - 2)}\u2502`);
+  lines.push(`\u2502${" ".repeat(W)}\u2502`);
+
+  // Base stats
+  lines.push(`\u2502  ${pad("Base Stats:", W - 2)}\u2502`);
+  for (const stat of CODING_STATS) {
+    const statKey = stat as CodingStat;
+    const baseStatKey = CODING_TO_BASE[statKey];
+    const value = Math.floor(species.baseStats[baseStatKey] * 0.5);
+    const bar = renderStatBar(value);
+    const label = STAT_DISPLAY_NAMES[statKey].padEnd(10);
+    lines.push(`\u2502  ${pad(`${label} ${bar}  ${String(value).padStart(3)}`, W - 2)}\u2502`);
+  }
+
+  // Evolution chain
+  const chain = findEvolutionChain(species.id);
+  if (chain && chain.links.length > 0) {
+    lines.push(`\u2502${" ".repeat(W)}\u2502`);
+    lines.push(`\u2502  ${pad("Evolution Chain:", W - 2)}\u2502`);
+
+    // Collect all unique IDs in chain order
+    const chainIds: number[] = [];
+    const visited = new Set<number>();
+    for (const link of chain.links) {
+      if (!visited.has(link.from)) {
+        chainIds.push(link.from);
+        visited.add(link.from);
+      }
+      if (!visited.has(link.to)) {
+        chainIds.push(link.to);
+        visited.add(link.to);
+      }
+    }
+
+    const chainNames = chainIds.map((id) => {
+      const sp = POKEMON_BY_ID.get(id);
+      const name = sp ? sp.name : `#${id}`;
+      const isCurrent = id === species!.id;
+      return isCurrent ? `[${name}]` : name;
+    });
+    lines.push(`\u2502  ${pad(chainNames.join(" \u2192 "), W - 2)}\u2502`);
+  }
+
+  lines.push(`\u2514${border}\u2518`);
+
+  return {
+    content: [{ type: "text" as const, text: lines.join("\n") }],
+  };
+}