epoch-tui 0.1.0

package/dist/components/tasks/TasksPane.js

@@ -0,0 +1,410 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState, useEffect, useMemo, useRef } from "react";
+import { Box, Text, useInput } from "ink";
+import { TextInput } from "@inkjs/ui";
+import { useTheme } from "../../contexts/ThemeContext";
+import { useApp } from "../../contexts/AppContext";
+import { Pane } from "../layout/Pane";
+import { TaskHeader } from "./TaskHeader";
+import { getDateString } from "../../utils/date";
+import { taskService } from "../../services/taskService";
+import { timelineService } from "../../services/timelineService";
+import { TimelineEventType } from "../../types/timeline";
+import { useTerminalSize } from "../../hooks/useTerminalSize";
+export const TasksPane = () => {
+    const { tasks, setTasks, timeline, setTimeline, activePane, selectedDate, isInputMode, setIsInputMode, isModalOpen, } = useApp();
+    const { theme } = useTheme();
+    const [expandedIds, setExpandedIds] = useState(new Set());
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [editMode, setEditMode] = useState("none");
+    const [editValue, setEditValue] = useState("");
+    const [parentTaskId, setParentTaskId] = useState(null);
+    const inputValueRef = useRef(""); // Track current input value for uncontrolled TextInput
+    const [inputKey, setInputKey] = useState(0); // Key to force TextInput remount
+    const [scrollOffset, setScrollOffset] = useState(0);
+    const { height: terminalHeight } = useTerminalSize();
+    const visibleRows = useMemo(() => {
+        // Header/Stats (4) + Keyboard Hints (3) + Padding/Margins (4) = ~11 lines
+        return Math.max(5, terminalHeight - 11);
+    }, [terminalHeight]);
+    const dateStr = getDateString(new Date(selectedDate.year, selectedDate.month, selectedDate.day));
+    const dayTasks = tasks[dateStr] || [];
+    const stats = taskService.getTaskStats(tasks, dateStr);
+    const isFocused = activePane === "tasks" && !isModalOpen;
+    // Flatten tasks for navigation (only visible ones based on expanded state)
+    const flatTasks = useMemo(() => {
+        const result = [];
+        const traverse = (taskList, depth) => {
+            for (const task of taskList) {
+                result.push({ task, depth });
+                if (task.children.length > 0 && expandedIds.has(task.id)) {
+                    traverse(task.children, depth + 1);
+                }
+            }
+        };
+        traverse(dayTasks, 0);
+        return result;
+    }, [dayTasks, expandedIds]);
+    const selectedTask = flatTasks[selectedIndex]?.task;
+    const selectedTaskId = selectedTask?.id;
+    // Reset selection when day changes
+    useEffect(() => {
+        setSelectedIndex(0);
+        setEditMode("none");
+    }, [dateStr]);
+    // Clamp selection index when tasks change
+    useEffect(() => {
+        if (selectedIndex >= flatTasks.length && flatTasks.length > 0) {
+            setSelectedIndex(flatTasks.length - 1);
+        }
+    }, [flatTasks.length, selectedIndex]);
+    // Keep selected task in view
+    useEffect(() => {
+        if (selectedIndex < scrollOffset) {
+            setScrollOffset(selectedIndex);
+        }
+        else if (selectedIndex >= scrollOffset + visibleRows) {
+            setScrollOffset(selectedIndex - visibleRows + 1);
+        }
+    }, [selectedIndex, visibleRows, scrollOffset]);
+    // Reset scroll when day changes
+    useEffect(() => {
+        setScrollOffset(0);
+    }, [dateStr]);
+    const handleAddTask = () => {
+        inputValueRef.current = "";
+        setEditMode("add");
+        setEditValue("");
+        setInputKey((k) => k + 1);
+        setIsInputMode(true);
+    };
+    const handleEditTask = () => {
+        if (selectedTask) {
+            inputValueRef.current = selectedTask.title;
+            setEditMode("edit");
+            setEditValue(selectedTask.title);
+            setInputKey((k) => k + 1);
+            setIsInputMode(true);
+        }
+    };
+    const handleAddSubtask = () => {
+        if (selectedTask) {
+            inputValueRef.current = "";
+            setEditMode("addSubtask");
+            setEditValue("");
+            setParentTaskId(selectedTask.id);
+            setInputKey((k) => k + 1);
+            setIsInputMode(true);
+            setExpandedIds((prev) => new Set(prev).add(selectedTask.id));
+        }
+    };
+    const handleDeleteTask = () => {
+        if (selectedTaskId) {
+            try {
+                const updated = taskService.deleteTask(tasks, selectedTaskId);
+                setTasks(updated);
+                // Remove all timeline events for this task
+                const updatedTimeline = timelineService.removeEventsByTaskId(timeline, selectedTaskId);
+                setTimeline(updatedTimeline);
+            }
+            catch (err) {
+                console.error("Error deleting task:", err);
+            }
+        }
+    };
+    const handleChangeState = (newState) => {
+        if (selectedTaskId && selectedTask) {
+            try {
+                const previousState = selectedTask.state;
+                const updated = taskService.changeTaskState(tasks, selectedTaskId, newState);
+                setTasks(updated);
+                // Handle timeline based on state change
+                if (newState === "todo") {
+                    // If toggling back to todo, remove the previous state event
+                    const eventTypeToRemove = {
+                        todo: TimelineEventType.STARTED, // shouldn't happen
+                        completed: TimelineEventType.COMPLETED,
+                        delegated: TimelineEventType.DELEGATED,
+                        delayed: TimelineEventType.DELAYED,
+                    };
+                    const updatedTimeline = timelineService.removeLastEventByType(timeline, selectedTaskId, eventTypeToRemove[previousState]);
+                    setTimeline(updatedTimeline);
+                }
+                else {
+                    // Create timeline event for state change
+                    const eventTypeMap = {
+                        todo: TimelineEventType.STARTED, // shouldn't happen
+                        completed: TimelineEventType.COMPLETED,
+                        delegated: TimelineEventType.DELEGATED,
+                        delayed: TimelineEventType.DELAYED,
+                    };
+                    const event = timelineService.createEvent(selectedTaskId, selectedTask.title, eventTypeMap[newState], new Date(), previousState, newState);
+                    const updatedTimeline = timelineService.addEvent(timeline, event);
+                    setTimeline(updatedTimeline);
+                }
+            }
+            catch (err) {
+                console.error("Error changing task state:", err);
+            }
+        }
+    };
+    const handleToggleComplete = () => {
+        if (selectedTask) {
+            const newState = selectedTask.state === "completed" ? "todo" : "completed";
+            handleChangeState(newState);
+        }
+    };
+    const handleSubmitEdit = (value) => {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            setEditMode("none");
+            setEditValue("");
+            setParentTaskId(null);
+            setIsInputMode(false);
+            return;
+        }
+        try {
+            if (editMode === "add") {
+                const newTask = taskService.createTask(trimmed, dateStr);
+                const newTasks = {
+                    ...tasks,
+                    [dateStr]: [...dayTasks, newTask],
+                };
+                setTasks(newTasks);
+                setSelectedIndex(flatTasks.length); // Select newly added task
+                // No timeline event for task creation - only track started/completed/etc
+            }
+            else if (editMode === "addSubtask" && parentTaskId) {
+                const updated = taskService.addSubtask(tasks, parentTaskId, trimmed);
+                setTasks(updated);
+                // Find and select the newly added subtask
+                const parentIndex = flatTasks.findIndex((ft) => ft.task.id === parentTaskId);
+                if (parentIndex !== -1) {
+                    setSelectedIndex(parentIndex + 1); // Select first child (newly added)
+                }
+                // No timeline event for subtask creation
+            }
+            else if (editMode === "edit" && selectedTaskId) {
+                const updated = taskService.updateTask(tasks, selectedTaskId, {
+                    title: trimmed,
+                });
+                setTasks(updated);
+            }
+        }
+        catch (err) {
+            console.error("Error saving task:", err);
+        }
+        setEditMode("none");
+        setEditValue("");
+        setParentTaskId(null);
+        setIsInputMode(false);
+    };
+    const handleCancelEdit = () => {
+        setEditMode("none");
+        setEditValue("");
+        setParentTaskId(null);
+        setIsInputMode(false);
+    };
+    const handleToggleExpand = () => {
+        if (selectedTaskId && selectedTask?.children.length > 0) {
+            setExpandedIds((prev) => {
+                const newSet = new Set(prev);
+                if (newSet.has(selectedTaskId)) {
+                    newSet.delete(selectedTaskId);
+                }
+                else {
+                    newSet.add(selectedTaskId);
+                }
+                return newSet;
+            });
+        }
+    };
+    const handleExpand = () => {
+        if (selectedTaskId && selectedTask?.children.length > 0) {
+            setExpandedIds((prev) => new Set(prev).add(selectedTaskId));
+        }
+    };
+    const handleCollapse = () => {
+        if (selectedTaskId && selectedTask?.children.length > 0) {
+            setExpandedIds((prev) => {
+                const newSet = new Set(prev);
+                newSet.delete(selectedTaskId);
+                return newSet;
+            });
+        }
+    };
+    const handleExpandAll = () => {
+        // Get all task IDs that have children
+        const allParentIds = new Set();
+        const collectParents = (taskList) => {
+            for (const task of taskList) {
+                if (task.children.length > 0) {
+                    allParentIds.add(task.id);
+                    collectParents(task.children);
+                }
+            }
+        };
+        collectParents(dayTasks);
+        setExpandedIds(allParentIds);
+    };
+    const handleCollapseAll = () => {
+        setExpandedIds(new Set());
+    };
+    // Handle escape key to cancel editing
+    useInput((_input, key) => {
+        if (key.escape) {
+            handleCancelEdit();
+        }
+    }, { isActive: isFocused && editMode !== "none" });
+    // Input handler for navigation/command mode
+    useInput((input, key) => {
+        // Expand/Collapse ALL with Cmd/Ctrl + arrow keys
+        // Note: On Mac terminals, Cmd+Left sends Ctrl+a and Cmd+Right sends Ctrl+e
+        if ((key.meta || key.ctrl) && (input === "a" || key.leftArrow)) {
+            handleCollapseAll();
+            return;
+        }
+        if ((key.meta || key.ctrl) && (input === "e" || key.rightArrow)) {
+            handleExpandAll();
+            return;
+        }
+        // Navigation
+        if (input === "j" || key.downArrow) {
+            setSelectedIndex((prev) => Math.min(prev + 1, flatTasks.length - 1));
+            return;
+        }
+        if (input === "k" || key.upArrow) {
+            setSelectedIndex((prev) => Math.max(prev - 1, 0));
+            return;
+        }
+        // Expand/Collapse current with arrow keys (no modifiers)
+        if (key.leftArrow && !key.meta && !key.ctrl) {
+            handleCollapse();
+            return;
+        }
+        if (key.rightArrow && !key.meta && !key.ctrl) {
+            handleExpand();
+            return;
+        }
+        // Task actions (only if no modifier keys are pressed)
+        if (input === "a" && !key.meta && !key.ctrl && !key.shift) {
+            handleAddTask();
+            return;
+        }
+        if (input === "e" &&
+            selectedTask &&
+            !key.meta &&
+            !key.ctrl &&
+            !key.shift) {
+            handleEditTask();
+            return;
+        }
+        if (input === "d" && selectedTask) {
+            handleDeleteTask();
+            return;
+        }
+        if (input === " " && selectedTask) {
+            handleToggleComplete();
+            return;
+        }
+        if (input === "D" && selectedTask) {
+            handleChangeState("delegated");
+            return;
+        }
+        if (input === "x" && selectedTask) {
+            // Toggle delayed state
+            if (selectedTask.state === "delayed") {
+                handleChangeState("todo");
+            }
+            else {
+                handleChangeState("delayed");
+            }
+            return;
+        }
+        if (input === "s" && selectedTask) {
+            try {
+                // Toggle start - if already started (has startTime but no endTime), unstart it
+                if (selectedTask.startTime && !selectedTask.endTime) {
+                    // Unstart: clear startTime and remove timeline event
+                    const updated = taskService.updateTask(tasks, selectedTaskId, {
+                        startTime: undefined,
+                    });
+                    setTasks(updated);
+                    // Remove the started event from timeline
+                    const updatedTimeline = timelineService.removeLastEventByType(timeline, selectedTaskId, TimelineEventType.STARTED);
+                    setTimeline(updatedTimeline);
+                }
+                else {
+                    // Start task
+                    const updated = taskService.startTask(tasks, selectedTaskId);
+                    setTasks(updated);
+                    // Create timeline event for starting task
+                    const event = timelineService.createEvent(selectedTaskId, selectedTask.title, TimelineEventType.STARTED, new Date());
+                    const updatedTimeline = timelineService.addEvent(timeline, event);
+                    setTimeline(updatedTimeline);
+                }
+            }
+            catch (err) {
+                console.error("Error toggling task start:", err);
+            }
+            return;
+        }
+        if (key.return && selectedTask) {
+            handleToggleExpand();
+            return;
+        }
+        if (key.tab && selectedTask) {
+            handleAddSubtask();
+            return;
+        }
+    }, { isActive: isFocused && editMode === "none" });
+    return (_jsx(Pane, { title: "Tasks", isFocused: isFocused, children: _jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(TaskHeader, { selectedDate: new Date(selectedDate.year, selectedDate.month, selectedDate.day), completionPercentage: stats.percentage }), editMode === "add" && (_jsxs(Box, { marginY: 1, children: [_jsx(Text, { color: theme.colors.focusIndicator, children: ">  " }), _jsx(TextInput, { defaultValue: "", placeholder: "Enter task name...", onChange: (val) => {
+                                inputValueRef.current = val;
+                            }, onSubmit: handleSubmitEdit }, `add-${inputKey}`)] })), editMode === "addSubtask" && (_jsxs(Box, { marginY: 1, children: [_jsx(Text, { color: theme.colors.focusIndicator, children: ">  " }), _jsx(Text, { color: theme.colors.keyboardHint, children: "  " }), _jsx(TextInput, { defaultValue: "", placeholder: "Enter subtask name...", onChange: (val) => {
+                                inputValueRef.current = val;
+                            }, onSubmit: handleSubmitEdit }, `subtask-${inputKey}`)] })), dayTasks.length === 0 &&
+                    editMode !== "add" &&
+                    editMode !== "addSubtask" ? (_jsx(Box, { marginY: 1, children: _jsx(Text, { color: theme.colors.keyboardHint, dimColor: true, children: "No tasks. Press 'a' to add one." }) })) : (_jsxs(Box, { flexDirection: "column", marginY: 1, paddingRight: 2, children: [scrollOffset > 0 && (_jsx(Box, { justifyContent: "center", marginBottom: 1, children: _jsx(Text, { color: theme.colors.keyboardHint, dimColor: true, children: "-- more above --" }) })), flatTasks
+                            .slice(scrollOffset, scrollOffset + visibleRows)
+                            .map(({ task, depth }, sliceIndex) => {
+                            const index = scrollOffset + sliceIndex;
+                            const isSelected = index === selectedIndex;
+                            const isExpanded = expandedIds.has(task.id);
+                            const isEditing = editMode === "edit" && isSelected;
+                            if (isEditing) {
+                                return (_jsxs(Box, { children: [_jsx(Text, { color: theme.colors.focusIndicator, children: ">  " }), _jsx(TextInput, { defaultValue: editValue, onChange: (val) => {
+                                                inputValueRef.current = val;
+                                            }, onSubmit: handleSubmitEdit }, `edit-${inputKey}`)] }, task.id));
+                            }
+                            return (_jsxs(Box, { children: [_jsx(Text, { color: isSelected
+                                            ? theme.colors.focusIndicator
+                                            : theme.colors.foreground, children: isSelected ? ">" : " " }), _jsx(Text, { children: " " }), _jsx(Text, { children: "  ".repeat(depth) }), _jsx(Text, { color: isSelected
+                                            ? theme.colors.focusIndicator
+                                            : getStateColor(task.state, theme), children: getCheckbox(task.state) }), _jsx(Text, { children: " " }), task.children.length > 0 && (_jsxs(_Fragment, { children: [_jsx(Text, { children: isExpanded ? "▼" : "▶" }), _jsx(Text, { children: " " })] })), _jsx(Text, { color: isSelected
+                                            ? theme.colors.focusIndicator
+                                            : getStateColor(task.state, theme), strikethrough: task.state === "completed", dimColor: task.state === "delayed" && !isSelected, children: task.title }), task.startTime && !task.endTime && (_jsxs(Text, { color: isSelected
+                                            ? theme.colors.focusIndicator
+                                            : theme.colors.timelineEventStarted, children: [" ", "\u25B6"] }))] }, task.id));
+                        }), scrollOffset + visibleRows < flatTasks.length && (_jsx(Box, { justifyContent: "center", marginTop: 1, children: _jsx(Text, { color: theme.colors.keyboardHint, dimColor: true, children: "-- more below --" }) }))] })), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: theme.colors.keyboardHint, dimColor: true, children: "j/k: navigate a: add Tab: add subtask e: edit d: delete" }), _jsx(Text, { color: theme.colors.keyboardHint, dimColor: true, children: "Space: complete D: delegate x: delay s: start" }), _jsx(Text, { color: theme.colors.keyboardHint, dimColor: true, children: "\u2190/\u2192: collapse/expand Cmd+\u2190/\u2192: collapse/expand all" })] })] }) }));
+};
+function getCheckbox(state) {
+    switch (state) {
+        case "completed":
+            return "[✓]";
+        case "delegated":
+            return "[→]";
+        case "delayed":
+            return "[‖]";
+        default:
+            return "[ ]";
+    }
+}
+function getStateColor(state, theme) {
+    const colors = {
+        todo: theme.colors.taskStateTodo,
+        completed: theme.colors.taskStateCompleted,
+        delegated: theme.colors.taskStateDelegated,
+        delayed: theme.colors.taskStateDelayed,
+    };
+    return colors[state] || theme.colors.foreground;
+}

