@umang-boss/claudemon 1.3.0 → 1.4.1

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

@@ -0,0 +1,116 @@
+/**
+ * buddy_settings tool — Configure Claudemon settings.
+ * Supports: encounter-speed, xp-share.
+ */
+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"];
+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, xp-share)", {
+        setting: z.enum(["encounter-speed", "xp-share"]).describe("The setting to configure"),
+        value: z.string().describe("The value to set"),
+    }, 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.",
+                    },
+                ],
+            };
+        }
+        // ── Encounter Speed ──────────────────────────────────
+        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: ${previousSpeed} → ${validSpeed}`,
+                            "",
+                            SPEED_DESCRIPTIONS[validSpeed],
+                            `XP threshold: ${ENCOUNTER_THRESHOLDS[validSpeed]}`,
+                        ].join("\n"),
+                    },
+                ],
+            };
+        }
+        // ── XP Share ─────────────────────────────────────────
+        if (params.setting === "xp-share") {
+            const percent = parseInt(params.value, 10);
+            if (isNaN(percent) || percent < 0 || percent > 100) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: [
+                                `Invalid XP share value: "${params.value}"`,
+                                "",
+                                "Enter a number 0-100 (percentage of XP shared to inactive party):",
+                                "  0   — No XP sharing (only active Pokemon earns)",
+                                "  25  — Default (inactive get 25% of earned XP)",
+                                "  50  — Half XP shared to inactive party",
+                                "  100 — Full XP to everyone",
+                            ].join("\n"),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const previous = state.config.xpSharePercent ?? 25;
+            state.config.xpSharePercent = percent;
+            await stateManager.save();
+            const desc = percent === 0
+                ? "Disabled — only active Pokemon earns XP"
+                : `Inactive party members receive ${percent}% of earned XP`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: [`XP share: ${previous}% → ${percent}%`, "", desc].join("\n"),
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unknown setting: "${params.setting}". Available: encounter-speed, xp-share`,
+                },
+            ],
+            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/train.js

@@ -0,0 +1,144 @@
+/**
+ * buddy_train tool — Train your active Pokemon's coding stats.
+ * Has a 30-minute cooldown. Awards +3 to a stat and +5 XP.
+ */
+import { z } from "zod";
+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(arr) {
+    const index = Math.floor(Math.random() * arr.length);
+    return arr[index];
+}
+/** 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_train tool on the MCP server. */
+export function registerTrainTool(server) {
+    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",
+                        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.lastTrainedAt;
+        if (elapsed < TRAIN_COOLDOWN_MS) {
+            const remaining = TRAIN_COOLDOWN_MS - elapsed;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Still resting from training! Try again in ${formatCooldownRemaining(remaining)}.`,
+                    },
+                ],
+            };
+        }
+        // Determine which stat to train
+        let targetStat;
+        if (statInput !== undefined && statInput !== "") {
+            const normalized = statInput.toLowerCase().trim();
+            if (!CODING_STATS.includes(normalized)) {
+                const validStats = CODING_STATS.map((s) => STAT_DISPLAY_NAMES[s].toLowerCase()).join(", ");
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Invalid stat "${statInput}". Valid stats: ${validStats}`,
+                        },
+                    ],
+                };
+            }
+            targetStat = normalized;
+        }
+        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 = [];
+        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", text: lines.join("\n") }],
+        };
+    });
+}

package/dist/src/state/schemas.js

@@ -3,7 +3,7 @@
  * Catches disk corruption early at load boundaries.
  */
 import { z } from "zod";
-import { BADGE_TYPES, CODING_STATS, EVENT_COUNTER_KEYS, } from "../engine/types.js";
+import { BADGE_TYPES, CODING_STATS, EVENT_COUNTER_KEYS, MOOD_TYPES, } from "../engine/types.js";
 // ---- Shared Primitives ----
 const BadgeTypeSchema = z.enum(BADGE_TYPES);
 // ---- Coding Stats ----
