@umang-boss/claudemon 1.3.0 → 1.4.1

package/src/engine/mood.ts

@@ -0,0 +1,220 @@
+/**
+ * Mood engine for Claudemon.
+ * Pure functions that calculate mood based on recent events, time of day,
+ * and special triggers (evolution, achievements, catches).
+ */
+
+import type { MoodType, EventCounters } from "./types.js";
+
+// ── Mood Decay Durations (milliseconds) ───────────────────
+
+/** How long each mood lasts before decaying back to neutral */
+const MOOD_DECAY_MS: Record<MoodType, number> = {
+  happy: 600_000, // 10 minutes
+  worried: 300_000, // 5 minutes
+  sleepy: Infinity, // Resets based on time-of-day, not duration
+  energetic: 900_000, // 15 minutes
+  proud: 600_000, // 10 minutes
+  neutral: Infinity, // Never decays (it IS the default)
+};
+
+// ── XP Event Types That Trigger Moods ─────────────────────
+
+const POSITIVE_EVENTS = new Set(["test_pass", "build_success", "commit"]);
+
+const NEGATIVE_EVENTS = new Set(["test_fail", "build_fail", "error"]);
+
+// ── Mood Calculation ──────────────────────────────────────
+
+/**
+ * Calculate the current mood based on recent events, time, and special triggers.
+ *
+ * Priority order:
+ * 1. Sleepy (midnight to 5 AM)
+ * 2. Proud (just evolved/achieved/caught)
+ * 3. Worried (recent negative event)
+ * 4. Happy (recent positive event)
+ * 5. Energetic (morning + active streak)
+ * 6. Keep current mood if it hasn't decayed
+ * 7. Neutral (default fallback)
+ *
+ * @param recentEvent - The last XP event type, or null
+ * @param counters - Current event counters (for context)
+ * @param currentHour - Hour of day (0-23)
+ * @param lastMood - The previous mood
+ * @param moodSetAt - Timestamp when last mood was set
+ * @param hadEvolution - Whether the Pokemon just evolved
+ * @param hadAchievement - Whether the player just unlocked an achievement
+ * @param hadCatch - Whether the player just caught a Pokemon
+ * @returns The calculated mood
+ */
+export function calculateMood(
+  recentEvent: string | null,
+  counters: EventCounters,
+  currentHour: number,
+  lastMood: MoodType,
+  moodSetAt: number,
+  hadEvolution: boolean,
+  hadAchievement: boolean,
+  hadCatch: boolean,
+): MoodType {
+  // 1. Sleepy: midnight to 5 AM (hours 0-4)
+  if (currentHour >= 0 && currentHour < 5) {
+    return "sleepy";
+  }
+
+  // 2. Proud: just evolved, achieved, or caught a Pokemon
+  if (hadEvolution || hadAchievement || hadCatch) {
+    return "proud";
+  }
+
+  // 3. Worried: recent negative event
+  if (recentEvent !== null && NEGATIVE_EVENTS.has(recentEvent)) {
+    return "worried";
+  }
+
+  // 4. Happy: recent positive event
+  if (recentEvent !== null && POSITIVE_EVENTS.has(recentEvent)) {
+    return "happy";
+  }
+
+  // 5. Energetic: morning coding (5 AM - 10 AM) with an active streak
+  if (currentHour >= 5 && currentHour < 10) {
+    // Use a simple heuristic: if there have been any sessions, consider it an active streak
+    const hasStreak = counters.sessions > 0;
+    if (hasStreak) {
+      return "energetic";
+    }
+  }
+
+  // 6. Keep current mood if it hasn't decayed
+  if (!hasMoodDecayed(lastMood, moodSetAt, Date.now())) {
+    return lastMood;
+  }
+
+  // 7. Default fallback
+  return "neutral";
+}
+
+/**
+ * Check whether a mood has expired based on its decay duration.
+ *
+ * @param mood - The mood to check
+ * @param setAt - Timestamp when the mood was set
+ * @param now - Current timestamp
+ * @returns true if the mood has decayed (expired)
+ */
+export function hasMoodDecayed(mood: MoodType, setAt: number, now: number): boolean {
+  const duration = MOOD_DECAY_MS[mood];
+  if (duration === Infinity) {
+    // Sleepy decays when it's no longer midnight-5 AM (handled in calculateMood)
+    // Neutral never decays
+    return false;
+  }
+  return now - setAt >= duration;
+}
+
+// ── Mood Speeches ─────────────────────────────────────────
+
+/** Mood-specific speech lines for the status line. Name placeholder {name} is replaced at call time. */
+const MOOD_SPEECHES: Record<MoodType, readonly string[]> = {
+  happy: [
+    "*{name} is beaming with pride!*",
+    "*{name} does a little victory dance*",
+    "*{name} radiates positive energy*",
+    "*{name} bounces happily*",
+    "*{name} gives you a thumbs up*",
+  ],
+  worried: [
+    "*{name} looks concerned...*",
+    "*{name} nervously watches the errors*",
+    "*{name} hides behind the terminal*",
+    "*{name} paces back and forth*",
+    "*{name} offers you a virtual hug*",
+  ],
+  sleepy: [
+    "*{name} yawns widely*",
+    "*{name} dozes off... zzz*",
+    "*{name} rubs its eyes*",
+    "*{name} curls up near the keyboard*",
+    "*{name} mumbles in its sleep*",
+  ],
+  energetic: [
+    "*{name} is fired up! Let's go!*",
+    "*{name} bounces off the walls*",
+    "*{name} can't sit still!*",
+    "*{name} is ready to code all day!*",
+    "*{name} stretches and flexes*",
+  ],
+  proud: [
+    "*{name} puffs up with pride*",
+    "*{name} strikes a victory pose*",
+    "*{name} shows off to everyone*",
+    "*{name} earned bragging rights!*",
+    "*{name} stands tall and proud*",
+  ],
+  neutral: [
+    "*{name} looks at your code curiously*",
+    "*{name} nods along as you type*",
+    "*{name} is watching closely*",
+    "*{name} hums softly*",
+    "*{name} waits patiently*",
+    "*{name} tilts head at the screen*",
+    "*{name} chirps encouragingly*",
+    "*{name} peers at a variable name*",
+  ],
+};
+
+/**
+ * Get mood-specific speech messages with the Pokemon's name filled in.
+ *
+ * @param name - The Pokemon's display name
+ * @param mood - The current mood
+ * @returns Array of speech strings with the name interpolated
+ */
+export function getMoodSpeeches(name: string, mood: MoodType): string[] {
+  const templates = MOOD_SPEECHES[mood];
+  return templates.map((t) => t.replace("{name}", name));
+}
+
+// ── Mood Display Helpers ──────────────────────────────────
+
+/** Emoji representation for each mood */
+const MOOD_EMOJIS: Record<MoodType, string> = {
+  happy: "\u{1F60A}", // 😊
+  worried: "\u{1F61F}", // 😟
+  sleepy: "\u{1F634}", // 😴
+  energetic: "\u{26A1}", // ⚡
+  proud: "\u{1F451}", // 👑
+  neutral: "\u{1F610}", // 😐
+};
+
+/** Human-readable mood descriptions */
+const MOOD_DESCRIPTIONS: Record<MoodType, string> = {
+  happy: "Happy",
+  worried: "Worried",
+  sleepy: "Sleepy",
+  energetic: "Energetic",
+  proud: "Proud",
+  neutral: "Neutral",
+};
+
+/**
+ * Get the emoji for a mood.
+ *
+ * @param mood - The mood type
+ * @returns The emoji string
+ */
+export function getMoodEmoji(mood: MoodType): string {
+  return MOOD_EMOJIS[mood];
+}
+
+/**
+ * Get a human-readable description for a mood.
+ *
+ * @param mood - The mood type
+ * @returns The description string (e.g. "Happy")
+ */
+export function getMoodDescription(mood: MoodType): string {
+  return MOOD_DESCRIPTIONS[mood];
+}

