epoch-tui 0.1.0

package/dist/contexts/AppContext.js

@@ -0,0 +1,104 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useState, useRef, useCallback, } from "react";
+import { useStorage } from "./StorageContext";
+const AppContext = createContext(undefined);
+export const AppProvider = ({ children }) => {
+    const { data, save, saveNow } = useStorage();
+    const today = new Date();
+    const [selectedDate, setSelectedDate] = useState({
+        year: today.getFullYear(),
+        month: today.getMonth(),
+        day: today.getDate(),
+    });
+    const [tasks, setTasks] = useState({});
+    const [timeline, setTimeline] = useState({});
+    const [activePane, setActivePane] = useState("tasks");
+    const [showHelp, setShowHelp] = useState(false);
+    // Use ref for isInputMode to avoid React state timing issues
+    const isInputModeRef = useRef(false);
+    const [isInputModeState, setIsInputModeState] = useState(false);
+    const [showOverview, setShowOverview] = useState(false);
+    // Use ref for immediate updates to avoid React state timing issues with useInput hooks
+    const setIsInputMode = useCallback((mode) => {
+        isInputModeRef.current = mode;
+        setIsInputModeState(mode);
+    }, []);
+    // Read from ref for immediate access in useInput hooks
+    const isInputMode = isInputModeRef.current;
+    const [overviewMonth, setOverviewMonth] = useState({
+        year: today.getFullYear(),
+        month: today.getMonth(),
+    });
+    const [exitConfirmation, setExitConfirmation] = useState(false);
+    const [showThemeDialog, setShowThemeDialog] = useState(false);
+    const [showClearTimelineDialog, setShowClearTimelineDialog] = useState(false);
+    // Function to clear timeline for a specific date
+    const clearTimelineForDate = useCallback((dateStr) => {
+        setTimeline((prev) => {
+            const newTimeline = { ...prev };
+            delete newTimeline[dateStr];
+            return newTimeline;
+        });
+    }, []);
+    // Track if initial data has been loaded to prevent save loop
+    const initialLoadDone = useRef(false);
+    const dataRef = useRef(data);
+    const saveRef = useRef(save);
+    // Keep refs updated
+    useEffect(() => {
+        dataRef.current = data;
+        saveRef.current = save;
+    }, [data, save]);
+    // Load data from storage (only once)
+    useEffect(() => {
+        if (data && !initialLoadDone.current) {
+            setTasks(data.tasks);
+            setTimeline(data.timeline);
+            initialLoadDone.current = true;
+        }
+    }, [data]);
+    // Save when tasks or timeline change (only after initial load)
+    useEffect(() => {
+        if (initialLoadDone.current && dataRef.current) {
+            saveRef.current({
+                ...dataRef.current,
+                tasks,
+                timeline,
+            });
+        }
+    }, [tasks, timeline]);
+    return (_jsx(AppContext.Provider, { value: {
+            selectedDate,
+            setSelectedDate,
+            tasks,
+            setTasks,
+            timeline,
+            setTimeline,
+            activePane,
+            setActivePane,
+            showHelp,
+            setShowHelp,
+            isInputMode,
+            setIsInputMode,
+            showOverview,
+            setShowOverview,
+            overviewMonth,
+            setOverviewMonth,
+            exitConfirmation,
+            setExitConfirmation,
+            showThemeDialog,
+            setShowThemeDialog,
+            showClearTimelineDialog,
+            setShowClearTimelineDialog,
+            clearTimelineForDate,
+            isModalOpen: showHelp || showThemeDialog || showOverview || showClearTimelineDialog,
+            saveNow,
+        }, children: children }));
+};
+export const useApp = () => {
+    const context = useContext(AppContext);
+    if (!context) {
+        throw new Error("useApp must be used within AppProvider");
+    }
+    return context;
+};

package/dist/contexts/StorageContext.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { StorageSchema } from '../types/storage';
+interface StorageContextType {
+    data: StorageSchema | null;
+    isLoading: boolean;
+    error: Error | null;
+    save: (data: StorageSchema) => Promise<void>;
+    saveNow: () => Promise<void>;
+}
+interface StorageProviderProps {
+    children: React.ReactNode;
+}
+export declare const StorageProvider: React.FC<StorageProviderProps>;
+export declare const useStorage: () => StorageContextType;
+export {};

