floq 0.2.3 → 0.3.0

package/dist/ui/components/KanbanBoard.js

@@ -14,10 +14,12 @@ import { t, fmt } from '../../i18n/index.js';
 import { useTheme } from '../theme/index.js';
 import { isTursoEnabled } from '../../config.js';
 import { VERSION } from '../../version.js';
+import { useHistory, CreateTaskCommand, MoveTaskCommand, LinkTaskCommand, CreateCommentCommand, DeleteCommentCommand, } from '../history/index.js';
 const COLUMNS = ['todo', 'doing', 'done'];
 export function KanbanBoard({ onSwitchToGtd, onOpenSettings }) {
     const theme = useTheme();
     const { exit } = useApp();
+    const history = useHistory();
     const [mode, setMode] = useState('normal');
     const [inputValue, setInputValue] = useState('');
     const [currentColumnIndex, setCurrentColumnIndex] = useState(0);
@@ -87,32 +89,42 @@ export function KanbanBoard({ onSwitchToGtd, onOpenSettings }) {
         setTaskComments(comments);
     }, []);
     const addCommentToTask = useCallback(async (task, content) => {
-        const db = getDb();
-        await db.insert(schema.comments).values({
-            id: uuidv4(),
-            taskId: task.id,
-            content: content.trim(),
-            createdAt: new Date(),
+        const commentId = uuidv4();
+        const command = new CreateCommentCommand({
+            comment: {
+                id: commentId,
+                taskId: task.id,
+                content: content.trim(),
+                createdAt: new Date(),
+            },
+            description: i18n.tui.commentAdded || 'Comment added',
         });
+        await history.execute(command);
         setMessage(i18n.tui.commentAdded || 'Comment added');
         await loadTaskComments(task.id);
-    }, [i18n.tui.commentAdded, loadTaskComments]);
+    }, [i18n.tui.commentAdded, loadTaskComments, history]);
     const deleteComment = useCallback(async (comment) => {
-        const db = getDb();
-        await db.delete(schema.comments).where(eq(schema.comments.id, comment.id));
+        const command = new DeleteCommentCommand({
+            comment,
+            description: i18n.tui.commentDeleted || 'Comment deleted',
+        });
+        await history.execute(command);
         setMessage(i18n.tui.commentDeleted || 'Comment deleted');
         if (selectedTask) {
             await loadTaskComments(selectedTask.id);
         }
-    }, [i18n.tui.commentDeleted, loadTaskComments, selectedTask]);
+    }, [i18n.tui.commentDeleted, loadTaskComments, selectedTask, history]);
     const linkTaskToProject = useCallback(async (task, project) => {
-        const db = getDb();
-        await db.update(schema.tasks)
-            .set({ parentId: project.id, updatedAt: new Date() })
-            .where(eq(schema.tasks.id, task.id));
+        const command = new LinkTaskCommand({
+            taskId: task.id,
+            fromParentId: task.parentId,
+            toParentId: project.id,
+            description: fmt(i18n.tui.linkedToProject || 'Linked "{title}" to {project}', { title: task.title, project: project.title }),
+        });
+        await history.execute(command);
         setMessage(fmt(i18n.tui.linkedToProject || 'Linked "{title}" to {project}', { title: task.title, project: project.title }));
         await loadTasks();
-    }, [i18n.tui.linkedToProject, loadTasks]);
+    }, [i18n.tui.linkedToProject, loadTasks, history]);
     const currentColumn = COLUMNS[currentColumnIndex];
     const currentTasks = tasks[currentColumn];
     const selectedTaskIndex = selectedTaskIndices[currentColumn];
