roguelike-cli 1.3.2 → 1.3.4

package/dist/storage/profile.js

@@ -33,42 +33,39 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ACHIEVEMENTS = void 0;
+exports.ACHIEVEMENT_THRESHOLDS = void 0;
 exports.xpForLevel = xpForLevel;
 exports.levelFromXP = levelFromXP;
 exports.xpToNextLevel = xpToNextLevel;
 exports.readProfile = readProfile;
 exports.saveProfile = saveProfile;
-exports.addXP = addXP;
 exports.completeTask = completeTask;
+exports.getAchievementInfo = getAchievementInfo;
 exports.formatStats = formatStats;
 exports.formatAchievements = formatAchievements;
+exports.formatInventoryDisplay = formatInventoryDisplay;
 exports.addToUndoHistory = addToUndoHistory;
 exports.getLastUndo = getLastUndo;
 exports.performUndo = performUndo;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
+const dictionaries_1 = require("../data/dictionaries");
+const loot_1 = require("../data/loot");
 const PROFILE_FILE = path.join(os.homedir(), '.rlc', 'profile.json');
-// Achievement definitions
-exports.ACHIEVEMENTS = [
-    { id: 'first_blood', name: 'First Blood', description: 'Complete your first task' },
-    { id: 'ten_tasks', name: 'Getting Started', description: 'Complete 10 tasks' },
-    { id: 'fifty_tasks', name: 'Productive', description: 'Complete 50 tasks' },
-    { id: 'hundred_tasks', name: 'Centurion', description: 'Complete 100 tasks' },
-    { id: 'deep_nesting', name: 'Deep Diver', description: 'Complete a task at depth 5+' },
-    { id: 'boss_slayer', name: 'Boss Slayer', description: 'Complete a boss task' },
-    { id: 'five_bosses', name: 'Boss Hunter', description: 'Defeat 5 bosses' },
-    { id: 'speedrunner', name: 'Speedrunner', description: 'Complete a task on the same day it was created' },
-    { id: 'streak_3', name: 'On a Roll', description: '3 day completion streak' },
-    { id: 'streak_7', name: 'Streak Master', description: '7 day completion streak' },
-    { id: 'streak_30', name: 'Unstoppable', description: '30 day completion streak' },
-    { id: 'level_5', name: 'Adventurer', description: 'Reach level 5' },
-    { id: 'level_10', name: 'Veteran', description: 'Reach level 10' },
-    { id: 'level_25', name: 'Legend', description: 'Reach level 25' },
-    { id: 'xp_1000', name: 'XP Collector', description: 'Earn 1000 XP' },
-    { id: 'xp_10000', name: 'XP Hoarder', description: 'Earn 10000 XP' },
-];
+// Achievement thresholds (infinite, level-based)
+exports.ACHIEVEMENT_THRESHOLDS = {
+    tasks: [1, 10, 50, 100, 250, 500, 1000, 2500, 5000, 10000],
+    bosses: [1, 5, 10, 25, 50, 100, 250, 500],
+    streaks: [3, 7, 14, 30, 60, 90, 180, 365],
+    depths: [3, 5, 7, 10, 15, 20],
+    levels: [5, 10, 25, 50, 100, 150, 200],
+    xp: [1000, 5000, 10000, 50000, 100000, 500000, 1000000],
+};
+// Map threshold to achievement ID
+function getAchievementId(type, threshold) {
+    return `${type}_${threshold}`;
+}
 // XP required for each level (cumulative)
 function xpForLevel(level) {
     return Math.floor(100 * Math.pow(1.5, level - 1));
@@ -106,6 +103,10 @@ function readProfile() {
         return {
             ...createDefaultProfile(),
             ...profile,
+            stats: {
+                ...createDefaultProfile().stats,
+                ...profile.stats,
+            },
         };
     }
     catch {
@@ -130,36 +131,41 @@ function createDefaultProfile() {
         currentStreak: 0,
         longestStreak: 0,
         achievements: [],
+        inventory: [],
         undoHistory: [],
         stats: {
             completedByDay: {},
             createdAt: new Date().toISOString(),
+            deepestDepth: 0,
+            speedruns: 0,
+            nightOwlTasks: 0,
+            earlyBirdTasks: 0,
         },
     };
 }
-function addXP(amount) {
-    const profile = readProfile();
-    const oldLevel = profile.level;
-    profile.totalXP += amount;
-    profile.level = levelFromXP(profile.totalXP);
-    saveProfile(profile);
-    return {
-        newXP: profile.totalXP,
-        levelUp: profile.level > oldLevel,
-        newLevel: profile.level,
-    };
-}
-function completeTask(xp, isBoss, depth, createdAt) {
+function completeTask(xp, isBoss, depth, createdAt, rulesPreset) {
     const profile = readProfile();
     const oldLevel = profile.level;
     const today = new Date().toISOString().split('T')[0];
     const createdDate = createdAt.split('T')[0];
+    const hour = new Date().getHours();
     // Add XP
     profile.totalXP += xp;
     profile.tasksCompleted += 1;
     if (isBoss) {
         profile.bossesDefeated += 1;
     }
+    // Track special completions
+    if (createdDate === today) {
+        profile.stats.speedruns = (profile.stats.speedruns || 0) + 1;
+    }
+    if (hour >= 0 && hour < 6) {
+        profile.stats.earlyBirdTasks = (profile.stats.earlyBirdTasks || 0) + 1;
+    }
+    if (hour >= 0 && hour < 5) {
+        profile.stats.nightOwlTasks = (profile.stats.nightOwlTasks || 0) + 1;
+    }
+    profile.stats.deepestDepth = Math.max(profile.stats.deepestDepth || 0, depth);
     // Update streak
     if (profile.lastCompletionDate) {
         const lastDate = new Date(profile.lastCompletionDate);
@@ -171,7 +177,6 @@ function completeTask(xp, isBoss, depth, createdAt) {
         else if (diffDays > 1) {
             profile.currentStreak = 1;
         }
-        // Same day - streak continues but doesn't increment
     }
     else {
         profile.currentStreak = 1;
@@ -182,105 +187,228 @@ function completeTask(xp, isBoss, depth, createdAt) {
     profile.stats.completedByDay[today] = (profile.stats.completedByDay[today] || 0) + 1;
     // Update level
     profile.level = levelFromXP(profile.totalXP);
+    const levelUp = profile.level > oldLevel;
     // Check for new achievements
     const newAchievements = [];
     const checkAchievement = (id) => {
         if (!profile.achievements.includes(id)) {
             profile.achievements.push(id);
-            const achievement = exports.ACHIEVEMENTS.find(a => a.id === id);
-            if (achievement)
-                newAchievements.push(achievement);
+            newAchievements.push(id);
         }
     };
-    // Task count achievements
-    if (profile.tasksCompleted >= 1)
-        checkAchievement('first_blood');
-    if (profile.tasksCompleted >= 10)
-        checkAchievement('ten_tasks');
-    if (profile.tasksCompleted >= 50)
-        checkAchievement('fifty_tasks');
-    if (profile.tasksCompleted >= 100)
-        checkAchievement('hundred_tasks');
-    // Boss achievements
-    if (isBoss)
-        checkAchievement('boss_slayer');
-    if (profile.bossesDefeated >= 5)
-        checkAchievement('five_bosses');
-    // Depth achievement
-    if (depth >= 5)
-        checkAchievement('deep_nesting');
-    // Speedrunner achievement
-    if (createdDate === today)
-        checkAchievement('speedrunner');
-    // Streak achievements
-    if (profile.currentStreak >= 3)
-        checkAchievement('streak_3');
-    if (profile.currentStreak >= 7)
-        checkAchievement('streak_7');
-    if (profile.currentStreak >= 30)
-        checkAchievement('streak_30');
-    // Level achievements
-    if (profile.level >= 5)
-        checkAchievement('level_5');
-    if (profile.level >= 10)
-        checkAchievement('level_10');
-    if (profile.level >= 25)
-        checkAchievement('level_25');
-    // XP achievements
-    if (profile.totalXP >= 1000)
-        checkAchievement('xp_1000');
-    if (profile.totalXP >= 10000)
-        checkAchievement('xp_10000');
+    // Task count achievements (infinite)
+    for (const threshold of exports.ACHIEVEMENT_THRESHOLDS.tasks) {
+        if (profile.tasksCompleted >= threshold) {
+            checkAchievement(getAchievementId('tasks', threshold));
+        }
+    }
+    // Boss achievements (infinite)
+    for (const threshold of exports.ACHIEVEMENT_THRESHOLDS.bosses) {
+        if (profile.bossesDefeated >= threshold) {
+            checkAchievement(getAchievementId('bosses', threshold));
+        }
+    }
+    // Depth achievements (infinite)
+    for (const threshold of exports.ACHIEVEMENT_THRESHOLDS.depths) {
+        if (profile.stats.deepestDepth >= threshold) {
+            checkAchievement(getAchievementId('depth', threshold));
+        }
+    }
+    // Streak achievements (infinite)
+    for (const threshold of exports.ACHIEVEMENT_THRESHOLDS.streaks) {
+        if (profile.currentStreak >= threshold) {
+            checkAchievement(getAchievementId('streak', threshold));
+        }
+    }
+    // Level achievements (infinite)
+    for (const threshold of exports.ACHIEVEMENT_THRESHOLDS.levels) {
+        if (profile.level >= threshold) {
+            checkAchievement(getAchievementId('level', threshold));
+        }
+    }
+    // XP achievements (infinite)
+    for (const threshold of exports.ACHIEVEMENT_THRESHOLDS.xp) {
+        if (profile.totalXP >= threshold) {
+            checkAchievement(getAchievementId('xp', threshold));
+        }
+    }
+    // Special achievements
+    if (createdDate === today) {
+        checkAchievement('speedrun');
+    }
+    if (hour >= 0 && hour < 5) {
+        checkAchievement('nightowl');
+    }
+    if (hour >= 5 && hour < 7) {
+        checkAchievement('earlybird');
+    }
+    // Roll for loot
+    let lootDropped;
+    // Roll from task completion
+    const taskLoot = (0, loot_1.rollForLoot)(profile.level, isBoss ? 'boss' : 'task', rulesPreset);
+    if (taskLoot.dropped && taskLoot.item) {
+        lootDropped = taskLoot.item;
+        profile.inventory = profile.inventory || [];
+        profile.inventory.push(taskLoot.item);
+    }
+    // Additional roll on level up
+    if (levelUp) {
+        const levelLoot = (0, loot_1.rollForLoot)(profile.level, 'levelup', rulesPreset);
+        if (levelLoot.dropped && levelLoot.item) {
+            if (!lootDropped) {
+                lootDropped = levelLoot.item;
+            }
+            profile.inventory.push(levelLoot.item);
+        }
+    }
+    // Additional roll on new achievements
+    if (newAchievements.length > 0) {
+        const achievementLoot = (0, loot_1.rollForLoot)(profile.level, 'achievement', rulesPreset);
+        if (achievementLoot.dropped && achievementLoot.item) {
+            if (!lootDropped) {
+                lootDropped = achievementLoot.item;
+            }
+            profile.inventory.push(achievementLoot.item);
+        }
+    }
     saveProfile(profile);
     return {
         xpGained: xp,
-        levelUp: profile.level > oldLevel,
+        levelUp,
+        oldLevel,
         newLevel: profile.level,
         newAchievements,
+        lootDropped,
+    };
+}
+// Get achievement display info from dictionary
+function getAchievementInfo(achievementId, dict) {
+    // Parse achievement ID
+    const parts = achievementId.split('_');
+    const type = parts[0];
+    const threshold = parseInt(parts[1]);
+    // Map to dictionary keys
+    const keyMap = {
+        tasks: { 1: 'firstTask', 10: 'tasks10', 50: 'tasks50', 100: 'tasks100', 500: 'tasks500', 1000: 'tasks1000' },
+        bosses: { 1: 'boss1', 5: 'boss5', 10: 'boss10', 25: 'boss25' },
+        streak: { 3: 'streak3', 7: 'streak7', 14: 'streak14', 30: 'streak30' },
+        depth: { 3: 'depth3', 5: 'depth5', 10: 'depth10' },
+    };
+    // Special achievements
+    if (achievementId === 'speedrun') {
+        return dict.achievements.speedrun;
+    }
+    if (achievementId === 'nightowl') {
+        return dict.achievements.nightOwl;
+    }
+    if (achievementId === 'earlybird') {
+        return dict.achievements.earlyBird;
+    }
+    // Get from map
+    if (keyMap[type] && keyMap[type][threshold]) {
+        const key = keyMap[type][threshold];
+        return dict.achievements[key];
+    }
+    // Generate for achievements beyond dictionary
+    return {
+        name: `${type.charAt(0).toUpperCase() + type.slice(1)} ${threshold}`,
+        desc: `Reach ${threshold} ${type}`,
     };
 }
-function formatStats() {
+function formatStats(rulesPreset) {
     const profile = readProfile();
+    const dict = (0, dictionaries_1.getDictionary)(rulesPreset);
     const nextLevel = xpToNextLevel(profile.totalXP);
     const lines = [
         '',
         '=== PLAYER STATS ===',
         '',
-        `Level: ${profile.level}`,
-        `XP: ${profile.totalXP} (${nextLevel.current}/${nextLevel.required} to next level)`,
+        `${dict.stats.level}: ${profile.level}`,
+        `${dict.stats.xp}: ${profile.totalXP} (${nextLevel.current}/${nextLevel.required} to next)`,
         `Progress: [${'#'.repeat(Math.floor(nextLevel.progress / 5))}${'.'.repeat(20 - Math.floor(nextLevel.progress / 5))}] ${nextLevel.progress}%`,
         '',
-        `Tasks Completed: ${profile.tasksCompleted}`,
-        `Bosses Defeated: ${profile.bossesDefeated}`,
-        `Current Streak: ${profile.currentStreak} days`,
-        `Longest Streak: ${profile.longestStreak} days`,
+        `${dict.stats.tasksCompleted}: ${profile.tasksCompleted}`,
+        `${dict.stats.bossesDefeated}: ${profile.bossesDefeated}`,
+        `${dict.stats.currentStreak}: ${profile.currentStreak} days`,
+        `${dict.stats.longestStreak}: ${profile.longestStreak} days`,
         '',
-        `Achievements: ${profile.achievements.length}/${exports.ACHIEVEMENTS.length}`,
+        `Achievements: ${profile.achievements.length}`,
+        `${dict.stats.inventory}: ${(profile.inventory || []).length} items`,
+        `Inventory Value: ${(0, loot_1.calculateInventoryValue)(profile.inventory || [])}`,
         '',
     ];
     return lines.join('\n');
 }
-function formatAchievements() {
+function formatAchievements(rulesPreset) {
     const profile = readProfile();
+    const dict = (0, dictionaries_1.getDictionary)(rulesPreset);
     const lines = [
         '',
         '=== ACHIEVEMENTS ===',
         '',
     ];
-    for (const achievement of exports.ACHIEVEMENTS) {
-        const unlocked = profile.achievements.includes(achievement.id);
-        const status = unlocked ? '[x]' : '[ ]';
-        lines.push(`${status} ${achievement.name}`);
-        lines.push(`    ${achievement.description}`);
+    // Show unlocked achievements
+    if (profile.achievements.length === 0) {
+        lines.push('No achievements yet. Complete tasks to unlock!');
+    }
+    else {
+        lines.push('Unlocked:');
+        for (const id of profile.achievements) {
+            const info = getAchievementInfo(id, dict);
+            if (info) {
+                lines.push(`[x] ${info.name}`);
+                lines.push(`    ${info.desc}`);
+            }
+        }
     }
+    // Show next achievements to unlock
     lines.push('');
-    lines.push(`Unlocked: ${profile.achievements.length}/${exports.ACHIEVEMENTS.length}`);
+    lines.push('Next to unlock:');
+    // Find next task achievement
+    for (const threshold of exports.ACHIEVEMENT_THRESHOLDS.tasks) {
+        const id = getAchievementId('tasks', threshold);
+        if (!profile.achievements.includes(id)) {
+            const info = getAchievementInfo(id, dict);
+            if (info) {
+                lines.push(`[ ] ${info.name} (${profile.tasksCompleted}/${threshold})`);
+            }
+            break;
+        }
+    }
+    // Find next boss achievement
+    for (const threshold of exports.ACHIEVEMENT_THRESHOLDS.bosses) {
+        const id = getAchievementId('bosses', threshold);
+        if (!profile.achievements.includes(id)) {
+            const info = getAchievementInfo(id, dict);
+            if (info) {
+                lines.push(`[ ] ${info.name} (${profile.bossesDefeated}/${threshold})`);
+            }
+            break;
+        }
+    }
+    // Find next streak achievement
+    for (const threshold of exports.ACHIEVEMENT_THRESHOLDS.streaks) {
+        const id = getAchievementId('streak', threshold);
+        if (!profile.achievements.includes(id)) {
+            const info = getAchievementInfo(id, dict);
+            if (info) {
+                lines.push(`[ ] ${info.name} (${profile.currentStreak}/${threshold})`);
+            }
+            break;
+        }
+    }
+    lines.push('');
+    lines.push(`Total unlocked: ${profile.achievements.length}`);
     lines.push('');
     return lines.join('\n');
 }
+function formatInventoryDisplay(rulesPreset) {
+    const profile = readProfile();
+    const dict = (0, dictionaries_1.getDictionary)(rulesPreset);
+    return (0, loot_1.formatInventory)(profile.inventory || [], dict);
+}
 function addToUndoHistory(entry) {
     const profile = readProfile();
-    // Keep only last 10 undo entries
     profile.undoHistory = profile.undoHistory || [];
     profile.undoHistory.unshift(entry);
     if (profile.undoHistory.length > 10) {
@@ -301,15 +429,12 @@ function performUndo() {
         return { success: false, entry: null, message: 'Nothing to undo.' };
     }
     const entry = profile.undoHistory.shift();
-    // Subtract XP
     profile.totalXP = Math.max(0, profile.totalXP - entry.xpLost);
     profile.tasksCompleted = Math.max(0, profile.tasksCompleted - 1);
     if (entry.wasBoss) {
         profile.bossesDefeated = Math.max(0, profile.bossesDefeated - 1);
     }
-    // Update level
     profile.level = levelFromXP(profile.totalXP);
-    // Update daily stats
     const today = new Date().toISOString().split('T')[0];
     if (profile.stats.completedByDay[today]) {
         profile.stats.completedByDay[today] = Math.max(0, profile.stats.completedByDay[today] - 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roguelike-cli",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "description": "AI-powered interactive terminal for creating schemas and todo lists",
   "main": "dist/index.js",
   "bin": {

package/src/commands/init.ts

@@ -110,15 +110,15 @@ export async function initCommand(existingRl?: readline.Interface): Promise<void
     const apiKey = apiKeyInput.trim() || existingApiKey;
     
     if (!apiKey) {
-      console.log('Warning: API key not set. You can set it later with: config -k <key>');
+      console.log('Warning: API key not set. You can set it later with: config -K=<key>');
     } else if (apiKeyInput.trim()) {
       console.log('API key saved');
     } else {
       console.log('Using existing API key');
     }
 
-    // 4. Theme/Rules selection
-    console.log('\nSelect AI Theme (affects language style):');
+    // 4. Rules preset selection
+    console.log('\nSelect AI Rules (affects language style):');
     const presetKeys = Object.keys(RULES_PRESETS);
     presetKeys.forEach((key, index) => {
       console.log(`  ${index + 1}. ${RULES_PRESETS[key].name}`);
@@ -177,7 +177,7 @@ export async function initCommand(existingRl?: readline.Interface): Promise<void
     console.log(`Root directory: ${rootDir}`);
     console.log(`AI Provider: ${selectedProvider.name}`);
     console.log(`Model: ${selectedProvider.model}`);
-    console.log(`Theme: ${RULES_PRESETS[selectedPreset]?.name || 'Custom'}\n`);
+    console.log(`Rules: ${RULES_PRESETS[selectedPreset]?.name || 'Custom'}\n`);
   } finally {
     if (shouldCloseRl) {
       rl.close();

package/src/config/config.ts

@@ -13,7 +13,18 @@ export interface Config {
   rulesPreset?: string;
 }
 
-// Preset rules for different themes
+// Supported models for validation
+export const SUPPORTED_MODELS = [
+  'claude-sonnet-4-20250514',
+  'claude-opus-4-20250514',
+  'gpt-4o',
+  'gpt-4-turbo',
+  'gemini-3-pro',
+  'gemini-2.0-flash',
+  'grok-beta',
+];
+
+// Preset rules
 export const RULES_PRESETS: Record<string, { name: string; rules: string }> = {
   default: {
     name: 'Default (No theme)',