@umang-boss/claudemon 1.2.1 → 1.4.0

package/dist/src/server/tools/feed.js

@@ -0,0 +1,120 @@
+/**
+ * buddy_feed tool — Feed your active Pokemon to boost happiness.
+ * Has a 1-hour cooldown. Returns type-flavored food reactions.
+ */
+import { POKEMON_BY_ID } from "../../engine/pokemon-data.js";
+import { MAX_HAPPINESS } from "../../engine/constants.js";
+import { StateManager } from "../../state/state-manager.js";
+/** Cooldown: 1 hour in milliseconds. */
+const FEED_COOLDOWN_MS = 3_600_000;
+/** Happiness increase per feed. */
+const FEED_HAPPINESS_BOOST = 10;
+/** Food reactions keyed by primary Pokemon type. */
+const FEED_REACTIONS = {
+    Normal: (n) => `*${n} enjoys a PokePuff!* \u{1F9C1}`,
+    Fire: (n) => `*${n} gobbles down a Spicy Berry!* \u{1F336}\u{FE0F}`,
+    Water: (n) => `*${n} slurps an Oran Berry!* \u{1F4A7}`,
+    Electric: (n) => `*${n} munches a Cheri Berry!* \u{26A1}`,
+    Grass: (n) => `*${n} nibbles a fresh Leaf Salad!* \u{1F33F}`,
+    Ice: (n) => `*${n} crunches a Frozen Berry!* \u{2744}\u{FE0F}`,
+    Fighting: (n) => `*${n} devours a Protein Shake!* \u{1F4AA}`,
+    Poison: (n) => `*${n} sips a Pecha Smoothie!* \u{1F49C}`,
+    Ground: (n) => `*${n} chews a Rawst Root!* \u{1F33E}`,
+    Flying: (n) => `*${n} pecks at Skyberry Seeds!* \u{1F426}`,
+    Psychic: (n) => `*${n} absorbs a Mind Melon!* \u{1F52E}`,
+    Bug: (n) => `*${n} nibbles on Sweet Honey!* \u{1F36F}`,
+    Rock: (n) => `*${n} crunches a Mineral Cookie!* \u{1FAA8}`,
+    Ghost: (n) => `*${n} absorbs a Shadow Treat!* \u{1F47B}`,
+    Dragon: (n) => `*${n} feasts on a Dragon Scale Fruit!* \u{1F409}`,
+};
+/** Get a feed reaction based on the Pokemon's primary type. */
+function getFeedReaction(species, displayName) {
+    const primaryType = species.types[0];
+    return FEED_REACTIONS[primaryType](displayName);
+}
+/** Format remaining cooldown as "Xm Ys". */
+function formatCooldownRemaining(remainingMs) {
+    const totalSeconds = Math.ceil(remainingMs / 1000);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    if (minutes > 0 && seconds > 0) {
+        return `${minutes}m ${seconds}s`;
+    }
+    if (minutes > 0) {
+        return `${minutes}m`;
+    }
+    return `${seconds}s`;
+}
+/** Registers the buddy_feed tool on the MCP server. */
+export function registerFeedTool(server) {
+    server.tool("buddy_feed", "Feed your active Pokemon to boost happiness. 1-hour cooldown.", {}, async () => {
+        const stateManager = StateManager.getInstance();
+        const state = await stateManager.load();
+        if (!state || state.party.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "You don't have a Pokemon yet! Use buddy_starter to pick your first companion.",
+                    },
+                ],
+            };
+        }
+        const active = stateManager.getActivePokemon();
+        if (!active) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No active Pokemon found. Use buddy_party to set one active.",
+                    },
+                ],
+            };
+        }
+        const species = POKEMON_BY_ID.get(active.pokemonId);
+        if (!species) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Could not find species data for Pokemon ID ${active.pokemonId}.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Check cooldown
+        const now = Date.now();
+        const elapsed = now - state.lastFedAt;
+        if (elapsed < FEED_COOLDOWN_MS) {
+            const remaining = FEED_COOLDOWN_MS - elapsed;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Already fed! Try again in ${formatCooldownRemaining(remaining)}.`,
+                    },
+                ],
+            };
+        }
+        const displayName = active.nickname ?? species.name;
+        // Increase happiness (cap at MAX_HAPPINESS)
+        const previousHappiness = active.happiness;
+        active.happiness = Math.min(MAX_HAPPINESS, active.happiness + FEED_HAPPINESS_BOOST);
+        // Set mood to happy
+        state.mood = "happy";
+        state.moodSetAt = now;
+        // Record feed timestamp
+        state.lastFedAt = now;
+        // Save state and update status line
+        await stateManager.save();
+        await stateManager.writeStatus();
+        // Build response
+        const reaction = getFeedReaction(species, displayName);
+        const lines = [reaction, ""];
+        lines.push(`Happiness: ${previousHappiness} \u2192 ${active.happiness}`);
+        return {
+            content: [{ type: "text", text: lines.join("\n") }],
+        };
+    });
+}

package/dist/src/server/tools/play.js

@@ -0,0 +1,310 @@
+/**
+ * buddy_play tool — Play a Pokemon trivia quiz with your active Pokemon.
+ * Has a 15-minute cooldown (applied after quiz completion, not between question and answer).
+ * Awards +20 XP for correct answers, +5 XP for wrong answers.
+ */
+import { z } from "zod";
+import { POKEMON_TYPES } from "../../engine/types.js";
+import { POKEDEX, POKEMON_BY_ID } from "../../engine/pokemon-data.js";
+import { EVOLUTION_CHAINS } from "../../engine/evolution-data.js";
+import { addXp } from "../../engine/xp.js";
+import { StateManager } from "../../state/state-manager.js";
+/** Cooldown: 15 minutes in milliseconds (applied after completing a quiz). */
+const PLAY_COOLDOWN_MS = 900_000;
+/** XP awarded for correct answer. */
+const CORRECT_XP = 20;
+/** XP awarded for wrong answer (participation). */
+const WRONG_XP = 5;
+// ── Gen 1 Type Effectiveness Chart ────────────────────────
+/** Maps each type to the types that are super effective against it. */
+const TYPE_WEAKNESSES = {
+    Normal: ["Fighting"],
+    Fire: ["Water", "Ground", "Rock"],
+    Water: ["Electric", "Grass"],
+    Electric: ["Ground"],
+    Grass: ["Fire", "Ice", "Poison", "Flying", "Bug"],
+    Ice: ["Fire", "Fighting", "Rock"],
+    Fighting: ["Flying", "Psychic"],
+    Poison: ["Ground", "Psychic"],
+    Ground: ["Water", "Grass", "Ice"],
+    Flying: ["Electric", "Ice", "Rock"],
+    Psychic: ["Bug", "Ghost"],
+    Bug: ["Fire", "Flying", "Rock"],
+    Rock: ["Water", "Grass", "Fighting", "Ground"],
+    Ghost: ["Ghost"],
+    Dragon: ["Ice", "Dragon"],
+};
+// ── Utility Functions ─────────────────────────────────────
+/** Pick a random element from a non-empty array. */
+function randomPick(arr) {
+    const index = Math.floor(Math.random() * arr.length);
+    return arr[index];
+}
+/** Shuffle an array in place (Fisher-Yates) and return it. */
+function shuffle(arr) {
+    for (let i = arr.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        const temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }
+    return arr;
+}
+/** Format remaining cooldown as "Xm Ys". */
+function formatCooldownRemaining(remainingMs) {
+    const totalSeconds = Math.ceil(remainingMs / 1000);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    if (minutes > 0 && seconds > 0) {
+        return `${minutes}m ${seconds}s`;
+    }
+    if (minutes > 0) {
+        return `${minutes}m`;
+    }
+    return `${seconds}s`;
+}
+// ── Quiz Generators ───────────────────────────────────────
+/** Generate a type matchup quiz question. */
+function generateTypeMatchup() {
+    // Pick a type that has weaknesses
+    const typesWithWeaknesses = POKEMON_TYPES.filter((t) => TYPE_WEAKNESSES[t].length > 0);
+    const targetType = randomPick(typesWithWeaknesses);
+    const weaknesses = TYPE_WEAKNESSES[targetType];
+    const correctType = randomPick(weaknesses);
+    // Generate 3 wrong answers (types NOT in the weakness list)
+    const wrongTypes = POKEMON_TYPES.filter((t) => !weaknesses.includes(t) && t !== targetType);
+    const wrongAnswers = shuffle([...wrongTypes]).slice(0, 3);
+    // Combine and shuffle, tracking correct position
+    const options = shuffle([correctType, ...wrongAnswers]);
+    const correctAnswer = options.indexOf(correctType) + 1; // 1-indexed
+    return {
+        type: "type_matchup",
+        question: `What type is super effective against ${targetType}?`,
+        options,
+        correctAnswer,
+    };
+}
+/** Generate a stat comparison quiz question. */
+function generateStatCompare() {
+    const statPairs = [
+        { name: "HP", key: "hp" },
+        { name: "Attack", key: "attack" },
+        { name: "Defense", key: "defense" },
+        { name: "Speed", key: "speed" },
+        { name: "Special", key: "special" },
+    ];
+    const pair = randomPick(statPairs);
+    const statName = pair.name;
+    const statKey = pair.key;
+    // Pick 2 different Pokemon
+    let pokemon1 = randomPick(POKEDEX);
+    let pokemon2 = randomPick(POKEDEX);
+    // Ensure they are different and have different stat values for a clear answer
+    let attempts = 0;
+    while ((pokemon2.id === pokemon1.id || pokemon1.baseStats[statKey] === pokemon2.baseStats[statKey]) &&
+        attempts < 50) {
+        pokemon2 = randomPick(POKEDEX);
+        attempts++;
+    }
+    const stat1 = pokemon1.baseStats[statKey];
+    const stat2 = pokemon2.baseStats[statKey];
+    // If still tied after attempts, just pick a winner
+    const correctName = stat1 >= stat2 ? pokemon1.name : pokemon2.name;
+    const options = [pokemon1.name, pokemon2.name];
+    const correctAnswer = options.indexOf(correctName) + 1; // 1 or 2
+    return {
+        type: "stat_compare",
+        question: `Who has higher ${statName}: ${pokemon1.name} or ${pokemon2.name}?`,
+        options,
+        correctAnswer,
+    };
+}
+/** Generate an evolution quiz question. */
+function generateEvolutionQuiz() {
+    // Get chains that have at least one evolution link
+    const chainsWithEvolutions = EVOLUTION_CHAINS.filter((c) => c.links.length > 0);
+    const chain = randomPick(chainsWithEvolutions);
+    const link = randomPick(chain.links);
+    const fromPokemon = POKEMON_BY_ID.get(link.from);
+    const toPokemon = POKEMON_BY_ID.get(link.to);
+    if (!fromPokemon || !toPokemon) {
+        // Fallback to a known evolution if data lookup fails
+        return generateTypeMatchup();
+    }
+    // Generate 3 wrong answers (random Pokemon that are NOT the correct evolution)
+    const wrongPokemon = shuffle(POKEDEX.filter((p) => p.id !== toPokemon.id && p.id !== fromPokemon.id)).slice(0, 3);
+    const options = shuffle([toPokemon.name, ...wrongPokemon.map((p) => p.name)]);
+    const correctAnswer = options.indexOf(toPokemon.name) + 1;
+    return {
+        type: "evolution",
+        question: `What does ${fromPokemon.name} evolve into?`,
+        options,
+        correctAnswer,
+    };
+}
+/** Generate a Pokedex type trivia question. */
+function generatePokedexTrivia() {
+    const pokemon = randomPick(POKEDEX);
+    const correctType = pokemon.types[0];
+    // Generate 3 wrong type answers
+    const wrongTypes = shuffle([...POKEMON_TYPES].filter((t) => t !== correctType && !pokemon.types.includes(t))).slice(0, 3);
+    const options = shuffle([correctType, ...wrongTypes]);
+    const correctAnswer = options.indexOf(correctType) + 1;
+    return {
+        type: "pokedex_trivia",
+        question: `What is ${pokemon.name}'s primary type?`,
+        options,
+        correctAnswer,
+    };
+}
+/** Generate a random quiz question. */
+function generateQuiz() {
+    const generators = [
+        generateTypeMatchup,
+        generateStatCompare,
+        generateEvolutionQuiz,
+        generatePokedexTrivia,
+    ];
+    return randomPick(generators)();
+}
+/** Format a quiz for display. */
+function formatQuiz(quiz) {
+    const lines = [];
+    lines.push(`**${quiz.question}**`);
+    lines.push("");
+    for (let i = 0; i < quiz.options.length; i++) {
+        lines.push(`  ${i + 1}. ${quiz.options[i]}`);
+    }
+    lines.push("");
+    lines.push("Use `/buddy play answer 1`, `2`, `3`, or `4` to answer.");
+    return lines.join("\n");
+}
+/** Registers the buddy_play tool on the MCP server. */
+export function registerPlayTool(server) {
+    server.tool("buddy_play", "Play a Pokemon trivia quiz with your active Pokemon. Use without arguments to get a question, or with answer=N (1-4) to answer.", {
+        answer: z.number().int().min(1).max(4).optional().describe("Your answer: 1, 2, 3, or 4."),
+    }, async ({ answer }) => {
+        const stateManager = StateManager.getInstance();
+        const state = await stateManager.load();
+        if (!state || state.party.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "You don't have a Pokemon yet! Use buddy_starter to pick your first companion.",
+                    },
+                ],
+            };
+        }
+        const active = stateManager.getActivePokemon();
+        if (!active) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No active Pokemon found. Use buddy_party to set one active.",
+                    },
+                ],
+            };
+        }
+        const species = POKEMON_BY_ID.get(active.pokemonId);
+        if (!species) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Could not find species data for Pokemon ID ${active.pokemonId}.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const displayName = active.nickname ?? species.name;
+        // ── Answer an existing quiz ────────────────────────────
+        if (answer !== undefined) {
+            if (!state.pendingQuiz) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "No quiz in progress! Use `/buddy play` to start a new one.",
+                        },
+                    ],
+                };
+            }
+            const quiz = state.pendingQuiz;
+            const isCorrect = answer === quiz.correctAnswer;
+            const xpAmount = isCorrect ? CORRECT_XP : WRONG_XP;
+            // Award XP
+            const levelUp = addXp(active, xpAmount, species);
+            // Set mood based on result
+            if (isCorrect) {
+                state.mood = "happy";
+            }
+            state.moodSetAt = Date.now();
+            // Clear quiz and set cooldown
+            state.pendingQuiz = null;
+            state.lastPlayedAt = Date.now();
+            // Save state
+            await stateManager.save();
+            await stateManager.writeStatus();
+            // Build response
+            const lines = [];
+            if (isCorrect) {
+                lines.push(`*${displayName} cheers! Correct!* \u{1F389}`);
+            }
+            else {
+                const correctOption = quiz.options[quiz.correctAnswer - 1];
+                lines.push(`*${displayName} shrugs. Better luck next time!*`);
+                lines.push(`The correct answer was: **${quiz.correctAnswer}. ${correctOption}**`);
+            }
+            lines.push("");
+            lines.push(`+${xpAmount} XP`);
+            if (levelUp) {
+                lines.push("");
+                lines.push(`*** ${displayName} grew to Lv.${levelUp.newLevel}! ***`);
+            }
+            return {
+                content: [{ type: "text", text: lines.join("\n") }],
+            };
+        }
+        // ── Start a new quiz ───────────────────────────────────
+        // If there's already a pending quiz, show it again
+        if (state.pendingQuiz) {
+            const lines = [];
+            lines.push(`*${displayName} is still waiting for your answer!*`);
+            lines.push("");
+            lines.push(formatQuiz(state.pendingQuiz));
+            return {
+                content: [{ type: "text", text: lines.join("\n") }],
+            };
+        }
+        // Check cooldown (only applies when starting a new quiz after completing one)
+        const now = Date.now();
+        const elapsed = now - state.lastPlayedAt;
+        if (state.lastPlayedAt > 0 && elapsed < PLAY_COOLDOWN_MS) {
+            const remaining = PLAY_COOLDOWN_MS - elapsed;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `${displayName} needs a break from quizzing! Try again in ${formatCooldownRemaining(remaining)}.`,
+                    },
+                ],
+            };
+        }
+        // Generate and store a new quiz
+        const quiz = generateQuiz();
+        state.pendingQuiz = quiz;
+        // Save state (stores the pending quiz)
+        await stateManager.save();
+        // Build response
+        const lines = [];
+        lines.push(`*${displayName} perks up for quiz time!* \u{1F4DA}`);
+        lines.push("");
+        lines.push(formatQuiz(quiz));
+        return {
+            content: [{ type: "text", text: lines.join("\n") }],
+        };
+    });
+}

