roguelike-cli 1.3.2 → 1.3.4

package/src/data/loot.ts

@@ -0,0 +1,177 @@
+import { getDictionary, Dictionary } from './dictionaries';
+
+export type Rarity = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
+
+export interface LootItem {
+  name: string;
+  rarity: Rarity;
+  droppedAt: string;
+  source: 'task' | 'levelup' | 'achievement' | 'boss';
+}
+
+export interface LootDropResult {
+  dropped: boolean;
+  item?: LootItem;
+}
+
+// Rarity drop chances by player level
+// Higher level = higher chance for rare items, but overall drop rate decreases
+function getDropChances(level: number): { dropRate: number; rarityWeights: Record<Rarity, number> } {
+  // Base drop rate decreases with level (starts at 30%, min 5%)
+  const baseDropRate = Math.max(0.05, 0.30 - (level * 0.01));
+  
+  // Rarity weights shift toward rarer items at higher levels
+  const legendaryWeight = Math.min(0.05, level * 0.002);
+  const epicWeight = Math.min(0.10, level * 0.004);
+  const rareWeight = Math.min(0.20, 0.05 + level * 0.005);
+  const uncommonWeight = Math.min(0.30, 0.15 + level * 0.005);
+  const commonWeight = 1 - legendaryWeight - epicWeight - rareWeight - uncommonWeight;
+  
+  return {
+    dropRate: baseDropRate,
+    rarityWeights: {
+      common: commonWeight,
+      uncommon: uncommonWeight,
+      rare: rareWeight,
+      epic: epicWeight,
+      legendary: legendaryWeight,
+    },
+  };
+}
+
+// Bonus multipliers for different sources
+const SOURCE_MULTIPLIERS: Record<string, number> = {
+  task: 1.0,
+  levelup: 3.0,      // 3x chance on level up
+  achievement: 2.5,  // 2.5x chance on achievement
+  boss: 2.0,         // 2x chance on boss
+};
+
+// Select random rarity based on weights
+function selectRarity(weights: Record<Rarity, number>): Rarity {
+  const roll = Math.random();
+  let cumulative = 0;
+  
+  const rarities: Rarity[] = ['common', 'uncommon', 'rare', 'epic', 'legendary'];
+  for (const rarity of rarities) {
+    cumulative += weights[rarity];
+    if (roll < cumulative) {
+      return rarity;
+    }
+  }
+  
+  return 'common';
+}
+
+// Select random item from rarity pool
+function selectItem(rarity: Rarity, dict: Dictionary): string {
+  const pool = dict.loot[rarity];
+  return pool[Math.floor(Math.random() * pool.length)];
+}
+
+// Main function to roll for loot
+export function rollForLoot(
+  level: number,
+  source: 'task' | 'levelup' | 'achievement' | 'boss',
+  rulesPreset?: string
+): LootDropResult {
+  const dict = getDictionary(rulesPreset);
+  const { dropRate, rarityWeights } = getDropChances(level);
+  
+  // Apply source multiplier
+  const adjustedDropRate = Math.min(0.95, dropRate * (SOURCE_MULTIPLIERS[source] || 1.0));
+  
+  // Roll for drop
+  if (Math.random() > adjustedDropRate) {
+    return { dropped: false };
+  }
+  
+  // Select rarity and item
+  const rarity = selectRarity(rarityWeights);
+  const name = selectItem(rarity, dict);
+  
+  return {
+    dropped: true,
+    item: {
+      name,
+      rarity,
+      droppedAt: new Date().toISOString(),
+      source,
+    },
+  };
+}
+
+// Format loot drop message
+export function formatLootDrop(item: LootItem, dict: Dictionary): string {
+  const rarityName = dict.rarities[item.rarity];
+  const raritySymbol = getRaritySymbol(item.rarity);
+  
+  return `
+=== ${dict.messages.lootDropped} ===
+
+${raritySymbol} [${rarityName}] ${item.name}
+`.trim();
+}
+
+// Get rarity symbol/color indicator
+function getRaritySymbol(rarity: Rarity): string {
+  switch (rarity) {
+    case 'common': return '[.]';
+    case 'uncommon': return '[+]';
+    case 'rare': return '[*]';
+    case 'epic': return '[#]';
+    case 'legendary': return '[!]';
+  }
+}
+
+// Format inventory display
+export function formatInventory(inventory: LootItem[], dict: Dictionary): string {
+  if (!inventory || inventory.length === 0) {
+    return `${dict.stats.inventory}: (empty)`;
+  }
+  
+  // Group by rarity
+  const byRarity: Record<Rarity, LootItem[]> = {
+    legendary: [],
+    epic: [],
+    rare: [],
+    uncommon: [],
+    common: [],
+  };
+  
+  for (const item of inventory) {
+    byRarity[item.rarity].push(item);
+  }
+  
+  const lines: string[] = [`=== ${dict.stats.inventory} (${inventory.length} items) ===`, ''];
+  
+  for (const rarity of ['legendary', 'epic', 'rare', 'uncommon', 'common'] as Rarity[]) {
+    const items = byRarity[rarity];
+    if (items.length > 0) {
+      const symbol = getRaritySymbol(rarity);
+      const rarityName = dict.rarities[rarity];
+      lines.push(`${rarityName}:`);
+      for (const item of items) {
+        lines.push(`  ${symbol} ${item.name}`);
+      }
+      lines.push('');
+    }
+  }
+  
+  return lines.join('\n').trim();
+}
+
+// Calculate inventory value (for stats)
+export function calculateInventoryValue(inventory: LootItem[]): number {
+  if (!inventory) return 0;
+  
+  const values: Record<Rarity, number> = {
+    common: 1,
+    uncommon: 5,
+    rare: 25,
+    epic: 100,
+    legendary: 500,
+  };
+  
+  return inventory.reduce((sum, item) => sum + values[item.rarity], 0);
+}

