roguelike-cli 1.2.6 → 1.3.0

package/src/interactive/startup.ts

@@ -17,11 +17,14 @@ const ASCII_ART = [
   '║      Roguelike CLI      ║',
   '╚═════════════════════════╝',
   '',
-  '  Commands: ls, cd, mkdir, open, cp, mv, rm, tree, pwd, clean',
-  '  TAB to autocomplete, | pbcopy to copy output',
+  '  Navigation: ls, cd, tree, pwd, open',
+  '  Tasks: done, deadline, boss, block, status',
+  '  Gamification: stats, achievements, map',
   '',
+  '  TAB to autocomplete, | pbcopy to copy',
   '  Workflow: <description> -> refine -> save',
-  '  init - setup, config - settings, help - examples',
+  '',
+  '  help - all commands, init - setup',
   '',
   '  www.rlc.rocks',
   '',

package/src/storage/nodeConfig.ts

@@ -1,9 +1,16 @@
 import * as fs from 'fs';
 import * as path from 'path';
 
+export type NodeStatus = 'open' | 'done' | 'blocked';
+
 export interface NodeConfig {
   name: string;
+  status: NodeStatus;
   deadline?: string;
+  completedAt?: string;
+  xp: number;
+  isBoss?: boolean;
+  blockedBy?: string[];
   branch?: string;
   zone?: string;
   description?: string;
@@ -23,13 +30,19 @@ export function readNodeConfig(nodePath: string): NodeConfig | null {
   
   try {
     const data = fs.readFileSync(configPath, 'utf-8');
-    return JSON.parse(data);
+    const config = JSON.parse(data);
+    // Ensure defaults for older configs
+    return {
+      status: 'open',
+      xp: 10,
+      ...config,
+    };
   } catch {
     return null;
   }
 }
 
-export function writeNodeConfig(nodePath: string, config: NodeConfig): void {
+export function writeNodeConfig(nodePath: string, config: Partial<NodeConfig>): void {
   if (!fs.existsSync(nodePath)) {
     fs.mkdirSync(nodePath, { recursive: true });
   }
@@ -38,6 +51,9 @@ export function writeNodeConfig(nodePath: string, config: NodeConfig): void {
   const existing = readNodeConfig(nodePath);
   
   const updated: NodeConfig = {
+    name: config.name || existing?.name || path.basename(nodePath),
+    status: config.status ?? existing?.status ?? 'open',
+    xp: config.xp ?? existing?.xp ?? 10,
     ...existing,
     ...config,
     updatedAt: new Date().toISOString(),
@@ -55,6 +71,8 @@ export function createNode(
     branch?: string;
     zone?: string;
     description?: string;
+    isBoss?: boolean;
+    xp?: number;
     metadata?: Record<string, any>;
   }
 ): string {
@@ -67,7 +85,10 @@ export function createNode(
   
   const config: NodeConfig = {
     name,
+    status: 'open',
+    xp: options?.xp || 10,
     deadline: options?.deadline,
+    isBoss: options?.isBoss,
     branch: options?.branch,
     zone: options?.zone,
     description: options?.description,
@@ -81,6 +102,14 @@ export function createNode(
   return nodePath;
 }
 
+// Calculate XP based on depth (deeper = more XP)
+export function calculateXP(depth: number, isBoss: boolean = false): number {
+  const baseXP = 10;
+  const depthBonus = depth * 5;
+  const bossMultiplier = isBoss ? 3 : 1;
+  return (baseXP + depthBonus) * bossMultiplier;
+}
+
 // Save schema content to .rlc.schema file
 export function saveSchemaFile(dirPath: string, filename: string, content: string): string {
   if (!fs.existsSync(dirPath)) {
@@ -98,6 +127,23 @@ export function saveSchemaFile(dirPath: string, filename: string, content: strin
   return schemaPath;
 }
 
+// Save map content to .rlc.map file
+export function saveMapFile(dirPath: string, filename: string, content: string): string {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+  
+  const safeName = filename
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  
+  const mapPath = path.join(dirPath, `${safeName}.rlc.map`);
+  fs.writeFileSync(mapPath, content, 'utf-8');
+  
+  return mapPath;
+}
+
 // Read schema file
 export function readSchemaFile(filePath: string): string | null {
   if (!fs.existsSync(filePath)) {

package/src/storage/profile.ts

@@ -0,0 +1,281 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+export interface Achievement {
+  id: string;
+  name: string;
+  description: string;
+  unlockedAt?: string;
+}
+
+export interface Profile {
+  totalXP: number;
+  level: number;
+  tasksCompleted: number;
+  bossesDefeated: number;
+  currentStreak: number;
+  longestStreak: number;
+  lastCompletionDate?: string;
+  achievements: string[];
+  stats: {
+    completedByDay: Record<string, number>;
+    createdAt: string;
+  };
+}
+
+const PROFILE_FILE = path.join(os.homedir(), '.rlc', 'profile.json');
+
+// Achievement definitions
+export const ACHIEVEMENTS: Achievement[] = [
+  { 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' },
+];
+
+// XP required for each level (cumulative)
+export function xpForLevel(level: number): number {
+  return Math.floor(100 * Math.pow(1.5, level - 1));
+}
+
+export function levelFromXP(xp: number): number {
+  let level = 1;
+  let totalRequired = 0;
+  while (totalRequired + xpForLevel(level) <= xp) {
+    totalRequired += xpForLevel(level);
+    level++;
+  }
+  return level;
+}
+
+export function xpToNextLevel(xp: number): { current: number; required: number; progress: number } {
+  const level = levelFromXP(xp);
+  let totalForCurrentLevel = 0;
+  for (let i = 1; i < level; i++) {
+    totalForCurrentLevel += xpForLevel(i);
+  }
+  const xpInCurrentLevel = xp - totalForCurrentLevel;
+  const required = xpForLevel(level);
+  return {
+    current: xpInCurrentLevel,
+    required,
+    progress: Math.floor((xpInCurrentLevel / required) * 100),
+  };
+}
+
+export function readProfile(): Profile {
+  if (!fs.existsSync(PROFILE_FILE)) {
+    return createDefaultProfile();
+  }
+  
+  try {
+    const data = fs.readFileSync(PROFILE_FILE, 'utf-8');
+    const profile = JSON.parse(data);
+    return {
+      ...createDefaultProfile(),
+      ...profile,
+    };
+  } catch {
+    return createDefaultProfile();
+  }
+}
+
+export function saveProfile(profile: Profile): void {
+  const dir = path.dirname(PROFILE_FILE);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  
+  // Update level based on XP
+  profile.level = levelFromXP(profile.totalXP);
+  
+  fs.writeFileSync(PROFILE_FILE, JSON.stringify(profile, null, 2), 'utf-8');
+}
+
+function createDefaultProfile(): Profile {
+  return {
+    totalXP: 0,
+    level: 1,
+    tasksCompleted: 0,
+    bossesDefeated: 0,
+    currentStreak: 0,
+    longestStreak: 0,
+    achievements: [],
+    stats: {
+      completedByDay: {},
+      createdAt: new Date().toISOString(),
+    },
+  };
+}
+
+export function addXP(amount: number): { newXP: number; levelUp: boolean; newLevel: number } {
+  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,
+  };
+}
+
+export function completeTask(xp: number, isBoss: boolean, depth: number, createdAt: string): {
+  xpGained: number;
+  levelUp: boolean;
+  newLevel: number;
+  newAchievements: Achievement[];
+} {
+  const profile = readProfile();
+  const oldLevel = profile.level;
+  const today = new Date().toISOString().split('T')[0];
+  const createdDate = createdAt.split('T')[0];
+  
+  // Add XP
+  profile.totalXP += xp;
+  profile.tasksCompleted += 1;
+  
+  if (isBoss) {
+    profile.bossesDefeated += 1;
+  }
+  
+  // Update streak
+  if (profile.lastCompletionDate) {
+    const lastDate = new Date(profile.lastCompletionDate);
+    const todayDate = new Date(today);
+    const diffDays = Math.floor((todayDate.getTime() - lastDate.getTime()) / (1000 * 60 * 60 * 24));
+    
+    if (diffDays === 1) {
+      profile.currentStreak += 1;
+    } else if (diffDays > 1) {
+      profile.currentStreak = 1;
+    }
+    // Same day - streak continues but doesn't increment
+  } else {
+    profile.currentStreak = 1;
+  }
+  
+  profile.longestStreak = Math.max(profile.longestStreak, profile.currentStreak);
+  profile.lastCompletionDate = today;
+  
+  // Update daily stats
+  profile.stats.completedByDay[today] = (profile.stats.completedByDay[today] || 0) + 1;
+  
+  // Update level
+  profile.level = levelFromXP(profile.totalXP);
+  
+  // Check for new achievements
+  const newAchievements: Achievement[] = [];
+  
+  const checkAchievement = (id: string) => {
+    if (!profile.achievements.includes(id)) {
+      profile.achievements.push(id);
+      const achievement = ACHIEVEMENTS.find(a => a.id === id);
+      if (achievement) newAchievements.push(achievement);
+    }
+  };
+  
+  // 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');
+  
+  saveProfile(profile);
+  
+  return {
+    xpGained: xp,
+    levelUp: profile.level > oldLevel,
+    newLevel: profile.level,
+    newAchievements,
+  };
+}
+
+export function formatStats(): string {
+  const profile = readProfile();
+  const nextLevel = xpToNextLevel(profile.totalXP);
+  
+  const lines: string[] = [
+    '',
+    '=== PLAYER STATS ===',
+    '',
+    `Level: ${profile.level}`,
+    `XP: ${profile.totalXP} (${nextLevel.current}/${nextLevel.required} to next level)`,
+    `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`,
+    '',
+    `Achievements: ${profile.achievements.length}/${ACHIEVEMENTS.length}`,
+    '',
+  ];
+  
+  return lines.join('\n');
+}
+
+export function formatAchievements(): string {
+  const profile = readProfile();
+  
+  const lines: string[] = [
+    '',
+    '=== ACHIEVEMENTS ===',
+    '',
+  ];
+  
+  for (const achievement of ACHIEVEMENTS) {
+    const unlocked = profile.achievements.includes(achievement.id);
+    const status = unlocked ? '[x]' : '[ ]';
+    lines.push(`${status} ${achievement.name}`);
+    lines.push(`    ${achievement.description}`);
+  }
+  
+  lines.push('');
+  lines.push(`Unlocked: ${profile.achievements.length}/${ACHIEVEMENTS.length}`);
+  lines.push('');
+  
+  return lines.join('\n');
+}
+