@brainfile/cli 0.9.2 → 0.10.0

package/dist/tui/hooks/useKeyboardNavigation.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useKeyboardNavigation = useKeyboardNavigation;
 const ink_1 = require("ink");
 const actions_js_1 = require("../actions.js");
+const RULE_TYPES = ['always', 'never', 'prefer', 'context'];
 // Helper to show status message
 function showStatus(setState, text, type) {
     const timestamp = Date.now();
@@ -173,7 +174,7 @@ function useKeyboardNavigation({ state, setState, currentTasks, maxTaskIndex, fi
             }
             return;
         }
-        // Search mode handling
+        // Search mode handling (Tasks panel)
         if (state.mode === 'search') {
             if (key.escape) {
                 setState(prev => ({ ...prev, mode: 'browse', searchQuery: '' }));
@@ -193,7 +194,162 @@ function useKeyboardNavigation({ state, setState, currentTasks, maxTaskIndex, fi
             }
             return;
         }
-        // Browse mode
+        // Rule add/edit mode
+        if (state.mode === 'rule-add' || state.mode === 'rule-edit') {
+            if (key.escape) {
+                setState(prev => ({ ...prev, mode: 'browse', ruleEditText: '', ruleEditId: null }));
+                return;
+            }
+            if (key.return) {
+                const text = state.ruleEditText.trim();
+                if (!text) {
+                    showStatus(setState, 'Rule text required', 'error');
+                    return;
+                }
+                if (state.mode === 'rule-add') {
+                    const result = (0, actions_js_1.addRuleAction)(filePath, state.activeRuleType, text);
+                    if (result.success) {
+                        showStatus(setState, result.message || 'Rule added', 'success');
+                        loadBrainfile(true);
+                    }
+                    else {
+                        showStatus(setState, result.error || 'Failed to add rule', 'error');
+                    }
+                }
+                else if (state.ruleEditId !== null) {
+                    const result = (0, actions_js_1.updateRuleAction)(filePath, state.activeRuleType, state.ruleEditId, text);
+                    if (result.success) {
+                        showStatus(setState, result.message || 'Rule updated', 'success');
+                        loadBrainfile(true);
+                    }
+                    else {
+                        showStatus(setState, result.error || 'Failed to update rule', 'error');
+                    }
+                }
+                setState(prev => ({ ...prev, mode: 'browse', ruleEditText: '', ruleEditId: null }));
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setState(prev => ({ ...prev, ruleEditText: prev.ruleEditText.slice(0, -1) }));
+                return;
+            }
+            if (input && !key.ctrl && !key.meta) {
+                setState(prev => ({ ...prev, ruleEditText: prev.ruleEditText + input }));
+                return;
+            }
+            return;
+        }
+        // Rule delete confirmation
+        if (state.mode === 'rule-delete-confirm') {
+            const rules = state.board?.rules?.[state.activeRuleType] || [];
+            const rule = rules[state.selectedRuleIndex];
+            if (input === 'y' || input === 'Y') {
+                if (rule) {
+                    const result = (0, actions_js_1.deleteRuleAction)(filePath, state.activeRuleType, rule.id);
+                    if (result.success) {
+                        showStatus(setState, result.message || 'Rule deleted', 'success');
+                        loadBrainfile(true);
+                        // Adjust selection if needed
+                        setState(prev => ({
+                            ...prev,
+                            mode: 'browse',
+                            selectedRuleIndex: Math.max(0, prev.selectedRuleIndex - 1),
+                        }));
+                    }
+                    else {
+                        showStatus(setState, result.error || 'Failed to delete rule', 'error');
+                        setState(prev => ({ ...prev, mode: 'browse' }));
+                    }
+                }
+                return;
+            }
+            if (input === 'n' || input === 'N' || key.escape) {
+                setState(prev => ({ ...prev, mode: 'browse' }));
+                showStatus(setState, 'Delete cancelled', 'info');
+                return;
+            }
+            return;
+        }
+        // Archive restore mode - column picker
+        if (state.mode === 'archive-restore') {
+            if (key.escape) {
+                setState(prev => ({ ...prev, mode: 'browse' }));
+                return;
+            }
+            if (key.downArrow || input === 'j') {
+                setState(prev => ({
+                    ...prev,
+                    archiveRestoreColumnIndex: Math.min(prev.archiveRestoreColumnIndex + 1, allColumns.length - 1),
+                }));
+                return;
+            }
+            if (key.upArrow || input === 'k') {
+                setState(prev => ({
+                    ...prev,
+                    archiveRestoreColumnIndex: Math.max(prev.archiveRestoreColumnIndex - 1, 0),
+                }));
+                return;
+            }
+            if (key.return) {
+                const task = state.archive[state.selectedArchiveIndex];
+                const column = allColumns[state.archiveRestoreColumnIndex];
+                if (task && column) {
+                    const result = (0, actions_js_1.restoreTaskAction)(filePath, task.id, column.id);
+                    if (result.success) {
+                        showStatus(setState, result.message || 'Task restored', 'success');
+                        loadBrainfile(true);
+                        // Reload archive
+                        const archiveResult = (0, actions_js_1.loadArchive)(filePath);
+                        setState(prev => ({
+                            ...prev,
+                            mode: 'browse',
+                            archive: archiveResult.archive,
+                            selectedArchiveIndex: Math.max(0, prev.selectedArchiveIndex - 1),
+                        }));
+                    }
+                    else {
+                        showStatus(setState, result.error || 'Failed to restore task', 'error');
+                        setState(prev => ({ ...prev, mode: 'browse' }));
+                    }
+                }
+                return;
+            }
+            return;
+        }
+        // Archive delete confirmation
+        if (state.mode === 'archive-delete-confirm') {
+            const task = state.archive[state.selectedArchiveIndex];
+            if (input === 'y' || input === 'Y') {
+                if (task) {
+                    const result = (0, actions_js_1.deleteArchivedTaskAction)(filePath, task.id);
+                    if (result.success) {
+                        showStatus(setState, result.message || 'Task permanently deleted', 'success');
+                        // Reload archive
+                        const archiveResult = (0, actions_js_1.loadArchive)(filePath);
+                        setState(prev => ({
+                            ...prev,
+                            mode: 'browse',
+                            archive: archiveResult.archive,
+                            selectedArchiveIndex: Math.max(0, prev.selectedArchiveIndex - 1),
+                        }));
+                    }
+                    else {
+                        showStatus(setState, result.error || 'Failed to delete task', 'error');
+                        setState(prev => ({ ...prev, mode: 'browse' }));
+                    }
+                }
+                return;
+            }
+            if (input === 'n' || input === 'N' || key.escape) {
+                setState(prev => ({ ...prev, mode: 'browse' }));
+                showStatus(setState, 'Delete cancelled', 'info');
+                return;
+            }
+            return;
+        }
+        // ============================================================
+        // GLOBAL KEYS (work in browse mode across all panels)
+        // ============================================================
         if (input === 'q' || (key.ctrl && input === 'c')) {
             exit();
             return;
@@ -202,232 +358,402 @@ function useKeyboardNavigation({ state, setState, currentTasks, maxTaskIndex, fi
             setState(prev => ({ ...prev, mode: 'help' }));
             return;
         }
-        if (input === '/') {
-            setState(prev => ({ ...prev, mode: 'search', searchQuery: '' }));
+        // Panel switching: 1/2/3
+        if (input === '1') {
+            setState(prev => ({ ...prev, activePanel: 'tasks', mode: 'browse' }));
+            return;
+        }
+        if (input === '2') {
+            setState(prev => ({ ...prev, activePanel: 'rules', mode: 'browse' }));
+            return;
+        }
+        if (input === '3') {
+            setState(prev => ({ ...prev, activePanel: 'archive', mode: 'browse' }));
+            // Archive is loaded via useEffect in BrainfileTUI
             return;
         }
         // Refresh (force refresh bypasses hash check)
-        if (input === 'r') {
+        if (input === 'r' && state.activePanel !== 'archive') {
             loadBrainfile(true);
             showStatus(setState, 'Refreshed', 'info');
             return;
         }
-        // === Task Management Keys ===
-        // 'e' - Edit task in $EDITOR (blocks until editor closes)
-        if (input === 'e') {
-            if (!currentTask) {
-                showStatus(setState, 'No task selected', 'error');
+        // ============================================================
+        // TASKS PANEL - Browse mode
+        // ============================================================
+        if (state.activePanel === 'tasks') {
+            if (input === '/') {
+                setState(prev => ({ ...prev, mode: 'search', searchQuery: '' }));
                 return;
             }
-            // spawnSync blocks the entire process, giving terminal to editor
-            const result = (0, actions_js_1.editTaskInEditor)(filePath, currentTask.id);
-            if (result.success) {
-                showStatus(setState, result.message || 'Task updated', 'success');
-                loadBrainfile(true);
+            // 'e' - Edit task in $EDITOR
+            if (input === 'e') {
+                if (!currentTask) {
+                    showStatus(setState, 'No task selected', 'error');
+                    return;
+                }
+                const result = (0, actions_js_1.editTaskInEditor)(filePath, currentTask.id);
+                if (result.success) {
+                    showStatus(setState, result.message || 'Task updated', 'success');
+                    loadBrainfile(true);
+                }
+                else {
+                    showStatus(setState, result.error || 'Edit failed', 'error');
+                }
+                return;
             }
-            else {
-                showStatus(setState, result.error || 'Edit failed', 'error');
+            // 'm' - Move task
+            if (input === 'm') {
+                if (!currentTask) {
+                    showStatus(setState, 'No task selected', 'error');
+                    return;
+                }
+                setState(prev => ({ ...prev, mode: 'move', moveTargetIndex: prev.activeColumnIndex }));
+                return;
             }
-            return;
-        }
-        // 'm' - Move task (open column picker)
-        if (input === 'm') {
-            if (!currentTask) {
-                showStatus(setState, 'No task selected', 'error');
+            // 'd' - Delete task
+            if (input === 'd') {
+                if (!currentTask) {
+                    showStatus(setState, 'No task selected', 'error');
+                    return;
+                }
+                setState(prev => ({ ...prev, mode: 'delete-confirm' }));
                 return;
             }
-            setState(prev => ({ ...prev, mode: 'move', moveTargetIndex: prev.activeColumnIndex }));
-            return;
-        }
-        // 'd' - Delete task (with confirmation)
-        if (input === 'd') {
-            if (!currentTask) {
-                showStatus(setState, 'No task selected', 'error');
+            // 'A' - Archive task
+            if (input === 'A') {
+                if (!currentTask) {
+                    showStatus(setState, 'No task selected', 'error');
+                    return;
+                }
+                const result = (0, actions_js_1.archiveTaskAction)(filePath, currentTask.id);
+                if (result.success) {
+                    showStatus(setState, result.message || 'Task archived', 'success');
+                    loadBrainfile(true);
+                }
+                else {
+                    showStatus(setState, result.error || 'Archive failed', 'error');
+                }
                 return;
             }
-            setState(prev => ({ ...prev, mode: 'delete-confirm' }));
-            return;
-        }
-        // 'a' - Archive task
-        if (input === 'a') {
-            if (!currentTask) {
-                showStatus(setState, 'No task selected', 'error');
+            // 'p' - Cycle priority
+            if (input === 'p') {
+                if (!currentTask) {
+                    showStatus(setState, 'No task selected', 'error');
+                    return;
+                }
+                const result = (0, actions_js_1.cyclePriorityAction)(filePath, currentTask.id);
+                if (result.success) {
+                    showStatus(setState, result.message || 'Priority updated', 'success');
+                    loadBrainfile(true);
+                }
+                else {
+                    showStatus(setState, result.error || 'Failed to update priority', 'error');
+                }
                 return;
             }
-            const result = (0, actions_js_1.archiveTaskAction)(filePath, currentTask.id);
-            if (result.success) {
-                showStatus(setState, result.message || 'Task archived', 'success');
-                loadBrainfile(true);
+            // 't' - Toggle subtask
+            if (input === 't') {
+                if (!currentTask) {
+                    showStatus(setState, 'No task selected', 'error');
+                    return;
+                }
+                if (!currentTask.subtasks || currentTask.subtasks.length === 0) {
+                    showStatus(setState, 'No subtasks', 'info');
+                    return;
+                }
+                setState(prev => ({ ...prev, mode: 'subtask', selectedSubtaskIndex: 0 }));
+                return;
             }
-            else {
-                showStatus(setState, result.error || 'Archive failed', 'error');
+            // 'y' - Copy task ID
+            if (input === 'y') {
+                if (!currentTask) {
+                    showStatus(setState, 'No task selected', 'error');
+                    return;
+                }
+                const result = (0, actions_js_1.copyToClipboard)(currentTask.id);
+                if (result.success) {
+                    showStatus(setState, `Copied ${currentTask.id}`, 'success');
+                }
+                else {
+                    showStatus(setState, result.error || 'Copy failed', 'error');
+                }
+                return;
             }
-            return;
-        }
-        // 'p' - Cycle priority
-        if (input === 'p') {
-            if (!currentTask) {
-                showStatus(setState, 'No task selected', 'error');
+            // 'n' - New task (quick)
+            if (input === 'n') {
+                setState(prev => ({ ...prev, mode: 'new-task', newTaskTitle: '' }));
                 return;
             }
-            const result = (0, actions_js_1.cyclePriorityAction)(filePath, currentTask.id);
-            if (result.success) {
-                showStatus(setState, result.message || 'Priority updated', 'success');
-                loadBrainfile(true);
+            // 'N' - New task (editor)
+            if (input === 'N') {
+                const currentCol = allColumns[state.activeColumnIndex];
+                if (currentCol) {
+                    const result = (0, actions_js_1.newTaskInEditor)(filePath, currentCol.id);
+                    if (result.success) {
+                        showStatus(setState, result.message || 'Task created', 'success');
+                        loadBrainfile(true);
+                    }
+                    else {
+                        showStatus(setState, result.error || 'Failed to create task', 'error');
+                    }
+                }
+                return;
             }
-            else {
-                showStatus(setState, result.error || 'Failed to update priority', 'error');
+            // Navigation: up/down
+            if (key.downArrow || input === 'j') {
+                setState(prev => ({
+                    ...prev,
+                    selectedTaskIndex: Math.min(prev.selectedTaskIndex + 1, maxTaskIndex),
+                }));
+                return;
             }
-            return;
-        }
-        // 't' - Toggle subtask (open subtask picker if has subtasks)
-        if (input === 't') {
-            if (!currentTask) {
-                showStatus(setState, 'No task selected', 'error');
+            if (key.upArrow || input === 'k') {
+                setState(prev => ({
+                    ...prev,
+                    selectedTaskIndex: Math.max(prev.selectedTaskIndex - 1, 0),
+                }));
                 return;
             }
-            if (!currentTask.subtasks || currentTask.subtasks.length === 0) {
-                showStatus(setState, 'No subtasks', 'info');
+            // Page scrolling
+            if (key.ctrl && input === 'd') {
+                setState(prev => ({
+                    ...prev,
+                    selectedTaskIndex: Math.min(prev.selectedTaskIndex + Math.floor(viewportHeight / 2), maxTaskIndex),
+                }));
                 return;
             }
-            setState(prev => ({ ...prev, mode: 'subtask', selectedSubtaskIndex: 0 }));
-            return;
-        }
-        // 'y' - Yank/copy task ID to clipboard
-        if (input === 'y') {
-            if (!currentTask) {
-                showStatus(setState, 'No task selected', 'error');
+            if (key.ctrl && input === 'u') {
+                setState(prev => ({
+                    ...prev,
+                    selectedTaskIndex: Math.max(prev.selectedTaskIndex - Math.floor(viewportHeight / 2), 0),
+                }));
+                return;
+            }
+            // Column switching
+            if (key.tab || key.rightArrow || input === 'l') {
+                setState(prev => ({
+                    ...prev,
+                    activeColumnIndex: (prev.activeColumnIndex + 1) % filteredColumnsLength,
+                    selectedTaskIndex: 0,
+                }));
                 return;
             }
-            const result = (0, actions_js_1.copyToClipboard)(currentTask.id);
-            if (result.success) {
-                showStatus(setState, `Copied ${currentTask.id}`, 'success');
+            if ((key.shift && key.tab) || key.leftArrow || input === 'h') {
+                setState(prev => ({
+                    ...prev,
+                    activeColumnIndex: prev.activeColumnIndex === 0
+                        ? filteredColumnsLength - 1
+                        : prev.activeColumnIndex - 1,
+                    selectedTaskIndex: 0,
+                }));
+                return;
             }
-            else {
-                showStatus(setState, result.error || 'Copy failed', 'error');
+            // Home/End
+            if (input === 'g') {
+                setState(prev => ({ ...prev, selectedTaskIndex: 0 }));
+                return;
+            }
+            if (input === 'G') {
+                setState(prev => ({ ...prev, selectedTaskIndex: maxTaskIndex }));
+                return;
+            }
+            // Expand/collapse task
+            if (key.return) {
+                const task = currentTasks[state.selectedTaskIndex];
+                if (task) {
+                    setState(prev => {
+                        const newExpanded = new Set(prev.expandedTaskIds);
+                        if (newExpanded.has(task.id)) {
+                            newExpanded.delete(task.id);
+                        }
+                        else {
+                            newExpanded.add(task.id);
+                        }
+                        return { ...prev, expandedTaskIds: newExpanded };
+                    });
+                }
+                return;
+            }
+            // Escape: collapse all or clear search
+            if (key.escape) {
+                setState(prev => ({
+                    ...prev,
+                    expandedTaskIds: new Set(),
+                    searchQuery: '',
+                }));
+                return;
             }
-            return;
-        }
-        // 'n' - New task (quick add - title only)
-        if (input === 'n') {
-            setState(prev => ({ ...prev, mode: 'new-task', newTaskTitle: '' }));
-            return;
         }
-        // 'N' - New task (full editor)
-        if (input === 'N') {
-            const currentCol = allColumns[state.activeColumnIndex];
-            if (currentCol) {
-                const result = (0, actions_js_1.newTaskInEditor)(filePath, currentCol.id);
-                if (result.success) {
-                    showStatus(setState, result.message || 'Task created', 'success');
-                    loadBrainfile(true);
+        // ============================================================
+        // RULES PANEL - Browse mode
+        // ============================================================
+        if (state.activePanel === 'rules') {
+            const rules = state.board?.rules?.[state.activeRuleType] || [];
+            const maxRuleIndex = Math.max(0, rules.length - 1);
+            // h/l or left/right to switch rule type
+            if (key.leftArrow || input === 'h') {
+                const currentIdx = RULE_TYPES.indexOf(state.activeRuleType);
+                const newIdx = currentIdx === 0 ? RULE_TYPES.length - 1 : currentIdx - 1;
+                setState(prev => ({ ...prev, activeRuleType: RULE_TYPES[newIdx], selectedRuleIndex: 0 }));
+                return;
+            }
+            if (key.rightArrow || input === 'l') {
+                const currentIdx = RULE_TYPES.indexOf(state.activeRuleType);
+                const newIdx = (currentIdx + 1) % RULE_TYPES.length;
+                setState(prev => ({ ...prev, activeRuleType: RULE_TYPES[newIdx], selectedRuleIndex: 0 }));
+                return;
+            }
+            // j/k to navigate rules
+            if (key.downArrow || input === 'j') {
+                setState(prev => ({
+                    ...prev,
+                    selectedRuleIndex: Math.min(prev.selectedRuleIndex + 1, maxRuleIndex),
+                }));
+                return;
+            }
+            if (key.upArrow || input === 'k') {
+                setState(prev => ({
+                    ...prev,
+                    selectedRuleIndex: Math.max(prev.selectedRuleIndex - 1, 0),
+                }));
+                return;
+            }
+            // n - New rule
+            if (input === 'n') {
+                setState(prev => ({ ...prev, mode: 'rule-add', ruleEditText: '', ruleEditId: null }));
+                return;
+            }
+            // e - Edit rule
+            if (input === 'e') {
+                const rule = rules[state.selectedRuleIndex];
+                if (rule) {
+                    setState(prev => ({
+                        ...prev,
+                        mode: 'rule-edit',
+                        ruleEditText: rule.rule,
+                        ruleEditId: rule.id,
+                    }));
                 }
                 else {
-                    showStatus(setState, result.error || 'Failed to create task', 'error');
+                    showStatus(setState, 'No rule selected', 'error');
                 }
+                return;
             }
-            return;
-        }
-        // Navigation: up/down through tasks
-        if (key.downArrow || input === 'j') {
-            setState(prev => ({
-                ...prev,
-                selectedTaskIndex: Math.min(prev.selectedTaskIndex + 1, maxTaskIndex),
-            }));
-            return;
-        }
-        if (key.upArrow || input === 'k') {
-            setState(prev => ({
-                ...prev,
-                selectedTaskIndex: Math.max(prev.selectedTaskIndex - 1, 0),
-            }));
-            return;
-        }
-        // Page scrolling
-        if (key.ctrl && input === 'd') {
-            setState(prev => ({
-                ...prev,
-                selectedTaskIndex: Math.min(prev.selectedTaskIndex + Math.floor(viewportHeight / 2), maxTaskIndex),
-            }));
-            return;
-        }
-        if (key.ctrl && input === 'u') {
-            setState(prev => ({
-                ...prev,
-                selectedTaskIndex: Math.max(prev.selectedTaskIndex - Math.floor(viewportHeight / 2), 0),
-            }));
-            return;
-        }
-        // Column switching: TAB / left/right
-        if (key.tab || key.rightArrow || input === 'l') {
-            setState(prev => ({
-                ...prev,
-                activeColumnIndex: (prev.activeColumnIndex + 1) % filteredColumnsLength,
-                selectedTaskIndex: 0,
-            }));
-            return;
-        }
-        if ((key.shift && key.tab) || key.leftArrow || input === 'h') {
-            setState(prev => ({
-                ...prev,
-                activeColumnIndex: prev.activeColumnIndex === 0
-                    ? filteredColumnsLength - 1
-                    : prev.activeColumnIndex - 1,
-                selectedTaskIndex: 0,
-            }));
-            return;
-        }
-        // Jump to column headers with { and }
-        if (input === '{') {
-            setState(prev => ({
-                ...prev,
-                activeColumnIndex: Math.max(0, prev.activeColumnIndex - 1),
-                selectedTaskIndex: 0,
-            }));
-            return;
-        }
-        if (input === '}') {
-            setState(prev => ({
-                ...prev,
-                activeColumnIndex: Math.min(filteredColumnsLength - 1, prev.activeColumnIndex + 1),
-                selectedTaskIndex: 0,
-            }));
-            return;
-        }
-        // Home/End
-        if (input === 'g') {
-            setState(prev => ({ ...prev, selectedTaskIndex: 0 }));
-            return;
-        }
-        if (input === 'G') {
-            setState(prev => ({ ...prev, selectedTaskIndex: maxTaskIndex }));
-            return;
-        }
-        // Expand/collapse task
-        if (key.return) {
-            const task = currentTasks[state.selectedTaskIndex];
-            if (task) {
-                setState(prev => {
-                    const newExpanded = new Set(prev.expandedTaskIds);
-                    if (newExpanded.has(task.id)) {
-                        newExpanded.delete(task.id);
-                    }
-                    else {
-                        newExpanded.add(task.id);
-                    }
-                    return { ...prev, expandedTaskIds: newExpanded };
-                });
+            // d - Delete rule
+            if (input === 'd') {
+                const rule = rules[state.selectedRuleIndex];
+                if (rule) {
+                    setState(prev => ({ ...prev, mode: 'rule-delete-confirm' }));
+                }
+                else {
+                    showStatus(setState, 'No rule selected', 'error');
+                }
+                return;
+            }
+            // Home/End
+            if (input === 'g') {
+                setState(prev => ({ ...prev, selectedRuleIndex: 0 }));
+                return;
+            }
+            if (input === 'G') {
+                setState(prev => ({ ...prev, selectedRuleIndex: maxRuleIndex }));
+                return;
+            }
+            // Escape
+            if (key.escape) {
+                setState(prev => ({ ...prev, selectedRuleIndex: 0 }));
+                return;
             }
-            return;
         }
-        // Escape: collapse all or clear search
-        if (key.escape) {
-            setState(prev => ({
-                ...prev,
-                expandedTaskIds: new Set(),
-                searchQuery: '',
-            }));
-            return;
+        // ============================================================
+        // ARCHIVE PANEL - Browse mode
+        // ============================================================
+        if (state.activePanel === 'archive') {
+            const maxArchiveIndex = Math.max(0, state.archive.length - 1);
+            // / - Search archive
+            if (input === '/') {
+                // Archive search is inline in the panel, just focus on it
+                // For simplicity, we'll clear and let user type
+                setState(prev => ({ ...prev, archiveSearchQuery: '' }));
+                showStatus(setState, 'Type to search archive', 'info');
+                return;
+            }
+            // r - Refresh archive
+            if (input === 'r') {
+                const result = (0, actions_js_1.loadArchive)(filePath);
+                setState(prev => ({ ...prev, archive: result.archive }));
+                showStatus(setState, 'Archive refreshed', 'info');
+                return;
+            }
+            // j/k navigation
+            if (key.downArrow || input === 'j') {
+                setState(prev => ({
+                    ...prev,
+                    selectedArchiveIndex: Math.min(prev.selectedArchiveIndex + 1, maxArchiveIndex),
+                }));
+                return;
+            }
+            if (key.upArrow || input === 'k') {
+                setState(prev => ({
+                    ...prev,
+                    selectedArchiveIndex: Math.max(prev.selectedArchiveIndex - 1, 0),
+                }));
+                return;
+            }
+            // Enter - Expand/collapse
+            if (key.return) {
+                const task = state.archive[state.selectedArchiveIndex];
+                if (task) {
+                    setState(prev => {
+                        const newExpanded = new Set(prev.expandedArchiveIds);
+                        if (newExpanded.has(task.id)) {
+                            newExpanded.delete(task.id);
+                        }
+                        else {
+                            newExpanded.add(task.id);
+                        }
+                        return { ...prev, expandedArchiveIds: newExpanded };
+                    });
+                }
+                return;
+            }
+            // r key for restore (use 'R' to avoid conflict with refresh)
+            if (input === 'R') {
+                if (state.archive.length === 0) {
+                    showStatus(setState, 'No archived tasks', 'error');
+                    return;
+                }
+                setState(prev => ({ ...prev, mode: 'archive-restore', archiveRestoreColumnIndex: 0 }));
+                return;
+            }
+            // d - Delete permanently
+            if (input === 'd') {
+                if (state.archive.length === 0) {
+                    showStatus(setState, 'No archived tasks', 'error');
+                    return;
+                }
+                setState(prev => ({ ...prev, mode: 'archive-delete-confirm' }));
+                return;
+            }
+            // Home/End
+            if (input === 'g') {
+                setState(prev => ({ ...prev, selectedArchiveIndex: 0 }));
+                return;
+            }
+            if (input === 'G') {
+                setState(prev => ({ ...prev, selectedArchiveIndex: maxArchiveIndex }));
+                return;
+            }
+            // Escape
+            if (key.escape) {
+                setState(prev => ({
+                    ...prev,
+                    expandedArchiveIds: new Set(),
+                    archiveSearchQuery: '',
+                }));
+                return;
+            }
         }
     });
 }