@umang-boss/claudemon 1.3.0 → 1.4.1

package/src/server/tools/train.ts

@@ -0,0 +1,180 @@
+/**
+ * buddy_train tool — Train your active Pokemon's coding stats.
+ * Has a 30-minute cooldown. Awards +3 to a stat and +5 XP.
+ */
+
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import type { CodingStat } from "../../engine/types.js";
+import { CODING_STATS } from "../../engine/types.js";
+import { POKEMON_BY_ID } from "../../engine/pokemon-data.js";
+import { STAT_DISPLAY_NAMES } from "../../engine/constants.js";
+import { addXp } from "../../engine/xp.js";
+import { applyStatBoost, renderStatBar } from "../../engine/stats.js";
+import { StateManager } from "../../state/state-manager.js";
+
+/** Cooldown: 30 minutes in milliseconds. */
+const TRAIN_COOLDOWN_MS = 1_800_000;
+
+/** Stat boost per training session. */
+const TRAIN_STAT_BOOST = 3;
+
+/** XP awarded per training session. */
+const TRAIN_XP_AWARD = 5;
+
+/** Pick a random element from a non-empty array. */
+function randomPick<T>(arr: readonly T[]): T {
+  const index = Math.floor(Math.random() * arr.length);
+  return arr[index] as T;
+}
+
+/** 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_train tool on the MCP server. */
+export function registerTrainTool(server: McpServer): void {
+  server.tool(
+    "buddy_train",
+    "Train your active Pokemon's coding stats. Optionally specify a stat (debugging, stability, velocity, wisdom, stamina). 30-minute cooldown.",
+    {
+      stat: z
+        .string()
+        .optional()
+        .describe(
+          "Stat to train: debugging, stability, velocity, wisdom, or stamina. Random if omitted.",
+        ),
+    },
+    async ({ stat: statInput }) => {
+      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.lastTrainedAt;
+      if (elapsed < TRAIN_COOLDOWN_MS) {
+        const remaining = TRAIN_COOLDOWN_MS - elapsed;
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Still resting from training! Try again in ${formatCooldownRemaining(remaining)}.`,
+            },
+          ],
+        };
+      }
+
+      // Determine which stat to train
+      let targetStat: CodingStat;
+      if (statInput !== undefined && statInput !== "") {
+        const normalized = statInput.toLowerCase().trim();
+        if (!CODING_STATS.includes(normalized as CodingStat)) {
+          const validStats = CODING_STATS.map((s) => STAT_DISPLAY_NAMES[s].toLowerCase()).join(
+            ", ",
+          );
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: `Invalid stat "${statInput}". Valid stats: ${validStats}`,
+              },
+            ],
+          };
+        }
+        targetStat = normalized as CodingStat;
+      } else {
+        targetStat = randomPick(CODING_STATS);
+      }
+
+      const displayName = active.nickname ?? species.name;
+
+      // Record stat before boost for display
+      const statBefore = active.codingStats[targetStat];
+
+      // Apply stat boost
+      applyStatBoost(active, targetStat, TRAIN_STAT_BOOST);
+
+      const statAfter = active.codingStats[targetStat];
+
+      // Award XP
+      const levelUp = addXp(active, TRAIN_XP_AWARD, species);
+
+      // Set mood to energetic
+      state.mood = "energetic";
+      state.moodSetAt = now;
+
+      // Record train timestamp
+      state.lastTrainedAt = now;
+
+      // Save state and update status line
+      await stateManager.save();
+      await stateManager.writeStatus();
+
+      // Build response
+      const statDisplayName = STAT_DISPLAY_NAMES[targetStat];
+      const lines: string[] = [];
+
+      lines.push(`*${displayName} trains its ${statDisplayName}! +${TRAIN_STAT_BOOST}*`);
+      lines.push("");
+      lines.push(
+        `${statDisplayName}: ${statBefore} \u2192 ${statAfter}  ${renderStatBar(statAfter)}`,
+      );
+      lines.push(`+${TRAIN_XP_AWARD} 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/state/schemas.ts

@@ -9,6 +9,7 @@ import {
   BADGE_TYPES,
   CODING_STATS,
   EVENT_COUNTER_KEYS,
+  MOOD_TYPES,
 } from "../engine/types.js";
 
 // ---- Shared Primitives ----
@@ -69,6 +70,8 @@ export const BuddyConfigSchema = z.object({
   reactionCooldownMs: z.number().int().min(0).default(30_000),
   statusLineEnabled: z.boolean().default(true),
   bellEnabled: z.boolean().default(true),
+  encounterSpeed: z.enum(["fast", "normal", "slow"]).default("normal"),
+  xpSharePercent: z.number().min(0).max(100).default(25),
 });
 
 // ---- Pokedex ----
@@ -93,6 +96,15 @@ export const UnlockedAchievementSchema = z.object({
   unlockedAt: z.string(),
 });
 
+// ---- Pending Quiz ----
+
+export const PendingQuizSchema = z.object({
+  type: z.enum(["type_matchup", "stat_compare", "evolution", "pokedex_trivia"]),
+  question: z.string(),
+  options: z.array(z.string()),
+  correctAnswer: z.number().int().min(1).max(4),
+});
+
 // ---- Catch Condition ----
 
 export const CatchConditionSchema = z.object({
@@ -127,5 +139,13 @@ export const PlayerStateSchema = z.object({
   totalSessions: z.number().int().min(0).default(0),
   pendingEncounter: WildEncounterSchema.nullable().default(null),
   xpSinceLastEncounter: z.number().int().min(0).default(0),
+  recentToolTypes: z.array(z.string()).default([]),
+  lastEncounterTime: z.number().int().min(0).default(0),
+  mood: z.enum(MOOD_TYPES).default("neutral"),
+  moodSetAt: z.number().default(0),
+  lastFedAt: z.number().default(0),
+  lastTrainedAt: z.number().default(0),
+  lastPlayedAt: z.number().default(0),
+  pendingQuiz: PendingQuizSchema.nullable().default(null),
 });
 

package/src/state/state-manager.ts

@@ -13,6 +13,7 @@ import type {
   BuddyConfig,
   PokedexState,
   WildEncounter,
+  MoodType,
 } from "../engine/types.js";
 import { EVENT_COUNTER_KEYS } from "../engine/types.js";
 import { atomicWrite, safeRead, ensureDir, backupCorrupted, withLock } from "./io.js";
@@ -25,6 +26,7 @@ interface StatusPayload {
   xpPercent: number;
   speciesId: number;
   evolutionReady: boolean;
+  mood: MoodType;
 }
 
 /** Build a zeroed-out EventCounters record */
@@ -53,6 +55,8 @@ function defaultConfig(): BuddyConfig {
     reactionCooldownMs: 30_000,
     statusLineEnabled: true,
     bellEnabled: true,
+    encounterSpeed: "normal",
+    xpSharePercent: 25,
   };
 }
 
@@ -188,6 +192,14 @@ export class StateManager {
       totalSessions: 0,
       pendingEncounter: null,
       xpSinceLastEncounter: 0,
+      recentToolTypes: [],
+      lastEncounterTime: 0,
+      mood: "neutral",
+      moodSetAt: 0,
+      lastFedAt: 0,
+      lastTrainedAt: 0,
+      lastPlayedAt: 0,
+      pendingQuiz: null,
     };
 
     this.state = state;
@@ -210,19 +222,21 @@ export class StateManager {
     await this.save();
   }
 
-  /** Update daily streak based on today vs lastActiveDate, then save */
+  /**
+   * Update daily streak with weekend grace period.
+   * Allows up to 2 days off without breaking the streak (covers weekends).
+   * Streak counts "coding days" not "consecutive calendar days".
+   */
   async updateStreak(): Promise<void> {
     const state = this.getState();
     const today = todayDateString();
     const { streak } = state;
 
     if (streak.lastActiveDate === today) {
-      // Already recorded today, nothing to do
       return;
     }
 
     if (streak.lastActiveDate === null) {
-      // First ever activity
       streak.currentStreak = 1;
       streak.totalDaysActive = 1;
     } else {
@@ -231,11 +245,14 @@ export class StateManager {
       const diffMs = now.getTime() - last.getTime();
       const diffDays = Math.round(diffMs / (1000 * 60 * 60 * 24));
 
-      if (diffDays === 1) {
-        // Consecutive day
+      // Grace period: up to 2 days off (covers weekends)
+      // 1 day gap = next day (consecutive) ✓
+      // 2 day gap = skipped 1 day (e.g., Friday → Sunday) ✓
+      // 3 day gap = skipped 2 days (e.g., Friday → Monday) ✓
+      // 4+ day gap = streak broken
+      if (diffDays <= 3) {
         streak.currentStreak += 1;
       } else {
-        // Streak broken
         streak.currentStreak = 1;
       }
       streak.totalDaysActive += 1;
@@ -256,6 +273,8 @@ export class StateManager {
       return;
     }
 
+    const state = this.getState();
+
     // XP percent is currentXp as a rough percentage toward next level
     // Exact formula depends on exp group; use a simple ratio for the status line
     const xpPercent = active.level >= 100 ? 100 : Math.min(100, Math.floor((active.currentXp / Math.max(1, active.currentXp + 50)) * 100));
@@ -274,6 +293,7 @@ export class StateManager {
       xpPercent,
       speciesId: active.pokemonId,
       evolutionReady,
+      mood: state.mood ?? "neutral",
     };
 
     const stateDir = getStateDir();

package/statusline/buddy-status.sh

@@ -56,6 +56,7 @@ SPECIES_ID=$(echo "$STATUS" | jq -r '.speciesId // 0')
 EVOLVING=$(echo "$STATUS" | jq -r '.evolutionReady // false')
 REACTION=$(echo "$STATUS" | jq -r '.reaction // empty')
 ENCOUNTER=$(echo "$STATUS" | jq -r '.encounter // empty')
+MOOD=$(echo "$STATUS" | jq -r '.mood // "neutral"')
 
 # ── Colors ──────────────────────────────────────────────────
 NC=$'\033[0m'
@@ -158,69 +159,83 @@ if [ -n "$ENCOUNTER" ]; then
 elif [ -n "$REACTION" ]; then
   SPEECH="$REACTION"
 else
+  # Mood-based speeches — pick from mood-specific arrays
   NOW=$(date +%s)
-  IDX=$(( (NOW / 30) % 60 ))
-  SPEECHES=(
-    "*${NAME} looks at your code curiously*"
-    ""
-    "*${NAME} nods along as you type*"
-    ""
-    "*${NAME} is watching closely*"
-    ""
-    "*${NAME} hums softly*"
-    ""
-    "*${NAME} stretches and yawns*"
-    ""
-    "*${NAME} bounces excitedly*"
-    ""
-    "*${NAME} waits patiently*"
-    ""
-    "*${NAME} tilts head at the screen*"
-    ""
-    "*${NAME} chirps encouragingly*"
-    ""
-    "*${NAME} peers at a variable name*"
-    ""
-    "*${NAME} sniffs at a function*"
-    ""
-    "*${NAME} sits on the keyboard*"
-    ""
-    "*${NAME} chases the cursor*"
-    ""
-    "*${NAME} judges your indentation*"
-    ""
-    "*${NAME} found a semicolon!*"
-    ""
-    "*${NAME} debugs alongside you*"
-    ""
-    "*${NAME} spots a typo... maybe*"
-    ""
-    "*${NAME} celebrates a clean build*"
-    ""
-    "*${NAME} is impressed by that refactor*"
-    ""
-    "*${NAME} blinks at the test results*"
-    ""
-    "*${NAME} dreams of evolution*"
-    ""
-    "*${NAME} wants to learn new moves*"
-    ""
-    "*${NAME} is proud of your progress*"
-    ""
-    "*${NAME} snoozes between commits*"
-    ""
-    "*${NAME} practices its type moves*"
-    ""
-    "*${NAME} stares at the linter output*"
-    ""
-    "*${NAME} wonders about that TODO*"
-    ""
-    "*${NAME} approves of that commit msg*"
-    ""
-    "*${NAME} is ready for action!*"
-    ""
-  )
-  SPEECH="${SPEECHES[$IDX]}"
+
+  case "$MOOD" in
+    happy)
+      MOOD_SPEECHES=(
+        "*${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)
+      MOOD_SPEECHES=(
+        "*${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)
+      MOOD_SPEECHES=(
+        "*${NAME} yawns widely*"
+        "*${NAME} dozes off... zzz*"
+        "*${NAME} rubs its eyes*"
+        "*${NAME} curls up near the keyboard*"
+        "*${NAME} mumbles in its sleep*"
+      )
+      ;;
+    energetic)
+      MOOD_SPEECHES=(
+        "*${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)
+      MOOD_SPEECHES=(
+        "*${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 / default — use the original idle speeches
+      MOOD_SPEECHES=(
+        "*${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*"
+        "*${NAME} sniffs at a function*"
+        "*${NAME} sits on the keyboard*"
+        "*${NAME} chases the cursor*"
+        "*${NAME} judges your indentation*"
+        "*${NAME} found a semicolon!*"
+        "*${NAME} debugs alongside you*"
+        "*${NAME} spots a typo... maybe*"
+        "*${NAME} celebrates a clean build*"
+        "*${NAME} dreams of evolution*"
+        "*${NAME} is ready for action!*"
+      )
+      ;;
+  esac
+
+  MOOD_COUNT=${#MOOD_SPEECHES[@]}
+  IDX=$(( (NOW / 30) % MOOD_COUNT ))
+  SPEECH="${MOOD_SPEECHES[$IDX]}"
 fi
 if [ -n "$ENCOUNTER" ]; then
   # Bright yellow for encounter alerts