package/src/interactive/commands.ts

@@ -473,16 +473,27 @@ export async function processCommand(
   
   // Stats command
   if (command === 'stats') {
-    return wrapResult({ output: formatStats() });
+    return wrapResult({ output: formatStats(config.rulesPreset) });
+  }
+  
+  // Inventory command
+  if (command === 'inventory' || command === 'inv' || command === 'loot') {
+    const { formatInventoryDisplay } = await import('../storage/profile');
+    return wrapResult({ output: formatInventoryDisplay(config.rulesPreset) });
   }
   
   // Achievements command
   if (command === 'achievements' || command === 'ach') {
-    return wrapResult({ output: formatAchievements() });
+    return wrapResult({ output: formatAchievements(config.rulesPreset) });
   }
   
   // Done command - mark current node as completed
   if (command === 'done') {
+    const { getDictionary } = await import('../data/dictionaries');
+    const { formatLootDrop } = await import('../data/loot');
+    const { getAchievementInfo } = await import('../storage/profile');
+    const dict = getDictionary(config.rulesPreset);
+    
     const nodeConfig = readNodeConfig(currentPath);
     
     if (!nodeConfig) {
@@ -502,7 +513,8 @@ export async function processCommand(
       result.xpGained,
       nodeConfig.isBoss || false,
       depth,
-      nodeConfig.createdAt
+      nodeConfig.createdAt,
+      config.rulesPreset
     );
     
     // Save to undo history
@@ -513,27 +525,33 @@ export async function processCommand(
       timestamp: new Date().toISOString(),
     });
     
-    let output = `\n=== TASK COMPLETED ===\n`;
-    output += `\nTasks completed: ${result.tasksCompleted}`;
+    let output = `\n=== ${dict.messages.questCompleted} ===\n`;
+    output += `\nTasks: ${result.tasksCompleted}`;
     if (result.bossesDefeated > 0) {
-      output += `\nBosses defeated: ${result.bossesDefeated}`;
+      output += ` | Bosses: ${result.bossesDefeated}`;
     }
     output += `\n+${result.xpGained} XP`;
     
     if (taskResult.levelUp) {
-      output += `\n\n*** LEVEL UP! ***`;
-      output += `\nYou are now level ${taskResult.newLevel}!`;
+      output += `\n\n*** ${dict.messages.levelUp} ***`;
+      output += `\n${dict.stats.level} ${taskResult.newLevel}!`;
     }
     
     if (taskResult.newAchievements.length > 0) {
-      output += `\n\n=== NEW ACHIEVEMENTS ===`;
-      for (const ach of taskResult.newAchievements) {
-        output += `\n[x] ${ach.name}: ${ach.description}`;
+      output += `\n\n=== ${dict.messages.newAchievement} ===`;
+      for (const achId of taskResult.newAchievements) {
+        const achInfo = getAchievementInfo(achId, dict);
+        if (achInfo) {
+          output += `\n[x] ${achInfo.name}: ${achInfo.desc}`;
+        }
       }
     }
     
-    output += '\n';
-    output += '[Type "undo" to revert]';
+    if (taskResult.lootDropped) {
+      output += `\n\n${formatLootDrop(taskResult.lootDropped, dict)}`;
+    }
+    
+    output += '\n\n[Type "undo" to revert]';
     
     return wrapResult({ output });
   }
@@ -566,10 +584,10 @@ export async function processCommand(
     return wrapResult({ output });
   }
   
-  // Deadline command
-  if (command === 'deadline') {
+  // Deadline command (dl as alias)
+  if (command === 'deadline' || command === 'dl') {
     if (parts.length < 2) {
-      return wrapResult({ output: 'Usage: deadline <date>\nExamples: deadline today, deadline tomorrow, deadline +3d, deadline Jan 15' });
+      return wrapResult({ output: 'Usage: deadline <date> (or dl <date>)\nExamples: dl today, dl +3d, deadline Jan 15' });
     }
     
     const dateStr = parts.slice(1).join(' ');
@@ -1107,22 +1125,29 @@ export async function processCommand(
   }
   
   if (command === 'config') {
-    const { updateConfig, RULES_PRESETS } = await import('../config/config');
+    const { updateConfig, SUPPORTED_MODELS } = await import('../config/config');
     
-    // Check for flags
-    const keyFlag = parts.find(p => p.startsWith('-k=') || p.startsWith('--key='));
-    const modelFlag = parts.find(p => p.startsWith('-m=') || p.startsWith('--model='));
-    const rulesFlag = parts.find(p => p.startsWith('-r=') || p.startsWith('--rules='));
-    const themeFlag = parts.find(p => p.startsWith('-t=') || p.startsWith('--theme='));
+    // Check for flags (uppercase short, lowercase long)
+    const keyFlag = parts.find(p => p.startsWith('-K=') || p.startsWith('--key='));
+    const modelFlag = parts.find(p => p.startsWith('-M=') || p.startsWith('--model='));
+    const rulesFlag = parts.find(p => p.startsWith('-R=') || p.startsWith('--rules='));
     
     if (keyFlag) {
       const value = keyFlag.split('=').slice(1).join('=');
+      if (!value) {
+        return wrapResult({ output: 'Error: API key cannot be empty' });
+      }
       updateConfig({ apiKey: value });
       return wrapResult({ output: 'API key updated.' });
     }
     
     if (modelFlag) {
       const value = modelFlag.split('=').slice(1).join('=');
+      if (!SUPPORTED_MODELS.includes(value)) {
+        return wrapResult({ 
+          output: `Error: Unknown model "${value}"\n\nSupported models:\n  ${SUPPORTED_MODELS.join('\n  ')}` 
+        });
+      }
       updateConfig({ model: value });
       return wrapResult({ output: `Model updated: ${value}` });
     }
@@ -1130,21 +1155,7 @@ export async function processCommand(
     if (rulesFlag) {
       const value = rulesFlag.split('=').slice(1).join('=');
       updateConfig({ rules: value, rulesPreset: 'custom' });
-      return wrapResult({ output: 'Custom rules updated.' });
-    }
-    
-    if (themeFlag) {
-      const value = themeFlag.split('=').slice(1).join('=').toLowerCase();
-      if (RULES_PRESETS[value]) {
-        updateConfig({ 
-          rules: RULES_PRESETS[value].rules, 
-          rulesPreset: value 
-        });
-        return wrapResult({ output: `Theme updated: ${RULES_PRESETS[value].name}` });
-      } else {
-        const themes = Object.keys(RULES_PRESETS).join(', ');
-        return wrapResult({ output: `Unknown theme. Available: ${themes}` });
-      }
+      return wrapResult({ output: 'Rules updated.' });
     }
     
     // Show config
@@ -1152,27 +1163,21 @@ export async function processCommand(
       ? config.apiKey.slice(0, 8) + '...' + config.apiKey.slice(-4)
       : '(not set)';
     
-    const themeName = config.rulesPreset 
-      ? (RULES_PRESETS[config.rulesPreset]?.name || 'Custom')
-      : 'Default';
-    
     const rulesPreview = config.rules 
-      ? (config.rules.length > 50 ? config.rules.substring(0, 50) + '...' : config.rules)
-      : '(none)';
+      ? (config.rules.length > 60 ? config.rules.substring(0, 60) + '...' : config.rules)
+      : '(default)';
     
     const output = `
 Provider:     ${config.aiProvider}
 Model:        ${config.model || '(default)'}
 API Key:      ${maskedKey}
 Storage:      ${config.storagePath}
-Theme:        ${themeName}
 Rules:        ${rulesPreview}
 
 Set with flags:
-  config -k=<key>       Set API key
-  config -m=<model>     Set model
-  config -t=<theme>     Set theme (fantasy, space, starwars, western, cyberpunk, pirate)
-  config -r="<rules>"   Set custom rules
+  config -K=<key>       or --key=<key>
+  config -M=<model>     or --model=<model>
+  config -R="<rules>"   or --rules="<rules>"
 `.trim();
     
     return wrapResult({ output });
@@ -1187,49 +1192,51 @@ Navigation:
   ls                    List tasks and files
   tree [-A] [--depth=N] Show task tree
   cd <task>             Navigate into task
-  cd .., ...            Go back 1 or 2 levels
-  pwd                   Show current path
-  open                  Open folder in Finder
+  .., ...               Go up 1 or 2 levels
+  pwd                   Current path
+  open                  Open in Finder
 
-Task Management:
-  mkdir <name>          Create new task
-  done                  Complete task (earns XP)
+Tasks:
+  mkdir <name>          Create task
+  done                  Complete (earns XP)
   undo                  Undo last done
-  deadline <date>       Set deadline (today, +3d, Jan 15)
-  boss                  Toggle boss status (3x XP)
-  block [node]          Block by task or text
+  dl <date>             Set deadline (dl +3d, dl Jan 15)
+  boss                  Toggle boss (3x XP)
+  block [node]          Block by task
   unblock               Remove block
   status                Task details
-  check                 Upcoming deadlines
+  check                 Deadline alerts
 
 Gamification:
   stats                 XP, level, streaks
-  achievements          Achievement list
-  map [--ai]            Dungeon map view
+  achievements          Achievement list (infinite)
+  inventory             Loot collection
+  map                   Dungeon map
+  map --ai              AI-generated map
 
-Configuration:
+Rules (AI style presets):
+  Set via init or config -R="<rules>"
+  Presets: fantasy, space, starwars, western, cyberpunk, pirate
+
+Config:
   init                  Setup wizard
   config                Show settings
-  config -k=<key>       Set API key
-  config -m=<model>     Set model
-  config -t=<theme>     Set theme (fantasy, space, starwars, etc)
-  config -r="<rules>"   Custom AI rules
-
-Themes:
-  default, fantasy, space, starwars, western, cyberpunk, pirate
+  config -K=<key>       or --key=<key>
+  config -M=<model>     or --model=<model>
+  config -R="<rules>"   or --rules="<rules>"
 
-File Operations:
-  cp, mv, rm [-rf]      Standard file operations
-  clean --yes           Clear current folder
+Files:
+  cp, mv, rm [-rf]      Standard operations
+  clean --yes           Clear folder
 
-AI Generation:
-  <description>         AI generates preview
-  save                  Save to folders/file
+AI:
+  <description>         Generate preview
+  save                  Save to folders
   cancel                Discard
 
 Clipboard:
-  <cmd> | pbcopy        Copy to clipboard (macOS)
-  <cmd> | clip          Copy to clipboard (Windows)
+  <cmd> | pbcopy        macOS
+  <cmd> | clip          Windows
 
 www.rlc.rocks
 `.trim()
@@ -1254,17 +1261,17 @@ www.rlc.rocks
       
       return wrapResult({ output: `Created todo folder: ${safeName}/` });
     } else {
-      const schemaPath = saveSchemaFile(
-        currentPath,
+    const schemaPath = saveSchemaFile(
+      currentPath,
         pending.title,
         pending.content
-      );
-      const filename = path.basename(schemaPath);
-      
-      sessionState.pending = null;
-      sessionState.history = [];
-      
-      return wrapResult({ output: `Saved: ${filename}` });
+    );
+    const filename = path.basename(schemaPath);
+    
+    sessionState.pending = null;
+    sessionState.history = [];
+    
+    return wrapResult({ output: `Saved: ${filename}` });
     }
   }
   

package/src/interactive/startup.ts

@@ -17,16 +17,17 @@ const ASCII_ART = [
   '║      Roguelike CLI      ║',
   '╚═════════════════════════╝',
   '',
-  '  Tasks: done, undo, deadline, boss, block',
-  '  Stats: stats, achievements, map, check',
-  '  Config: init, config -t=<theme>',
+  '  Tasks: done, undo, dl <date>, boss, block',
+  '  Stats: stats, achievements, inventory, map',
   '',
-  '  Themes: fantasy, space, starwars, cyberpunk',
+  '  Rules: fantasy, space, starwars, cyberpunk',
+  '  Config: init, config -R="<rules>"',
   '',
   '  TAB autocomplete, | pbcopy to copy',
   '  <description> -> refine -> save',
   '',
-  '  help - commands, www.rlc.rocks',
+  '  help - commands',
+  '  www.rlc.rocks',
   '',
   '  Ready...',
   '',