package/dist/contexts/StorageContext.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useRef, useState, useCallback, } from 'react';
+import { storageService } from '../services/storage';
+const StorageContext = createContext(undefined);
+export const StorageProvider = ({ children, }) => {
+    const [data, setData] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const saveTimeoutRef = useRef(undefined);
+    // Keep a ref to always have the latest data for sync saves
+    const latestDataRef = useRef(null);
+    // Load data on mount
+    useEffect(() => {
+        const loadData = async () => {
+            try {
+                setIsLoading(true);
+                const loadedData = await storageService.load();
+                setData(loadedData);
+                latestDataRef.current = loadedData;
+                setError(null);
+            }
+            catch (err) {
+                setError(err instanceof Error ? err : new Error('Unknown error'));
+            }
+            finally {
+                setIsLoading(false);
+            }
+        };
+        loadData();
+    }, []);
+    // Debounced save
+    const save = useCallback(async (newData) => {
+        setData(newData);
+        latestDataRef.current = newData;
+        if (saveTimeoutRef.current) {
+            clearTimeout(saveTimeoutRef.current);
+        }
+        saveTimeoutRef.current = setTimeout(async () => {
+            try {
+                await storageService.save(newData);
+            }
+            catch (err) {
+                setError(err instanceof Error ? err : new Error('Failed to save'));
+            }
+        }, 500);
+    }, []);
+    // Immediate save (for exit)
+    const saveNow = useCallback(async () => {
+        if (saveTimeoutRef.current) {
+            clearTimeout(saveTimeoutRef.current);
+        }
+        if (latestDataRef.current) {
+            try {
+                await storageService.save(latestDataRef.current);
+            }
+            catch (err) {
+                console.error('Failed to save:', err);
+            }
+        }
+    }, []);
+    // Save on unmount using the ref (always has latest data)
+    useEffect(() => {
+        return () => {
+            if (saveTimeoutRef.current) {
+                clearTimeout(saveTimeoutRef.current);
+            }
+            if (latestDataRef.current) {
+                // Use sync write for unmount to ensure data is saved
+                storageService.save(latestDataRef.current).catch(err => {
+                    console.error('Failed to save on unmount:', err);
+                });
+            }
+        };
+    }, []);
+    return (_jsx(StorageContext.Provider, { value: { data, isLoading, error, save, saveNow }, children: children }));
+};
+export const useStorage = () => {
+    const context = useContext(StorageContext);
+    if (!context) {
+        throw new Error('useStorage must be used within StorageProvider');
+    }
+    return context;
+};

package/dist/contexts/ThemeContext.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+import type { Theme } from "../types/theme";
+interface ThemeContextType {
+    theme: Theme;
+    themeName: string;
+    setTheme: (name: string) => void;
+    availableThemes: string[];
+}
+interface ThemeProviderProps {
+    children: React.ReactNode;
+    initialTheme?: string;
+}
+export declare const ThemeProvider: React.FC<ThemeProviderProps>;
+export declare const useTheme: () => ThemeContextType;
+export {};

package/dist/contexts/ThemeContext.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState, useEffect } from "react";
+import { getTheme, getThemeNames } from "../themes";
+import { useStorage } from "./StorageContext";
+const ThemeContext = createContext(undefined);
+export const ThemeProvider = ({ children, initialTheme = "dark", }) => {
+    const { data, save } = useStorage();
+    const [themeName, setThemeName] = useState(initialTheme);
+    const theme = getTheme(themeName);
+    // Load theme from storage when data is available
+    useEffect(() => {
+        if (data?.settings?.theme) {
+            setThemeName(data.settings.theme);
+        }
+    }, [data?.settings?.theme]);
+    const handleSetTheme = (name) => {
+        if (getThemeNames().includes(name)) {
+            setThemeName(name);
+            // Save theme to storage
+            if (data) {
+                save({
+                    ...data,
+                    settings: {
+                        ...data.settings,
+                        theme: name,
+                    },
+                });
+            }
+        }
+    };
+    return (_jsx(ThemeContext.Provider, { value: {
+            theme,
+            themeName,
+            setTheme: handleSetTheme,
+            availableThemes: getThemeNames(),
+        }, children: children }));
+};
+export const useTheme = () => {
+    const context = useContext(ThemeContext);
+    if (!context) {
+        throw new Error("useTheme must be used within ThemeProvider");
+    }
+    return context;
+};

package/dist/hooks/useKeyboardNav.d.ts

@@ -0,0 +1 @@
+export declare const useKeyboardNav: () => void;

package/dist/hooks/useKeyboardNav.js