@@ -167,19 +179,22 @@ export function KanbanBoard({ onSwitchToGtd, onOpenSettings }) {
     const addTask = useCallback(async (title) => {
         if (!title.trim())
             return;
-        const db = getDb();
         const now = new Date();
-        await db.insert(schema.tasks)
-            .values({
-            id: uuidv4(),
-            title: title.trim(),
-            status: 'inbox', // New tasks go to inbox (which maps to TODO)
-            createdAt: now,
-            updatedAt: now,
+        const taskId = uuidv4();
+        const command = new CreateTaskCommand({
+            task: {
+                id: taskId,
+                title: title.trim(),
+                status: 'inbox', // New tasks go to inbox (which maps to TODO)
+                createdAt: now,
+                updatedAt: now,
+            },
+            description: fmt(i18n.tui.added, { title: title.trim() }),
         });
+        await history.execute(command);
         setMessage(fmt(i18n.tui.added, { title: title.trim() }));
         await loadTasks();
-    }, [i18n.tui.added, loadTasks]);
+    }, [i18n.tui.added, loadTasks, history]);
     const handleInputSubmit = async (value) => {
         if (mode === 'add-comment' && selectedTask) {
             if (value.trim()) {
@@ -210,7 +225,6 @@ export function KanbanBoard({ onSwitchToGtd, onOpenSettings }) {
         setMode('normal');
     };
     const moveTaskRight = useCallback(async (task) => {
-        const db = getDb();
         let newStatus;
         // Determine new status based on current status
         if (task.status === 'inbox' || task.status === 'someday') {
@@ -225,14 +239,19 @@ export function KanbanBoard({ onSwitchToGtd, onOpenSettings }) {
             // Already done, do nothing
             return;
         }
-        await db.update(schema.tasks)
-            .set({ status: newStatus, waitingFor: null, updatedAt: new Date() })
-            .where(eq(schema.tasks.id, task.id));
+        const command = new MoveTaskCommand({
+            taskId: task.id,
+            fromStatus: task.status,
+            toStatus: newStatus,
+            fromWaitingFor: task.waitingFor,
+            toWaitingFor: null,
+            description: fmt(i18n.tui.movedTo, { title: task.title, status: i18n.status[newStatus] }),
+        });
+        await history.execute(command);
         setMessage(fmt(i18n.tui.movedTo, { title: task.title, status: i18n.status[newStatus] }));
         await loadTasks();
-    }, [i18n.tui.movedTo, i18n.status, loadTasks]);
+    }, [i18n.tui.movedTo, i18n.status, loadTasks, history]);
     const moveTaskLeft = useCallback(async (task) => {
-        const db = getDb();
         let newStatus;
         // Determine new status based on current status
         if (task.status === 'next' || task.status === 'waiting') {
@@ -247,20 +266,31 @@ export function KanbanBoard({ onSwitchToGtd, onOpenSettings }) {
             // Already in TODO, do nothing
             return;
         }
-        await db.update(schema.tasks)
-            .set({ status: newStatus, waitingFor: null, updatedAt: new Date() })
-            .where(eq(schema.tasks.id, task.id));
+        const command = new MoveTaskCommand({
+            taskId: task.id,
+            fromStatus: task.status,
+            toStatus: newStatus,
+            fromWaitingFor: task.waitingFor,
+            toWaitingFor: null,
+            description: fmt(i18n.tui.movedTo, { title: task.title, status: i18n.status[newStatus] }),
+        });
+        await history.execute(command);
         setMessage(fmt(i18n.tui.movedTo, { title: task.title, status: i18n.status[newStatus] }));
         await loadTasks();
-    }, [i18n.tui.movedTo, i18n.status, loadTasks]);
+    }, [i18n.tui.movedTo, i18n.status, loadTasks, history]);
     const markTaskDone = useCallback(async (task) => {
-        const db = getDb();
-        await db.update(schema.tasks)
-            .set({ status: 'done', updatedAt: new Date() })
-            .where(eq(schema.tasks.id, task.id));
+        const command = new MoveTaskCommand({
+            taskId: task.id,
+            fromStatus: task.status,
+            toStatus: 'done',
+            fromWaitingFor: task.waitingFor,
+            toWaitingFor: null,
+            description: fmt(i18n.tui.completed, { title: task.title }),
+        });
+        await history.execute(command);
         setMessage(fmt(i18n.tui.completed, { title: task.title }));
         await loadTasks();
-    }, [i18n.tui.completed, loadTasks]);
+    }, [i18n.tui.completed, loadTasks, history]);
     const getColumnLabel = (column) => {
         return i18n.kanban[column];
     };
@@ -500,11 +530,41 @@ export function KanbanBoard({ onSwitchToGtd, onOpenSettings }) {
             return;
         }
         // Refresh
