clibuddy 1.0.0

package/dist/index.js

@@ -0,0 +1,1665 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const readline = __importStar(require("readline"));
+const types_1 = require("./buddy/types");
+const roll_1 = require("./buddy/roll");
+const decay_1 = require("./buddy/decay");
+const activities_1 = require("./buddy/activities");
+const species_1 = require("./buddy/species");
+const save_1 = require("./state/save");
+const screen_1 = require("./rendering/screen");
+const display_1 = require("./rendering/display");
+const commandPalette_1 = require("./rendering/commandPalette");
+const registry_1 = require("./commands/registry");
+const engine_1 = require("./dialogue/engine");
+const lines_1 = require("./dialogue/lines");
+const engine_2 = require("./events/engine");
+const titles_1 = require("./buddy/titles");
+const finding_1 = require("./inventory/finding");
+const items_1 = require("./inventory/items");
+const inventoryUI_1 = require("./rendering/inventoryUI");
+const overlayUI_1 = require("./rendering/overlayUI");
+const shop_1 = require("./story/shop");
+const progress_1 = require("./story/progress");
+const settings_1 = require("./state/settings");
+const sound_1 = require("./sound/sound");
+const types_2 = require("./adventure/types");
+const engine_3 = require("./adventure/engine");
+const combat_1 = require("./adventure/combat/combat");
+const enemies_1 = require("./adventure/combat/enemies");
+const skills_1 = require("./adventure/combat/skills");
+const combatUI_1 = require("./adventure/combat/combatUI");
+const adventureUI_1 = require("./adventure/adventureUI");
+const progress_2 = require("./story/progress");
+const mainStory_1 = require("./story/mainStory");
+const generator_1 = require("./adventure/generation/generator");
+const endless_1 = require("./adventure/generation/endless");
+const minigameUI_1 = require("./rendering/minigameUI");
+const types_3 = require("./minigames/types");
+const registry_2 = require("./minigames/registry");
+const titles_2 = require("./buddy/titles");
+const leveling_1 = require("./buddy/leveling");
+// Register all commands
+require("./commands/actions");
+if (process.env.CLIBUDDY_DEV)
+    require("./commands/admin");
+require("./commands/social");
+// Register all mini-games
+require("./minigames/copycat");
+require("./minigames/quickpaws");
+require("./minigames/treasurehunt");
+require("./minigames/moodmatch");
+require("./minigames/fetch");
+require("./minigames/rpsplus");
+// ─── App State ───────────────────────────────────────────────
+const screen = new screen_1.Screen();
+let buddyState = null;
+let animFrame = 0;
+let animTimer = null;
+let decayTimer = null;
+let feedbackMessage;
+let feedbackTimeout = null;
+let dialogueMessage;
+let dialogueSource;
+let dialogueTimeout = null;
+let dialogueTick = 0;
+let activeEvent = null;
+let inventoryUI = (0, inventoryUI_1.createInventoryUI)();
+let overlay = (0, overlayUI_1.createOverlay)();
+let minigameMenu = (0, minigameUI_1.createMinigameMenu)();
+let activeMiniGame = (0, types_3.createInactiveGame)();
+let activeAdventure = (0, types_2.createInactiveAdventure)();
+let currentAdventureDef = null;
+let endlessDepth = 0;
+let isEndlessMode = false;
+let adventureMenu = (0, adventureUI_1.createAdventureMenu)();
+let showingSkillMenu = false;
+let petSequence = null;
+let petTick = 0;
+let palette = (0, commandPalette_1.createPalette)();
+let inputBuffer = "";
+let pendingCommand = null; // command selected, waiting for args
+let argsBuffer = "";
+let appPhase = "roll-wait";
+let nameBuffer = "";
+// ─── Rendering ───────────────────────────────────────────────
+function redraw() {
+    if (appPhase === "playing" && buddyState) {
+        // Active adventure takes over the screen
+        if (activeAdventure.active) {
+            const adv = currentAdventureDef;
+            if (adv) {
+                if (activeAdventure.phase === "combat" && activeAdventure.combat) {
+                    let screen_ = (0, combatUI_1.renderCombat)(activeAdventure.combat, buddyState, adv.name);
+                    if (showingSkillMenu) {
+                        screen_ += "\n" + (0, combatUI_1.renderSkillMenu)(activeAdventure.combat, buddyState);
+                    }
+                    screen.draw(screen_, `  ${screen_1.ansi.dim}Esc to flee${screen_1.ansi.reset}`);
+                }
+                else if (activeAdventure.phase === "result") {
+                    screen.draw((0, adventureUI_1.renderResult)(activeAdventure, adv, buddyState.name), `  ${screen_1.ansi.dim}Press Enter${screen_1.ansi.reset}`);
+                }
+                else {
+                    screen.draw((0, adventureUI_1.renderRoom)(activeAdventure, adv, buddyState.name), `  ${screen_1.ansi.dim}Esc to retreat${screen_1.ansi.reset}`);
+                }
+            }
+            return;
+        }
+        // Active mini-game takes over the screen entirely
+        if (activeMiniGame.active) {
+            const handler = (0, registry_2.getGameHandler)(activeMiniGame.gameId);
+            if (handler) {
+                const gameScreen = handler.render(activeMiniGame, buddyState.name);
+                screen.draw(gameScreen, `  ${screen_1.ansi.dim}Esc to quit${screen_1.ansi.reset}`);
+            }
+            return;
+        }
+        const main = (0, display_1.renderMainScreen)(buddyState, animFrame, feedbackMessage, dialogueMessage, dialogueSource);
+        // Minigame menu overlay
+        if (adventureMenu.active) {
+            const menuLines = (0, adventureUI_1.renderAdventureMenu)(adventureMenu, buddyState);
+            const combined = main + "\n" + menuLines.join("\n");
+            screen.draw(combined, `  ${screen_1.ansi.dim}Esc to close${screen_1.ansi.reset}`);
+        }
+        else if (minigameMenu.active) {
+            const menuLines = (0, minigameUI_1.renderMinigameMenu)(minigameMenu);
+            const combined = main + "\n" + menuLines.join("\n");
+            screen.draw(combined, `  ${screen_1.ansi.dim}Esc to close${screen_1.ansi.reset}`);
+        }
+        else if (overlay.type) {
+            let overlayLines;
+            if (overlay.type === "titles") {
+                overlayLines = (0, overlayUI_1.renderTitlesOverlay)(buddyState, overlay);
+            }
+            else if (overlay.type === "notifications") {
+                overlayLines = (0, overlayUI_1.renderNotificationsOverlay)(buddyState.notifications, overlay);
+            }
+            else if (overlay.type === "gear") {
+                overlayLines = (0, overlayUI_1.renderGearOverlay)(buddyState);
+            }
+            else if (overlay.type === "combatinfo") {
+                overlayLines = (0, overlayUI_1.renderCombatInfoOverlay)(buddyState);
+            }
+            else if (overlay.type === "shop") {
+                overlayLines = (0, overlayUI_1.renderShopOverlay)(buddyState, overlay);
+            }
+            else {
+                overlayLines = (0, overlayUI_1.renderSettingsOverlay)((0, settings_1.getSettings)(), overlay);
+            }
+            const combined = main + "\n" + overlayLines.join("\n");
+            screen.draw(combined, `  ${screen_1.ansi.dim}Esc to close${screen_1.ansi.reset}`);
+        }
+        else if (inventoryUI.active) {
+            const s = buddyState.adventureStats;
+            const invLines = (0, inventoryUI_1.renderInventoryUI)(inventoryUI, s.equippedWeapon, s.equippedArmor, s.equippedHelmet, s.equippedBoots, s.equippedAccessory, buddyState.questProgress.gold);
+            const combined = main + "\n" + invLines.join("\n");
+            screen.draw(combined, `  ${screen_1.ansi.dim}Inventory open${screen_1.ansi.reset}`);
+        }
+        else if (palette.active) {
+            const paletteLines = (0, commandPalette_1.renderPalette)(palette);
+            const combined = main + "\n" + paletteLines.join("\n");
+            const inputDisplay = `  ${screen_1.ansi.dim}>${screen_1.ansi.reset} /${palette.filter}`;
+            screen.draw(combined, inputDisplay);
+        }
+        else if (pendingCommand) {
+            const inputDisplay = `  ${screen_1.ansi.dim}>${screen_1.ansi.reset} /${pendingCommand} ${argsBuffer}`;
+            screen.draw(main, inputDisplay);
+        }
+        else {
+            const inputDisplay = inputBuffer
+                ? `  ${screen_1.ansi.dim}>${screen_1.ansi.reset} ${inputBuffer}`
+                : `  ${screen_1.ansi.dim}> Type / for commands${screen_1.ansi.reset}`;
+            screen.draw(main, inputDisplay);
+        }
+    }
+}
+function showFeedback(msg, durationMs = 3000) {
+    feedbackMessage = msg;
+    if (feedbackTimeout)
+        clearTimeout(feedbackTimeout);
+    feedbackTimeout = setTimeout(() => {
+        feedbackMessage = undefined;
+        redraw();
+    }, durationMs);
+    redraw();
+}
+// ─── Animation Loop ──────────────────────────────────────────
+function startAnimation() {
+    animTimer = setInterval(() => {
+        animFrame++;
+        // Tick active adventure combat
+        if (activeAdventure.active && activeAdventure.combat) {
+            const phase = activeAdventure.combat.phase;
+            if (phase === "player_animate" || phase === "enemy_turn" || phase === "enemy_animate") {
+                activeAdventure = {
+                    ...activeAdventure,
+                    combat: (0, combat_1.tickCombat)(activeAdventure.combat),
+                };
+            }
+            redraw();
+            return;
+        }
+        // Tick active mini-game
+        if (activeMiniGame.active) {
+            const handler = (0, registry_2.getGameHandler)(activeMiniGame.gameId);
+            if (handler) {
+                activeMiniGame = handler.tick(activeMiniGame);
+                // Check if game ended during tick
+                if (activeMiniGame.phase === "result" && activeMiniGame.ticksInPhase > 8) {
+                    finishMiniGame();
+                }
+            }
+            redraw();
+            return; // Skip normal processing during games
+        }
+        // Process activity progress each frame
+        if (buddyState?.activity) {
+            const beforeType = buddyState.activity.type;
+            const beforeLevel = buddyState.level;
+            buddyState = (0, activities_1.applyActivityProgress)(buddyState);
+            // Activity just completed
+            if (beforeType !== "idle" && !buddyState.activity) {
+                const label = beforeType === "sleeping" ? "wakes up feeling refreshed!" :
+                    beforeType === "eating" ? "finishes eating. Yum!" :
+                        "is done playing!";
+                let msg = `${buddyState.name} ${label}`;
+                if (buddyState.level > beforeLevel) {
+                    msg += ` LEVEL UP! Now level ${buddyState.level}!`;
+                    (0, sound_1.soundLevelUp)();
+                }
+                // Check for new titles after activity
+                const newTitles = (0, titles_1.checkForNewTitles)(buddyState);
+                if (newTitles.length > 0) {
+                    buddyState = { ...buddyState, titles: [...buddyState.titles, ...newTitles], activeTitle: newTitles[newTitles.length - 1] };
+                    msg += ` New title earned!`;
+                    (0, sound_1.soundTitleEarned)();
+                }
+                showFeedback(msg);
+                (0, save_1.saveState)(buddyState);
+            }
+        }
+        // Periodic title check (for age/level/inventory titles)
+        if (buddyState && animFrame % 50 === 0) {
+            const newTitles = (0, titles_1.checkForNewTitles)(buddyState);
+            if (newTitles.length > 0) {
+                buddyState = { ...buddyState, titles: [...buddyState.titles, ...newTitles], activeTitle: newTitles[newTitles.length - 1] };
+                showFeedback(`New title earned!`);
+                (0, save_1.saveState)(buddyState);
+            }
+        }
+        // Item finding — during idle
+        if (buddyState && !buddyState.activity && !activeEvent) {
+            const found = (0, finding_1.checkForItemFind)(buddyState);
+            if (found) {
+                const inventory = (0, items_1.addItemToInventory)(buddyState.inventory, found.item.id);
+                const itemCounts = { ...buddyState.actionCounts, itemsFound: buddyState.actionCounts.itemsFound + 1 };
+                buddyState = {
+                    ...buddyState,
+                    inventory,
+                    actionCounts: itemCounts,
+                    notifications: [...buddyState.notifications, { message: found.flavorText, timestamp: Date.now() }],
+                };
+                showFeedback(found.flavorText);
+                (0, sound_1.soundItemFound)();
+                (0, save_1.saveState)(buddyState);
+            }
+        }
+        // Advance pet sequence
+        if (petSequence) {
+            petTick++;
+            // Each line shows for 3 ticks (~2.4s)
+            const frameIndex = Math.floor(petTick / 3);
+            if (frameIndex < petSequence.length) {
+                dialogueMessage = petSequence[frameIndex];
+                dialogueSource = "Petting";
+            }
+            else {
+                // Sequence done — keep last line visible briefly
+                petSequence = null;
+                petTick = 0;
+                dialogueTimeout = setTimeout(() => {
+                    dialogueMessage = undefined;
+                    dialogueSource = undefined;
+                    redraw();
+                }, 3000);
+            }
+        }
+        // Idle events — only when no activity and not petting
+        if (buddyState && !buddyState.activity && !petSequence && activeEvent) {
+            const result = (0, engine_2.advanceEvent)(activeEvent);
+            // Override dialogue with event's current frame
+            dialogueMessage = result.dialogue;
+            dialogueSource = activeEvent.event.name.replace(/_/g, " ");
+            if (dialogueTimeout) {
+                clearTimeout(dialogueTimeout);
+                dialogueTimeout = null;
+            }
+            if (result.done) {
+                activeEvent = null;
+                // Keep last event line visible a bit longer
+                dialogueTimeout = setTimeout(() => {
+                    dialogueMessage = undefined;
+                    dialogueSource = undefined;
+                    redraw();
+                }, 4000);
+            }
+        }
+        else if (buddyState && !buddyState.activity && !activeEvent) {
+            const event = (0, engine_2.checkForEvent)(buddyState);
+            if (event) {
+                activeEvent = event;
+            }
+        }
+        // Random dialogue — every ~30 ticks (24s), only during idle with no event
+        dialogueTick++;
+        if (buddyState && !buddyState.activity && !activeEvent && !petSequence && dialogueTick >= 30) {
+            dialogueTick = Math.floor(Math.random() * 10); // randomize next interval
+            const line = (0, engine_1.pickDialogue)(buddyState);
+            if (line) {
+                dialogueMessage = line;
+                dialogueSource = "Idle";
+                if (dialogueTimeout)
+                    clearTimeout(dialogueTimeout);
+                dialogueTimeout = setTimeout(() => {
+                    dialogueMessage = undefined;
+                    dialogueSource = undefined;
+                    redraw();
+                }, 8000);
+            }
+        }
+        redraw();
+    }, 800);
+}
+function stopAnimation() {
+    if (animTimer) {
+        clearInterval(animTimer);
+        animTimer = null;
+    }
+}
+// ─── Real-time Decay ─────────────────────────────────────────
+function startDecay() {
+    // Apply decay every 30 seconds for visible stat movement
+    decayTimer = setInterval(() => {
+        if (buddyState && buddyState.alive) {
+            const wasAlive = buddyState.alive;
+            buddyState = (0, decay_1.applyDecay)(buddyState);
+            if (wasAlive && !buddyState.alive) {
+                (0, sound_1.soundDeath)();
+                showFeedback(`${buddyState.name} has passed away...`);
+            }
+            (0, save_1.saveState)(buddyState);
+            redraw();
+        }
+    }, 30_000);
+}
+// ─── Input Handling ──────────────────────────────────────────
+function setupInput() {
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    // Use readline's keypress parser for proper escape sequence handling
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.on("keypress", (str, key) => {
+        // Normalize into a single string for our handler
+        if (key.ctrl && key.name === "c") {
+            handleKeypress("\x03");
+        }
+        else if (key.name === "up") {
+            handleKeypress("\x1b[A");
+        }
+        else if (key.name === "down") {
+            handleKeypress("\x1b[B");
+        }
+        else if (key.name === "escape") {
+            handleKeypress("\x1b");
+        }
+        else if (key.name === "return") {
+            handleKeypress("\r");
+        }
+        else if (key.name === "backspace") {
+            handleKeypress("\x7f");
+        }
+        else if (key.name === "tab") {
+            handleKeypress("\t");
+        }
+        else if (str && str.length === 1 && str >= " ") {
+            handleKeypress(str);
+        }
+    });
+}
+function handleKeypress(key) {
+    // Ctrl+C — always exit
+    if (key === "\x03") {
+        shutdown();
+        return;
+    }
+    switch (appPhase) {
+        case "roll-wait":
+            handleRollWaitInput(key);
+            break;
+        case "rolling":
+            // ignore input during roll animation
+            break;
+        case "reveal":
+            handleRevealInput(key);
+            break;
+        case "naming":
+            handleNamingInput(key);
+            break;
+        case "playing":
+            handlePlayingInput(key);
+            break;
+    }
+}
+// ─── Roll Flow ───────────────────────────────────────────────
+function handleRollWaitInput(key) {
+    if (key === "\r" || key === "\n") {
+        startRollAnimation();
+    }
+}
+function startRollAnimation() {
+    appPhase = "rolling";
+    // Pre-roll the result
+    const result = (0, roll_1.rollBuddy)();
+    // Build a shuffled sequence of species to cycle through
+    const shuffled = [...species_1.SPECIES].sort(() => Math.random() - 0.5);
+    // Ensure the actual result is last
+    const filtered = shuffled.filter((s) => s.id !== result.id);
+    const sequence = [...filtered, result];
+    // Tick schedule: fast → slow → reveal
+    // 8 fast ticks (250ms), 3 medium (500ms), 2 slow (800ms), then reveal
+    const schedule = [
+        ...Array(8).fill(250),
+        500, 500, 500,
+        800, 800,
+    ];
+    let tick = 0;
+    function nextTick() {
+        if (tick >= schedule.length) {
+            // Show reveal
+            showRollReveal(result);
+            return;
+        }
+        const speciesIndex = tick % sequence.length;
+        const species = sequence[speciesIndex];
+        const art = species.animations.idle[0];
+        // Render cycling silhouette in dim gray
+        screen.draw((0, display_1.renderRollScreen)("rolling", species.name, art));
+        tick++;
+        setTimeout(nextTick, schedule[tick - 1]);
+    }
+    nextTick();
+}
+let rolledSpecies = null;
+function showRollReveal(result) {
+    appPhase = "reveal";
+    rolledSpecies = result;
+    const color = types_1.RARITY_COLORS[result.rarity];
+    const label = types_1.RARITY_LABELS[result.rarity];
+    // Sound for epic/legendary
+    if (result.rarity === "epic" || result.rarity === "legendary") {
+        (0, sound_1.soundRareRoll)();
+    }
+    const content = (0, display_1.renderRollScreen)("reveal", result.name, result.animations.idle[0], color, label);
+    screen.draw(content + (0, display_1.renderNamePrompt)(result.name), `  ${screen_1.ansi.dim}>${screen_1.ansi.reset} `);
+    appPhase = "naming";
+    nameBuffer = "";
+}
+function handleRevealInput(key) {
+    if (key === "\r" || key === "\n") {
+        appPhase = "naming";
+    }
+}
+function handleNamingInput(key) {
+    if (!rolledSpecies)
+        return;
+    if (key === "\r" || key === "\n") {
+        // Confirm name
+        const name = nameBuffer.trim() || rolledSpecies.name;
+        buddyState = (0, roll_1.createBuddyState)(rolledSpecies, name);
+        (0, save_1.saveState)(buddyState);
+        appPhase = "playing";
+        showFeedback(`Welcome, ${name}! Take good care of them.`, 4000);
+        startAnimation();
+        startDecay();
+        redraw();
+        return;
+    }
+    if (key === "\x7f" || key === "\b") {
+        // Backspace
+        nameBuffer = nameBuffer.slice(0, -1);
+    }
+    else if (key.length === 1 && key >= " ") {
+        nameBuffer += key;
+    }
+    // Redraw name input
+    const color = types_1.RARITY_COLORS[rolledSpecies.rarity];
+    const label = types_1.RARITY_LABELS[rolledSpecies.rarity];
+    const content = (0, display_1.renderRollScreen)("reveal", rolledSpecies.name, rolledSpecies.animations.idle[0], color, label);
+    screen.draw(content + (0, display_1.renderNamePrompt)(rolledSpecies.name), `  ${screen_1.ansi.dim}>${screen_1.ansi.reset} ${nameBuffer}`);
+}
+// ─── Playing Input ───────────────────────────────────────────
+function handlePlayingInput(key) {
+    if (!buddyState)
+        return;
+    // Active adventure gets highest priority
+    if (activeAdventure.active) {
+        handleAdventureInput(key);
+        return;
+    }
+    // Adventure menu
+    if (adventureMenu.active) {
+        handleAdventureMenuInput(key);
+        return;
+    }
+    // Active mini-game
+    if (activeMiniGame.active) {
+        handleMiniGameInput(key);
+        return;
+    }
+    // Minigame menu
+    if (minigameMenu.active) {
+        handleMinigameMenuInput(key);
+        return;
+    }
+    // Overlay menus (titles, notifications)
+    if (overlay.type) {
+        handleOverlayInput(key);
+        return;
+    }
+    // Inventory UI open
+    if (inventoryUI.active) {
+        handleInventoryInput(key);
+        return;
+    }
+    // Args input mode — typing arguments for a selected command
+    if (pendingCommand) {
+        if (key === "\r" || key === "\n") {
+            const cmd = pendingCommand;
+            const args = argsBuffer.trim().split(/\s+/).filter(Boolean);
+            pendingCommand = null;
+            argsBuffer = "";
+            executeCommand(cmd, args);
+            return;
+        }
+        if (key === "\x1b") {
+            pendingCommand = null;
+            argsBuffer = "";
+            redraw();
+            return;
+        }
+        if (key === "\x7f" || key === "\b") {
+            argsBuffer = argsBuffer.slice(0, -1);
+            redraw();
+            return;
+        }
+        if (key.length === 1 && key >= " ") {
+            argsBuffer += key;
+            redraw();
+            return;
+        }
+        return;
+    }
+    // Fast-forward: any key during an activity skips to completion (unless unskippable)
+    if (buddyState.activity && buddyState.activity.type !== "idle" && !buddyState.activity.unskippable) {
+        // Force completion by setting startedAt far in the past
+        buddyState = {
+            ...buddyState,
+            activity: {
+                ...buddyState.activity,
+                startedAt: Date.now() - buddyState.activity.durationMs - 1000,
+            },
+        };
+        const beforeLevel = buddyState.level;
+        buddyState = (0, activities_1.applyActivityProgress)(buddyState);
+        const label = buddyState.activity ? "" :
+            "Done!";
+        let msg = label;
+        if (buddyState.level > beforeLevel) {
+            msg += ` LEVEL UP! Now level ${buddyState.level}!`;
+        }
+        showFeedback(msg);
+        (0, save_1.saveState)(buddyState);
+        redraw();
+        return;
+    }
+    if (palette.active) {
+        handlePaletteInput(key);
+        return;
+    }
+    if (key === "/") {
+        // Open command palette
+        palette = (0, commandPalette_1.openPalette)(palette);
+        inputBuffer = "/";
+        redraw();
+        return;
+    }
+    if (key === "\x7f" || key === "\b") {
+        inputBuffer = inputBuffer.slice(0, -1);
+        redraw();
+        return;
+    }
+    if (key === "\r" || key === "\n") {
+        const trimmed = inputBuffer.trim();
+        if (trimmed.startsWith("/")) {
+            // Parse typed command with arguments
+            const parts = trimmed.slice(1).split(/\s+/);
+            const cmdName = parts[0].toLowerCase();
+            const args = parts.slice(1);
+            inputBuffer = "";
+            executeCommand(cmdName, args);
+        }
+        else if (trimmed) {
+            showFeedback(`${buddyState.name} tilts their head. Try / for commands.`);
+            inputBuffer = "";
+            redraw();
+        }
+        else {
+            inputBuffer = "";
+            redraw();
+        }
+        return;
+    }
+    // Regular character
+    if (key.length === 1 && key >= " ") {
+        inputBuffer += key;
+        redraw();
+    }
+}
+function handlePaletteInput(key) {
+    if (!buddyState)
+        return;
+    // Escape — close palette
+    if (key === "\x1b") {
+        palette = (0, commandPalette_1.createPalette)();
+        inputBuffer = "";
+        redraw();
+        return;
+    }
+    // Arrow up
+    if (key === "\x1b[A") {
+        palette = (0, commandPalette_1.moveSelection)(palette, -1);
+        redraw();
+        return;
+    }
+    // Arrow down
+    if (key === "\x1b[B") {
+        palette = (0, commandPalette_1.moveSelection)(palette, 1);
+        redraw();
+        return;
+    }
+    // Enter — execute selected command
+    if (key === "\r" || key === "\n") {
+        const cmdName = (0, commandPalette_1.getSelectedCommand)(palette);
+        palette = (0, commandPalette_1.createPalette)();
+        inputBuffer = "";
+        if (cmdName) {
+            executeCommand(cmdName);
+        }
+        return;
+    }
+    // Backspace
+    if (key === "\x7f" || key === "\b") {
+        if (palette.filter.length > 0) {
+            palette = (0, commandPalette_1.updateFilter)(palette, palette.filter.slice(0, -1));
+        }
+        else {
+            // Close palette if filter is empty and backspace is pressed
+            palette = (0, commandPalette_1.createPalette)();
+            inputBuffer = "";
+        }
+        redraw();
+        return;
+    }
+    // Tab — confirm top match
+    if (key === "\t") {
+        const cmdName = (0, commandPalette_1.getSelectedCommand)(palette);
+        palette = (0, commandPalette_1.createPalette)();
+        inputBuffer = "";
+        if (cmdName) {
+            executeCommand(cmdName);
+        }
+        return;
+    }
+    // Space — if the filter matches a command, switch to args mode
+    if (key === " ") {
+        const cmdName = (0, commandPalette_1.getSelectedCommand)(palette);
+        if (cmdName && palette.filteredCommands.length === 1) {
+            // Exact single match — enter args input for this command
+            palette = (0, commandPalette_1.createPalette)();
+            inputBuffer = "";
+            pendingCommand = cmdName;
+            argsBuffer = "";
+            redraw();
+            return;
+        }
+        // Otherwise just add space to filter
+        palette = (0, commandPalette_1.updateFilter)(palette, palette.filter + key);
+        redraw();
+        return;
+    }
+    // Regular typing — filter commands
+    if (key.length === 1 && key >= " ") {
+        palette = (0, commandPalette_1.updateFilter)(palette, palette.filter + key);
+        redraw();
+    }
+}
+function executeCommand(cmdName, args = []) {
+    if (!buddyState)
+        return;
+    const cmd = (0, registry_1.getCommand)(cmdName);
+    if (!cmd)
+        return;
+    // Special handling for rename — need to enter a name
+    // For now, just execute directly
+    const result = cmd.execute(buddyState, args);
+    if (result.state) {
+        buddyState = result.state;
+        (0, save_1.saveState)(buddyState);
+    }
+    if (result.quit) {
+        shutdown();
+        return;
+    }
+    if (result.message === "__OPEN_INVENTORY__") {
+        inventoryUI = (0, inventoryUI_1.openInventoryUI)(buddyState.inventory);
+        redraw();
+        return;
+    }
+    if (result.message === "__OPEN_TITLES__") {
+        overlay = (0, overlayUI_1.openOverlay)("titles");
+        redraw();
+        return;
+    }
+    if (result.message === "__OPEN_NOTIFICATIONS__") {
+        overlay = (0, overlayUI_1.openOverlay)("notifications");
+        redraw();
+        return;
+    }
+    if (result.message === "__OPEN_MINIGAMES__") {
+        minigameMenu = (0, minigameUI_1.openMinigameMenu)((0, registry_2.getAllGames)());
+        redraw();
+        return;
+    }
+    if (result.message === "__OPEN_GEAR__") {
+        overlay = (0, overlayUI_1.openOverlay)("gear");
+        redraw();
+        return;
+    }
+    if (result.message === "__OPEN_COMBATINFO__") {
+        overlay = (0, overlayUI_1.openOverlay)("combatinfo");
+        redraw();
+        return;
+    }
+    if (result.message === "__OPEN_SHOP__") {
+        overlay = (0, overlayUI_1.openOverlay)("shop");
+        redraw();
+        return;
+    }
+    if (result.message === "__OPEN_ADVENTURE__") {
+        adventureMenu = (0, adventureUI_1.openAdventureMenu)((0, mainStory_1.getAllQuestChains)(buddyState?.questProgress.completedChapters ?? []));
+        redraw();
+        return;
+    }
+    if (result.message === "__OPEN_SETTINGS__") {
+        overlay = (0, overlayUI_1.openOverlay)("settings");
+        redraw();
+        return;
+    }
+    if (result.message === "__PET__") {
+        startPetSequence();
+        redraw();
+        return;
+    }
+    if (result.message) {
+        showFeedback(result.message);
+    }
+    redraw();
+}
+function pickRandom(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+function startPetSequence() {
+    if (!buddyState)
+        return;
+    // 50% chance of a multi-step sequence, 50% chance of a quick single + species line
+    if (Math.random() < 0.5) {
+        petSequence = [...pickRandom(lines_1.PET_SEQUENCES)];
+    }
+    else {
+        const single = pickRandom(lines_1.PET_SINGLES);
+        const speciesLines = lines_1.SPECIES_PET[buddyState.speciesId];
+        const speciesLine = speciesLines ? pickRandom(speciesLines) : null;
+        petSequence = speciesLine ? [single, speciesLine] : [single];
+    }
+    petTick = 0;
+    // Show first line immediately
+    dialogueMessage = petSequence[0];
+    dialogueSource = "Petting";
+    if (dialogueTimeout)
+        clearTimeout(dialogueTimeout);
+    dialogueTimeout = null;
+}
+// ─── Adventure Handlers ──────────────────────────────────────
+function handleAdventureMenuInput(key) {
+    if (!buddyState)
+        return;
+    if (key === "\x1b") {
+        adventureMenu = (0, adventureUI_1.createAdventureMenu)();
+        redraw();
+        return;
+    }
+    if (key === "\t") {
+        adventureMenu = (0, adventureUI_1.switchTab)(adventureMenu);
+        redraw();
+        return;
+    }
+    if (key === "\x1b[A") {
+        adventureMenu = (0, adventureUI_1.moveAdventureSelection)(adventureMenu, -1);
+        redraw();
+        return;
+    }
+    if (key === "\x1b[B") {
+        adventureMenu = (0, adventureUI_1.moveAdventureSelection)(adventureMenu, 1);
+        redraw();
+        return;
+    }
+    if (key === "\x1b[C" || key === "\x1b[D") {
+        if (adventureMenu.tab === "story") {
+            adventureMenu = (0, adventureUI_1.changeQuestChain)(adventureMenu, key === "\x1b[C" ? 1 : -1);
+            redraw();
+        }
+        else if (adventureMenu.tab === "expedition") {
+            adventureMenu = (0, adventureUI_1.changeExpeditionBiome)(adventureMenu, key === "\x1b[C" ? 1 : -1);
+            redraw();
+        }
+        return;
+    }
+    if (key === "\r" || key === "\n") {
+        let adv;
+        if (adventureMenu.tab === "story") {
+            const chain = adventureMenu.questChains[adventureMenu.selectedChainIndex];
+            if (!chain)
+                return;
+            const chapter = chain.chapters[adventureMenu.selectedIndex];
+            if (!chapter)
+                return;
+            const { canStartChapter } = require("./story/types");
+            const blockReason = canStartChapter(chapter, buddyState.questProgress, buddyState.level);
+            if (blockReason) {
+                showFeedback(blockReason);
+                redraw();
+                return;
+            }
+            if (!chapter.acts || chapter.acts.length === 0) {
+                showFeedback("This chapter isn't available yet — coming soon!");
+                redraw();
+                return;
+            }
+            // Check for saved progress to resume
+            const saved = buddyState.questProgress.savedAdventure;
+            const resumeActIndex = buddyState.questProgress.activeActIndex ?? 0;
+            if (saved) {
+                const act = chapter.acts[resumeActIndex];
+                if (act) {
+                    try {
+                        adv = act.buildAdventure();
+                    }
+                    catch {
+                        showFeedback("Coming soon!");
+                        redraw();
+                        return;
+                    }
+                    currentAdventureDef = adv;
+                    activeAdventure = (0, progress_2.restoreAdventureState)(saved);
+                    buddyState = (0, progress_2.clearSavedAdventure)(buddyState);
+                    buddyState = (0, progress_2.setActiveQuest)(buddyState, chain.id, chapter.id);
+                    adventureMenu = (0, adventureUI_1.createAdventureMenu)();
+                    const resumeRoom = (0, types_2.getRoom)(adv, activeAdventure.currentRoomId);
+                    if (resumeRoom && (resumeRoom.type === "combat" || resumeRoom.type === "boss") && resumeRoom.enemyId) {
+                        const enemy = (0, enemies_1.getEnemy)(resumeRoom.enemyId);
+                        if (enemy)
+                            activeAdventure = { ...activeAdventure, phase: "combat", combat: (0, combat_1.startCombat)(buddyState, enemy, activeAdventure.morale) };
+                    }
+                    (0, save_1.saveState)(buddyState);
+                    showFeedback("Resuming quest where you left off!");
+                    redraw();
+                    return;
+                }
+            }
+            // Start first act
+            const firstAct = chapter.acts[0];
+            try {
+                adv = firstAct.buildAdventure();
+            }
+            catch {
+                showFeedback("This chapter isn't available yet — coming soon!");
+                redraw();
+                return;
+            }
+            isEndlessMode = false;
+            buddyState = (0, progress_2.setActiveQuest)(buddyState, chain.id, chapter.id);
+            buddyState = { ...buddyState, questProgress: { ...buddyState.questProgress, activeActIndex: 0 } };
+        }
+        else if (adventureMenu.tab === "expedition") {
+            const biomeId = (0, adventureUI_1.getSelectedBiomeId)(adventureMenu);
+            adv = (0, generator_1.generateExpedition)({
+                difficulty: adventureMenu.expeditionDifficulty,
+                biomeId,
+                buddyState,
+            });
+            isEndlessMode = false;
+        }
+        else {
+            // Endless Depths
+            adv = (0, endless_1.createEndlessAdventure)(buddyState);
+            isEndlessMode = true;
+            endlessDepth = 0;
+        }
+        const err = (0, engine_3.canStartAdventure)(buddyState, adv);
+        if (err) {
+            showFeedback(err);
+            redraw();
+            return;
+        }
+        const result = (0, engine_3.beginAdventure)(buddyState, adv);
+        buddyState = result.state;
+        activeAdventure = result.adventure;
+        // Store the generated adventure so we can reference it
+        currentAdventureDef = adv;
+        adventureMenu = (0, adventureUI_1.createAdventureMenu)();
+        // If start room is combat, start it
+        const startRoom = (0, types_2.getRoom)(adv, adv.startRoomId);
+        if (startRoom && (startRoom.type === "combat" || startRoom.type === "boss") && startRoom.enemyId) {
+            const enemy = (0, enemies_1.getEnemy)(startRoom.enemyId);
+            if (enemy) {
+                activeAdventure = { ...activeAdventure, combat: (0, combat_1.startCombat)(buddyState, enemy, activeAdventure.morale) };
+            }
+        }
+        (0, save_1.saveState)(buddyState);
+        redraw();
+    }
+}
+function handleAdventureInput(key) {
+    if (!buddyState)
+        return;
+    if (activeAdventure.phase === "combat" && activeAdventure.combat) {
+        handleCombatInput(key);
+        return;
+    }
+    if (activeAdventure.phase === "result") {
+        if (key === "\r" || key === "\n") {
+            finishAdventure();
+        }
+        return;
+    }
+    // Room input
+    if (key === "\x1b") {
+        // Retreat from adventure — save progress if it's a quest
+        if (buddyState.questProgress.activeChapter) {
+            buddyState = (0, progress_2.saveQuestAdventure)(buddyState, activeAdventure);
+            (0, save_1.saveState)(buddyState);
+            showFeedback("Quest progress saved. Resume anytime!");
+        }
+        else {
+            showFeedback("Retreated from adventure.");
+        }
+        activeAdventure = (0, types_2.createInactiveAdventure)();
+        currentAdventureDef = null;
+        redraw();
+        return;
+    }
+    const adv = currentAdventureDef;
+    if (!adv)
+        return;
+    const room = (0, types_2.getRoom)(adv, activeAdventure.currentRoomId);
+    if (!room)
+        return;
+    // Text paging — advance page on Enter/Space if text isn't fully shown
+    if (!activeAdventure.textFullyShown) {
+        if (key === "\r" || key === "\n" || key === " ") {
+            const LINES_PER_PAGE = 3;
+            const totalPages = Math.ceil(room.text.length / LINES_PER_PAGE);
+            const nextPage = activeAdventure.textPage + 1;
+            if (nextPage >= totalPages) {
+                // Beyond last page — already fully shown, FALL THROUGH to choice handling
+                activeAdventure = { ...activeAdventure, textFullyShown: true };
+                redraw();
+                // DON'T return — let the rest of the handler process this Enter
+            }
+            else {
+                // Advancing to next page — mark fully shown if this IS the last page
+                const isLastPage = nextPage >= totalPages - 1;
+                activeAdventure = { ...activeAdventure, textPage: nextPage, textFullyShown: isLastPage };
+                redraw();
+                // Only fall through on last page if room has choices (so 1/2 keys work immediately)
+                // Otherwise always return — let the user SEE the last page before advancing
+                const hasChoices = (room.type === "narrative" && room.choices) || (room.type === "event" && room.eventChoices);
+                if (!isLastPage || !hasChoices)
+                    return;
+                // Last page with choices — fall through so choices are immediately selectable
+            }
+        }
+        else {
+            return; // Block non-Enter input during paging
+        }
+    }
+    if (room.type === "narrative" && room.choices) {
+        const choice = parseInt(key) - 1;
+        if (choice >= 0 && choice < room.choices.length) {
+            activeAdventure = (0, engine_3.makeChoice)(activeAdventure, adv, choice);
+            // Check if new room is combat
+            const newRoom = (0, types_2.getRoom)(adv, activeAdventure.currentRoomId);
+            if (newRoom && (newRoom.type === "combat" || newRoom.type === "boss") && newRoom.enemyId) {
+                const enemy = (0, enemies_1.getEnemy)(newRoom.enemyId);
+                if (enemy) {
+                    activeAdventure = { ...activeAdventure, combat: (0, combat_1.startCombat)(buddyState, enemy, activeAdventure.morale) };
+                }
+            }
+            redraw();
+        }
+        return;
+    }
+    if (room.type === "rest") {
+        if (key === "1" && room.healAmount) {
+            buddyState = { ...buddyState, stats: { ...buddyState.stats, health: Math.min(100, buddyState.stats.health + room.healAmount) } };
+            activeAdventure = (0, engine_3.adjustMorale)(activeAdventure, 10);
+            advanceEndlessOrNormal(adv);
+            redraw();
+        }
+        else if (key === "2") {
+            advanceEndlessOrNormal(adv);
+            redraw();
+        }
+        return;
+    }
+    if (room.type === "event" && room.eventChoices) {
+        // Check if event was already resolved (buddy reaction is an outcome)
+        const alreadyResolved = room.eventChoices.some((c) => c.outcome === activeAdventure.buddyReaction);
+        if (alreadyResolved) {
+            // Any key advances to next room
+            advanceEndlessOrNormal(adv);
+            redraw();
+            return;
+        }
+        const choice = parseInt(key) - 1;
+        if (choice >= 0 && choice < room.eventChoices.length) {
+            const eventChoice = room.eventChoices[choice];
+            activeAdventure = { ...activeAdventure, buddyReaction: eventChoice.outcome };
+            // Apply effect
+            if (eventChoice.effect?.itemGain) {
+                buddyState = { ...buddyState, inventory: (0, items_1.addItemToInventory)(buddyState.inventory, eventChoice.effect.itemGain) };
+                activeAdventure = { ...activeAdventure, lootCollected: [...activeAdventure.lootCollected, eventChoice.effect.itemGain] };
+            }
+            redraw();
+            return;
+        }
+        return;
+    }
+    if (room.type === "treasure") {
+        if (key === "\r" || key === "\n") {
+            const lootId = (0, engine_3.rollTreasureLoot)(room);
+            if (lootId) {
+                const prevLen = buddyState.inventory.length;
+                buddyState = { ...buddyState, inventory: (0, items_1.addItemToInventory)(buddyState.inventory, lootId) };
+                const wasNew = buddyState.inventory.length > prevLen;
+                activeAdventure = (0, engine_3.adjustMorale)({ ...activeAdventure, lootCollected: [...activeAdventure.lootCollected, lootId] }, 5);
+                showFeedback(wasNew ? `Found: ${lootId.replace(/_/g, " ")}!` : `Found: ${lootId.replace(/_/g, " ")} (already owned)`);
+            }
+            advanceEndlessOrNormal(adv);
+            redraw();
+        }
+        return;
+    }
+    // Default: Enter to advance
+    if (key === "\r" || key === "\n") {
+        advanceEndlessOrNormal(adv);
+        redraw();
+    }
+}
+function advanceEndlessOrNormal(adv) {
+    if (!buddyState)
+        return;
+    if (isEndlessMode && currentAdventureDef) {
+        endlessDepth++;
+        // XP per room
+        const roomXp = 5 + endlessDepth * 3;
+        activeAdventure = { ...activeAdventure, xpEarned: activeAdventure.xpEarned + roomXp };
+        // Generate next room
+        const result = (0, endless_1.addEndlessRoom)(currentAdventureDef, endlessDepth, buddyState);
+        currentAdventureDef = result.adventure;
+        activeAdventure = {
+            ...activeAdventure,
+            currentRoomId: result.roomId,
+            roomsVisited: [...activeAdventure.roomsVisited, result.roomId],
+            phase: "room",
+            combat: undefined,
+            textPage: 0,
+            textFullyShown: true, // endless rooms are short, show immediately
+            buddyReaction: `Depth ${endlessDepth + 1}... deeper we go!`,
+        };
+        // Check if new room is combat
+        const newRoom = (0, types_2.getRoom)(currentAdventureDef, result.roomId);
+        if (newRoom && (newRoom.type === "combat" || newRoom.type === "boss") && newRoom.enemyId) {
+            const enemy = (0, enemies_1.getEnemy)(newRoom.enemyId);
+            if (enemy) {
+                // Scale enemy stats for endless depth
+                const scaled = (0, endless_1.scaleEndlessEnemy)(enemy.baseHp, enemy.baseAtk, enemy.baseDef, endlessDepth);
+                const scaledEnemy = { ...enemy, baseHp: scaled.hp, baseAtk: scaled.atk, baseDef: scaled.def };
+                activeAdventure = { ...activeAdventure, phase: "combat", combat: (0, combat_1.startCombat)(buddyState, scaledEnemy, activeAdventure.morale) };
+            }
+        }
+    }
+    else {
+        activeAdventure = (0, engine_3.advanceToNextRoom)(activeAdventure, adv);
+        // Scene acts skip the result screen — auto-finish when the last room ends
+        if (activeAdventure.phase === "result" && adv.isScene) {
+            finishAdventure();
+            return;
+        }
+        checkAndStartCombat(adv);
+    }
+}
+function checkAndStartCombat(adv) {
+    if (!buddyState)
+        return;
+    const room = (0, types_2.getRoom)(adv, activeAdventure.currentRoomId);
+    if (activeAdventure.phase === "combat" && (room?.type === "combat" || room?.type === "boss") && room.enemyId) {
+        const enemy = (0, enemies_1.getEnemy)(room.enemyId);
+        if (enemy) {
+            activeAdventure = { ...activeAdventure, combat: (0, combat_1.startCombat)(buddyState, enemy, activeAdventure.morale) };
+        }
+    }
+}
+function handleCombatInput(key) {
+    if (!buddyState || !activeAdventure.combat)
+        return;
+    const combat = activeAdventure.combat;
+    // Victory/Defeat/Fled — Enter to continue
+    if (combat.phase === "victory" || combat.phase === "defeat" || combat.phase === "fled") {
+        if (key === "\r" || key === "\n") {
+            const adv = currentAdventureDef;
+            if (!adv)
+                return;
+            if (combat.phase === "victory") {
+                (0, sound_1.soundBattleWin)();
+                // Track combos from this battle
+                if (combat.comboTriggeredThisBattle > 0) {
+                    const cc = { ...buddyState.actionCounts, combosTriggered: buddyState.actionCounts.combosTriggered + combat.comboTriggeredThisBattle };
+                    buddyState = { ...buddyState, actionCounts: cc };
+                }
+                activeAdventure = (0, engine_3.adjustMorale)({
+                    ...activeAdventure,
+                    combat: undefined,
+                    battlesWon: activeAdventure.battlesWon + 1,
+                    xpEarned: activeAdventure.xpEarned + combat.enemy.xpReward,
+                    damageTaken: activeAdventure.damageTaken + combat.damageTakenThisBattle,
+                }, 10);
+                // Check for loot drop
+                if (Math.random() < combat.enemy.dropChance && combat.enemy.dropPool.length > 0) {
+                    const dropId = combat.enemy.dropPool[Math.floor(Math.random() * combat.enemy.dropPool.length)];
+                    const prevLen = buddyState.inventory.length;
+                    buddyState = { ...buddyState, inventory: (0, items_1.addItemToInventory)(buddyState.inventory, dropId) };
+                    const wasNew = buddyState.inventory.length > prevLen;
+                    activeAdventure = { ...activeAdventure, lootCollected: [...activeAdventure.lootCollected, dropId] };
+                    if (wasNew)
+                        showFeedback(`Enemy dropped: ${dropId.replace(/_/g, " ")}!`);
+                    else
+                        showFeedback(`Enemy dropped: ${dropId.replace(/_/g, " ")} (already owned)`);
+                }
+                // Advance to next room (or next depth in endless)
+                advanceEndlessOrNormal(adv);
+            }
+            else if (combat.phase === "defeat") {
+                // Adventure over — buddy is hurt and needs mandatory recovery
+                activeAdventure = { ...activeAdventure, battlesLost: activeAdventure.battlesLost + 1, phase: "result", combat: undefined, buddyReaction: "Ow... I need to rest..." };
+                // Penalty: lose happiness + hunger, and forced into 5-minute unskippable recovery
+                const newStats = {
+                    ...buddyState.stats,
+                    happiness: Math.max(0, buddyState.stats.happiness - 20),
+                    hunger: Math.max(0, buddyState.stats.hunger - 15),
+                };
+                // Start a 5-minute recovery activity (not skippable — we'll block fast-forward for it)
+                const recoveryActivity = {
+                    type: "sleeping",
+                    startedAt: Date.now(),
+                    durationMs: 300_000, // 5 minutes
+                    statBaseline: { energy: newStats.energy },
+                    statTarget: { energy: Math.min(100, newStats.energy + 15) },
+                    unskippable: true,
+                };
+                buddyState = { ...buddyState, stats: newStats, activity: recoveryActivity };
+            }
+            else {
+                // Fled — advance past this room
+                activeAdventure = { ...activeAdventure, battlesFled: activeAdventure.battlesFled + 1, combat: undefined };
+                advanceEndlessOrNormal(adv);
+            }
+            (0, save_1.saveState)(buddyState);
+            redraw();
+        }
+        return;
+    }
+    // Player turn actions
+    if (combat.phase !== "player_turn")
+        return;
+    if (showingSkillMenu) {
+        // Skill selection
+        if (key === "0") {
+            showingSkillMenu = false;
+            redraw();
+            return;
+        }
+        const skills = (0, skills_1.getAvailableSkills)(buddyState.speciesId, buddyState.level);
+        const idx = parseInt(key) - 1;
+        if (idx >= 0 && idx < skills.length) {
+            activeAdventure = { ...activeAdventure, combat: (0, combat_1.playerUseSkill)(combat, skills[idx]) };
+            showingSkillMenu = false;
+        }
+        redraw();
+        return;
+    }
+    switch (key) {
+        case "1": // Attack
+            activeAdventure = { ...activeAdventure, combat: (0, combat_1.playerAttack)(combat) };
+            break;
+        case "2": // Skill menu
+            showingSkillMenu = true;
+            break;
+        case "3": // Item (use potion/food from inventory mid-combat)
+            // Simple: use first medicine in inventory
+            const medicine = buddyState.inventory.find((s) => {
+                const item = (0, items_1.getItem)(s.itemId);
+                return item?.type === "medicine" && s.count > 0;
+            });
+            if (medicine) {
+                const item = (0, items_1.getItem)(medicine.itemId);
+                const healAmount = item.statEffect.health ?? 0;
+                const newHp = Math.min(combat.playerStats.maxHp, combat.playerStats.hp + healAmount);
+                activeAdventure = {
+                    ...activeAdventure,
+                    combat: { ...combat, playerStats: { ...combat.playerStats, hp: newHp }, phase: "player_animate", log: [...combat.log, `Used ${item.name}! +${healAmount} HP`], ticksInPhase: 0 },
+                };
+                buddyState = { ...buddyState, inventory: buddyState.inventory.map((s) => s.itemId === medicine.itemId ? { ...s, count: s.count - 1 } : s).filter((s) => s.count > 0) };
+            }
+            else {
+                activeAdventure = { ...activeAdventure, combat: { ...combat, log: [...combat.log, "No medicine in inventory!"] } };
+            }
+            break;
+        case "4": // Defend
+            activeAdventure = { ...activeAdventure, combat: (0, combat_1.playerDefend)(combat) };
+            break;
+        case "5": // Flee
+        case "\x1b":
+            activeAdventure = { ...activeAdventure, combat: (0, combat_1.playerFlee)(combat) };
+            break;
+        default:
+            return;
+    }
+    redraw();
+}
+function finishAdventure() {
+    if (!buddyState)
+        return;
+    (0, sound_1.soundAdventureComplete)();
+    const adv = currentAdventureDef;
+    // Award XP
+    buddyState = { ...buddyState, xp: buddyState.xp + activeAdventure.xpEarned };
+    const { state: leveled } = (0, leveling_1.checkLevelUp)(buddyState);
+    buddyState = leveled;
+    // Update adventure stats
+    const stats = { ...buddyState.adventureStats };
+    stats.adventuresCompleted++;
+    stats.battlesWon += activeAdventure.battlesWon;
+    stats.battlesLost += activeAdventure.battlesLost;
+    stats.battlesFled += activeAdventure.battlesFled;
+    if (activeAdventure.damageTaken === 0 && activeAdventure.battlesWon > 0) {
+        stats.perfectAdventures++;
+    }
+    if (adv?.difficulty === "boss" && activeAdventure.battlesLost === 0) {
+        stats.bossesDefeated++;
+    }
+    buddyState = { ...buddyState, adventureStats: stats };
+    // Complete quest chapter if this was a quest adventure
+    if (buddyState.questProgress.activeChapter) {
+        const chainId = buddyState.questProgress.activeChain;
+        const chapterId = buddyState.questProgress.activeChapter;
+        if (chainId) {
+            const chain = (0, mainStory_1.getQuestChain)(chainId);
+            const chapter = chain?.chapters.find((c) => c.id === chapterId);
+            if (chapter) {
+                const actIndex = buddyState.questProgress.activeActIndex ?? 0;
+                const nextActIndex = actIndex + 1;
+                if (nextActIndex < chapter.acts.length) {
+                    // More acts — load the next one
+                    buddyState = { ...buddyState, questProgress: { ...buddyState.questProgress, activeActIndex: nextActIndex } };
+                    try {
+                        const nextAct = chapter.acts[nextActIndex];
+                        const nextAdv = nextAct.buildAdventure();
+                        currentAdventureDef = nextAdv;
+                        const startResult = (0, engine_3.beginAdventure)(buddyState, nextAdv);
+                        buddyState = startResult.state;
+                        activeAdventure = startResult.adventure;
+                        // Check if first room is combat
+                        const startRoom = (0, types_2.getRoom)(nextAdv, nextAdv.startRoomId);
+                        if (startRoom && (startRoom.type === "combat" || startRoom.type === "boss") && startRoom.enemyId) {
+                            const enemy = (0, enemies_1.getEnemy)(startRoom.enemyId);
+                            if (enemy)
+                                activeAdventure = { ...activeAdventure, phase: "combat", combat: (0, combat_1.startCombat)(buddyState, enemy, activeAdventure.morale) };
+                        }
+                        (0, save_1.saveState)(buddyState);
+                        showFeedback(`${nextAct.name}`);
+                        redraw();
+                        return; // Don't fall through to normal finish
+                    }
+                    catch {
+                        // Act not built yet — complete chapter
+                    }
+                }
+                // Final act or error — complete the chapter
+                buddyState = (0, progress_2.completeChapter)(buddyState, chapter);
+                buddyState = (0, progress_2.clearSavedAdventure)(buddyState);
+                buddyState = { ...buddyState, questProgress: { ...buddyState.questProgress, activeActIndex: undefined } };
+                showFeedback(`Chapter complete! +${chapter.rewards.xp} XP, +${chapter.rewards.gold} gold`);
+            }
+        }
+    }
+    (0, save_1.saveState)(buddyState);
+    const depthMsg = isEndlessMode ? ` Reached Depth ${endlessDepth + 1}!` : "";
+    if (!buddyState.questProgress.activeChapter) {
+        showFeedback(`Adventure complete! +${activeAdventure.xpEarned} XP${depthMsg}`);
+    }
+    activeAdventure = (0, types_2.createInactiveAdventure)();
+    currentAdventureDef = null;
+    isEndlessMode = false;
+    endlessDepth = 0;
+    redraw();
+}
+function handleMiniGameInput(key) {
+    if (!buddyState)
+        return;
+    // Escape — quit game
+    if (key === "\x1b") {
+        activeMiniGame = (0, types_3.createInactiveGame)();
+        redraw();
+        return;
+    }
+    // Delegate to game handler
+    const handler = (0, registry_2.getGameHandler)(activeMiniGame.gameId);
+    if (handler) {
+        activeMiniGame = handler.handleInput(key, activeMiniGame);
+        // If game just entered result phase, let it show for a few ticks
+        if (activeMiniGame.phase === "result" && activeMiniGame.ticksInPhase === 0) {
+            activeMiniGame = { ...activeMiniGame, ticksInPhase: 1 };
+        }
+    }
+    redraw();
+}
+function handleMinigameMenuInput(key) {
+    if (key === "\x1b") {
+        minigameMenu = (0, minigameUI_1.createMinigameMenu)();
+        redraw();
+        return;
+    }
+    if (key === "\x1b[A") {
+        minigameMenu = (0, minigameUI_1.moveMinigameSelection)(minigameMenu, -1);
+        redraw();
+        return;
+    }
+    if (key === "\x1b[B") {
+        minigameMenu = (0, minigameUI_1.moveMinigameSelection)(minigameMenu, 1);
+        redraw();
+        return;
+    }
+    if (key === "\r" || key === "\n") {
+        const game = minigameMenu.games[minigameMenu.selectedIndex];
+        if (game) {
+            const handler = (0, registry_2.getGameHandler)(game.id);
+            if (handler) {
+                minigameMenu = (0, minigameUI_1.createMinigameMenu)();
+                activeMiniGame = handler.start();
+                redraw();
+            }
+        }
+        return;
+    }
+}
+function finishMiniGame() {
+    if (!buddyState)
+        return;
+    const xp = (0, types_3.getXpReward)(activeMiniGame.score, activeMiniGame.maxRounds, 20);
+    const gameCounts = { ...buddyState.actionCounts, minigamesWon: buddyState.actionCounts.minigamesWon + 1 };
+    buddyState = { ...buddyState, xp: buddyState.xp + xp, actionCounts: gameCounts };
+    const { state: leveled } = (0, leveling_1.checkLevelUp)(buddyState);
+    buddyState = leveled;
+    (0, save_1.saveState)(buddyState);
+    showFeedback(`Game over! +${xp} XP`);
+    (0, sound_1.soundGameEnd)();
+    activeMiniGame = (0, types_3.createInactiveGame)();
+}
+function handleOverlayInput(key) {
+    if (!buddyState)
+        return;
+    // Escape — close
+    if (key === "\x1b") {
+        overlay = (0, overlayUI_1.createOverlay)();
+        redraw();
+        return;
+    }
+    // Arrow up/down — scroll
+    if (key === "\x1b[A") {
+        const maxItems = overlay.type === "titles" ? titles_2.TITLE_RULES.length :
+            overlay.type === "settings" ? (0, overlayUI_1.getSettingEntries)().length :
+                overlay.type === "notifications" ? buddyState.notifications.length :
+                    overlay.type === "shop" ? shop_1.SHOP_ITEMS.length :
+                        0;
+        overlay = (0, overlayUI_1.scrollOverlay)(overlay, -1, maxItems);
+        redraw();
+        return;
+    }
+    if (key === "\x1b[B") {
+        const maxItems = overlay.type === "titles" ? titles_2.TITLE_RULES.length :
+            overlay.type === "settings" ? (0, overlayUI_1.getSettingEntries)().length :
+                overlay.type === "notifications" ? buddyState.notifications.length :
+                    overlay.type === "shop" ? shop_1.SHOP_ITEMS.length :
+                        0;
+        overlay = (0, overlayUI_1.scrollOverlay)(overlay, 1, maxItems);
+        redraw();
+        return;
+    }
+    // Enter — action depending on overlay type
+    if (key === "\r" || key === "\n") {
+        if (overlay.type === "titles") {
+            const rule = titles_2.TITLE_RULES[overlay.scrollIndex];
+            if (rule && buddyState.titles.includes(rule.id)) {
+                buddyState = { ...buddyState, activeTitle: rule.id };
+                (0, save_1.saveState)(buddyState);
+                showFeedback(`Title equipped: ${rule.label}`);
+            }
+        }
+        else if (overlay.type === "notifications") {
+            buddyState = { ...buddyState, notifications: [] };
+            (0, save_1.saveState)(buddyState);
+            showFeedback("Notifications cleared.");
+        }
+        else if (overlay.type === "settings") {
+            // Toggle the selected setting
+            const entries = (0, overlayUI_1.getSettingEntries)();
+            const entry = entries[overlay.scrollIndex];
+            if (entry) {
+                const current = (0, settings_1.getSettings)();
+                const updated = { ...current, [entry.key]: !current[entry.key] };
+                (0, settings_1.saveSettings)(updated);
+                showFeedback(`${entry.name}: ${updated[entry.key] ? "ON" : "OFF"}`);
+            }
+            // Don't close — stay in settings to toggle more
+            redraw();
+            return;
+        }
+        else if (overlay.type === "shop") {
+            // Buy selected item
+            const shopItem = shop_1.SHOP_ITEMS[overlay.scrollIndex];
+            if (shopItem) {
+                const result = (0, progress_1.spendGold)(buddyState, shopItem.price);
+                if (result) {
+                    buddyState = { ...result, inventory: (0, items_1.addItemToInventory)(result.inventory, shopItem.itemId) };
+                    (0, save_1.saveState)(buddyState);
+                    const item = (0, items_1.getItem)(shopItem.itemId);
+                    showFeedback(`Bought ${item?.name ?? shopItem.itemId}! (-${shopItem.price}g)`);
+                }
+                else {
+                    showFeedback("Not enough gold!");
+                }
+            }
+            // Stay in shop
+            redraw();
+            return;
+        }
+        overlay = (0, overlayUI_1.createOverlay)();
+        redraw();
+        return;
+    }
+}
+function handleInventoryInput(key) {
+    if (!buddyState)
+        return;
+    if (key === "\x1b") {
+        inventoryUI = (0, inventoryUI_1.createInventoryUI)();
+        redraw();
+        return;
+    }
+    if (key === "\t") {
+        inventoryUI = (0, inventoryUI_1.switchInventoryTab)(inventoryUI);
+        redraw();
+        return;
+    }
+    if (key === "\x1b[A") {
+        inventoryUI = (0, inventoryUI_1.moveInventorySelection)(inventoryUI, -1);
+        redraw();
+        return;
+    }
+    if (key === "\x1b[B") {
+        inventoryUI = (0, inventoryUI_1.moveInventorySelection)(inventoryUI, 1);
+        redraw();
+        return;
+    }
+    if (key === "\r" || key === "\n") {
+        const slot = (0, inventoryUI_1.getSelectedSlot)(inventoryUI);
+        if (!slot)
+            return;
+        const item = (0, items_1.getItem)(slot.itemId);
+        if (!item)
+            return;
+        // Use or equip the item
+        inventoryUI = (0, inventoryUI_1.createInventoryUI)();
+        if (item.type === "weapon") {
+            // Equip weapon (don't consume)
+            const advStats = { ...buddyState.adventureStats, equippedWeapon: item.id };
+            buddyState = { ...buddyState, adventureStats: advStats };
+            showFeedback(`Equipped ${item.name}! (+${item.combatATK} ATK)`);
+        }
+        else if (item.type === "armor") {
+            const advStats = { ...buddyState.adventureStats, equippedArmor: item.id };
+            buddyState = { ...buddyState, adventureStats: advStats };
+            showFeedback(`Equipped ${item.name}! (+${item.combatDEF} DEF)`);
+        }
+        else if (item.type === "helmet") {
+            const advStats = { ...buddyState.adventureStats, equippedHelmet: item.id };
+            buddyState = { ...buddyState, adventureStats: advStats };
+            showFeedback(`Equipped ${item.name}! (${item.description})`);
+        }
+        else if (item.type === "boots") {
+            const advStats = { ...buddyState.adventureStats, equippedBoots: item.id };
+            buddyState = { ...buddyState, adventureStats: advStats };
+            showFeedback(`Equipped ${item.name}! (${item.description})`);
+        }
+        else if (item.type === "accessory") {
+            const advStats = { ...buddyState.adventureStats, equippedAccessory: item.id };
+            buddyState = { ...buddyState, adventureStats: advStats };
+            showFeedback(`Equipped ${item.name}! (${item.description})`);
+        }
+        else {
+            // Consumable — decrement count
+            const inventory = buddyState.inventory
+                .map((s) => s.itemId === item.id ? { ...s, count: s.count - 1 } : s)
+                .filter((s) => s.count > 0);
+            buddyState = { ...buddyState, inventory };
+            if (item.type === "food") {
+                const activity = (0, activities_1.startActivity)(buddyState, "eating", item.statEffect);
+                buddyState = { ...buddyState, activity };
+                showFeedback(`${buddyState.name} eats a ${item.name}!`);
+            }
+            else if (item.type === "toy") {
+                const activity = (0, activities_1.startActivity)(buddyState, "playing", item.statEffect);
+                buddyState = { ...buddyState, activity };
+                showFeedback(`${buddyState.name} plays with the ${item.name}!`);
+            }
+            else if (item.type === "medicine") {
+                const bStats = { ...buddyState.stats };
+                for (const [key, delta] of Object.entries(item.statEffect)) {
+                    bStats[key] = Math.min(100, Math.max(0, bStats[key] + delta));
+                }
+                buddyState = { ...buddyState, stats: bStats, xp: buddyState.xp + item.xpBonus };
+                showFeedback(`${buddyState.name} uses a ${item.name}!`);
+            }
+        }
+        (0, save_1.saveState)(buddyState);
+        redraw();
+        return;
+    }
+}
+// ─── Lifecycle ───────────────────────────────────────────────
+function shutdown() {
+    stopAnimation();
+    if (decayTimer)
+        clearInterval(decayTimer);
+    if (feedbackTimeout)
+        clearTimeout(feedbackTimeout);
+    if (buddyState)
+        (0, save_1.saveState)(buddyState);
+    screen.cleanup();
+    console.log(`  ${screen_1.ansi.dim}Goodbye! Your buddy will be waiting.${screen_1.ansi.reset}\n`);
+    process.exit(0);
+}
+async function main() {
+    // Check for updates in the background (non-blocking)
+    const { checkForUpdates, getUpdateBanner } = require("./updates");
+    checkForUpdates();
+    // Show update banner after a short delay (gives the HTTP request time to complete)
+    setTimeout(() => {
+        const banner = getUpdateBanner();
+        if (banner)
+            showFeedback("New version available! Type /update to install.", 5000);
+    }, 4000);
+    // Load settings
+    (0, settings_1.loadSettings)();
+    // Handle clean exit
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    buddyState = (0, save_1.loadState)();
+    setupInput();
+    if (buddyState) {
+        // Returning player — catch up on activities and decay
+        buddyState = (0, activities_1.applyActivityProgress)(buddyState);
+        buddyState = (0, decay_1.applyDecay)(buddyState);
+        (0, save_1.saveState)(buddyState);
+        appPhase = "playing";
+        const hoursAway = (Date.now() - buddyState.lastUpdated) / (1000 * 60 * 60);
+        if (hoursAway > 1) {
+            showFeedback(`You were away for ${Math.round(hoursAway)} hours. ${buddyState.name} missed you!`, 4000);
+        }
+        else {
+            showFeedback(`Welcome back! ${buddyState.name} is happy to see you.`, 3000);
+        }
+        startAnimation();
+        startDecay();
+        redraw();
+    }
+    else {
+        // New player — show roll screen
+        appPhase = "roll-wait";
+        screen.draw((0, display_1.renderRollScreen)("waiting"), `  ${screen_1.ansi.dim}Press Enter to roll...${screen_1.ansi.reset}`);
+    }
+}
+main().catch((err) => {
+    screen.cleanup();
+    console.error("Fatal error:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map