clibuddy 1.0.0

package/dist/buddy/titles.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TITLE_RULES = void 0;
+exports.checkForNewTitles = checkForNewTitles;
+exports.getTitleRule = getTitleRule;
+exports.formatNameWithTitle = formatNameWithTitle;
+exports.TITLE_RULES = [
+    // Level titles
+    { id: "newborn", label: "Newborn", position: "prefix", hint: "Start your journey", condition: () => true },
+    { id: "apprentice", label: "Apprentice", position: "prefix", hint: "Reach level 5", condition: (s) => s.level >= 5 },
+    { id: "veteran", label: "Veteran", position: "prefix", hint: "Reach level 10", condition: (s) => s.level >= 10 },
+    { id: "elder", label: "Elder", position: "prefix", hint: "Reach level 15", condition: (s) => s.level >= 15 },
+    { id: "master", label: "Master", position: "prefix", hint: "Reach level 20", condition: (s) => s.level >= 20 },
+    { id: "grandmaster", label: "Grandmaster", position: "prefix", hint: "Reach level 30", condition: (s) => s.level >= 30 },
+    // Age titles
+    { id: "survivor", label: "Survivor", position: "suffix", hint: "Survive 24 hours", condition: (s) => s.age >= 24 },
+    { id: "ancient", label: "the Ancient", position: "suffix", hint: "Survive 7 days", condition: (s) => s.age >= 168 },
+    { id: "eternal", label: "the Eternal", position: "suffix", hint: "Survive 30 days", condition: (s) => s.age >= 720 },
+    // Action titles
+    { id: "snack_lord", label: "Snack Lord", position: "suffix", hint: "Feed 50 times", condition: (s) => s.actionCounts.feeds >= 50 },
+    { id: "well_fed", label: "the Well-Fed", position: "suffix", hint: "Feed 10 times", condition: (s) => s.actionCounts.feeds >= 10 },
+    { id: "sleepyhead", label: "Sleepyhead", position: "suffix", hint: "Sleep 20 times", condition: (s) => s.actionCounts.sleeps >= 20 },
+    { id: "hyperactive", label: "the Hyperactive", position: "suffix", hint: "Play 50 times", condition: (s) => s.actionCounts.plays >= 50 },
+    { id: "playful", label: "the Playful", position: "suffix", hint: "Play 10 times", condition: (s) => s.actionCounts.plays >= 10 },
+    { id: "iron_will", label: "of Iron Will", position: "suffix", hint: "Revive 3 times", condition: (s) => s.actionCounts.revives >= 3 },
+    { id: "healer", label: "the Mended", position: "suffix", hint: "Heal 15 times", condition: (s) => s.actionCounts.heals >= 15 },
+    // Fun / rare
+    { id: "hoarder", label: "the Hoarder", position: "suffix", hint: "Collect 20 items", condition: (s) => s.inventory.reduce((sum, sl) => sum + sl.count, 0) >= 20 },
+    { id: "king", label: "King", position: "prefix", hint: "Reach level 25 and survive 7 days", condition: (s) => s.level >= 25 && s.age >= 168 },
+    // Adventure / combat titles
+    { id: "adventurer", label: "the Adventurer", position: "suffix", hint: "Complete 1 adventure", condition: (s) => s.adventureStats.adventuresCompleted >= 1 },
+    { id: "vet_explorer", label: "Veteran Explorer", position: "prefix", hint: "Complete 10 adventures", condition: (s) => s.adventureStats.adventuresCompleted >= 10 },
+    { id: "unscathed", label: "the Unscathed", position: "suffix", hint: "Complete an adventure with no damage", condition: (s) => s.adventureStats.perfectAdventures >= 1 },
+    { id: "dragon_slayer", label: "Dragon Slayer", position: "prefix", hint: "Defeat a boss", condition: (s) => s.adventureStats.bossesDefeated >= 1 },
+    { id: "warrior", label: "the Warrior", position: "suffix", hint: "Win 10 battles", condition: (s) => s.adventureStats.battlesWon >= 10 },
+    { id: "champion", label: "Champion", position: "prefix", hint: "Win 50 battles", condition: (s) => s.adventureStats.battlesWon >= 50 },
+    { id: "pacifist", label: "the Pacifist", position: "suffix", hint: "Complete an adventure fleeing all combats", condition: (s) => s.adventureStats.battlesFled >= 3 },
+    { id: "collector", label: "the Collector", position: "suffix", hint: "Own 5 different gear pieces", condition: (s) => s.inventory.filter((sl) => sl.itemId.includes("sword") || sl.itemId.includes("blade") || sl.itemId.includes("mail") || sl.itemId.includes("armor") || sl.itemId.includes("stick") || sl.itemId.includes("cloak") || sl.itemId.includes("scepter") || sl.itemId.includes("fang") || sl.itemId.includes("robe") || sl.itemId.includes("scale")).length >= 5 },
+    // Minigame titles
+    { id: "quick_master", label: "Quick Paws Master", position: "suffix", hint: "Score 8+ in Quick Paws", condition: (s) => s.actionCounts.minigamesWon >= 3 },
+    { id: "memory_champ", label: "Memory Champion", position: "suffix", hint: "Win Copycat", condition: (s) => s.actionCounts.minigamesWon >= 2 },
+    { id: "game_master", label: "Game Master", position: "prefix", hint: "Win 10 minigames", condition: (s) => s.actionCounts.minigamesWon >= 10 },
+    // Relationship titles
+    { id: "best_friends", label: "Best Friends", position: "suffix", hint: "Pet 50 times", condition: (s) => s.actionCounts.pets >= 50 },
+    { id: "devoted", label: "the Devoted", position: "suffix", hint: "Age over 30 days", condition: (s) => s.age >= 720 },
+    { id: "caretaker", label: "Caretaker", position: "prefix", hint: "Feed, play, sleep, heal 20+ each", condition: (s) => s.actionCounts.feeds >= 20 && s.actionCounts.plays >= 20 && s.actionCounts.sleeps >= 20 && s.actionCounts.heals >= 20 },
+    // Combat depth titles
+    { id: "combo_king", label: "Combo King", position: "prefix", hint: "Trigger 10 combos", condition: (s) => s.actionCounts.combosTriggered >= 10 },
+    { id: "elementalist", label: "the Elementalist", position: "suffix", hint: "Win 20 adventures", condition: (s) => s.adventureStats.adventuresCompleted >= 20 },
+    { id: "untouchable", label: "the Untouchable", position: "suffix", hint: "Complete 5 perfect adventures", condition: (s) => s.adventureStats.perfectAdventures >= 5 },
+    // Rare/fun titles
+    { id: "the_immortal", label: "the Immortal", position: "suffix", hint: "Revive 10 times", condition: (s) => s.actionCounts.revives >= 10 },
+    { id: "loot_goblin", label: "Loot Goblin", position: "prefix", hint: "Find 50 items", condition: (s) => s.actionCounts.itemsFound >= 50 },
+    { id: "pet_lover", label: "the Beloved", position: "suffix", hint: "Pet 100 times", condition: (s) => s.actionCounts.pets >= 100 },
+    { id: "legend", label: "Legend", position: "prefix", hint: "Level 20 + 50 battles + 10 adventures", condition: (s) => s.level >= 20 && s.adventureStats.battlesWon >= 50 && s.adventureStats.adventuresCompleted >= 10 },
+    { id: "completionist", label: "the Completionist", position: "suffix", hint: "Earn 40 other titles", condition: (s) => s.titles.length >= 40 },
+    // Story titles
+    { id: "world_savior", label: "World Savior", position: "prefix", hint: "Complete The Shattered Harmony", condition: (s) => s.questProgress.storyFlags.includes("ch8_complete") },
+    { id: "stone_seeker", label: "Stone Seeker", position: "suffix", hint: "Restore 3 Harmony Stones", condition: (s) => s.questProgress.completedChapters.filter((c) => c.startsWith("ch")).length >= 3 },
+    { id: "shadow_walker", label: "Shadow Walker", position: "prefix", hint: "Enter the Shadow Realm", condition: (s) => s.questProgress.storyFlags.includes("ch7_complete") },
+];
+/**
+ * Check for newly earned titles. Returns IDs of titles just earned (not previously in state.titles).
+ */
+function checkForNewTitles(state) {
+    const newTitles = [];
+    for (const rule of exports.TITLE_RULES) {
+        if (!state.titles.includes(rule.id) && rule.condition(state)) {
+            newTitles.push(rule.id);
+        }
+    }
+    return newTitles;
+}
+function getTitleRule(id) {
+    return exports.TITLE_RULES.find((r) => r.id === id);
+}
+/** Format the buddy's display name with active title */
+function formatNameWithTitle(state, speciesName) {
+    if (!state.activeTitle)
+        return `${state.name} the ${speciesName}`;
+    const rule = getTitleRule(state.activeTitle);
+    if (!rule)
+        return `${state.name} the ${speciesName}`;
+    if (rule.position === "prefix") {
+        return `${rule.label} ${state.name} the ${speciesName}`;
+    }
+    return `${state.name} ${rule.label}`;
+}
+//# sourceMappingURL=titles.js.map