@@ -47,6 +47,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 ----
 export const PokedexEntrySchema = z.object({
@@ -65,6 +67,13 @@ export const UnlockedAchievementSchema = z.object({
     achievementId: z.string(),
     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({
     requiredStat: z.enum(CODING_STATS).nullable(),
@@ -94,4 +103,12 @@ 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/dist/src/state/state-manager.js

@@ -30,6 +30,8 @@ function defaultConfig() {
         reactionCooldownMs: 30_000,
         statusLineEnabled: true,
         bellEnabled: true,
+        encounterSpeed: "normal",
+        xpSharePercent: 25,
     };
 }
 /** Build empty pokedex */
@@ -150,6 +152,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;
         await this.save();
@@ -168,17 +178,19 @@ export class StateManager {
         state.counters[key] += amount;
         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() {
         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;
         }
@@ -187,12 +199,15 @@ export class StateManager {
             const now = new Date(today);
             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;
@@ -209,6 +224,7 @@ export class StateManager {
         if (!active) {
             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));
@@ -225,6 +241,7 @@ export class StateManager {
             xpPercent,
             speciesId: active.pokemonId,
             evolutionReady,
+            mood: state.mood ?? "neutral",
         };
         const stateDir = getStateDir();
         await ensureDir(stateDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umang-boss/claudemon",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "Pokemon coding companion for Claude Code — Gotta code 'em all!",
   "type": "module",
   "main": "dist/src/server/index.js",

package/skills/buddy/SKILL.md

@@ -41,6 +41,22 @@ This ensures first-time users get the starter selection flow automatically.
 | `rename` (empty) | `buddy_rename` with name="" — reset to species name |
 | `hide` | `buddy_hide` — hide sprite from status line |
 | `unhide` | `buddy_unhide` — show sprite in status line |
+| `feed` | `buddy_feed` — feed your Pokemon (+10 happiness, 1h cooldown) |
+| `train` | `buddy_train` — train a random stat (+3 stat, +5 XP, 30m cooldown) |
+| `train debugging` | `buddy_train` with stat="debugging" |
+| `train stability` | `buddy_train` with stat="stability" |
+| `train velocity` | `buddy_train` with stat="velocity" |
+| `train wisdom` | `buddy_train` with stat="wisdom" |
+| `train stamina` | `buddy_train` with stat="stamina" |
+| `play` | `buddy_play` — start a Pokemon trivia quiz (15m cooldown after completion) |
+| `play answer 1` | `buddy_play` with answer=1 |
+| `play answer 2` | `buddy_play` with answer=2 |
+| `play answer 3` | `buddy_play` with answer=3 |
+| `play answer 4` | `buddy_play` with answer=4 |
+| `settings encounter-speed fast` | `buddy_settings` with setting="encounter-speed", value="fast" — fastest encounters (100 XP) |
+| `settings encounter-speed normal` | `buddy_settings` with setting="encounter-speed", value="normal" — default (250 XP) |
+| `settings encounter-speed slow` | `buddy_settings` with setting="encounter-speed", value="slow" — less interruptions (500 XP) |
+| `settings xp-share N` | `buddy_settings` with setting="xp-share", value="N" — share N% XP to inactive party (0-100) |
 | `help` | List all available /buddy commands |
 
 Pass $ARGUMENTS to determine which subcommand to route to.

package/src/engine/constants.ts

@@ -46,8 +46,17 @@ export const STAT_DISPLAY_NAMES: Record<CodingStat, string> = {
 
 // ── Encounter Rate ─────────────────────────────────────────
 
-/** XP earned between wild encounters */
-export const XP_PER_ENCOUNTER = 500;
+/** XP thresholds for encounter triggers by speed setting */
+export const ENCOUNTER_THRESHOLDS = {
+  fast: 100,
+  normal: 250,
+  slow: 500,
+} as const;
+
+export type EncounterSpeed = keyof typeof ENCOUNTER_THRESHOLDS;
+
+/** Default encounter speed */
+export const DEFAULT_ENCOUNTER_SPEED: EncounterSpeed = "normal";
 
 // ── Reaction Cooldown ──────────────────────────────────────
 
@@ -92,7 +101,7 @@ export const BADGES: readonly Badge[] = [
   {
     type: "lunar",
     name: "Lunar Badge",
-    description: "Maintain a 30-day coding streak — unlocks Moon Stone evolutions",
+    description: "Code for 30 days (weekends off OK) — unlocks Moon Stone evolutions",
     condition: { type: "streak", minDays: 30 },
   },
   {

package/src/engine/encounters.ts

@@ -1,7 +1,8 @@
 /**
  * Wild encounter system.
- * Pokemon appear based on coding activity type and are catchable
- * based on the active Pokemon's stats and level.
+ * Pokemon appear based on coding activity type, streak bonuses,
+ * tool diversity, and time-of-day biases. Catch eligibility is
+ * determined by the active Pokemon's stats and level.
  */
 
 import type {
@@ -14,7 +15,8 @@ import type {
   CodingStat,
   RarityTier,
 } from "./types.js";
-import { XP_PER_ENCOUNTER } from "./constants.js";
+import { ENCOUNTER_THRESHOLDS } from "./constants.js";
+import type { EncounterSpeed } from "./constants.js";
 import { POKEMON_BY_ID } from "./pokemon-data.js";
 import { TYPE_POOLS } from "./encounter-pool.js";
 
@@ -41,14 +43,55 @@ export function getEncounterTypes(eventType: XpEventType): readonly PokemonType[
   return ENCOUNTER_TYPE_MAP[eventType];
 }
 
+// ── Encounter Context ─────────────────────────────────────────
+
+export interface EncounterContext {
+  xpSinceLastEncounter: number;
+  encounterSpeed: EncounterSpeed;
+  currentStreak: number;
+  recentToolTypes: string[]; // tool types used recently
+  currentHour: number; // 0-23
+}
+
 // ── Encounter Trigger ─────────────────────────────────────────
 
 /**
- * Check if a wild encounter should trigger based on XP earned since last encounter.
- * Returns true roughly every XP_PER_ENCOUNTER (500) XP.
+ * Check if a wild encounter should trigger based on XP earned,
+ * encounter speed setting, and streak bonus.
+ * Streak bonus: 7+ day streak halves the threshold.
  */
-export function shouldTriggerEncounter(xpSinceLastEncounter: number): boolean {
-  return xpSinceLastEncounter >= XP_PER_ENCOUNTER;
+export function shouldTriggerEncounter(ctx: EncounterContext): boolean {
+  const threshold = ENCOUNTER_THRESHOLDS[ctx.encounterSpeed];
+
+  // Streak bonus: 7+ day streak = halve the threshold
+  const streakMultiplier = ctx.currentStreak >= 7 ? 0.5 : 1;
+  const effectiveThreshold = Math.floor(threshold * streakMultiplier);
+
+  if (ctx.xpSinceLastEncounter < effectiveThreshold) return false;
+
+  return true;
+}
+
+/** Check for bonus encounter (10% chance after a regular encounter). */
+export function shouldBonusEncounter(): boolean {
+  return Math.random() < 0.1;
+}
+
+/** Check for activity diversity bonus (3+ unique tool types in recent history). */
+export function shouldDiversityBonus(recentToolTypes: string[]): boolean {
+  const uniqueTypes = new Set(recentToolTypes);
+  return uniqueTypes.size >= 3;
+}
+
+// ── Time-of-Day Bias ──────────────────────────────────────────
+
+/** Get time-of-day type biases for encounter generation. */
+export function getTimeOfDayBias(hour: number): PokemonType[] {
+  if (hour >= 22 || hour < 5) return ["Ghost", "Poison"]; // Night: Ghost types
+  if (hour >= 5 && hour < 9) return ["Grass", "Bug"]; // Morning: Grass types
+  if (hour >= 12 && hour < 14) return ["Fire", "Rock"]; // Midday: Fire types
+  if (hour >= 17 && hour < 20) return ["Water", "Flying"]; // Evening: Water types
+  return []; // No bias
 }
 
 // ── Rarity Weights ────────────────────────────────────────────
@@ -235,14 +278,27 @@ function determineEncounterLevel(state: PlayerState, seed: number): number {
 /**
  * Generate a wild encounter based on the activity type.
  * Picks a Pokemon from the matching type pool, weighted by rarity.
- * Excludes Pokemon already in the player's party/box (unless duplicates are common tier).
+ * If time-of-day bias types are provided, there is a 40% chance to
+ * use those types instead of the activity-based types.
+ * Excludes Pokemon already in the player's party/box (unless common tier).
  * Returns null if no eligible Pokemon found.
  */
 export function generateEncounter(
   eventType: XpEventType,
   state: PlayerState,
+  timeOfDayTypes?: readonly PokemonType[],
 ): WildEncounter | null {
-  const types = getEncounterTypes(eventType);
+  let types = getEncounterTypes(eventType);
+
+  // 40% chance to use time-of-day biased types if available
+  if (timeOfDayTypes && timeOfDayTypes.length > 0) {
+    const seed = Math.floor(Date.now() / 1000);
+    const biasRoll = seededRandom(seed + 42);
+    if (biasRoll < 0.4) {
+      types = timeOfDayTypes;
+    }
+  }
+
   const candidates = buildCandidatePool(types, state);
 
   if (candidates.length === 0) return null;