roguelike-cli 1.2.6 → 1.3.0

package/dist/interactive/commands.js

@@ -41,60 +41,60 @@ const child_process_1 = require("child_process");
 const storage_1 = require("../storage/storage");
 const nodeConfig_1 = require("../storage/nodeConfig");
 const claude_1 = require("../ai/claude");
+const profile_1 = require("../storage/profile");
 // Parse tree ASCII art and create folder structure
 function createFoldersFromTree(rootPath, treeContent) {
-    // Create root folder
     if (!fs.existsSync(rootPath)) {
         fs.mkdirSync(rootPath, { recursive: true });
     }
-    // Parse tree lines
     const lines = treeContent.split('\n');
     const stack = [{ path: rootPath, indent: -1 }];
     for (const line of lines) {
-        // Skip empty lines
         if (!line.trim())
             continue;
-        // Extract node name from tree line
-        // Patterns: "├── Name", "└── Name", "│   ├── Name", etc.
         const match = line.match(/^([\s│]*)[├└]──\s*(.+)$/);
         if (!match)
             continue;
         const prefix = match[1];
         let nodeName = match[2].trim();
-        // Calculate indent level (each │ or space block = 1 level)
         const indent = Math.floor(prefix.replace(/│/g, ' ').length / 4);
-        // Clean node name - remove extra info in parentheses, brackets
+        // Extract metadata from node name
+        const isBoss = /\[BOSS\]/i.test(nodeName) || /\[MILESTONE\]/i.test(nodeName);
+        const deadlineMatch = nodeName.match(/\[(?:DUE|DEADLINE):\s*([^\]]+)\]/i);
+        const deadline = deadlineMatch ? deadlineMatch[1].trim() : undefined;
+        // Clean node name
         nodeName = nodeName.replace(/\s*\([^)]*\)\s*/g, '').trim();
         nodeName = nodeName.replace(/\s*\[[^\]]*\]\s*/g, '').trim();
-        // Create safe folder name
         const safeName = nodeName
             .toLowerCase()
             .replace(/[^a-z0-9]+/g, '-')
             .replace(/^-+|-+$/g, '');
         if (!safeName)
             continue;
-        // Pop stack until we find parent
         while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
             stack.pop();
         }
         const parentPath = stack[stack.length - 1].path;
         const folderPath = path.join(parentPath, safeName);
-        // Create folder
         if (!fs.existsSync(folderPath)) {
             fs.mkdirSync(folderPath, { recursive: true });
         }
-        // Create node config
+        // Calculate depth for XP
+        const depth = stack.length;
         (0, nodeConfig_1.writeNodeConfig)(folderPath, {
             name: nodeName,
+            status: 'open',
+            xp: (0, nodeConfig_1.calculateXP)(depth, isBoss),
+            isBoss,
+            deadline,
             createdAt: new Date().toISOString(),
             updatedAt: new Date().toISOString(),
         });
-        // Push to stack
         stack.push({ path: folderPath, indent });
     }
 }
 // Generate dungeon map visualization from folder structure