package/src/engine/types.ts

@@ -3,6 +3,11 @@
  * Single source of truth for all shared interfaces and types.
  */
 
+// ── Mood Types ────────────────────────────────────────────
+
+export const MOOD_TYPES = ["happy", "worried", "sleepy", "energetic", "proud", "neutral"] as const;
+export type MoodType = (typeof MOOD_TYPES)[number];
+
 // ── Pokemon Types ──────────────────────────────────────────
 
 export const POKEMON_TYPES = [
@@ -159,6 +164,14 @@ export interface PlayerState {
   totalSessions: number;
   pendingEncounter: WildEncounter | null;
   xpSinceLastEncounter: number;
+  recentToolTypes: string[]; // Track tool diversity for bonus encounters
+  lastEncounterTime: number; // Timestamp of last encounter (for cooldown)
+  mood: MoodType; // Current mood of the active Pokemon
+  moodSetAt: number; // Timestamp when mood was last set
+  lastFedAt: number; // Timestamp of last feed action
+  lastTrainedAt: number; // Timestamp of last train action
+  lastPlayedAt: number; // Timestamp of last play (quiz completed) action
+  pendingQuiz: PendingQuiz | null; // Active quiz awaiting answer
 }
 
 // ── Pokedex ────────────────────────────────────────────────
@@ -240,6 +253,8 @@ export interface BuddyConfig {
   reactionCooldownMs: number; // Default 30000
   statusLineEnabled: boolean;
   bellEnabled: boolean; // Terminal bell on level-up/encounters
+  encounterSpeed: "fast" | "normal" | "slow"; // Configurable encounter frequency
+  xpSharePercent: number; // 0-100, default 25. Percentage of XP shared to inactive party
 }
 
 // ── XP Events (what triggers XP awards) ────────────────────
@@ -269,6 +284,15 @@ export interface XpEvent {
   readonly boostAmount: number;
 }
 
+// ── Pending Quiz (for /buddy play) ────────────────────────
+
+export interface PendingQuiz {
+  readonly type: "type_matchup" | "stat_compare" | "evolution" | "pokedex_trivia";
+  readonly question: string;
+  readonly options: readonly string[];
+  readonly correctAnswer: number; // 1-4
+}
+
 // ── Encounters ─────────────────────────────────────────────
 
 export interface WildEncounter {

package/src/gamification/achievements.ts

@@ -103,21 +103,21 @@ export const ACHIEVEMENTS: readonly Achievement[] = [
   {
     id: "iron_coder",
     name: "Iron Coder",
-    description: "Maintain a 7-day coding streak",
+    description: "Code for 7 days (weekends off OK)",
     category: "coding",
     condition: { type: "streak", minDays: 7 },
   },
   {
     id: "marathon",
     name: "Marathon",
-    description: "Maintain a 30-day coding streak",
+    description: "Code for 30 days (weekends off OK)",
     category: "coding",
     condition: { type: "streak", minDays: 30 },
   },
   {
     id: "centurion",
     name: "Centurion",
-    description: "Maintain a 100-day coding streak",
+    description: "Code for 100 days (weekends off OK)",
     category: "coding",
     condition: { type: "streak", minDays: 100 },
   },

package/src/gamification/legendary-quests.ts

@@ -16,7 +16,7 @@ export const LEGENDARY_QUESTS: readonly LegendaryQuest[] = [
     name: "The Ice Bird of Endurance",
     steps: [
       {
-        description: "Maintain a 30-day coding streak",
+        description: "Code for 30 days (weekends off OK)",
         condition: { type: "streak", minDays: 30 },
       },
       {
@@ -25,7 +25,7 @@ export const LEGENDARY_QUESTS: readonly LegendaryQuest[] = [
         condition: { type: "pokedex", minCaught: 3 },
       },
       {
-        description: "Maintain a 100-day coding streak",
+        description: "Code for 100 days (weekends off OK)",
         condition: { type: "streak", minDays: 100 },
       },
       {
@@ -113,7 +113,7 @@ export const LEGENDARY_QUESTS: readonly LegendaryQuest[] = [
     name: "The Myth",
     steps: [
       {
-        description: "Maintain a 100-day coding streak",
+        description: "Code for 100 days (weekends off OK)",
         condition: { type: "streak", minDays: 100 },
       },
       {
@@ -129,7 +129,7 @@ export const LEGENDARY_QUESTS: readonly LegendaryQuest[] = [
         condition: { type: "pokedex", minCaught: 149 },
       },
       {
-        description: "Maintain a 365-day coding streak",
+        description: "Code for 365 days (weekends off OK)",
         condition: { type: "streak", minDays: 365 },
       },
     ],

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;
@@ -52,6 +64,21 @@ if (xpEvent.statBoost && xpEvent.boostAmount > 0) {
   applyStatBoost(pokemon, xpEvent.statBoost, xpEvent.boostAmount);
 }
 
+// XP sharing: give inactive party members a percentage
+const sharePercent = state.config.xpSharePercent ?? 0;
+if (sharePercent > 0 && state.party.length > 1) {
+  const sharedXp = Math.floor((xpEvent.xp * sharePercent) / 100);
+  if (sharedXp > 0) {
+    for (const member of state.party) {
+      if (member.isActive) continue;
+      const memberSpecies = POKEMON_BY_ID.get(member.pokemonId);
+      if (memberSpecies) {
+        addXp(member, sharedXp, memberSpecies);
+      }
+    }
+  }
+}
+
 // Track total XP earned by the trainer
 state.totalXpEarned += xpEvent.xp;
 
@@ -60,6 +87,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 +135,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();