roguelike-cli 1.3.0 → 1.3.1

package/README.md

@@ -95,11 +95,13 @@ You are now level 2!
 | Command | Description |
 |---------|-------------|
 | `done` | Complete task (recursive, earns XP) |
+| `undo` | Undo last done (restores XP) |
 | `deadline <date>` | Set deadline |
 | `boss` | Toggle boss status (3x XP) |
-| `block [reason]` | Mark as blocked |
+| `block [node]` | Block by task or text reason |
 | `unblock` | Remove blocked status |
 | `status` | Show task details |
+| `check` | Show overdue/upcoming deadlines |
 
 ### Gamification
 

package/dist/interactive/commands.js

@@ -428,6 +428,13 @@ async function processCommand(input, currentPath, config, signal, rl) {
         // 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);
+        // Save to undo history
+        (0, profile_1.addToUndoHistory)({
+            path: currentPath,
+            xpLost: result.xpGained,
+            wasBoss: nodeConfig.isBoss || false,
+            timestamp: new Date().toISOString(),
+        });
         let output = `\n=== TASK COMPLETED ===\n`;
         output += `\nTasks completed: ${result.tasksCompleted}`;
         if (result.bossesDefeated > 0) {
@@ -445,6 +452,30 @@ async function processCommand(input, currentPath, config, signal, rl) {
             }
         }
         output += '\n';
+        output += '[Type "undo" to revert]';
+        return wrapResult({ output });
+    }
+    // Undo command
+    if (command === 'undo') {
+        const lastUndo = (0, profile_1.getLastUndo)();
+        if (!lastUndo) {
+            return wrapResult({ output: 'Nothing to undo.' });
+        }
+        // Revert the task status
+        const nodeConfig = (0, nodeConfig_1.readNodeConfig)(lastUndo.path);
+        if (nodeConfig) {
+            (0, nodeConfig_1.writeNodeConfig)(lastUndo.path, {
+                ...nodeConfig,
+                status: 'open',
+                completedAt: undefined,
+            });
+        }
+        // Revert profile stats
+        const result = (0, profile_1.performUndo)();
+        let output = `\n=== UNDO ===\n`;
+        output += `\nReverted: ${path.basename(lastUndo.path)}`;
+        output += `\n${result.message}`;
+        output += '\n';
         return wrapResult({ output });
     }
     // Deadline command
@@ -482,19 +513,48 @@ async function processCommand(input, currentPath, config, signal, rl) {
         });
         return wrapResult({ output: newIsBoss ? 'Marked as BOSS task (3x XP)' : 'Removed BOSS status' });
     }
-    // Block command
+    // Block command - block <node> or block "reason"
     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;
+        const arg = parts.length > 1 ? parts.slice(1).join(' ') : undefined;
+        let blockedBy = nodeConfig.blockedBy || [];
+        let blockMessage = 'Task marked as blocked';
+        if (arg) {
+            // Check if it's a path to another node
+            const potentialPath = path.join(currentPath, '..', arg);
+            const absolutePath = path.isAbsolute(arg) ? arg : potentialPath;
+            if (fs.existsSync(absolutePath) && fs.statSync(absolutePath).isDirectory()) {
+                // It's a node path
+                const blockerConfig = (0, nodeConfig_1.readNodeConfig)(absolutePath);
+                const blockerName = blockerConfig?.name || path.basename(absolutePath);
+                blockedBy = [...blockedBy, absolutePath];
+                blockMessage = `Blocked by: ${blockerName}`;
+            }
+            else {
+                // Check sibling folder
+                const siblingPath = path.join(path.dirname(currentPath), arg);
+                if (fs.existsSync(siblingPath) && fs.statSync(siblingPath).isDirectory()) {
+                    const blockerConfig = (0, nodeConfig_1.readNodeConfig)(siblingPath);
+                    const blockerName = blockerConfig?.name || arg;
+                    blockedBy = [...blockedBy, siblingPath];
+                    blockMessage = `Blocked by: ${blockerName}`;
+                }
+                else {
+                    // It's a text reason
+                    blockedBy = [...blockedBy, arg];
+                    blockMessage = `Blocked: ${arg}`;
+                }
+            }
+        }
         (0, nodeConfig_1.writeNodeConfig)(currentPath, {
             ...nodeConfig,
             status: 'blocked',
-            blockedBy: reason ? [reason] : nodeConfig.blockedBy,
+            blockedBy,
         });
