roguelike-cli 1.2.5 → 1.3.0

package/dist/interactive/startup.js

@@ -19,11 +19,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/dist/storage/nodeConfig.js

@@ -36,7 +36,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readNodeConfig = readNodeConfig;
 exports.writeNodeConfig = writeNodeConfig;
 exports.createNode = createNode;
+exports.calculateXP = calculateXP;
 exports.saveSchemaFile = saveSchemaFile;
+exports.saveMapFile = saveMapFile;
 exports.readSchemaFile = readSchemaFile;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -48,7 +50,13 @@ function readNodeConfig(nodePath) {
     }
     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;
@@ -61,6 +69,9 @@ function writeNodeConfig(nodePath, config) {
     const configPath = path.join(nodePath, CONFIG_FILE);
     const existing = readNodeConfig(nodePath);
     const updated = {
+        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(),
@@ -76,7 +87,10 @@ function createNode(parentPath, name, options) {
     const nodePath = path.join(parentPath, safeName);
     const config = {
         name,
+        status: 'open',
+        xp: options?.xp || 10,
         deadline: options?.deadline,
+        isBoss: options?.isBoss,
         branch: options?.branch,
         zone: options?.zone,
         description: options?.description,
@@ -87,6 +101,13 @@ function createNode(parentPath, name, options) {
     writeNodeConfig(nodePath, config);
     return nodePath;
 }
+// Calculate XP based on depth (deeper = more XP)
+function calculateXP(depth, isBoss = false) {
+    const baseXP = 10;
+    const depthBonus = depth * 5;
+    const bossMultiplier = isBoss ? 3 : 1;
+    return (baseXP + depthBonus) * bossMultiplier;
+}
 // Save schema content to .rlc.schema file
 function saveSchemaFile(dirPath, filename, content) {
     if (!fs.existsSync(dirPath)) {
@@ -100,6 +121,19 @@ function saveSchemaFile(dirPath, filename, content) {
     fs.writeFileSync(schemaPath, content, 'utf-8');
     return schemaPath;
 }
+// Save map content to .rlc.map file
+function saveMapFile(dirPath, filename, content) {
+    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
 function readSchemaFile(filePath) {
     if (!fs.existsSync(filePath)) {

package/dist/storage/profile.js

@@ -0,0 +1,276 @@
+"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 });
+exports.ACHIEVEMENTS = void 0;
+exports.xpForLevel = xpForLevel;
+exports.levelFromXP = levelFromXP;
+exports.xpToNextLevel = xpToNextLevel;
+exports.readProfile = readProfile;
+exports.saveProfile = saveProfile;
+exports.addXP = addXP;
+exports.completeTask = completeTask;
+exports.formatStats = formatStats;
+exports.formatAchievements = formatAchievements;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+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' },
+];
+// XP required for each level (cumulative)
+function xpForLevel(level) {
+    return Math.floor(100 * Math.pow(1.5, level - 1));
+}
+function levelFromXP(xp) {
+    let level = 1;
+    let totalRequired = 0;
+    while (totalRequired + xpForLevel(level) <= xp) {
+        totalRequired += xpForLevel(level);
+        level++;
+    }
+    return level;
+}
+function xpToNextLevel(xp) {
+    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),
+    };
+}
+function readProfile() {
+    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();
+    }
+}
+function saveProfile(profile) {
+    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() {
+    return {
+        totalXP: 0,
+        level: 1,
+        tasksCompleted: 0,
+        bossesDefeated: 0,
+        currentStreak: 0,
+        longestStreak: 0,
+        achievements: [],
+        stats: {
+            completedByDay: {},
+            createdAt: new Date().toISOString(),
+        },
+    };
+}
+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) {
+    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 = [];
+    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);
+        }
+    };
+    // 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,
+    };
+}
+function formatStats() {
+    const profile = readProfile();
+    const nextLevel = xpToNextLevel(profile.totalXP);
+    const lines = [
+        '',
+        '=== 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}/${exports.ACHIEVEMENTS.length}`,
+        '',
+    ];
+    return lines.join('\n');
+}
+function formatAchievements() {
+    const profile = readProfile();
+    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}`);
+    }
+    lines.push('');
+    lines.push(`Unlocked: ${profile.achievements.length}/${exports.ACHIEVEMENTS.length}`);
+    lines.push('');
+    return lines.join('\n');
+}

package/package.json

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

package/src/ai/claude.ts

@@ -16,49 +16,19 @@ export interface ConversationMessage {
 const SYSTEM_PROMPT = `You are a schema generator. Based on user input, generate EITHER:
 
 1. **BLOCK DIAGRAM** - when user mentions: "schema", "architecture", "infrastructure", "diagram", "system"
-   Use box-drawing to create visual blocks with connections:
-   
-   Example:
-   \`\`\`
-   ┌─────────────────────────────────────────────────────────────┐
-   │                     Kubernetes Cluster                       │
-   │                                                              │
-   │  ┌──────────────────┐      ┌──────────────────┐            │
-   │  │   Control Plane  │      │   Worker Nodes   │            │
-   │  │                  │◄────►│                  │            │
-   │  │  - API Server    │      │  - Node Pool 1   │            │
-   │  │  - Scheduler     │      │  - Node Pool 2   │            │
-   │  │  - etcd          │      │  - GPU Pool      │            │
-   │  └────────┬─────────┘      └────────┬─────────┘            │
-   │           │                          │                      │
-   │           └──────────┬───────────────┘                      │
-   │                      │                                       │
-   │  ┌──────────────────┐│┌──────────────────┐                 │
-   │  │    PostgreSQL    │││     Redis        │                 │
-   │  └──────────────────┘│└──────────────────┘                 │
-   └─────────────────────────────────────────────────────────────┘
-   \`\`\`
+   Use box-drawing to create visual blocks with connections.
 
 2. **TREE STRUCTURE** - when user mentions: "todo", "tasks", "list", "steps", "plan"
-   Use tree format:
-   
-   Example:
-   \`\`\`
-   ├── Phase 1: Setup
-   │   ├── Create repository
-   │   ├── Setup CI/CD
-   │   └── Configure environment
-   ├── Phase 2: Development
-   │   ├── Backend API
-   │   └── Frontend UI
-   └── Phase 3: Deploy
-   \`\`\`
+   Use tree format with metadata tags:
+   - [BOSS] or [MILESTONE] for major milestones
+   - [DUE: date] for deadlines (today, tomorrow, +3d, Jan 15)
 
 Rules:
 1. Extract a short title for filename
-2. If user says "schema" or "architecture" - ALWAYS use BLOCK DIAGRAM format
+2. If user says "schema" or "architecture" - use BLOCK DIAGRAM format
 3. If user says "todo" or "tasks" - use TREE format
 4. Keep context from previous messages
+5. For todos: add [BOSS] tags for major milestones, suggest deadlines
 
 Respond with JSON:
 {
@@ -67,6 +37,22 @@ Respond with JSON:
   "content": "the actual ASCII art schema here"
 }`;
 
+const DUNGEON_MAP_PROMPT = `You are a dungeon map generator for a roguelike task manager.
+Given a tree structure of tasks, create an ASCII dungeon map where:
+- Each major task group is a ROOM
+- Sub-tasks are items inside rooms (marked with *)
+- Boss/milestone tasks [BOSS] are marked with @ symbol
+- Completed tasks [DONE] are marked with x
+- Blocked tasks [BLOCKED] are marked with !
+- Rooms are connected by corridors (|, +, -)
+- Use # for walls
+- Use + for doors between rooms
+- Be creative with room shapes and layouts
+- Include a legend at the bottom
+
+Create a creative, interesting dungeon layout for the given tasks.
+Output ONLY the ASCII map, no JSON wrapper.`;
+
 export async function generateSchemaWithAI(
   input: string,
   config: Config,
@@ -81,22 +67,19 @@ export async function generateSchemaWithAI(
     apiKey: config.apiKey,
   });
   
-  // Build messages from history or just the current input
   const messages: { role: 'user' | 'assistant'; content: string }[] = [];
   
   if (history && history.length > 0) {
-    // Add previous messages for context
-    for (const msg of history.slice(0, -1)) { // exclude the last one (current input)
+    for (const msg of history.slice(0, -1)) {
       messages.push({
         role: msg.role,
         content: msg.role === 'assistant' 
-          ? `Previous schema generated:\n${msg.content}`
+          ? 'Previous schema generated:\n' + msg.content
           : msg.content
       });
     }
   }
   
-  // Add current user input
   messages.push({
     role: 'user',
     content: input
@@ -124,8 +107,6 @@ export async function generateSchemaWithAI(
     }
     
     const parsed = JSON.parse(jsonMatch[0]);
-    
-    // AI now returns ready content
     const schemaContent = parsed.content || '';
     
     return {
@@ -139,3 +120,39 @@ export async function generateSchemaWithAI(
   }
 }
 
+export async function generateDungeonMapWithAI(
+  treeContent: string,
+  config: Config,
+  signal?: AbortSignal
+): Promise<string | null> {
+  if (!config.apiKey) {
+    throw new Error('API key not set. Use config:apiKey=<key> to set it.');
+  }
+  
+  const client = new Anthropic({
+    apiKey: config.apiKey,
+  });
+
+  try {
+    const model = config.model || 'claude-sonnet-4-20250514';
+    const message = await client.messages.create({
+      model: model,
+      max_tokens: 2000,
+      system: DUNGEON_MAP_PROMPT,
+      messages: [{
+        role: 'user',
+        content: 'Generate a dungeon map for this task tree:\n\n' + treeContent
+      }],
+    });
+    
+    const content = message.content[0];
+    if (content.type !== 'text') {
+      return null;
+    }
+    
+    return content.text.trim();
+  } catch (error: any) {
+    console.error('AI Error:', error.message);
+    return null;
+  }
+}