package/dist/buddy/types.d.ts

@@ -0,0 +1,92 @@
+export type Rarity = "common" | "uncommon" | "rare" | "epic" | "legendary";
+export type ActivityType = "idle" | "sleeping" | "eating" | "playing";
+export interface AnimationSet {
+    idle: string[];
+    sleeping: string[];
+    eating: string[];
+    playing: string[];
+    sick: string[];
+    hungry?: string[];
+    tired?: string[];
+    sad?: string[];
+}
+export interface BuddySpecies {
+    id: string;
+    name: string;
+    rarity: Rarity;
+    animations: AnimationSet;
+    /** Base stats modifier (1.0 = normal) */
+    statModifier: number;
+}
+export interface BuddyStats {
+    hunger: number;
+    happiness: number;
+    health: number;
+    energy: number;
+}
+export interface ActivityState {
+    type: ActivityType;
+    startedAt: number;
+    durationMs: number;
+    statBaseline: Partial<BuddyStats>;
+    statTarget: Partial<BuddyStats>;
+    unskippable?: boolean;
+}
+export interface ActionCounts {
+    feeds: number;
+    plays: number;
+    sleeps: number;
+    heals: number;
+    revives: number;
+    pets: number;
+    minigamesWon: number;
+    itemsFound: number;
+    combosTriggered: number;
+}
+export interface InventorySlot {
+    itemId: string;
+    count: number;
+}
+export interface Notification {
+    message: string;
+    timestamp: number;
+}
+export interface AdventureStats {
+    adventuresCompleted: number;
+    battlesWon: number;
+    battlesLost: number;
+    battlesFled: number;
+    bossesDefeated: number;
+    totalDamageDealt: number;
+    perfectAdventures: number;
+    equippedWeapon?: string;
+    equippedArmor?: string;
+    equippedHelmet?: string;
+    equippedBoots?: string;
+    equippedAccessory?: string;
+}
+export interface BuddyState {
+    name: string;
+    speciesId: string;
+    stats: BuddyStats;
+    xp: number;
+    level: number;
+    age: number;
+    alive: boolean;
+    createdAt: number;
+    lastUpdated: number;
+    activity?: ActivityState;
+    titles: string[];
+    activeTitle?: string;
+    actionCounts: ActionCounts;
+    inventory: InventorySlot[];
+    notifications: Notification[];
+    adventureStats: AdventureStats;
+    questProgress: import("../story/types").QuestProgress;
+}
+export declare const RARITY_COLORS: Record<Rarity, string>;
+export declare const RARITY_LABELS: Record<Rarity, string>;
+export declare const RESET = "\u001B[0m";
+export declare const DIM = "\u001B[2m";
+export declare const BOLD = "\u001B[1m";
+//# sourceMappingURL=types.d.ts.map