package/dist/src/server/tools/settings.js

@@ -0,0 +1,80 @@
+/**
+ * buddy_settings tool — Configure Claudemon settings.
+ * Currently supports: encounter-speed (fast | normal | slow).
+ */
+import { z } from "zod";
+import { StateManager } from "../../state/state-manager.js";
+import { ENCOUNTER_THRESHOLDS } from "../../engine/constants.js";
+const VALID_ENCOUNTER_SPEEDS = ["fast", "normal", "slow"];
+/** Speed descriptions for user-facing messages. */
+const SPEED_DESCRIPTIONS = {
+    fast: "Fastest encounters — wild Pokemon appear every ~100 XP",
+    normal: "Default pace — wild Pokemon appear every ~250 XP",
+    slow: "Less interruptions — wild Pokemon appear every ~500 XP",
+};
+/** Registers the buddy_settings tool on the MCP server. */
+export function registerSettingsTool(server) {
+    server.tool("buddy_settings", "Configure Claudemon settings (encounter speed, etc.)", {
+        setting: z.enum(["encounter-speed"]).describe("The setting to configure"),
+        value: z.string().describe("The value to set (for encounter-speed: fast, normal, or slow)"),
+    }, async (params) => {
+        const stateManager = StateManager.getInstance();
+        const state = await stateManager.load();
+        if (!state) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No save data found. Use buddy_starter to pick your first Pokemon before changing settings.",
+                    },
+                ],
+            };
+        }
+        if (params.setting === "encounter-speed") {
+            const speed = params.value.toLowerCase();
+            if (!VALID_ENCOUNTER_SPEEDS.includes(speed)) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: [
+                                `Invalid encounter speed: "${params.value}"`,
+                                "",
+                                "Valid options:",
+                                ...VALID_ENCOUNTER_SPEEDS.map((s) => `  ${s} — ${SPEED_DESCRIPTIONS[s]} (${ENCOUNTER_THRESHOLDS[s]} XP threshold)`),
+                            ].join("\n"),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const validSpeed = speed;
+            const previousSpeed = state.config.encounterSpeed ?? "normal";
+            state.config.encounterSpeed = validSpeed;
+            await stateManager.save();
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: [
+                            `Encounter speed updated: ${previousSpeed} -> ${validSpeed}`,
+                            "",
+                            SPEED_DESCRIPTIONS[validSpeed],
+                            `XP threshold: ${ENCOUNTER_THRESHOLDS[validSpeed]}`,
+                        ].join("\n"),
+                    },
+                ],
+            };
+        }
+        // Unreachable with the current enum, but guards against future additions
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unknown setting: "${params.setting}". Available settings: encounter-speed`,
+                },
+            ],
+            isError: true,
+        };
+    });
+}

package/dist/src/server/tools/show.js

@@ -10,6 +10,7 @@ import { STAT_DISPLAY_NAMES } from "../../engine/constants.js";
 import { renderStatBar, getTrainerTitle } from "../../engine/stats.js";
 import { xpProgressPercent, xpToNextLevel } from "../../engine/xp.js";
 import { StateManager } from "../../state/state-manager.js";
+import { getMoodEmoji, getMoodDescription } from "../../engine/mood.js";
 import { formatTypes, renderXpBar, pad } from "./display-helpers.js";
 /** Registers the buddy_show tool on the MCP server. */
 export function registerShowTool(server) {
@@ -99,6 +100,10 @@ export function registerShowTool(server) {
             ? `Streak: ${state.streak.currentStreak} days`
             : "Streak: 0 days";
         lines.push(`\u2502  ${pad(streakDisplay, W - 2)}\u2502`);
+        const currentMood = state.mood ?? "neutral";
+        const moodEmoji = getMoodEmoji(currentMood);
+        const moodDesc = getMoodDescription(currentMood);
+        lines.push(`\u2502  ${pad(`Mood: ${moodEmoji} ${moodDesc}`, W - 2)}\u2502`);
         lines.push(`\u2514${border}\u2518`);
         // Prepend colorscript sprite if available
         // ANSI colorscripts don't render in MCP text output — skip sprites here

package/dist/src/server/tools/starter.js

@@ -56,10 +56,32 @@ async function getStarters() {
     catch {
         // No saved options or expired — generate new ones
     }
-    // Generate fresh random 3
+    // Generate fresh random 3 with different primary types
     const seed = hashString(`claudemon-${Date.now()}-${Math.random()}`);
     const shuffled = seededShuffle(STARTER_POOL, seed);
-    const starters = [shuffled[0], shuffled[1], shuffled[2]];
+    const starters = [];
+    const usedTypes = new Set();
+    for (const id of shuffled) {
+        if (starters.length >= 3)
+            break;
+        const pokemon = POKEMON_BY_ID.get(id);
+        if (!pokemon)
+            continue;
+        const primaryType = pokemon.types[0];
+        if (usedTypes.has(primaryType))
+            continue;
+        usedTypes.add(primaryType);
+        starters.push(id);
+    }
+    // Fallback if not enough unique types (shouldn't happen with 39 starters)
+    if (starters.length < 3) {
+        for (const id of shuffled) {
+            if (starters.length >= 3)
+                break;
+            if (!starters.includes(id))
+                starters.push(id);
+        }
+    }
     // Save for consistency until they pick
     try {
         const { writeFile, mkdir } = await import("node:fs/promises");