package/dist/components/timeline/TimelineEntry.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import type { TimelineEvent } from "../../types/timeline";
+interface TimelineEntryProps {
+    event: TimelineEvent;
+    isLast: boolean;
+    hasNextSameTask: boolean;
+}
+export declare const TimelineEntry: React.FC<TimelineEntryProps>;
+export {};

package/dist/components/timeline/TimelineEntry.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { useTheme } from "../../contexts/ThemeContext";
+export const TimelineEntry = ({ event, isLast, hasNextSameTask, }) => {
+    const { theme } = useTheme();
+    // Format time as "7:31 am"
+    const hours = event.timestamp.getHours();
+    const minutes = event.timestamp.getMinutes();
+    const ampm = hours >= 12 ? "pm" : "am";
+    const hour12 = hours % 12 || 12;
+    const timeStr = `${hour12}:${minutes.toString().padStart(2, "0")} ${ampm}`;
+    const typeStr = event.type.charAt(0).toUpperCase() + event.type.slice(1);
+    // Color mapping for event types
+    const eventTypeColors = {
+        created: theme.colors.foreground,
+        started: theme.colors.foreground,
+        completed: theme.colors.taskStateCompleted,
+        delegated: theme.colors.taskStateDelegated,
+        delayed: theme.colors.taskStateDelayed,
+        updated: theme.colors.foreground,
+    };
+    const color = eventTypeColors[event.type] || theme.colors.foreground;
+    // Circle style: hollow for started, filled for completed/delegated/delayed
+    const isFilledCircle = ["completed", "delegated", "delayed"].includes(event.type);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Box, { width: 3, justifyContent: "center", children: _jsx(Text, { color: color, children: isFilledCircle ? "●" : "○" }) }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(Box, { children: _jsxs(Text, { children: [_jsxs(Text, { color: color, bold: true, children: [typeStr, ":"] }), _jsxs(Text, { color: theme.colors.foreground, children: [" ", event.taskTitle] })] }) }), _jsx(Box, { children: _jsx(Text, { color: theme.colors.keyboardHint, dimColor: true, children: timeStr }) })] })] }), !isLast && (_jsx(Box, { children: _jsx(Box, { width: 3, justifyContent: "center", children: _jsx(Text, { color: hasNextSameTask ? color : theme.colors.border, children: "\u2502" }) }) }))] }));
+};