-        if (input === 'r') {
+        if (input === 'r' && !(key.ctrl)) {
             loadTasks();
             setMessage(i18n.tui.refreshed);
             return;
         }
+        // Undo (u key) - only in normal mode
+        if (input === 'u' && mode === 'normal') {
+            history.undo().then((didUndo) => {
+                if (didUndo) {
+                    setMessage(fmt(i18n.tui.undone, { action: history.undoDescription || '' }));
+                    loadTasks();
+                }
+                else {
+                    setMessage(i18n.tui.nothingToUndo);
+                }
+            }).catch(() => {
+                setMessage(i18n.tui.undoFailed);
+            });
+            return;
+        }
+        // Redo (Ctrl+r) - only in normal mode
+        if (key.ctrl && input === 'r' && mode === 'normal') {
+            history.redo().then((didRedo) => {
+                if (didRedo) {
+                    setMessage(fmt(i18n.tui.redone, { action: history.redoDescription || '' }));
+                    loadTasks();
+                }
+                else {
+                    setMessage(i18n.tui.nothingToRedo);
+                }
+            }).catch(() => {
+                setMessage(i18n.tui.redoFailed);
+            });
+            return;
+        }
     });
     // Help modal overlay
     if (mode === 'help') {

package/dist/ui/history/HistoryContext.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import type { UndoableCommand, HistoryState } from './types.js';
+interface HistoryContextValue {
+    /** Execute a command and add to history */
+    execute: (command: UndoableCommand) => Promise<void>;
+    /** Undo the last command */
+    undo: () => Promise<boolean>;
+    /** Redo the last undone command */
+    redo: () => Promise<boolean>;
+    /** Check if undo is available */
+    canUndo: boolean;
+    /** Check if redo is available */
+    canRedo: boolean;
+    /** Get the current history state */
+    state: HistoryState;
+    /** Description of command that would be undone */
+    undoDescription: string | null;
+    /** Description of command that would be redone */
+    redoDescription: string | null;
+}
+interface HistoryProviderProps {
+    children: React.ReactNode;
+}
+export declare function HistoryProvider({ children }: HistoryProviderProps): React.ReactElement;
+/**
+ * Hook to access history context
+ */
+export declare function useHistoryContext(): HistoryContextValue;
+export {};

package/dist/ui/history/HistoryContext.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useState, useCallback, useMemo } from 'react';
+import { getHistoryManager } from './HistoryManager.js';
+const HistoryContext = createContext(null);
+export function HistoryProvider({ children }) {
+    const manager = useMemo(() => getHistoryManager(), []);
+    const [state, setState] = useState(manager.getState());
+    useEffect(() => {
+        const unsubscribe = manager.subscribe(() => {
+            setState(manager.getState());
+        });
+        return unsubscribe;
+    }, [manager]);
+    const execute = useCallback(async (command) => {
+        await manager.execute(command);
+    }, [manager]);
+    const undo = useCallback(async () => {
+        return manager.undo();
+    }, [manager]);
+    const redo = useCallback(async () => {
+        return manager.redo();
+    }, [manager]);
+    const value = useMemo(() => ({
+        execute,
+        undo,
+        redo,
+        canUndo: manager.canUndo(),
+        canRedo: manager.canRedo(),
+        state,
+        undoDescription: manager.getUndoDescription(),
+        redoDescription: manager.getRedoDescription(),
+    }), [execute, undo, redo, state, manager]);
+    return _jsx(HistoryContext.Provider, { value: value, children: children });
+}
+/**
+ * Hook to access history context
+ */
+export function useHistoryContext() {
+    const context = useContext(HistoryContext);
+    if (!context) {
+        throw new Error('useHistoryContext must be used within a HistoryProvider');
+    }
+    return context;
+}

package/dist/ui/history/HistoryManager.d.ts

@@ -0,0 +1,56 @@
+import type { UndoableCommand, HistoryState } from './types.js';
+/**
+ * Manages undo/redo history using the Command Pattern
+ */
+export declare class HistoryManager {
+    private undoStack;
+    private redoStack;
+    private listeners;
+    /**
+     * Execute a command and add it to the undo stack
+     */
+    execute(command: UndoableCommand): Promise<void>;
+    /**
+     * Undo the last command
+     * @returns true if undo was performed, false if nothing to undo
+     */
+    undo(): Promise<boolean>;
+    /**
+     * Redo the last undone command
+     * @returns true if redo was performed, false if nothing to redo
+     */
+    redo(): Promise<boolean>;
+    /**
+     * Get the current history state
+     */
+    getState(): HistoryState;
+    /**
+     * Check if undo is available
+     */
+    canUndo(): boolean;
+    /**
+     * Check if redo is available
+     */
+    canRedo(): boolean;
+    /**
+     * Get description of the command that would be undone
+     */
+    getUndoDescription(): string | null;
+    /**
+     * Get description of the command that would be redone
+     */
+    getRedoDescription(): string | null;
+    /**
+     * Clear all history
+     */
+    clear(): void;
+    /**
+     * Subscribe to history changes
+     */
+    subscribe(listener: () => void): () => void;
+    private notifyListeners;
+}
+/**
+ * Get the singleton HistoryManager instance
+ */
+export declare function getHistoryManager(): HistoryManager;

package/dist/ui/history/HistoryManager.js

