@umang-boss/claudemon 1.3.0 → 1.4.0

package/src/hooks/award-xp.ts

@@ -4,6 +4,8 @@
  *
  * Loads state, awards XP to the active Pokemon, applies stat boosts,
  * increments the event counter, updates the streak, and saves.
+ * Supports enhanced encounter triggers: streak bonuses, time-of-day bias,
+ * bonus encounters (10%), and tool diversity encounters.
  * Emits a terminal bell on level-up.
  */
 
@@ -14,7 +16,17 @@ import { addXp, createXpEvent } from "../engine/xp.js";
 import { applyStatBoost } from "../engine/stats.js";
 import { POKEMON_BY_ID } from "../engine/pokemon-data.js";
 import { checkEvolution, getNewlyEarnedBadges } from "../engine/evolution.js";
-import { shouldTriggerEncounter, generateEncounter } from "../engine/encounters.js";
+import {
+  shouldTriggerEncounter,
+  generateEncounter,
+  shouldBonusEncounter,
+  shouldDiversityBonus,
+  getTimeOfDayBias,
+} from "../engine/encounters.js";
+import type { EncounterContext } from "../engine/encounters.js";
+import { calculateMood } from "../engine/mood.js";
+
+const MAX_RECENT_TOOL_TYPES = 20;
 
 const eventType = process.argv[2] as XpEventType;
 const counterKey = process.argv[3] as EventCounterKey | undefined;
@@ -60,6 +72,14 @@ if (counterKey) {
   state.counters[counterKey] += 1;
 }
 
+// Track tool type for diversity bonus (keep last MAX_RECENT_TOOL_TYPES entries)
+const recentToolTypes = state.recentToolTypes ?? [];
+recentToolTypes.push(eventType);
+if (recentToolTypes.length > MAX_RECENT_TOOL_TYPES) {
+  recentToolTypes.splice(0, recentToolTypes.length - MAX_RECENT_TOOL_TYPES);
+}
+state.recentToolTypes = recentToolTypes;
+
 // Update the daily coding streak
 // Inline the streak logic to avoid the extra save from updateStreak()
 const today = new Date();