-function generateDungeonMap(dirPath) {
+function generateDungeonMap(dirPath, config) {
     if (!fs.existsSync(dirPath)) {
         return 'Directory does not exist.';
     }
@@ -106,54 +106,64 @@ function generateDungeonMap(dirPath) {
     const lines = [];
     const roomWidth = 20;
     const roomsPerRow = 2;
-    const wall = '█';
+    const wall = '#';
     const door = '+';
     const task = '*';
     const milestone = '@';
-    // Group folders into rows of 2
+    const done = 'x';
+    const blocked = '!';
     const rows = [];
     for (let i = 0; i < folders.length; i += roomsPerRow) {
         rows.push(folders.slice(i, i + roomsPerRow));
     }
-    // Top border
+    lines.push('');
     lines.push('  ' + wall.repeat(roomWidth * roomsPerRow + 3));
     rows.forEach((row, rowIndex) => {
-        // Room content
         for (let line = 0; line < 6; line++) {
             let rowStr = '  ' + wall;
             row.forEach((folder, colIndex) => {
-                const name = folder.name.replace(/-/g, ' ');
+                const folderPath = path.join(dirPath, folder.name);
+                const nodeConfig = (0, nodeConfig_1.readNodeConfig)(folderPath);
+                const name = (nodeConfig?.name || folder.name).replace(/-/g, ' ');
                 const displayName = name.length > roomWidth - 4
                     ? name.substring(0, roomWidth - 7) + '...'
                     : name;
-                // Get sub-items
                 const subPath = path.join(dirPath, folder.name);
                 const subEntries = fs.existsSync(subPath)
                     ? fs.readdirSync(subPath, { withFileTypes: true })
                         .filter(e => e.isDirectory() && !e.name.startsWith('.'))
                     : [];
                 if (line === 0) {
-                    // Empty line
                     rowStr += ' '.repeat(roomWidth - 1) + wall;
                 }
                 else if (line === 1) {
-                    // Room name
+                    const statusIcon = nodeConfig?.status === 'done' ? '[DONE]'
+                        : nodeConfig?.isBoss ? '[BOSS]'
+                            : '';
+                    const title = statusIcon ? `${statusIcon}` : `[${displayName}]`;
+                    const padding = roomWidth - title.length - 1;
+                    rowStr += ' ' + title + ' '.repeat(Math.max(0, padding - 1)) + wall;
+                }
+                else if (line === 2 && !nodeConfig?.isBoss) {
                     const title = `[${displayName}]`;
                     const padding = roomWidth - title.length - 1;
                     rowStr += ' ' + title + ' '.repeat(Math.max(0, padding - 1)) + wall;
                 }
                 else if (line >= 2 && line <= 4) {
-                    // Sub-items
-                    const itemIndex = line - 2;
-                    if (itemIndex < subEntries.length) {
-                        const subName = subEntries[itemIndex].name.replace(/-/g, ' ');
+                    const itemIndex = nodeConfig?.isBoss ? line - 2 : line - 3;
+                    if (itemIndex >= 0 && itemIndex < subEntries.length) {
+                        const subConfig = (0, nodeConfig_1.readNodeConfig)(path.join(subPath, subEntries[itemIndex].name));
+                        const subName = (subConfig?.name || subEntries[itemIndex].name).replace(/-/g, ' ');
                         const shortName = subName.length > roomWidth - 6
                             ? subName.substring(0, roomWidth - 9) + '...'
                             : subName;
-                        const marker = subName.toLowerCase().includes('boss') ||
-                            subName.toLowerCase().includes('launch') ||
-                            subName.toLowerCase().includes('deploy')
-                            ? milestone : task;
+                        let marker = task;
+                        if (subConfig?.status === 'done')
+                            marker = done;
+                        else if (subConfig?.status === 'blocked')
+                            marker = blocked;
+                        else if (subConfig?.isBoss)
+                            marker = milestone;
                         const itemStr = `${marker} ${shortName}`;
                         const itemPadding = roomWidth - itemStr.length - 1;
                         rowStr += ' ' + itemStr + ' '.repeat(Math.max(0, itemPadding - 1)) + wall;
@@ -163,10 +173,8 @@ function generateDungeonMap(dirPath) {
                     }
                 }
                 else {
-                    // Empty line
                     rowStr += ' '.repeat(roomWidth - 1) + wall;
                 }
-                // Add door between rooms
                 if (colIndex < row.length - 1 && line === 3) {
                     rowStr = rowStr.slice(0, -1) + door + door + door;
                 }
@@ -174,21 +182,18 @@ function generateDungeonMap(dirPath) {
                     rowStr = rowStr.slice(0, -1) + wall;
                 }
             });
-            // Fill empty space if odd number of rooms
             if (row.length < roomsPerRow) {
                 rowStr += ' '.repeat(roomWidth) + wall;
             }
             lines.push(rowStr);
         }
-        // Bottom border with doors to next row
         if (rowIndex < rows.length - 1) {
             let borderStr = '  ' + wall.repeat(Math.floor(roomWidth / 2)) + door;
             borderStr += wall.repeat(roomWidth - 1) + door;
             borderStr += wall.repeat(Math.floor(roomWidth / 2) + 1);
             lines.push(borderStr);
-            // Corridor
-            let corridorStr = '  ' + ' '.repeat(Math.floor(roomWidth / 2)) + '│';
-            corridorStr += ' '.repeat(roomWidth - 1) + '│';
+            let corridorStr = '  ' + ' '.repeat(Math.floor(roomWidth / 2)) + '|';
+            corridorStr += ' '.repeat(roomWidth - 1) + '|';
             lines.push(corridorStr);
             borderStr = '  ' + wall.repeat(Math.floor(roomWidth / 2)) + door;
             borderStr += wall.repeat(roomWidth - 1) + door;
@@ -196,19 +201,94 @@ function generateDungeonMap(dirPath) {
             lines.push(borderStr);
         }
     });
-    // Bottom border
     lines.push('  ' + wall.repeat(roomWidth * roomsPerRow + 3));
-    // Legend
     lines.push('');
-    lines.push(`Legend: ${task} Task  ${milestone} Milestone  ${door} Door  ${wall} Wall`);
+    lines.push(`Legend: ${task} Task  ${done} Done  ${milestone} Boss/Milestone  ${blocked} Blocked  ${door} Door`);
     return lines.join('\n');
 }
-// Global session state
+// Parse human-readable date
+function parseDeadline(input) {
+    const lower = input.toLowerCase().trim();
+    const today = new Date();
+    if (lower === 'today') {
+        return today.toISOString().split('T')[0];
+    }
+    if (lower === 'tomorrow') {
+        today.setDate(today.getDate() + 1);
+        return today.toISOString().split('T')[0];
+    }
+    // +Nd format (e.g., +3d, +7d)
+    const plusDaysMatch = lower.match(/^\+(\d+)d$/);
+    if (plusDaysMatch) {
+        today.setDate(today.getDate() + parseInt(plusDaysMatch[1]));
+        return today.toISOString().split('T')[0];
+    }
+    // Try parsing as date
+    const parsed = new Date(input);
+    if (!isNaN(parsed.getTime())) {
+        return parsed.toISOString().split('T')[0];
+    }
+    return null;
+}
+// Format deadline for display
+function formatDeadline(deadline) {
+    const deadlineDate = new Date(deadline);
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    deadlineDate.setHours(0, 0, 0, 0);
+    const diffDays = Math.ceil((deadlineDate.getTime() - today.getTime()) / (1000 * 60 * 60 * 24));
+    if (diffDays < 0)
+        return `OVERDUE ${Math.abs(diffDays)}d`;
+    if (diffDays === 0)
+        return 'TODAY';
+    if (diffDays === 1)
+        return 'tomorrow';
+    if (diffDays <= 7)
+        return `${diffDays}d left`;
+    return deadlineDate.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+}
+// Get depth of current path relative to storage root
+function getDepth(currentPath, storagePath) {
+    const relative = path.relative(storagePath, currentPath);
+    if (!relative)
+        return 0;
+    return relative.split(path.sep).length;
+}
+// Mark node as done recursively
+function markDoneRecursive(nodePath, storagePath) {
+    let result = { xpGained: 0, tasksCompleted: 0, bossesDefeated: 0 };
+    const config = (0, nodeConfig_1.readNodeConfig)(nodePath);
+    if (!config || config.status === 'done') {
+        return result;
+    }
+    // First, mark all children as done
+    const entries = fs.readdirSync(nodePath, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory() && !entry.name.startsWith('.')) {
+            const childResult = markDoneRecursive(path.join(nodePath, entry.name), storagePath);
+            result.xpGained += childResult.xpGained;
+            result.tasksCompleted += childResult.tasksCompleted;
+            result.bossesDefeated += childResult.bossesDefeated;
+        }
+    }
+    // Mark this node as done
+    const depth = getDepth(nodePath, storagePath);
+    const xp = config.xp || (0, nodeConfig_1.calculateXP)(depth, config.isBoss || false);
+    (0, nodeConfig_1.writeNodeConfig)(nodePath, {
+        ...config,
+        status: 'done',
+        completedAt: new Date().toISOString(),
+    });
+    result.xpGained += xp;
+    result.tasksCompleted += 1;
+    if (config.isBoss)
+        result.bossesDefeated += 1;
+    return result;
+}
 exports.sessionState = {
     pending: null,
     history: []
 };
-// Format items in columns like native ls
 function formatColumns(items, termWidth = 80) {
     if (items.length === 0)
         return '';
@@ -221,7 +301,6 @@ function formatColumns(items, termWidth = 80) {
     }
     return rows.join('\n');
 }
-// Copy to clipboard (cross-platform)
 function copyToClipboard(text) {
     const platform = process.platform;
     try {
@@ -232,7 +311,6 @@ function copyToClipboard(text) {
             (0, child_process_1.execSync)('clip', { input: text });
         }
         else {
-            // Linux - try xclip or xsel
             try {
                 (0, child_process_1.execSync)('xclip -selection clipboard', { input: text });
             }
@@ -242,10 +320,9 @@ function copyToClipboard(text) {
         }
     }
     catch (e) {
-        // Silently fail if clipboard not available
+        // Silently fail
     }
 }
-// Helper function for recursive copy
 function copyRecursive(src, dest) {
     const stat = fs.statSync(src);
     if (stat.isDirectory()) {
@@ -263,14 +340,60 @@ function copyRecursive(src, dest) {
         fs.copyFileSync(src, dest);
     }
 }
+// Build tree with status and deadline info
+function getTreeWithStatus(dirPath, prefix = '', isRoot = true, maxDepth = 10, currentDepth = 0, showFiles = false) {
+    const lines = [];
+    if (!fs.existsSync(dirPath)) {
+        return lines;
+    }
+    if (currentDepth >= maxDepth) {
+        return lines;
+    }
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    const dirs = entries.filter(e => e.isDirectory() && !e.name.startsWith('.'));
+    const files = showFiles ? entries.filter(e => e.isFile() && !e.name.startsWith('.')) : [];
+    const allItems = [...dirs, ...files];
+    allItems.forEach((entry, index) => {
+        const isLast = index === allItems.length - 1;
+        const connector = isLast ? '└── ' : '├── ';
+        const nextPrefix = isLast ? '    ' : '│   ';
+        if (entry.isDirectory()) {
+            const nodePath = path.join(dirPath, entry.name);
+            const config = (0, nodeConfig_1.readNodeConfig)(nodePath);
+            let displayName = config?.name || entry.name;
+            const tags = [];
+            // Add status tag
+            if (config?.status === 'done') {
+                tags.push('DONE');
+            }
+            else if (config?.status === 'blocked') {
+                tags.push('BLOCKED');
+            }
+            // Add boss tag
+            if (config?.isBoss) {
+                tags.push('BOSS');
+            }
+            // Add deadline tag
+            if (config?.deadline && config.status !== 'done') {
+                tags.push(formatDeadline(config.deadline));
+            }
+            const tagStr = tags.length > 0 ? ` [${tags.join('] [')}]` : '';
+            lines.push(`${prefix}${connector}${displayName}/${tagStr}`);
+            const childLines = getTreeWithStatus(nodePath, prefix + nextPrefix, false, maxDepth, currentDepth + 1, showFiles);
+            lines.push(...childLines);
+        }
+        else {
+            lines.push(`${prefix}${connector}${entry.name}`);
+        }
+    });
+    return lines;
+}
 async function processCommand(input, currentPath, config, signal, rl) {
-    // Check for clipboard pipe
     const clipboardPipe = /\s*\|\s*(pbcopy|copy|clip)\s*$/i;
     const shouldCopy = clipboardPipe.test(input);
     const cleanInput = input.replace(clipboardPipe, '').trim();
     const parts = cleanInput.split(' ').filter(p => p.length > 0);
     const command = parts[0].toLowerCase();
-    // Helper to wrap result with clipboard copy
     const wrapResult = (result) => {
         if (shouldCopy && result.output) {
             copyToClipboard(result.output);
@@ -283,9 +406,155 @@ async function processCommand(input, currentPath, config, signal, rl) {
         const pkg = require('../../package.json');
         return wrapResult({ output: `Roguelike CLI v${pkg.version}` });
     }
+    // Stats command
+    if (command === 'stats') {
+        return wrapResult({ output: (0, profile_1.formatStats)() });
+    }
+    // Achievements command
+    if (command === 'achievements' || command === 'ach') {
+        return wrapResult({ output: (0, profile_1.formatAchievements)() });
+    }
+    // Done command - mark current node as completed
+    if (command === 'done') {
+        const nodeConfig = (0, nodeConfig_1.readNodeConfig)(currentPath);
+        if (!nodeConfig) {
+            return wrapResult({ output: 'No task at current location. Navigate to a task first.' });
+        }
+        if (nodeConfig.status === 'done') {
+            return wrapResult({ output: 'This task is already completed.' });
+        }
+        // Mark done recursively
+        const result = markDoneRecursive(currentPath, config.storagePath);
+        // Update profile with XP and achievements
+        const depth = getDepth(currentPath, config.storagePath);
+        const taskResult = (0, profile_1.completeTask)(result.xpGained, nodeConfig.isBoss || false, depth, nodeConfig.createdAt);
+        let output = `\n=== TASK COMPLETED ===\n`;
+        output += `\nTasks completed: ${result.tasksCompleted}`;
+        if (result.bossesDefeated > 0) {
+            output += `\nBosses defeated: ${result.bossesDefeated}`;
+        }
+        output += `\n+${result.xpGained} XP`;
+        if (taskResult.levelUp) {
+            output += `\n\n*** LEVEL UP! ***`;
+            output += `\nYou are now 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';
+        return wrapResult({ output });
+    }
+    // Deadline command
+    if (command === 'deadline') {
+        if (parts.length < 2) {
+            return wrapResult({ output: 'Usage: deadline <date>\nExamples: deadline today, deadline tomorrow, deadline +3d, deadline Jan 15' });
+        }
+        const dateStr = parts.slice(1).join(' ');
+        const deadline = parseDeadline(dateStr);
+        if (!deadline) {
+            return wrapResult({ output: `Could not parse date: ${dateStr}` });
+        }
+        const nodeConfig = (0, nodeConfig_1.readNodeConfig)(currentPath);
+        if (!nodeConfig) {
+            return wrapResult({ output: 'No task at current location.' });
+        }
+        (0, nodeConfig_1.writeNodeConfig)(currentPath, {
+            ...nodeConfig,
+            deadline,
+        });
+        return wrapResult({ output: `Deadline set: ${formatDeadline(deadline)}` });
+    }
+    // Boss command - mark as boss/milestone
+    if (command === 'boss' || command === 'milestone') {
+        const nodeConfig = (0, nodeConfig_1.readNodeConfig)(currentPath);
+        if (!nodeConfig) {
+            return wrapResult({ output: 'No task at current location.' });
+        }
+        const newIsBoss = !nodeConfig.isBoss;
+        const depth = getDepth(currentPath, config.storagePath);
+        (0, nodeConfig_1.writeNodeConfig)(currentPath, {
+            ...nodeConfig,
+            isBoss: newIsBoss,
+            xp: (0, nodeConfig_1.calculateXP)(depth, newIsBoss),
+        });
+        return wrapResult({ output: newIsBoss ? 'Marked as BOSS task (3x XP)' : 'Removed BOSS status' });
+    }
+    // Block command
+    if (command === 'block') {
+        const nodeConfig = (0, nodeConfig_1.readNodeConfig)(currentPath);
+        if (!nodeConfig) {
+            return wrapResult({ output: 'No task at current location.' });
+        }
+        const reason = parts.length > 1 ? parts.slice(1).join(' ') : undefined;
+        (0, nodeConfig_1.writeNodeConfig)(currentPath, {
+            ...nodeConfig,
+            status: 'blocked',
+            blockedBy: reason ? [reason] : nodeConfig.blockedBy,
+        });
+        return wrapResult({ output: reason ? `Blocked: ${reason}` : 'Task marked as blocked' });
+    }
+    // Unblock command
+    if (command === 'unblock') {
+        const nodeConfig = (0, nodeConfig_1.readNodeConfig)(currentPath);
+        if (!nodeConfig) {
+            return wrapResult({ output: 'No task at current location.' });
+        }
+        (0, nodeConfig_1.writeNodeConfig)(currentPath, {
+            ...nodeConfig,
+            status: 'open',
+            blockedBy: [],
+        });
+        return wrapResult({ output: 'Task unblocked' });
+    }
+    // Status command - show current task status
+    if (command === 'status') {
+        const nodeConfig = (0, nodeConfig_1.readNodeConfig)(currentPath);
+        if (!nodeConfig) {
+            return wrapResult({ output: 'No task at current location.' });
+        }
+        const lines = [
+            '',
+            `Task: ${nodeConfig.name}`,
+            `Status: ${nodeConfig.status.toUpperCase()}`,
+            `XP: ${nodeConfig.xp}`,
+        ];
+        if (nodeConfig.isBoss) {
+            lines.push('Type: BOSS');
+        }
+        if (nodeConfig.deadline) {
+            lines.push(`Deadline: ${formatDeadline(nodeConfig.deadline)}`);
+        }
+        if (nodeConfig.completedAt) {
+            lines.push(`Completed: ${new Date(nodeConfig.completedAt).toLocaleDateString()}`);
+        }
+        if (nodeConfig.blockedBy && nodeConfig.blockedBy.length > 0) {
+            lines.push(`Blocked by: ${nodeConfig.blockedBy.join(', ')}`);
+        }
+        lines.push('');
+        return wrapResult({ output: lines.join('\n') });
+    }
     // Map command - dungeon visualization
     if (command === 'map') {
-        const dungeonMap = generateDungeonMap(currentPath);
+        // Check for --ai flag to use AI generation
+        if (parts.includes('--ai') || parts.includes('-a')) {
+            const treeLines = getTreeWithStatus(currentPath, '', true, 10, 0, false);
+            const treeContent = treeLines.join('\n');
+            if (!treeContent) {
+                return wrapResult({ output: 'No tasks to visualize.' });
+            }
+            const mapContent = await (0, claude_1.generateDungeonMapWithAI)(treeContent, config, signal);
+            if (mapContent) {
+                // Save map to file
+                const folderName = path.basename(currentPath);
+                (0, nodeConfig_1.saveMapFile)(currentPath, folderName + '-map', mapContent);
+                return wrapResult({ output: mapContent + '\n\n[Map saved as .rlc.map]' });
+            }
+            return wrapResult({ output: 'Could not generate AI map. Using default.' });
+        }
+        const dungeonMap = generateDungeonMap(currentPath, config);
         return wrapResult({ output: dungeonMap });
     }
     if (command === 'ls') {
@@ -298,7 +567,16 @@ async function processCommand(input, currentPath, config, signal, rl) {
             if (entry.name.startsWith('.'))
                 continue;
             if (entry.isDirectory()) {
-                items.push(entry.name + '/');
+                const nodePath = path.join(currentPath, entry.name);
+                const config = (0, nodeConfig_1.readNodeConfig)(nodePath);
+                let suffix = '/';
+                if (config?.status === 'done')
+                    suffix = '/ [DONE]';
+                else if (config?.status === 'blocked')
+                    suffix = '/ [BLOCKED]';
+                else if (config?.isBoss)
+                    suffix = '/ [BOSS]';
+                items.push(entry.name + suffix);
             }
             else {
                 items.push(entry.name);
@@ -312,7 +590,6 @@ async function processCommand(input, currentPath, config, signal, rl) {
     }
     if (command === 'tree') {
         const showFiles = parts.includes('-A') || parts.includes('--all');
-        // Parse depth: --depth=N or -d N
         let maxDepth = 10;
         const depthFlag = parts.find(p => p.startsWith('--depth='));
         if (depthFlag) {
@@ -324,29 +601,25 @@ async function processCommand(input, currentPath, config, signal, rl) {
                 maxDepth = parseInt(parts[dIndex + 1]) || 10;
             }
         }
-        const treeLines = (0, storage_1.getTree)(currentPath, '', true, maxDepth, 0, showFiles);
+        const treeLines = getTreeWithStatus(currentPath, '', true, maxDepth, 0, showFiles);
         if (treeLines.length === 0) {
             return wrapResult({ output: 'No items found.' });
         }
         return wrapResult({ output: treeLines.join('\n') });
     }
-    // Handle navigation without 'cd' command (.., ..., ...., etc)
+    // Handle navigation without 'cd' command
     if (/^\.{2,}$/.test(command)) {
-        // Count dots: .. = 1 level, ... = 2 levels, .... = 3 levels, etc
         const levels = command.length - 1;
         let targetPath = currentPath;
-        // Already at root?
         if (targetPath === config.storagePath) {
             return { output: 'Already at root.' };
         }
         for (let i = 0; i < levels; i++) {
             const parentPath = path.dirname(targetPath);
-            // Stop at storage root
             if (targetPath === config.storagePath || parentPath.length < config.storagePath.length) {
                 break;
             }
             targetPath = parentPath;
-            // If we reached root, stop
             if (targetPath === config.storagePath) {
                 break;
             }
@@ -402,7 +675,6 @@ async function processCommand(input, currentPath, config, signal, rl) {
             return { output: `Moved: ${source} -> ${dest}` };
         }
         catch (error) {
-            // If rename fails (cross-device), copy then delete
             try {
                 copyRecursive(sourcePath, destPath);
                 fs.rmSync(sourcePath, { recursive: true, force: true });
@@ -415,23 +687,19 @@ async function processCommand(input, currentPath, config, signal, rl) {
     }
     if (command === 'open') {
         const { exec } = require('child_process');
-        // open or open . - open current folder in system file manager
         if (parts.length < 2 || parts[1] === '.') {
             exec(`open "${currentPath}"`);
             return { output: `Opening: ${currentPath}` };
         }
         const name = parts.slice(1).join(' ');
         const targetPath = path.join(currentPath, name);
-        // Check if target exists
         if (fs.existsSync(targetPath)) {
             const stat = fs.statSync(targetPath);
             if (stat.isDirectory()) {
-                // It's a folder, open in file manager
                 exec(`open "${targetPath}"`);
                 return { output: `Opening: ${targetPath}` };
             }
             if (stat.isFile()) {
-                // It's a file, show its content (supports | pbcopy)
                 const content = fs.readFileSync(targetPath, 'utf-8');
                 return wrapResult({ output: content });
             }
@@ -478,35 +746,29 @@ async function processCommand(input, currentPath, config, signal, rl) {
             return { output: 'Usage: cd <node> or cd .. or cd <path>' };
         }
         const target = parts.slice(1).join(' ');
-        // Handle cd .., cd ..., cd ...., etc
         if (/^\.{2,}$/.test(target)) {
             const levels = target.length - 1;
             let targetPath = currentPath;
-            // Already at root?
             if (targetPath === config.storagePath) {
                 return { output: 'Already at root.' };
             }
             for (let i = 0; i < levels; i++) {
                 const parentPath = path.dirname(targetPath);
-                // Stop at storage root
                 if (targetPath === config.storagePath || parentPath.length < config.storagePath.length) {
                     break;
                 }
                 targetPath = parentPath;
-                // If we reached root, stop
                 if (targetPath === config.storagePath) {
                     break;
                 }
             }
             return { newPath: targetPath, output: '' };
         }
-        // Handle paths like "cd bank/account" or "cd ../other"
         if (target.includes('/')) {
             let targetPath = currentPath;
             const pathParts = target.split('/');
             for (const part of pathParts) {
                 if (/^\.{2,}$/.test(part)) {
-                    // Handle .., ..., ...., etc in path
                     const levels = part.length - 1;
                     for (let i = 0; i < levels; i++) {
                         if (targetPath === config.storagePath)
@@ -572,120 +834,68 @@ Storage:      ${config.storagePath}
     }
     if (command === 'help') {
         return wrapResult({
-            output: `Commands:
-  init                  - Initialize rlc (first time setup)
-  ls                    - List all schemas, todos, and notes
-  tree                  - Show directory tree structure
-  tree -A               - Show tree with files
-  tree --depth=N        - Limit tree depth (e.g., --depth=2)
-  map                   - Dungeon map visualization
-  cd <node>             - Navigate into a node
-  cd ..                 - Go back to parent
-  pwd                   - Show current path
-  open                  - Open current folder in Finder
-  open <folder>         - Open specific folder in Finder
-  mkdir <name>          - Create new folder
-  cp <src> <dest>       - Copy file or folder
-  mv <src> <dest>       - Move/rename file or folder
-  rm <name>             - Delete file
-  rm -rf <name>         - Delete folder recursively
-  config                - Show configuration
-  config:apiKey=<key>   - Set API key
-  v, version            - Show version
-  <description>         - Create schema/todo (AI generates preview)
-  save                  - Save pending schema to disk
-  cancel                - Discard pending schema
-  clean                 - Show items to delete in current folder
-  clean --yes           - Delete all items in current folder
-  exit/quit             - Exit the program
-
-Clipboard:
-  ls | pbcopy           - Copy output to clipboard (macOS)
-  tree | pbcopy         - Works with any command
-  config | copy         - Alternative for Windows
+            output: `
+=== ROGUELIKE CLI ===
 
-Workflow:
-  1. Type description (e.g., "todo: deploy app")
-  2. AI generates schema preview
-  3. Refine with more instructions if needed
-  4. Type "save" to save or "cancel" to discard
+Navigation:
+  ls                    List tasks and files
+  tree                  Show task tree with status
+  tree -A               Include files
+  tree --depth=N        Limit tree depth
+  cd <task>             Navigate into task
+  cd .., ...            Go back 1 or 2 levels
+  pwd                   Show current path
+  open                  Open folder in Finder
 
-Examples:
+Task Management:
+  mkdir <name>          Create new task
+  done                  Mark current task as completed (recursive)
+  deadline <date>       Set deadline (today, tomorrow, +3d, Jan 15)
+  boss                  Toggle boss/milestone status (3x XP)
+  block [reason]        Mark task as blocked
+  unblock               Remove blocked status
+  status                Show current task details
 
-  > todo opening company in delaware
+File Operations:
+  cp <src> <dest>       Copy file or folder
+  mv <src> <dest>       Move/rename
+  rm <name>             Delete file
+  rm -rf <name>         Delete folder
 
-  ┌─ TODO opening company in delaware ───────────────────────────┐
-  │                                                               │
-  ├── register business name                                     │
-  ├── file incorporation papers                                  │
-  ├── get EIN number                                             │
-  └── Branch: legal                                               │
-      └── open business bank account                             │
-  │                                                               │
-  └───────────────────────────────────────────────────────────────┘
+Gamification:
+  stats                 Show XP, level, streaks
+  achievements          Show achievement list
+  map                   Dungeon map view
+  map --ai              AI-generated dungeon map
 
-  > yandex cloud production infrastructure
+Schema Generation:
+  <description>         AI generates todo/schema preview
+  save                  Save pending schema
+  cancel                Discard pending schema
 
-  ┌─────────────────────────────────────────────────────────────┐
-  │                  Yandex Cloud                               │
-  │                                                             │
-  │  ┌──────────────────┐      ┌──────────────────┐           │
-  │  │ back-fastapi     │      │ admin-next       │           │
-  │  │ (VM)             │      │ (VM)             │           │
-  │  └────────┬─────────┘      └──────────────────┘           │
-  │           │                                                 │
-  │           ├──────────────────┬─────────────────┐           │
-  │           │                  │                 │           │
-  │  ┌────────▼────────┐  ┌─────▼──────┐   ┌──────▼────────┐  │
-  │  │   PostgreSQL    │  │   Redis    │   │  Cloudflare   │  │
-  │  │  (Existing DB)  │  │  Cluster   │   │  R2 Storage   │  │
-  │  └─────────────────┘  └────────────┘   └───────────────┘  │
-  └─────────────────────────────────────────────────────────────┘
+Utility:
+  init                  Setup wizard
+  config                Show settings
+  clean --yes           Clear current folder
+  v, version            Show version
+  help                  This help
+  exit, quit            Exit
 
-  > architecture production redis web application
-
-  ┌─ Architecture production redis web application ────────────┐
-  │                                                               │
-  ├── load-balancer                                               │
-  ├── web-servers                                                 │
-  │   ├── app-server-1                                            │
-  │   ├── app-server-2                                            │
-  │   └── app-server-3                                            │
-  ├── redis                                                       │
-  │   ├── cache-cluster                                           │
-  │   └── session-store                                           │
-  └── database                                                    │
-      ├── postgres-primary                                        │
-      └── postgres-replica                                        │
-  │                                                               │
-  └───────────────────────────────────────────────────────────────┘
-
-  > kubernetes cluster with clusters postgres and redis
+Clipboard:
+  <cmd> | pbcopy        Copy output (macOS)
+  <cmd> | clip          Copy output (Windows)
 
-  ┌─────────────────────────────────────────────────────────────┐
-  │         Kubernetes cluster with clusters postgres          │
-  │                                                             │
-  │  ┌──────────────┐      ┌──────────────┐                  │
-  │  │   postgres   │      │    redis     │                  │
-  │  │              │      │              │                  │
-  │  │ primary-pod  │      │ cache-pod-1  │                  │
-  │  │ replica-pod-1│      │ cache-pod-2  │                  │
-  │  │ replica-pod-2│      │              │                  │
-  │  └──────┬───────┘      └──────┬───────┘                  │
-  │         │                      │                           │
-  │         └──────────┬───────────┘                           │
-  │                    │                                         │
-  │            ┌───────▼────────┐                              │
-  │            │ worker-zones   │                              │
-  │            │   zone-1       │                              │
-  │            │   zone-2       │                              │
-  │            └────────────────┘                              │
-  └─────────────────────────────────────────────────────────────┘
+Deadlines:
+  deadline today        Due today
+  deadline tomorrow     Due tomorrow
+  deadline +3d          Due in 3 days
+  deadline Jan 15       Due on date
 
-www.rlc.rocks`
+www.rlc.rocks
+`.trim()
         });
     }
-    // Save command - save pending schema/todo
+    // Save command
     if (command === 'save') {
         if (!exports.sessionState.pending) {
             return wrapResult({ output: 'Nothing to save. Create a schema first.' });
@@ -693,25 +903,21 @@ www.rlc.rocks`
         const pending = exports.sessionState.pending;
         const safeName = pending.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
         if (pending.format === 'tree') {
-            // Create folder structure from tree ASCII art
             const rootPath = path.join(currentPath, safeName);
             createFoldersFromTree(rootPath, pending.content);
-            // Clear session
             exports.sessionState.pending = null;
             exports.sessionState.history = [];
             return wrapResult({ output: `Created todo folder: ${safeName}/` });
         }
         else {
-            // Save as .rlc.schema file
             const schemaPath = (0, nodeConfig_1.saveSchemaFile)(currentPath, pending.title, pending.content);
             const filename = path.basename(schemaPath);
-            // Clear session
             exports.sessionState.pending = null;
             exports.sessionState.history = [];
             return wrapResult({ output: `Saved: ${filename}` });
         }
     }
-    // Cancel command - discard pending schema
+    // Cancel command
     if (command === 'cancel') {
         if (!exports.sessionState.pending) {
             return wrapResult({ output: 'Nothing to cancel.' });
@@ -720,14 +926,13 @@ www.rlc.rocks`
         exports.sessionState.history = [];
         return wrapResult({ output: 'Discarded pending schema.' });
     }
-    // Clean command - clear current directory
+    // Clean command
     if (command === 'clean') {
         const entries = fs.readdirSync(currentPath);
         const toDelete = entries.filter(e => !e.startsWith('.'));
         if (toDelete.length === 0) {
             return wrapResult({ output: 'Directory is already empty.' });
         }
-        // Check for --yes flag to skip confirmation
         if (!parts.includes('--yes') && !parts.includes('-y')) {
             return wrapResult({
                 output: `Will delete ${toDelete.length} items:\n${toDelete.join('\n')}\n\nRun "clean --yes" to confirm.`
@@ -739,23 +944,20 @@ www.rlc.rocks`
         }
         return wrapResult({ output: `Deleted ${toDelete.length} items.` });
     }
-    // AI generation - store in pending, don't save immediately
+    // AI generation
     const fullInput = cleanInput;
-    // Add user message to history
     exports.sessionState.history.push({ role: 'user', content: fullInput });
     const schema = await (0, claude_1.generateSchemaWithAI)(fullInput, config, signal, exports.sessionState.history);
     if (signal?.aborted) {
         return { output: 'Command cancelled.' };
     }
     if (schema) {
-        // Store in pending
         exports.sessionState.pending = {
             title: schema.title,
             content: schema.content,
             format: schema.format,
             tree: schema.tree
         };
-        // Add assistant response to history
         exports.sessionState.history.push({ role: 'assistant', content: schema.content });
         const safeName = schema.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
         const saveHint = schema.format === 'tree'