@@ -0,0 +1,137 @@
+import { MAX_HISTORY_SIZE } from './types.js';
+/**
+ * Manages undo/redo history using the Command Pattern
+ */
+export class HistoryManager {
+    undoStack = [];
+    redoStack = [];
+    listeners = new Set();
+    /**
+     * Execute a command and add it to the undo stack
+     */
+    async execute(command) {
+        await command.execute();
+        // Add to undo stack
+        this.undoStack.push(command);
+        // Clear redo stack (new action invalidates redo history)
+        this.redoStack = [];
+        // Enforce max history size
+        if (this.undoStack.length > MAX_HISTORY_SIZE) {
+            this.undoStack.shift();
+        }
+        this.notifyListeners();
+    }
+    /**
+     * Undo the last command
+     * @returns true if undo was performed, false if nothing to undo
+     */
+    async undo() {
+        const command = this.undoStack.pop();
+        if (!command) {
+            return false;
+        }
+        try {
+            await command.undo();
+            this.redoStack.push(command);
+            this.notifyListeners();
+            return true;
+        }
+        catch (error) {
+            // Re-add command to undo stack if undo fails
+            this.undoStack.push(command);
+            throw error;
+        }
+    }
+    /**
+     * Redo the last undone command
+     * @returns true if redo was performed, false if nothing to redo
+     */
+    async redo() {
+        const command = this.redoStack.pop();
+        if (!command) {
+            return false;
+        }
+        try {
+            await command.execute();
+            this.undoStack.push(command);
+            this.notifyListeners();
+            return true;
+        }
+        catch (error) {
+            // Re-add command to redo stack if redo fails
+            this.redoStack.push(command);
+            throw error;
+        }
+    }
+    /**
+     * Get the current history state
+     */
+    getState() {
+        return {
+            undoCount: this.undoStack.length,
+            redoCount: this.redoStack.length,
+            lastCommandDescription: this.undoStack.length > 0
+                ? this.undoStack[this.undoStack.length - 1].description
+                : null,
+        };
+    }
+    /**
+     * Check if undo is available
+     */
+    canUndo() {
+        return this.undoStack.length > 0;
+    }
+    /**
+     * Check if redo is available
+     */
+    canRedo() {
+        return this.redoStack.length > 0;
+    }
+    /**
+     * Get description of the command that would be undone
+     */
+    getUndoDescription() {
+        return this.undoStack.length > 0
+            ? this.undoStack[this.undoStack.length - 1].description
+            : null;
+    }
+    /**
+     * Get description of the command that would be redone
+     */
+    getRedoDescription() {
+        return this.redoStack.length > 0
+            ? this.redoStack[this.redoStack.length - 1].description
+            : null;
+    }
+    /**
+     * Clear all history
+     */
+    clear() {
+        this.undoStack = [];
+        this.redoStack = [];
+        this.notifyListeners();
+    }
+    /**
+     * Subscribe to history changes
+     */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    notifyListeners() {
+        for (const listener of this.listeners) {
+            listener();
+        }
+    }
+}
+// Singleton instance
+let historyManagerInstance = null;
+/**
+ * Get the singleton HistoryManager instance
+ */
+export function getHistoryManager() {
+    if (!historyManagerInstance) {
+        historyManagerInstance = new HistoryManager();
+    }
+    return historyManagerInstance;
+}

package/dist/ui/history/commands/ConvertToProjectCommand.d.ts

@@ -0,0 +1,19 @@
+import type { UndoableCommand } from '../types.js';
+import type { TaskStatus } from '../../../db/schema.js';
+interface ConvertToProjectParams {
+    taskId: string;
+    originalStatus: TaskStatus;
+    description: string;
+}
+/**
+ * Command to convert a task to a project
+ */
+export declare class ConvertToProjectCommand implements UndoableCommand {
+    readonly description: string;
+    private readonly taskId;
+    private readonly originalStatus;
+    constructor(params: ConvertToProjectParams);
+    execute(): Promise<void>;
+    undo(): Promise<void>;
+}
+export {};

package/dist/ui/history/commands/ConvertToProjectCommand.js

@@ -0,0 +1,37 @@
+import { eq } from 'drizzle-orm';
+import { getDb, schema } from '../../../db/index.js';
+/**
+ * Command to convert a task to a project
+ */
+export class ConvertToProjectCommand {
+    description;
+    taskId;
+    originalStatus;
+    constructor(params) {
+        this.taskId = params.taskId;
+        this.originalStatus = params.originalStatus;
+        this.description = params.description;
+    }
+    async execute() {
+        const db = getDb();
+        await db
+            .update(schema.tasks)
+            .set({
+            isProject: true,
+            status: 'next',
+            updatedAt: new Date(),
+        })
+            .where(eq(schema.tasks.id, this.taskId));
+    }
+    async undo() {
+        const db = getDb();
+        await db
+            .update(schema.tasks)
+            .set({
+            isProject: false,
+            status: this.originalStatus,
+            updatedAt: new Date(),
+        })
+            .where(eq(schema.tasks.id, this.taskId));
+    }
+}