@@ -100,19 +120,76 @@ for (const badge of newBadges) {
 // Check if evolution is available (sets flag in status for status line indicator)
 const evolutionReady = checkEvolution(pokemon, state) !== null;
 
-// Track XP toward next encounter and trigger if threshold met
-state.xpSinceLastEncounter = (state.xpSinceLastEncounter ?? 0) + xpEvent.xp;
+// Build encounter context for the enhanced trigger system
+const encounterSpeed = state.config.encounterSpeed ?? "normal";
+const currentHour = new Date().getHours();
+const timeOfDayTypes = getTimeOfDayBias(currentHour);
+
+const encounterCtx: EncounterContext = {
+  xpSinceLastEncounter: (state.xpSinceLastEncounter ?? 0) + xpEvent.xp,
+  encounterSpeed,
+  currentStreak: streak.currentStreak,
+  recentToolTypes: state.recentToolTypes,
+  currentHour,
+};
+
+// Track XP toward next encounter
+state.xpSinceLastEncounter = encounterCtx.xpSinceLastEncounter;
 let encounterTriggered = false;
 
-if (shouldTriggerEncounter(state.xpSinceLastEncounter) && !state.pendingEncounter) {
-  const encounter = generateEncounter(eventType, state);
+if (shouldTriggerEncounter(encounterCtx) && !state.pendingEncounter) {
+  const encounter = generateEncounter(eventType, state, timeOfDayTypes);
   if (encounter) {
     state.pendingEncounter = encounter;
     state.xpSinceLastEncounter = 0;
+    state.lastEncounterTime = Date.now();
     encounterTriggered = true;
+
+    // 10% chance for a bonus encounter after a regular one
+    // (bonus replaces the pending encounter with a second roll)
+    if (shouldBonusEncounter()) {
+      const bonusEncounter = generateEncounter(eventType, state, timeOfDayTypes);
+      if (bonusEncounter) {
+        // The bonus encounter replaces the first; first is already set as pending
+        // In practice the player still sees one encounter per trigger,
+        // but the bonus gives them a fresh roll (potentially rarer Pokemon)
+        state.pendingEncounter = bonusEncounter;
+      }
+    }
   }
 }
 
+// Tool diversity bonus: if 3+ unique tool types used recently and no pending encounter,
+// grant an extra encounter opportunity
+if (!encounterTriggered && !state.pendingEncounter && shouldDiversityBonus(state.recentToolTypes)) {
+  const diversityEncounter = generateEncounter(eventType, state, timeOfDayTypes);
+  if (diversityEncounter) {
+    state.pendingEncounter = diversityEncounter;
+    state.xpSinceLastEncounter = 0;
+    state.lastEncounterTime = Date.now();
+    // Clear recent tool types after diversity bonus triggers
+    state.recentToolTypes = [];
+    encounterTriggered = true;
+  }
+}
+
+// Calculate mood based on the event that just happened
+const newMood = calculateMood(
+  eventType,
+  state.counters,
+  currentHour,
+  state.mood ?? "neutral",
+  state.moodSetAt ?? 0,
+  evolutionReady, // evolution ready counts as a proud trigger
+  false, // achievements are checked in catch/evolve tools
+  false, // catches are handled in the catch tool
+);
+
+if (newMood !== (state.mood ?? "neutral")) {
+  state.mood = newMood;
+  state.moodSetAt = Date.now();
+}
+
 // Single atomic save for all mutations
 await stateManager.save();
 

package/src/server/index.ts

@@ -19,6 +19,10 @@ import { registerAchievementsTool } from "./tools/achievements.js";
 import { registerLegendaryTool } from "./tools/legendary.js";
 import { registerHideTool, registerUnhideTool } from "./tools/visibility.js";
 import { registerRenameTool } from "./tools/rename.js";
+import { registerSettingsTool } from "./tools/settings.js";
+import { registerFeedTool } from "./tools/feed.js";
+import { registerTrainTool } from "./tools/train.js";
+import { registerPlayTool } from "./tools/play.js";
 import { buildInstructions } from "./instructions.js";
 
 /** Safely register a tool, logging to stderr on failure instead of crashing. */
@@ -65,6 +69,10 @@ async function main(): Promise<void> {
   safeRegister("buddy_hide", registerHideTool, server);
   safeRegister("buddy_unhide", registerUnhideTool, server);
   safeRegister("buddy_rename", registerRenameTool, server);
+  safeRegister("buddy_settings", registerSettingsTool, server);
+  safeRegister("buddy_feed", registerFeedTool, server);
+  safeRegister("buddy_train", registerTrainTool, server);
+  safeRegister("buddy_play", registerPlayTool, server);
 
   // Connect via stdio transport
   const transport = new StdioServerTransport();

package/src/server/instructions.ts

@@ -9,6 +9,7 @@ import { POKEMON_BY_ID } from "../engine/pokemon-data.js";
 import { cumulativeXpForLevel } from "../engine/xp.js";
 import { getEvolutionLinks } from "../engine/evolution.js";
 import { getTypePersonality } from "../engine/reactions.js";
+import { getMoodDescription } from "../engine/mood.js";
 
 // ── Public API ──────────────────────────────────────────────
 
@@ -60,11 +61,17 @@ function buildActiveInstructions(
   const evolutionNote = buildEvolutionNote(active, species);
   const encounterNote = buildEncounterNote(state);
 
+  const currentMood = state.mood ?? "neutral";
+  const moodDesc = getMoodDescription(currentMood);
+  const moodHint = buildMoodHint(currentMood);
+
   const lines: string[] = [
     "You have a Claudemon Pokemon companion.",
     "",
     `Active Pokemon: ${displayName}, Level ${active.level}, ${typeStr} type.`,
     `Personality: ${personality}`,
+    `Current mood: ${moodDesc.toLowerCase()}${moodHint}`,
+    "Adjust your buddy references to match the mood.",
     "",
     `Occasionally (not every message), naturally reference ${displayName}:`,
     `- When an error occurs: ${displayName} reacts (use ${primaryType} type personality)`,
@@ -95,6 +102,24 @@ function buildActiveInstructions(
 
 // ── Helper Functions ────────────────────────────────────────
 
+/** Build a short contextual hint for the current mood. */
+function buildMoodHint(mood: string): string {
+  switch (mood) {
+    case "happy":
+      return " (tests passing, feeling good)";
+    case "worried":
+      return " (errors detected, feeling anxious)";
+    case "sleepy":
+      return " (late night coding, very drowsy)";
+    case "energetic":
+      return " (morning energy, fired up!)";
+    case "proud":
+      return " (just accomplished something big!)";
+    default:
+      return " (calm, waiting for action)";
+  }
+}
+
 /** Find the active Pokemon in the player's party. */
 function findActivePokemon(state: PlayerState): OwnedPokemon | null {
   return state.party.find((p) => p.isActive) ?? null;

package/src/server/tools/catch.ts

@@ -248,6 +248,10 @@ export function registerCatchTool(server: McpServer): void {
         state.achievements.push(unlockAchievement(achievement.id));
       }
 
+      // Set mood to proud after a successful catch
+      state.mood = "proud";
+      state.moodSetAt = Date.now();
+
       // Save state
       await stateManager.save();
       await stateManager.writeStatus();

package/src/server/tools/evolve.ts

@@ -197,6 +197,10 @@ export function registerEvolveTool(server: McpServer): void {
       // Confirm mode: apply evolution
       const { newName, newTypes } = applyEvolution(active, eligibleLink.to);
 
+      // Set mood to proud after evolution
+      state.mood = "proud";
+      state.moodSetAt = Date.now();
+
       // Save state
       await stateManager.save();
       await stateManager.writeStatus();

package/src/server/tools/feed.ts

@@ -0,0 +1,145 @@
+/**
+ * buddy_feed tool — Feed your active Pokemon to boost happiness.
+ * Has a 1-hour cooldown. Returns type-flavored food reactions.
+ */
+
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { PokemonType, Pokemon } from "../../engine/types.js";
+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: Record<PokemonType, (name: string) => string> = {
+  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: Pokemon, displayName: string): string {
+  const primaryType = species.types[0];
+  return FEED_REACTIONS[primaryType](displayName);
+}
+
+/** Format remaining cooldown as "Xm Ys". */
+function formatCooldownRemaining(remainingMs: number): string {
+  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: McpServer): void {
+  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" as const,
+              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" as const,
+              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" as const,
+              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" as const,
+              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: string[] = [reaction, ""];
+      lines.push(`Happiness: ${previousHappiness} \u2192 ${active.happiness}`);
+
+      return {
+        content: [{ type: "text" as const, text: lines.join("\n") }],
+      };
+    },
+  );
+}