package/dist/buddy/types.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BOLD = exports.DIM = exports.RESET = exports.RARITY_LABELS = exports.RARITY_COLORS = void 0;
+exports.RARITY_COLORS = {
+    common: "\x1b[37m", // white
+    uncommon: "\x1b[32m", // green
+    rare: "\x1b[34m", // blue
+    epic: "\x1b[35m", // magenta
+    legendary: "\x1b[33m", // yellow/gold
+};
+exports.RARITY_LABELS = {
+    common: "★ Common",
+    uncommon: "★★ Uncommon",
+    rare: "★★★ Rare",
+    epic: "★★★★ Epic",
+    legendary: "★★★★★ Legendary",
+};
+exports.RESET = "\x1b[0m";
+exports.DIM = "\x1b[2m";
+exports.BOLD = "\x1b[1m";
+//# sourceMappingURL=types.js.map

package/dist/commands/actions.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=actions.d.ts.map

package/dist/commands/actions.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const activities_1 = require("../buddy/activities");
+const leveling_1 = require("../buddy/leveling");
+const registry_1 = require("./registry");
+const screen_1 = require("../rendering/screen");
+function clampStat(value) {
+    return Math.max(0, Math.min(100, value));
+}
+function busyCheck(state, attempted) {
+    if (!state.alive)
+        return `${state.name} is no longer with us... Use /revive first.`;
+    if (state.activity && (0, activities_1.isActivityBlocked)(state.activity.type, attempted)) {
+        const remaining = (0, activities_1.formatTimeRemaining)(state.activity);
+        const doing = state.activity.type === "sleeping" ? "sleeping" :
+            state.activity.type === "eating" ? "eating" : "playing";
+        return `${state.name} is ${doing}... (${remaining} remaining)`;
+    }
+    return null;
+}
+/** Factory for activity commands (feed, play, sleep) */
+function registerActivityCommand(name, description, activityType, countKey, message, preCheck) {
+    (0, registry_1.registerCommand)({
+        name,
+        description,
+        execute: (state) => {
+            const blocked = busyCheck(state, activityType);
+            if (blocked)
+                return { state: null, message: blocked, rerender: false };
+            if (preCheck) {
+                const err = preCheck(state);
+                if (err)
+                    return { state: null, message: err, rerender: false };
+            }
+            const activity = (0, activities_1.startActivity)(state, activityType);
+            const counts = { ...state.actionCounts, [countKey]: state.actionCounts[countKey] + 1 };
+            return { state: { ...state, activity, actionCounts: counts }, message: message(state.name), rerender: true };
+        },
+    });
+}
+registerActivityCommand("feed", "Feed your buddy to restore hunger", "eating", "feeds", (name) => `${name} starts eating! Nom nom...`);
+registerActivityCommand("play", "Play with your buddy to boost happiness", "playing", "plays", (name) => `${name} starts playing!`, (state) => state.stats.energy < 10 ? `${state.name} is too tired to play. Let them /sleep first.` : null);
+registerActivityCommand("sleep", "Let your buddy rest to restore energy", "sleeping", "sleeps", (name) => `${name} curls up and falls asleep... Zzz`);
+(0, registry_1.registerCommand)({
+    name: "heal",
+    description: "Heal your buddy to restore health (instant)",
+    execute: (state) => {
+        if (!state.alive) {
+            return { state: null, message: `${state.name} is no longer with us... Use /revive first.`, rerender: false };
+        }
+        const newStats = { ...state.stats, health: clampStat(state.stats.health + 20) };
+        const counts = { ...state.actionCounts, heals: state.actionCounts.heals + 1 };
+        let newState = { ...state, stats: newStats, xp: state.xp + 3, actionCounts: counts };
+        const { state: checked, levelsGained } = (0, leveling_1.checkLevelUp)(newState);
+        newState = checked;
+        let msg = `You patch up ${state.name}. (+20 health, +3 XP)`;
+        if (levelsGained > 0)
+            msg += ` ${screen_1.ansi.bold}LEVEL UP! Now level ${newState.level}!${screen_1.ansi.reset}`;
+        return { state: newState, message: msg, rerender: true };
+    },
+});
+(0, registry_1.registerCommand)({
+    name: "revive",
+    description: "Revive a dead buddy (costs half your XP)",
+    execute: (state) => {
+        if (state.alive) {
+            return { state: null, message: `${state.name} is alive and well!`, rerender: false };
+        }
+        const counts = { ...state.actionCounts, revives: state.actionCounts.revives + 1 };
+        const newState = {
+            ...state,
+            alive: true,
+            xp: Math.floor(state.xp / 2),
+            stats: { hunger: 50, happiness: 50, health: 50, energy: 50 },
+            lastUpdated: Date.now(),
+            activity: undefined,
+            actionCounts: counts,
+        };
+        return {
+            state: newState,
+            message: `${state.name} stirs back to life! They lost half their XP but they're back.`,
+            rerender: true,
+        };
+    },
+});
+(0, registry_1.registerCommand)({
+    name: "rename",
+    description: "Rename your buddy (usage: /rename NewName)",
+    execute: (state, args) => {
+        const newName = args.join(" ").trim();
+        if (!newName) {
+            return { state: null, message: "Usage: /rename <new name>", rerender: false };
+        }
+        const oldName = state.name;
+        const newState = { ...state, name: newName };
+        return { state: newState, message: `${oldName} is now known as ${newName}!`, rerender: true };
+    },
+});
+(0, registry_1.registerCommand)({
+    name: "help",
+    description: "Show all available commands",
+    execute: () => {
+        return { state: null, message: "Press / to open the command palette!", rerender: false };
+    },
+});
+(0, registry_1.registerCommand)({
+    name: "pet",
+    description: "Pet your buddy!",
+    execute: (state) => {
+        if (!state.alive) {
+            return { state: null, message: `${state.name} is no longer with us...`, rerender: false };
+        }
+        // Petting gives a small happiness boost
+        const newStats = { ...state.stats, happiness: clampStat(state.stats.happiness + 5) };
+        const counts = { ...state.actionCounts, pets: state.actionCounts.pets + 1 };
+        const newState = { ...state, stats: newStats, actionCounts: counts };
+        return { state: newState, message: "__PET__", rerender: true };
+    },
+});
+(0, registry_1.registerCommand)({
+    name: "gear",
+    description: "View your equipped gear",
+    execute: () => {
+        return { state: null, message: "__OPEN_GEAR__", rerender: false };
+    },
+});
+(0, registry_1.registerCommand)({
+    name: "combatinfo",
+    description: "View your combat stats",
+    execute: () => {
+        return { state: null, message: "__OPEN_COMBATINFO__", rerender: false };
+    },
+});
+(0, registry_1.registerCommand)({
+    name: "quit",
+    description: "Save and exit CLIBuddy",
+    execute: (state) => {
+        return { state: null, message: `Goodbye! ${state.name} will be waiting.`, rerender: false, quit: true };
+    },
+});
+//# sourceMappingURL=actions.js.map