package/dist/components/timeline/TimelinePane.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const TimelinePane: React.FC;

package/dist/components/timeline/TimelinePane.js

@@ -0,0 +1,78 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useMemo } from "react";
+import { Box, Text, useInput } from "ink";
+import { useTheme } from "../../contexts/ThemeContext";
+import { useApp } from "../../contexts/AppContext";
+import { Pane } from "../layout/Pane";
+import { TimelineEntry } from "./TimelineEntry";
+import { getDateString } from "../../utils/date";
+import { useTerminalSize } from "../../hooks/useTerminalSize";
+export const TimelinePane = () => {
+    const { theme } = useTheme();
+    const { selectedDate, timeline, activePane, isModalOpen, isInputMode } = useApp();
+    const isFocused = activePane === "timeline" && !isModalOpen;
+    const [scrollOffset, setScrollOffset] = useState(0);
+    const { height: terminalHeight } = useTerminalSize();
+    const visibleRows = useMemo(() => {
+        // Pane header/footer and padding takes some space
+        return Math.max(5, terminalHeight - 10);
+    }, [terminalHeight]);
+    const dateStr = getDateString(new Date(selectedDate.year, selectedDate.month, selectedDate.day));
+    const dayEvents = timeline[dateStr] || [];
+    // Group events by task, then sort by timestamp within each task group
+    const sortedEvents = useMemo(() => {
+        // First, group events by taskId
+        const eventsByTask = new Map();
+        dayEvents.forEach((event) => {
+            const taskEvents = eventsByTask.get(event.taskId) || [];
+            taskEvents.push(event);
+            eventsByTask.set(event.taskId, taskEvents);
+        });
+        // Sort events within each task group by timestamp
+        eventsByTask.forEach((events) => {
+            events.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+        });
+        // Convert to array of task groups and sort by earliest event timestamp
+        const taskGroups = Array.from(eventsByTask.entries()).sort(([, eventsA], [, eventsB]) => {
+            const earliestA = eventsA[0]?.timestamp.getTime() || 0;
+            const earliestB = eventsB[0]?.timestamp.getTime() || 0;
+            return earliestA - earliestB;
+        });
+        // Flatten back to a single array
+        return taskGroups.flatMap(([, events]) => events);
+    }, [dayEvents]);
+    // Reset scroll when date changes
+    useEffect(() => {
+        setScrollOffset(0);
+    }, [dateStr]);
+    // Scroll with j/k when focused
+    useInput((input, key) => {
+        if (!isFocused)
+            return;
+        if (input === "j" || key.downArrow) {
+            setScrollOffset((prev) => Math.min(prev + 1, Math.max(0, sortedEvents.length - visibleRows)));
+        }
+        if (input === "k" || key.upArrow) {
+            setScrollOffset((prev) => Math.max(prev - 1, 0));
+        }
+        // Page down/up
+        if (input === "d" && key.ctrl) {
+            setScrollOffset((prev) => Math.min(prev + Math.floor(visibleRows / 2), Math.max(0, sortedEvents.length - visibleRows)));
+        }
+        if (input === "u" && key.ctrl) {
+            setScrollOffset((prev) => Math.max(prev - Math.floor(visibleRows / 2), 0));
+        }
+    }, { isActive: isFocused && !isInputMode });
+    // Get visible events based on scroll
+    const visibleEvents = sortedEvents.slice(scrollOffset, scrollOffset + visibleRows);
+    // Check if scrolling is possible
+    const canScrollUp = scrollOffset > 0;
+    const canScrollDown = scrollOffset + visibleRows < sortedEvents.length;
+    return (_jsx(Pane, { title: "Timeline", isFocused: isFocused, children: _jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [sortedEvents.length === 0 ? (_jsxs(Box, { marginY: 1, flexDirection: "column", paddingX: 1, children: [_jsx(Text, { color: theme.colors.keyboardHint, dimColor: true, children: "No activities yet." }), _jsx(Text, { color: theme.colors.keyboardHint, dimColor: true, children: "Press 's' to start a task." })] })) : (_jsxs(Box, { flexDirection: "column", children: [canScrollUp && (_jsx(Box, { justifyContent: "center", marginBottom: 1, children: _jsx(Text, { color: theme.colors.keyboardHint, dimColor: true, children: "-- more above --" }) })), _jsx(Box, { flexDirection: "column", children: visibleEvents.map((event, index) => {
+                                const globalIndex = scrollOffset + index;
+                                const isLast = globalIndex === sortedEvents.length - 1;
+                                const nextEvent = sortedEvents[globalIndex + 1];
+                                const hasNextSameTask = nextEvent && nextEvent.taskId === event.taskId;
+                                return (_jsx(TimelineEntry, { event: event, isLast: isLast, hasNextSameTask: hasNextSameTask }, event.id));
+                            }) }), canScrollDown && (_jsx(Box, { justifyContent: "center", marginTop: 1, children: _jsx(Text, { color: theme.colors.keyboardHint, dimColor: true, children: "-- more below --" }) }))] })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.colors.keyboardHint, dimColor: true, children: "j/k: scroll" }) })] }) }));
+};