-        return wrapResult({ output: reason ? `Blocked: ${reason}` : 'Task marked as blocked' });
+        return wrapResult({ output: blockMessage });
     }
     // Unblock command
     if (command === 'unblock') {
@@ -509,6 +569,67 @@ async function processCommand(input, currentPath, config, signal, rl) {
         });
         return wrapResult({ output: 'Task unblocked' });
     }
+    // Check command - show overdue/upcoming deadlines
+    if (command === 'check') {
+        const checkDeadlines = (dirPath, results) => {
+            if (!fs.existsSync(dirPath))
+                return;
+            const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory() || entry.name.startsWith('.'))
+                    continue;
+                const nodePath = path.join(dirPath, entry.name);
+                const cfg = (0, nodeConfig_1.readNodeConfig)(nodePath);
+                if (cfg && cfg.deadline && cfg.status !== 'done') {
+                    const deadlineDate = new Date(cfg.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 <= 3) { // Show tasks due within 3 days or overdue
+                        results.push({
+                            path: nodePath,
+                            name: cfg.name,
+                            deadline: formatDeadline(cfg.deadline),
+                            status: diffDays < 0 ? 'OVERDUE' : diffDays === 0 ? 'TODAY' : 'SOON',
+                        });
+                    }
+                }
+                checkDeadlines(nodePath, results);
+            }
+        };
+        const results = [];
+        checkDeadlines(config.storagePath, results);
+        if (results.length === 0) {
+            return wrapResult({ output: 'No upcoming deadlines within 3 days.' });
+        }
+        const lines = ['', '=== DEADLINE CHECK ===', ''];
+        const overdue = results.filter(r => r.status === 'OVERDUE');
+        const today = results.filter(r => r.status === 'TODAY');
+        const soon = results.filter(r => r.status === 'SOON');
+        if (overdue.length > 0) {
+            lines.push('OVERDUE:');
+            for (const r of overdue) {
+                lines.push(`  ! ${r.name} (${r.deadline})`);
+            }
+            lines.push('');
+        }
+        if (today.length > 0) {
+            lines.push('DUE TODAY:');
+            for (const r of today) {
+                lines.push(`  * ${r.name}`);
+            }
+            lines.push('');
+        }
+        if (soon.length > 0) {
+            lines.push('UPCOMING:');
+            for (const r of soon) {
+                lines.push(`  - ${r.name} (${r.deadline})`);
+            }
+            lines.push('');
+        }
+        return wrapResult({ output: lines.join('\n') });
+    }
     // Status command - show current task status
     if (command === 'status') {
         const nodeConfig = (0, nodeConfig_1.readNodeConfig)(currentPath);
@@ -531,7 +652,15 @@ async function processCommand(input, currentPath, config, signal, rl) {
             lines.push(`Completed: ${new Date(nodeConfig.completedAt).toLocaleDateString()}`);
         }
         if (nodeConfig.blockedBy && nodeConfig.blockedBy.length > 0) {
-            lines.push(`Blocked by: ${nodeConfig.blockedBy.join(', ')}`);
+            // Format blockedBy - show names if paths exist
+            const blockerNames = nodeConfig.blockedBy.map(b => {
+                if (fs.existsSync(b)) {
+                    const cfg = (0, nodeConfig_1.readNodeConfig)(b);
+                    return cfg?.name || path.basename(b);
+                }
+                return b;
+            });
+            lines.push(`Blocked by: ${blockerNames.join(', ')}`);
         }
         lines.push('');
         return wrapResult({ output: lines.join('\n') });
@@ -850,11 +979,13 @@ Navigation:
 Task Management:
   mkdir <name>          Create new task
   done                  Mark current task as completed (recursive)
+  undo                  Undo last done (restores XP)
   deadline <date>       Set deadline (today, tomorrow, +3d, Jan 15)
   boss                  Toggle boss/milestone status (3x XP)
-  block [reason]        Mark task as blocked
+  block [node]          Block by task (or text reason)
   unblock               Remove blocked status
   status                Show current task details
+  check                 Show overdue/upcoming deadlines
 
 File Operations:
   cp <src> <dest>       Copy file or folder
@@ -885,11 +1016,11 @@ Clipboard:
   <cmd> | pbcopy        Copy output (macOS)
   <cmd> | clip          Copy output (Windows)
 
-Deadlines:
-  deadline today        Due today
-  deadline tomorrow     Due tomorrow
+Examples:
+  block backend-api     Block current task by sibling task
+  block "waiting for design"   Block with text reason
   deadline +3d          Due in 3 days
-  deadline Jan 15       Due on date
+  check                 See all upcoming deadlines
 
 www.rlc.rocks
 `.trim()

package/dist/interactive/startup.js

@@ -20,8 +20,8 @@ const ASCII_ART = [
     '╚═════════════════════════╝',
     '',
     '  Navigation: ls, cd, tree, pwd, open',
-    '  Tasks: done, deadline, boss, block, status',
-    '  Gamification: stats, achievements, map',
+    '  Tasks: done, undo, deadline, boss, block',
+    '  Gamification: stats, achievements, map, check',
     '',
     '  TAB to autocomplete, | pbcopy to copy',
     '  Workflow: <description> -> refine -> save',

package/dist/storage/profile.js

@@ -43,6 +43,9 @@ exports.addXP = addXP;
 exports.completeTask = completeTask;
 exports.formatStats = formatStats;
 exports.formatAchievements = formatAchievements;
+exports.addToUndoHistory = addToUndoHistory;
+exports.getLastUndo = getLastUndo;
+exports.performUndo = performUndo;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
@@ -127,6 +130,7 @@ function createDefaultProfile() {
         currentStreak: 0,
         longestStreak: 0,
         achievements: [],
+        undoHistory: [],
         stats: {
             completedByDay: {},
             createdAt: new Date().toISOString(),
@@ -274,3 +278,46 @@ function formatAchievements() {
     lines.push('');
     return lines.join('\n');
 }
+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) {
+        profile.undoHistory = profile.undoHistory.slice(0, 10);
+    }
+    saveProfile(profile);
+}
+function getLastUndo() {
+    const profile = readProfile();
+    if (!profile.undoHistory || profile.undoHistory.length === 0) {
+        return null;
+    }
+    return profile.undoHistory[0];
+}
+function performUndo() {
+    const profile = readProfile();
+    if (!profile.undoHistory || profile.undoHistory.length === 0) {
+        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);
+    }
+    saveProfile(profile);
+    return {
+        success: true,
+        entry,
+        message: `Undo: -${entry.xpLost} XP`
+    };
+}

package/package.json

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

package/src/interactive/commands.ts

@@ -6,7 +6,7 @@ import { Config } from '../config/config';
 import { listSchemas, navigateToNode, getTree } from '../storage/storage';
 import { saveSchemaFile, writeNodeConfig, readNodeConfig, calculateXP, saveMapFile, NodeConfig } from '../storage/nodeConfig';
 import { generateSchemaWithAI, generateDungeonMapWithAI } from '../ai/claude';
-import { completeTask, formatStats, formatAchievements, readProfile } from '../storage/profile';
+import { completeTask, formatStats, formatAchievements, readProfile, addToUndoHistory, performUndo, getLastUndo } from '../storage/profile';
 
 // Parse tree ASCII art and create folder structure
 function createFoldersFromTree(rootPath: string, treeContent: string): void {
@@ -505,6 +505,14 @@ export async function processCommand(
       nodeConfig.createdAt
     );
     
+    // Save to undo history
+    addToUndoHistory({
+      path: currentPath,
+      xpLost: result.xpGained,
+      wasBoss: nodeConfig.isBoss || false,
+      timestamp: new Date().toISOString(),
+    });
+    
     let output = `\n=== TASK COMPLETED ===\n`;
     output += `\nTasks completed: ${result.tasksCompleted}`;
     if (result.bossesDefeated > 0) {
@@ -524,6 +532,35 @@ export async function processCommand(
       }
     }
     
+    output += '\n';
+    output += '[Type "undo" to revert]';
+    
+    return wrapResult({ output });
+  }
+  
+  // Undo command
+  if (command === 'undo') {
+    const lastUndo = getLastUndo();
+    if (!lastUndo) {
+      return wrapResult({ output: 'Nothing to undo.' });
+    }
+    
+    // Revert the task status
+    const nodeConfig = readNodeConfig(lastUndo.path);
+    if (nodeConfig) {
+      writeNodeConfig(lastUndo.path, {
+        ...nodeConfig,
+        status: 'open',
+        completedAt: undefined,
+      });
+    }
+    
+    // Revert profile stats
+    const result = performUndo();
+    
+    let output = `\n=== UNDO ===\n`;
+    output += `\nReverted: ${path.basename(lastUndo.path)}`;
+    output += `\n${result.message}`;
     output += '\n';
     
     return wrapResult({ output });
@@ -574,22 +611,51 @@ export async function processCommand(
     return wrapResult({ output: newIsBoss ? 'Marked as BOSS task (3x XP)' : 'Removed BOSS status' });
   }
   
-  // Block command
+  // Block command - block <node> or block "reason"
   if (command === 'block') {
     const nodeConfig = readNodeConfig(currentPath);
     if (!nodeConfig) {
       return wrapResult({ output: 'No task at current location.' });
     }
     
-    const reason = parts.length > 1 ? parts.slice(1).join(' ') : undefined;
+    const arg = parts.length > 1 ? parts.slice(1).join(' ') : undefined;
+    let blockedBy: string[] = nodeConfig.blockedBy || [];
+    let blockMessage = 'Task marked as blocked';
+    
+    if (arg) {
+      // Check if it's a path to another node
+      const potentialPath = path.join(currentPath, '..', arg);
+      const absolutePath = path.isAbsolute(arg) ? arg : potentialPath;
+      
+      if (fs.existsSync(absolutePath) && fs.statSync(absolutePath).isDirectory()) {
+        // It's a node path
+        const blockerConfig = readNodeConfig(absolutePath);
+        const blockerName = blockerConfig?.name || path.basename(absolutePath);
+        blockedBy = [...blockedBy, absolutePath];
+        blockMessage = `Blocked by: ${blockerName}`;
+      } else {
+        // Check sibling folder
+        const siblingPath = path.join(path.dirname(currentPath), arg);
+        if (fs.existsSync(siblingPath) && fs.statSync(siblingPath).isDirectory()) {
+          const blockerConfig = readNodeConfig(siblingPath);
+          const blockerName = blockerConfig?.name || arg;
+          blockedBy = [...blockedBy, siblingPath];
+          blockMessage = `Blocked by: ${blockerName}`;
+        } else {
+          // It's a text reason
+          blockedBy = [...blockedBy, arg];
+          blockMessage = `Blocked: ${arg}`;
+        }
+      }
+    }
     
     writeNodeConfig(currentPath, {
       ...nodeConfig,
       status: 'blocked',
-      blockedBy: reason ? [reason] : nodeConfig.blockedBy,
+      blockedBy,
     });
     
-    return wrapResult({ output: reason ? `Blocked: ${reason}` : 'Task marked as blocked' });
+    return wrapResult({ output: blockMessage });
   }
   
   // Unblock command
@@ -608,6 +674,80 @@ export async function processCommand(
     return wrapResult({ output: 'Task unblocked' });
   }
   
+  // Check command - show overdue/upcoming deadlines
+  if (command === 'check') {
+    const checkDeadlines = (dirPath: string, results: { path: string; name: string; deadline: string; status: string }[]) => {
+      if (!fs.existsSync(dirPath)) return;
+      
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+        
+        const nodePath = path.join(dirPath, entry.name);
+        const cfg = readNodeConfig(nodePath);
+        
+        if (cfg && cfg.deadline && cfg.status !== 'done') {
+          const deadlineDate = new Date(cfg.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 <= 3) { // Show tasks due within 3 days or overdue
+            results.push({
+              path: nodePath,
+              name: cfg.name,
+              deadline: formatDeadline(cfg.deadline),
+              status: diffDays < 0 ? 'OVERDUE' : diffDays === 0 ? 'TODAY' : 'SOON',
+            });
+          }
+        }
+        
+        checkDeadlines(nodePath, results);
+      }
+    };
+    
+    const results: { path: string; name: string; deadline: string; status: string }[] = [];
+    checkDeadlines(config.storagePath, results);
+    
+    if (results.length === 0) {
+      return wrapResult({ output: 'No upcoming deadlines within 3 days.' });
+    }
+    
+    const lines: string[] = ['', '=== DEADLINE CHECK ===', ''];
+    
+    const overdue = results.filter(r => r.status === 'OVERDUE');
+    const today = results.filter(r => r.status === 'TODAY');
+    const soon = results.filter(r => r.status === 'SOON');
+    
+    if (overdue.length > 0) {
+      lines.push('OVERDUE:');
+      for (const r of overdue) {
+        lines.push(`  ! ${r.name} (${r.deadline})`);
+      }
+      lines.push('');
+    }
+    
+    if (today.length > 0) {
+      lines.push('DUE TODAY:');
+      for (const r of today) {
+        lines.push(`  * ${r.name}`);
+      }
+      lines.push('');
+    }
+    
+    if (soon.length > 0) {
+      lines.push('UPCOMING:');
+      for (const r of soon) {
+        lines.push(`  - ${r.name} (${r.deadline})`);
+      }
+      lines.push('');
+    }
+    
+    return wrapResult({ output: lines.join('\n') });
+  }
+  
   // Status command - show current task status
   if (command === 'status') {
     const nodeConfig = readNodeConfig(currentPath);
@@ -635,7 +775,15 @@ export async function processCommand(
     }
     
     if (nodeConfig.blockedBy && nodeConfig.blockedBy.length > 0) {
-      lines.push(`Blocked by: ${nodeConfig.blockedBy.join(', ')}`);
+      // Format blockedBy - show names if paths exist
+      const blockerNames = nodeConfig.blockedBy.map(b => {
+        if (fs.existsSync(b)) {
+          const cfg = readNodeConfig(b);
+          return cfg?.name || path.basename(b);
+        }
+        return b;
+      });
+      lines.push(`Blocked by: ${blockerNames.join(', ')}`);
     }
     
     lines.push('');
@@ -1015,11 +1163,13 @@ Navigation:
 Task Management:
   mkdir <name>          Create new task
   done                  Mark current task as completed (recursive)
+  undo                  Undo last done (restores XP)
   deadline <date>       Set deadline (today, tomorrow, +3d, Jan 15)
   boss                  Toggle boss/milestone status (3x XP)
-  block [reason]        Mark task as blocked
+  block [node]          Block by task (or text reason)
   unblock               Remove blocked status
   status                Show current task details
+  check                 Show overdue/upcoming deadlines
 
 File Operations:
   cp <src> <dest>       Copy file or folder
@@ -1050,11 +1200,11 @@ Clipboard:
   <cmd> | pbcopy        Copy output (macOS)
   <cmd> | clip          Copy output (Windows)
 
-Deadlines:
-  deadline today        Due today
-  deadline tomorrow     Due tomorrow
+Examples:
+  block backend-api     Block current task by sibling task
+  block "waiting for design"   Block with text reason
   deadline +3d          Due in 3 days
-  deadline Jan 15       Due on date
+  check                 See all upcoming deadlines
 
 www.rlc.rocks
 `.trim()

package/src/interactive/startup.ts

@@ -18,8 +18,8 @@ const ASCII_ART = [
   '╚═════════════════════════╝',
   '',
   '  Navigation: ls, cd, tree, pwd, open',
-  '  Tasks: done, deadline, boss, block, status',
-  '  Gamification: stats, achievements, map',
+  '  Tasks: done, undo, deadline, boss, block',
+  '  Gamification: stats, achievements, map, check',
   '',
   '  TAB to autocomplete, | pbcopy to copy',
   '  Workflow: <description> -> refine -> save',

package/src/storage/profile.ts

@@ -9,6 +9,13 @@ export interface Achievement {
   unlockedAt?: string;
 }
 
+export interface UndoEntry {
+  path: string;
+  xpLost: number;
+  wasBoss: boolean;
+  timestamp: string;
+}
+
 export interface Profile {
   totalXP: number;
   level: number;
@@ -18,6 +25,7 @@ export interface Profile {
   longestStreak: number;
   lastCompletionDate?: string;
   achievements: string[];
+  undoHistory: UndoEntry[];
   stats: {
     completedByDay: Record<string, number>;
     createdAt: string;
@@ -114,6 +122,7 @@ function createDefaultProfile(): Profile {
     currentStreak: 0,
     longestStreak: 0,
     achievements: [],
+    undoHistory: [],
     stats: {
       completedByDay: {},
       createdAt: new Date().toISOString(),
@@ -279,3 +288,59 @@ export function formatAchievements(): string {
   return lines.join('\n');
 }
 
+export function addToUndoHistory(entry: UndoEntry): void {
+  const profile = readProfile();
+  
+  // Keep only last 10 undo entries
+  profile.undoHistory = profile.undoHistory || [];
+  profile.undoHistory.unshift(entry);
+  if (profile.undoHistory.length > 10) {
+    profile.undoHistory = profile.undoHistory.slice(0, 10);
+  }
+  
+  saveProfile(profile);
+}
+
+export function getLastUndo(): UndoEntry | null {
+  const profile = readProfile();
+  if (!profile.undoHistory || profile.undoHistory.length === 0) {
+    return null;
+  }
+  return profile.undoHistory[0];
+}
+
+export function performUndo(): { success: boolean; entry: UndoEntry | null; message: string } {
+  const profile = readProfile();
+  
+  if (!profile.undoHistory || profile.undoHistory.length === 0) {
+    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);
+  }
+  
+  saveProfile(profile);
+  
+  return { 
+    success: true, 
+    entry, 
+    message: `Undo: -${entry.xpLost} XP` 
+  };
+}
+