@@ -0,0 +1,89 @@
+import { useInput } from 'ink';
+import { useApp } from '../contexts/AppContext';
+import { useEffect } from 'react';
+export const useKeyboardNav = () => {
+    const { showHelp, setShowHelp, activePane, setActivePane, isInputMode, showOverview, setShowOverview, overviewMonth, setOverviewMonth, exitConfirmation, setExitConfirmation, showThemeDialog, setShowThemeDialog, showClearTimelineDialog, setShowClearTimelineDialog, saveNow } = useApp();
+    // Auto-reset exit confirmation after 3 seconds
+    useEffect(() => {
+        if (exitConfirmation) {
+            const timer = setTimeout(() => {
+                setExitConfirmation(false);
+            }, 3000);
+            return () => clearTimeout(timer);
+        }
+    }, [exitConfirmation, setExitConfirmation]);
+    // Global input handler - inactive when in input mode or dialogs open
+    const isActive = !isInputMode && !showThemeDialog && !showClearTimelineDialog;
+    useInput((input, key) => {
+        // Handle Ctrl+C with confirmation (always active for exit)
+        if (key.ctrl && input === 'c') {
+            if (exitConfirmation) {
+                // Save data before exiting
+                saveNow().then(() => {
+                    // Unmount the Ink app first
+                    const inkApp = global.__inkApp;
+                    if (inkApp) {
+                        inkApp.unmount();
+                    }
+                    // Clear the terminal completely
+                    setTimeout(() => {
+                        console.clear();
+                        process.stdout.write('\x1Bc'); // Reset terminal
+                        process.exit(0);
+                    }, 100); // Give Ink time to unmount
+                }).catch(() => {
+                    // Unmount the Ink app first even on error
+                    const inkApp = global.__inkApp;
+                    if (inkApp) {
+                        inkApp.unmount();
+                    }
+                    // Clear the terminal completely
+                    setTimeout(() => {
+                        console.clear();
+                        process.stdout.write('\x1Bc'); // Reset terminal
+                        process.exit(0);
+                    }, 100); // Give Ink time to unmount
+                });
+                return;
+            }
+            else {
+                setExitConfirmation(true);
+                return;
+            }
+        }
+        // Shift+; (colon) to toggle overview
+        if (input === ':') {
+            setShowOverview(!showOverview);
+            return;
+        }
+        if (input === '?') {
+            setShowHelp(!showHelp);
+            return;
+        }
+        if (key.ctrl && input === 't') {
+            setShowThemeDialog(true);
+            return;
+        }
+        // 'C' (shift+c) to clear timeline (when timeline pane is focused)
+        if (input === 'C' && activePane === 'timeline') {
+            setShowClearTimelineDialog(true);
+            return;
+        }
+        // Pane switching
+        if (input === '1') {
+            setActivePane('calendar');
+            return;
+        }
+        if (input === '2' || (key.tab && !key.shift)) {
+            setActivePane('tasks');
+            return;
+        }
+        if (input === '3' || (key.tab && key.shift)) {
+            setActivePane('timeline');
+            return;
+        }
+    }, {
+        // Disable this hook when in input mode or dialogs are open to prevent interference with TextInput
+        isActive: isActive
+    });
+};

package/dist/hooks/useTerminalSize.d.ts

@@ -0,0 +1,9 @@
+interface TerminalSize {
+    width: number;
+    height: number;
+}
+/**
+ * Hook to track terminal dimensions and automatically update on resize
+ */
+export declare const useTerminalSize: () => TerminalSize;
+export {};

package/dist/hooks/useTerminalSize.js