package/dist/contexts/AppContext.d.ts

@@ -0,0 +1,47 @@
+import React from "react";
+import type { TaskTree } from "../types/task";
+import type { TimelineEvent } from "../types/timeline";
+import type { CalendarDate } from "../types/calendar";
+interface AppContextType {
+    selectedDate: CalendarDate;
+    setSelectedDate: (date: CalendarDate) => void;
+    tasks: TaskTree;
+    setTasks: (tasks: TaskTree) => void;
+    timeline: {
+        [date: string]: TimelineEvent[];
+    };
+    setTimeline: (timeline: {
+        [date: string]: TimelineEvent[];
+    }) => void;
+    activePane: "calendar" | "tasks" | "timeline";
+    setActivePane: (pane: "calendar" | "tasks" | "timeline") => void;
+    showHelp: boolean;
+    setShowHelp: (show: boolean) => void;
+    isInputMode: boolean;
+    setIsInputMode: (mode: boolean) => void;
+    showOverview: boolean;
+    setShowOverview: (show: boolean) => void;
+    overviewMonth: {
+        year: number;
+        month: number;
+    };
+    setOverviewMonth: (date: {
+        year: number;
+        month: number;
+    }) => void;
+    exitConfirmation: boolean;
+    setExitConfirmation: (show: boolean) => void;
+    showThemeDialog: boolean;
+    setShowThemeDialog: (show: boolean) => void;
+    showClearTimelineDialog: boolean;
+    setShowClearTimelineDialog: (show: boolean) => void;
+    clearTimelineForDate: (dateStr: string) => void;
+    isModalOpen: boolean;
+    saveNow: () => Promise<void>;
+}
+interface AppProviderProps {
+    children: React.ReactNode;
+}
+export declare const AppProvider: React.FC<AppProviderProps>;
+export declare const useApp: () => AppContextType;
+export {};