package/dist/commands/admin.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=admin.d.ts.map

package/dist/commands/admin.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const species_1 = require("../buddy/species");
+const activities_1 = require("../buddy/activities");
+const titles_1 = require("../buddy/titles");
+const registry_1 = require("./registry");
+(0, registry_1.registerCommand)({
+    name: "admin",
+    description: "Toggle admin mode (shows debug commands)",
+    execute: () => {
+        const nowOn = (0, registry_1.toggleAdminMode)();
+        return { state: null, message: nowOn ? "Admin mode ON — debug commands visible in palette" : "Admin mode OFF", rerender: false };
+    },
+});
+(0, registry_1.registerCommand)({
+    name: "swap",
+    hidden: true,
+    description: "[Admin] Change buddy species",
+    execute: (state, args) => {
+        const speciesId = args[0]?.toLowerCase();
+        if (!speciesId) {
+            const list = species_1.SPECIES.map((s) => s.id).join(", ");
+            return { state: null, message: `Usage: /swap <species>  (${list})`, rerender: false };
+        }
+        const species = (0, species_1.getSpecies)(speciesId);
+        if (!species) {
+            const list = species_1.SPECIES.map((s) => s.id).join(", ");
+            return { state: null, message: `Unknown species "${speciesId}". Available: ${list}`, rerender: false };
+        }
+        const newState = { ...state, speciesId: species.id };
+        return {
+            state: newState,
+            message: `${state.name} transformed into a ${species.name}! (${species.rarity})`,
+            rerender: true,
+        };
+    },
+});
+(0, registry_1.registerCommand)({
+    name: "setstat",
+    hidden: true,
+    description: "[Admin] Set a stat value",
+    execute: (state, args) => {
+        const statName = args[0]?.toLowerCase();
+        const value = parseInt(args[1], 10);
+        const validStats = ["hunger", "happiness", "health", "energy"];
+        if (!statName || !validStats.includes(statName) || isNaN(value)) {
+            return { state: null, message: `Usage: /setstat <${validStats.join("|")}> <0-100>`, rerender: false };
+        }
+        const clamped = Math.max(0, Math.min(100, value));
+        const newStats = { ...state.stats, [statName]: clamped };
+        const newState = { ...state, stats: newStats };
+        return { state: newState, message: `Set ${statName} to ${clamped}`, rerender: true };
+    },
+});
+(0, registry_1.registerCommand)({
+    name: "setlevel",
+    hidden: true,
+    description: "[Admin] Set buddy level",
+    execute: (state, args) => {
+        const level = parseInt(args[0], 10);
+        if (isNaN(level) || level < 1) {
+            return { state: null, message: "Usage: /setlevel <number>", rerender: false };
+        }
+        const newState = { ...state, level };
+        return { state: newState, message: `Set level to ${level}`, rerender: true };
+    },
+});
+(0, registry_1.registerCommand)({
+    name: "setxp",
+    hidden: true,
+    description: "[Admin] Set buddy XP",
+    execute: (state, args) => {
+        const xp = parseInt(args[0], 10);
+        if (isNaN(xp) || xp < 0) {
+            return { state: null, message: "Usage: /setxp <number>", rerender: false };
+        }
+        const newState = { ...state, xp };
+        return { state: newState, message: `Set XP to ${xp}`, rerender: true };
+    },
+});
+(0, registry_1.registerCommand)({
+    name: "kill",
+    hidden: true,
+    description: "[Admin] Kill buddy to test death state",
+    execute: (state) => {
+        const newState = {
+            ...state,
+            alive: false,
+            stats: { ...state.stats, health: 0 },
+            activity: undefined,
+        };
+        return { state: newState, message: `${state.name} has been killed (admin).`, rerender: true };
+    },
+});
+(0, registry_1.registerCommand)({
+    name: "testact",
+    hidden: true,
+    description: "[Admin] Force an activity (sleeping/eating/playing)",
+    execute: (state, args) => {
+        const type = args[0]?.toLowerCase();
+        if (type !== "sleeping" && type !== "eating" && type !== "playing") {
+            return { state: null, message: "Usage: /testact <sleeping|eating|playing>", rerender: false };
+        }
+        const activity = (0, activities_1.startActivity)(state, type);
+        const newState = { ...state, activity };
+        return { state: newState, message: `Forced ${type} activity.`, rerender: true };
+    },
+});
+(0, registry_1.registerCommand)({
+    name: "stopact",
+    hidden: true,
+    description: "[Admin] Cancel current activity",
+    execute: (state) => {
+        if (!state.activity) {
+            return { state: null, message: "No active activity.", rerender: false };
+        }
+        const newState = { ...state, activity: undefined };
+        return { state: newState, message: "Activity cancelled.", rerender: true };
+    },
+});
+(0, registry_1.registerCommand)({
+    name: "equip",
+    hidden: true,
+    description: "[Admin] Equip a title by ID",
+    execute: (state, args) => {
+        const titleId = args[0]?.toLowerCase();
+        if (!titleId) {
+            const earned = state.titles.join(", ") || "none";
+            return { state: null, message: `Usage: /equip <title-id>  Earned: ${earned}`, rerender: false };
+        }
+        if (!state.titles.includes(titleId)) {
+            return { state: null, message: "You haven't earned that title yet!", rerender: false };
+        }
+        const rule = (0, titles_1.getTitleRule)(titleId);
+        const newState = { ...state, activeTitle: titleId };
+        return { state: newState, message: `Title equipped: ${rule?.label ?? titleId}`, rerender: true };
+    },
+});
+(0, registry_1.registerCommand)({
+    name: "resetstory",
+    hidden: true,
+    description: "[Admin] Reset all story/quest progress",
+    execute: (state) => {
+        const { createDefaultQuestProgress } = require("../story/types");
+        const newState = { ...state, questProgress: createDefaultQuestProgress() };
+        return { state: newState, message: "Story progress reset! All chapters, flags, and gold cleared.", rerender: true };
+    },
+});
+(0, registry_1.registerCommand)({
+    name: "resetchapter",
+    hidden: true,
+    description: "[Admin] Uncomplete a specific chapter (usage: /resetchapter ch1_whispers)",
+    execute: (state, args) => {
+        const chapterId = args[0];
+        if (!chapterId) {
+            const completed = state.questProgress.completedChapters.join(", ") || "none";
+            return { state: null, message: `Usage: /resetchapter <id>  Completed: ${completed}`, rerender: false };
+        }
+        const progress = { ...state.questProgress };
+        progress.completedChapters = progress.completedChapters.filter((c) => c !== chapterId);
+        // Also remove the story flag for that chapter
+        progress.storyFlags = progress.storyFlags.filter((f) => !f.startsWith(chapterId.replace("ch", "ch").split("_")[0]));
+        const newState = { ...state, questProgress: progress };
+        return { state: newState, message: `Uncompleted chapter: ${chapterId}`, rerender: true };
+    },
+});
+(0, registry_1.registerCommand)({
+    name: "addgold",
+    hidden: true,
+    description: "[Admin] Add gold (usage: /addgold 100)",
+    execute: (state, args) => {
+        const amount = parseInt(args[0], 10);
+        if (isNaN(amount))
+            return { state: null, message: "Usage: /addgold <amount>", rerender: false };
+        const progress = { ...state.questProgress, gold: state.questProgress.gold + amount };
+        return { state: { ...state, questProgress: progress }, message: `Added ${amount} gold (total: ${progress.gold})`, rerender: true };
+    },
+});
+(0, registry_1.registerCommand)({
+    name: "completechapter",
+    hidden: true,
+    description: "[Admin] Force-complete a chapter (usage: /completechapter ch1_whispers)",
+    execute: (state, args) => {
+        const chapterId = args[0];
+        if (!chapterId)
+            return { state: null, message: "Usage: /completechapter <id>", rerender: false };
+        const progress = { ...state.questProgress };
+        if (!progress.completedChapters.includes(chapterId)) {
+            progress.completedChapters = [...progress.completedChapters, chapterId];
+        }
+        // Derive the story flag (ch1_whispers → ch1_complete)
+        const chNum = chapterId.match(/ch(\d+)/)?.[1];
+        if (chNum) {
+            const flag = `ch${chNum}_complete`;
+            if (!progress.storyFlags.includes(flag)) {
+                progress.storyFlags = [...progress.storyFlags, flag];
+            }
+        }
+        return { state: { ...state, questProgress: progress }, message: `Completed chapter: ${chapterId}`, rerender: true };
+    },
+});
+//# sourceMappingURL=admin.js.map