@@ -0,0 +1,34 @@
+import { useState, useEffect } from "react";
+import { useStdout } from "ink";
+/**
+ * Hook to track terminal dimensions and automatically update on resize
+ */
+export const useTerminalSize = () => {
+    const { stdout } = useStdout();
+    const [size, setSize] = useState({
+        width: stdout?.columns || 100,
+        height: stdout?.rows || 30,
+    });
+    useEffect(() => {
+        if (!stdout)
+            return;
+        // Update size immediately in case it changed
+        setSize({
+            width: stdout.columns || 100,
+            height: stdout.rows || 30,
+        });
+        // Listen for resize events
+        const handleResize = () => {
+            setSize({
+                width: stdout.columns || 100,
+                height: stdout.rows || 30,
+            });
+        };
+        stdout.on("resize", handleResize);
+        // Cleanup listener on unmount
+        return () => {
+            stdout.off("resize", handleResize);
+        };
+    }, [stdout]);
+    return size;
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import App from "./App";
+console.clear();
+const app = render(_jsx(App, {}), { exitOnCtrlC: false });
+// Make the app instance globally accessible for clean exit
+global.__inkApp = app;

package/dist/services/calendarService.d.ts

@@ -0,0 +1,18 @@
+import type { CalendarView, CalendarDate } from '../types/calendar';
+import type { TaskTree } from '../types/task';
+export declare class CalendarService {
+    generateMonthView(year: number, month: number, selectedDate: CalendarDate, tasks: TaskTree): CalendarView;
+    private createCalendarDay;
+    private isSameDay;
+    getNextMonth(year: number, month: number): {
+        year: number;
+        month: number;
+    };
+    getPreviousMonth(year: number, month: number): {
+        year: number;
+        month: number;
+    };
+    getDayOfWeek(date: Date): number;
+    getMonthName(month: number): string;
+}
+export declare const calendarService: CalendarService;

package/dist/services/calendarService.js

@@ -0,0 +1,57 @@
+import { generateMonthCalendar, getDateString, isToday } from '../utils/date';
+export class CalendarService {
+    generateMonthView(year, month, selectedDate, tasks) {
+        const weeks = generateMonthCalendar(year, month);
+        const calendarDays = weeks.map(week => week.map(date => this.createCalendarDay(date, selectedDate, tasks, month)));
+        return {
+            year,
+            month,
+            weeks: calendarDays,
+        };
+    }
+    createCalendarDay(date, selectedDate, tasks, currentMonth) {
+        const dateString = getDateString(date);
+        const dayTasks = tasks[dateString] || [];
+        return {
+            date: {
+                year: date.getFullYear(),
+                month: date.getMonth(),
+                day: date.getDate(),
+            },
+            dateString,
+            isToday: isToday(date),
+            isSelected: this.isSameDay(date, selectedDate),
+            isCurrentMonth: date.getMonth() === currentMonth,
+            hasTasks: dayTasks.length > 0,
+            taskCount: dayTasks.length,
+        };
+    }
+    isSameDay(date, calendarDate) {
+        return (date.getDate() === calendarDate.day &&
+            date.getMonth() === calendarDate.month &&
+            date.getFullYear() === calendarDate.year);
+    }
+    getNextMonth(year, month) {
+        if (month === 11) {
+            return { year: year + 1, month: 0 };
+        }
+        return { year, month: month + 1 };
+    }
+    getPreviousMonth(year, month) {
+        if (month === 0) {
+            return { year: year - 1, month: 11 };
+        }
+        return { year, month: month - 1 };
+    }
+    getDayOfWeek(date) {
+        return date.getDay();
+    }
+    getMonthName(month) {
+        const months = [
+            'January', 'February', 'March', 'April', 'May', 'June',
+            'July', 'August', 'September', 'October', 'November', 'December',
+        ];
+        return months[month];
+    }
+}
+export const calendarService = new CalendarService();

package/dist/services/storage.d.ts

@@ -0,0 +1,14 @@
+import type { StorageSchema } from '../types/storage';
+export declare class StorageService {
+    private filePath;
+    constructor(filePath?: string);
+    load(): Promise<StorageSchema>;
+    save(data: StorageSchema): Promise<void>;
+    backup(): Promise<void>;
+    getStoragePath(): string;
+    private hydrateDates;
+    private hydrateTask;
+    private serializeDates;
+    private serializeTask;
+}
+export declare const storageService: StorageService;

package/dist/services/storage.js

@@ -0,0 +1,130 @@
+import { promises as fs } from 'fs';
+import { dirname } from 'path';
+import { homedir } from 'os';
+const getStoragePath = () => {
+    const home = homedir();
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        return `${home}/Library/Application Support/epoch/data.json`;
+    }
+    else if (platform === 'linux') {
+        return `${home}/.config/epoch/data.json`;
+    }
+    else if (platform === 'win32') {
+        const appData = process.env.APPDATA || `${home}\\AppData\\Roaming`;
+        return `${appData}\\epoch\\data.json`;
+    }
+    return `${home}/.epoch/data.json`;
+};
+const getDefaultSchema = () => ({
+    version: '1.0.0',
+    tasks: {},
+    timeline: {},
+    settings: {
+        theme: 'dark',
+        defaultStartTime: 'now',
+        dateFormat: 'MMMM do, yyyy',
+        timeFormat: '12h',
+    },
+});
+export class StorageService {
+    constructor(filePath) {
+        this.filePath = filePath || getStoragePath();
+    }
+    async load() {
+        try {
+            const data = await fs.readFile(this.filePath, 'utf-8');
+            const parsed = JSON.parse(data);
+            // Convert date strings back to Date objects
+            return this.hydrateDates(parsed);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return getDefaultSchema();
+            }
+            console.error('Failed to load storage:', error);
+            return getDefaultSchema();
+        }
+    }
+    async save(data) {
+        try {
+            const dir = dirname(this.filePath);
+            await fs.mkdir(dir, { recursive: true });
+            // Convert Date objects to ISO strings for JSON serialization
+            const serialized = this.serializeDates(data);
+            await fs.writeFile(this.filePath, JSON.stringify(serialized, null, 2), 'utf-8');
+        }
+        catch (error) {
+            console.error('Failed to save storage:', error);
+        }
+    }
+    async backup() {
+        try {
+            const timestamp = new Date().toISOString().replace(/:/g, '-');
+            const backupPath = `${this.filePath}.backup-${timestamp}`;
+            const data = await fs.readFile(this.filePath, 'utf-8');
+            await fs.writeFile(backupPath, data, 'utf-8');
+        }
+        catch (error) {
+            console.error('Failed to backup storage:', error);
+        }
+    }
+    getStoragePath() {
+        return this.filePath;
+    }
+    hydrateDates(data) {
+        if (data.tasks) {
+            Object.keys(data.tasks).forEach(date => {
+                data.tasks[date] = data.tasks[date].map((task) => this.hydrateTask(task));
+            });
+        }
+        if (data.timeline) {
+            Object.keys(data.timeline).forEach(date => {
+                data.timeline[date] = data.timeline[date].map((event) => ({
+                    ...event,
+                    timestamp: new Date(event.timestamp),
+                    previousState: event.previousState,
+                    newState: event.newState,
+                }));
+            });
+        }
+        return data;
+    }
+    hydrateTask(task) {
+        return {
+            ...task,
+            createdAt: new Date(task.createdAt),
+            updatedAt: new Date(task.updatedAt),
+            startTime: task.startTime ? new Date(task.startTime) : undefined,
+            endTime: task.endTime ? new Date(task.endTime) : undefined,
+            children: task.children ? task.children.map((child) => this.hydrateTask(child)) : [],
+        };
+    }
+    serializeDates(data) {
+        return {
+            ...data,
+            tasks: Object.keys(data.tasks).reduce((acc, date) => {
+                acc[date] = data.tasks[date].map(task => this.serializeTask(task));
+                return acc;
+            }, {}),
+            timeline: Object.keys(data.timeline).reduce((acc, date) => {
+                acc[date] = data.timeline[date].map(event => ({
+                    ...event,
+                    timestamp: event.timestamp.toISOString(),
+                }));
+                return acc;
+            }, {}),
+        };
+    }
+    serializeTask(task) {
+        return {
+            ...task,
+            createdAt: task.createdAt.toISOString(),
+            updatedAt: task.updatedAt.toISOString(),
+            startTime: task.startTime ? task.startTime.toISOString() : undefined,
+            endTime: task.endTime ? task.endTime.toISOString() : undefined,
+            children: task.children ? task.children.map((child) => this.serializeTask(child)) : [],
+        };
+    }
+}
+export const storageService = new StorageService();

package/dist/services/taskService.d.ts

@@ -0,0 +1,17 @@
+import type { Task, TaskState, TaskTree } from '../types/task';
+export declare class TaskService {
+    createTask(title: string, date: string, state?: TaskState): Task;
+    updateTask(tasks: TaskTree, taskId: string, updates: Partial<Task>): TaskTree;
+    deleteTask(tasks: TaskTree, taskId: string): TaskTree;
+    addSubtask(tasks: TaskTree, parentId: string, title: string): TaskTree;
+    changeTaskState(tasks: TaskTree, taskId: string, newState: TaskState): TaskTree;
+    startTask(tasks: TaskTree, taskId: string, startTime?: Date): TaskTree;
+    getTasksForDate(tasks: TaskTree, date: string): Task[];
+    getAllTasks(tasks: TaskTree): Task[];
+    getTaskStats(tasks: TaskTree, date: string): {
+        total: number;
+        completed: number;
+        percentage: number;
+    };
+}
+export declare const taskService: TaskService;