package/dist/ui/history/commands/CreateCommentCommand.d.ts

@@ -0,0 +1,18 @@
+import type { UndoableCommand } from '../types.js';
+import type { NewComment } from '../../../db/schema.js';
+interface CreateCommentParams {
+    comment: NewComment;
+    description: string;
+}
+/**
+ * Command to create a new comment
+ */
+export declare class CreateCommentCommand implements UndoableCommand {
+    readonly description: string;
+    private readonly comment;
+    private createdCommentId;
+    constructor(params: CreateCommentParams);
+    execute(): Promise<void>;
+    undo(): Promise<void>;
+}
+export {};

package/dist/ui/history/commands/CreateCommentCommand.js

@@ -0,0 +1,23 @@
+import { eq } from 'drizzle-orm';
+import { getDb, schema } from '../../../db/index.js';
+/**
+ * Command to create a new comment
+ */
+export class CreateCommentCommand {
+    description;
+    comment;
+    createdCommentId;
+    constructor(params) {
+        this.comment = params.comment;
+        this.description = params.description;
+        this.createdCommentId = params.comment.id;
+    }
+    async execute() {
+        const db = getDb();
+        await db.insert(schema.comments).values(this.comment);
+    }
+    async undo() {
+        const db = getDb();
+        await db.delete(schema.comments).where(eq(schema.comments.id, this.createdCommentId));
+    }
+}

package/dist/ui/history/commands/CreateTaskCommand.d.ts

@@ -0,0 +1,18 @@
+import type { UndoableCommand } from '../types.js';
+import type { NewTask } from '../../../db/schema.js';
+interface CreateTaskParams {
+    task: NewTask;
+    description: string;
+}
+/**
+ * Command to create a new task
+ */
+export declare class CreateTaskCommand implements UndoableCommand {
+    readonly description: string;
+    private readonly task;
+    private createdTaskId;
+    constructor(params: CreateTaskParams);
+    execute(): Promise<void>;
+    undo(): Promise<void>;
+}
+export {};

package/dist/ui/history/commands/CreateTaskCommand.js

@@ -0,0 +1,24 @@
+import { eq } from 'drizzle-orm';
+import { getDb, schema } from '../../../db/index.js';
+/**
+ * Command to create a new task
+ */
+export class CreateTaskCommand {
+    description;
+    task;
+    createdTaskId;
+    constructor(params) {
+        this.task = params.task;
+        this.description = params.description;
+        this.createdTaskId = params.task.id;
+    }
+    async execute() {
+        const db = getDb();
+        await db.insert(schema.tasks).values(this.task);
+    }
+    async undo() {
+        const db = getDb();
+        // Delete the created task
+        await db.delete(schema.tasks).where(eq(schema.tasks.id, this.createdTaskId));
+    }
+}

package/dist/ui/history/commands/DeleteCommentCommand.d.ts

@@ -0,0 +1,17 @@
+import type { UndoableCommand } from '../types.js';
+import type { Comment } from '../../../db/schema.js';
+interface DeleteCommentParams {
+    comment: Comment;
+    description: string;
+}
+/**
+ * Command to delete a comment
+ */
+export declare class DeleteCommentCommand implements UndoableCommand {
+    readonly description: string;
+    private readonly comment;
+    constructor(params: DeleteCommentParams);
+    execute(): Promise<void>;
+    undo(): Promise<void>;
+}
+export {};

package/dist/ui/history/commands/DeleteCommentCommand.js

@@ -0,0 +1,26 @@
+import { eq } from 'drizzle-orm';
+import { getDb, schema } from '../../../db/index.js';
+/**
+ * Command to delete a comment
+ */
+export class DeleteCommentCommand {
+    description;
+    comment;
+    constructor(params) {
+        this.comment = params.comment;
+        this.description = params.description;
+    }
+    async execute() {
+        const db = getDb();
+        await db.delete(schema.comments).where(eq(schema.comments.id, this.comment.id));
+    }
+    async undo() {
+        const db = getDb();
+        await db.insert(schema.comments).values({
+            id: this.comment.id,
+            taskId: this.comment.taskId,
+            content: this.comment.content,
+            createdAt: this.comment.createdAt,
+        });
+    }
+}