package/dist/commands/registry.d.ts

@@ -0,0 +1,25 @@
+import { BuddyState } from "../buddy/types";
+export interface CommandResult {
+    /** Updated state (null = no change) */
+    state: BuddyState | null;
+    /** Message to display to the user */
+    message: string;
+    /** Should the buddy be re-rendered after this command? */
+    rerender: boolean;
+    /** Should the app quit? */
+    quit?: boolean;
+}
+export interface Command {
+    name: string;
+    description: string;
+    hidden?: boolean;
+    execute: (state: BuddyState, args: string[]) => CommandResult;
+}
+export declare function registerCommand(cmd: Command): void;
+export declare function getCommand(name: string): Command | undefined;
+/** Get all commands visible in the palette (respects admin mode) */
+export declare function getAllCommands(): Command[];
+export declare function getCommandNames(): string[];
+export declare function isAdminMode(): boolean;
+export declare function toggleAdminMode(): boolean;
+//# sourceMappingURL=registry.d.ts.map

package/dist/commands/registry.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCommand = registerCommand;
+exports.getCommand = getCommand;
+exports.getAllCommands = getAllCommands;
+exports.getCommandNames = getCommandNames;
+exports.isAdminMode = isAdminMode;
+exports.toggleAdminMode = toggleAdminMode;
+let adminMode = false;
+const commands = new Map();
+function registerCommand(cmd) {
+    commands.set(cmd.name, cmd);
+}
+function getCommand(name) {
+    return commands.get(name);
+}
+/** Get all commands visible in the palette (respects admin mode) */
+function getAllCommands() {
+    return Array.from(commands.values()).filter((c) => !c.hidden || adminMode).sort((a, b) => a.name.localeCompare(b.name));
+}
+function getCommandNames() {
+    return getAllCommands().map((c) => `/${c.name}`);
+}
+function isAdminMode() {
+    return adminMode;
+}
+function toggleAdminMode() {
+    adminMode = !adminMode;
+    return adminMode;
+}
+//# sourceMappingURL=registry.js.map

package/dist/commands/social.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=social.d.ts.map