floq 1.4.1 → 1.5.0

package/dist/ui/components/KanbanMario.js

@@ -244,6 +244,7 @@ export function KanbanMario({ onOpenSettings }) {
             toStatus: newStatus,
             fromWaitingFor: task.waitingFor,
             toWaitingFor: null,
+            fromCompletedAt: task.completedAt,
             description: fmt(i18n.tui.movedTo, { title: task.title, status: i18n.status[newStatus] }),
         });
         await history.execute(command);
@@ -257,6 +258,7 @@ export function KanbanMario({ onOpenSettings }) {
             toStatus: 'done',
             fromWaitingFor: task.waitingFor,
             toWaitingFor: null,
+            fromCompletedAt: task.completedAt,
             description: fmt(i18n.tui.completed, { title: task.title }),
         });
         await history.execute(command);

package/dist/ui/components/TaskItem.d.ts

@@ -9,6 +9,7 @@ interface TaskItemProps {
     isSelected: boolean;
     projectName?: string;
     progress?: ProjectProgress;
+    showStatus?: boolean;
 }
-export declare function TaskItem({ task, isSelected, projectName, progress }: TaskItemProps): React.ReactElement;
+export declare function TaskItem({ task, isSelected, projectName, progress, showStatus }: TaskItemProps): React.ReactElement;
 export {};

package/dist/ui/components/TaskItem.js

@@ -1,16 +1,17 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { t } from '../../i18n/index.js';
 import { useTheme } from '../theme/index.js';
 import { ProgressBar } from './ProgressBar.js';
+import { StatusBadge } from './StatusBadge.js';
 const EFFORT_LABELS = {
     small: 'S',
     medium: 'M',
     large: 'L',
 };
-export function TaskItem({ task, isSelected, projectName, progress }) {
+export function TaskItem({ task, isSelected, projectName, progress, showStatus }) {
     const shortId = task.id.slice(0, 8);
     const i18n = t();
     const theme = useTheme();
-    return (_jsx(Box, { children: _jsxs(Text, { color: isSelected ? theme.colors.textSelected : theme.colors.text, bold: isSelected, children: [isSelected ? theme.style.selectedPrefix : theme.style.unselectedPrefix, task.isFocused && _jsx(Text, { color: theme.colors.accent, children: "\u2605 " }), "[", shortId, "] ", task.effort && _jsxs(Text, { color: theme.colors.secondary, children: ["[", EFFORT_LABELS[task.effort], "] "] }), task.title, task.context && (_jsxs(Text, { color: theme.colors.accent, children: [" @", task.context] })), projectName && (_jsxs(Text, { color: theme.colors.statusSomeday, children: [" [", projectName, "]"] })), progress && progress.total > 0 && (_jsx(ProgressBar, { completed: progress.completed, total: progress.total })), task.waitingFor && (_jsxs(Text, { color: theme.colors.statusWaiting, children: [" (", i18n.status.waiting.toLowerCase(), ": ", task.waitingFor, ")"] })), task.dueDate && (_jsxs(Text, { color: theme.colors.accent, children: [" (due: ", task.dueDate.toLocaleDateString(), ")"] }))] }) }));
+    return (_jsx(Box, { children: _jsxs(Text, { color: isSelected ? theme.colors.textSelected : theme.colors.text, bold: isSelected, children: [isSelected ? theme.style.selectedPrefix : theme.style.unselectedPrefix, task.isFocused && _jsx(Text, { color: theme.colors.accent, children: "\u2605 " }), "[", shortId, "] ", showStatus && _jsxs(_Fragment, { children: [_jsx(StatusBadge, { status: task.status }), _jsx(Text, { children: " " })] }), task.effort && _jsxs(Text, { color: theme.colors.secondary, children: ["[", EFFORT_LABELS[task.effort], "] "] }), task.title, task.context && (_jsxs(Text, { color: theme.colors.accent, children: [" @", task.context] })), projectName && (_jsxs(Text, { color: theme.colors.statusSomeday, children: [" [", projectName, "]"] })), progress && progress.total > 0 && (_jsx(ProgressBar, { completed: progress.completed, total: progress.total })), task.waitingFor && (_jsxs(Text, { color: theme.colors.statusWaiting, children: [" (", i18n.status.waiting.toLowerCase(), ": ", task.waitingFor, ")"] })), task.dueDate && (_jsxs(Text, { color: theme.colors.accent, children: [" (due: ", task.dueDate.toLocaleDateString(), ")"] }))] }) }));
 }

package/dist/ui/history/HistoryContext.js

@@ -5,6 +5,14 @@ const HistoryContext = createContext(null);
 export function HistoryProvider({ children }) {
     const manager = useMemo(() => getHistoryManager(), []);
     const [state, setState] = useState(manager.getState());
+    useEffect(() => {
+        // Load persisted history from DB on mount
+        manager.init().then(() => {
+            setState(manager.getState());
+        }).catch(() => {
+            // Ignore init errors - in-memory still works
+        });
+    }, [manager]);
     useEffect(() => {
         const unsubscribe = manager.subscribe(() => {
             setState(manager.getState());

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

@@ -1,11 +1,17 @@
 import type { UndoableCommand, HistoryState } from './types.js';
 /**
  * Manages undo/redo history using the Command Pattern
+ * with DB persistence for crash-safe undo
  */
 export declare class HistoryManager {
     private undoStack;
     private redoStack;
     private listeners;
+    private initialized;
+    /**
+     * Initialize by loading history from DB
+     */
+    init(): Promise<void>;
     /**
      * Execute a command and add it to the undo stack
      */
@@ -43,11 +49,13 @@ export declare class HistoryManager {
     /**
      * Clear all history
      */
-    clear(): void;
+    clear(): Promise<void>;
     /**
      * Subscribe to history changes
      */
     subscribe(listener: () => void): () => void;
+    private loadFromDb;
+    private clearRedoFromDb;
     private notifyListeners;
 }
 /**

package/dist/ui/history/HistoryManager.js

@@ -1,23 +1,70 @@
+import { v4 as uuidv4 } from 'uuid';
+import { eq, desc, asc } from 'drizzle-orm';
+import { getDb, schema } from '../../db/index.js';
+import { deserializeCommand } from './commands/registry.js';
 import { MAX_HISTORY_SIZE } from './types.js';
 /**
  * Manages undo/redo history using the Command Pattern
+ * with DB persistence for crash-safe undo
  */
 export class HistoryManager {
     undoStack = [];
     redoStack = [];
     listeners = new Set();
+    initialized = false;
+    /**
+     * Initialize by loading history from DB
+     */
+    async init() {
+        if (this.initialized)
+            return;
+        try {
+            await this.loadFromDb();
+        }
+        catch {
+            // DB may not have the table yet - that's OK, just use in-memory
+        }
+        this.initialized = true;
+    }
     /**
      * Execute a command and add it to the undo stack
      */
     async execute(command) {
         await command.execute();
+        const dbId = uuidv4();
+        // Persist to DB
+        try {
+            const serialized = command.toJSON();
+            const db = getDb();
+            await db.insert(schema.operationHistory).values({
+                id: dbId,
+                commandType: serialized.type,
+                commandData: JSON.stringify(serialized.data),
+                executedAt: new Date(),
+                isUndone: false,
+            });
+        }
+        catch {
+            // If DB write fails, in-memory undo still works
+        }
         // Add to undo stack
-        this.undoStack.push(command);
+        this.undoStack.push({ dbId, command });
         // Clear redo stack (new action invalidates redo history)
+        // Also clean up DB records for redo items
+        await this.clearRedoFromDb();
         this.redoStack = [];
         // Enforce max history size
         if (this.undoStack.length > MAX_HISTORY_SIZE) {
-            this.undoStack.shift();
+            const removed = this.undoStack.shift();
+            if (removed) {
+                try {
+                    const db = getDb();
+                    await db.delete(schema.operationHistory).where(eq(schema.operationHistory.id, removed.dbId));
+                }
+                catch {
+                    // ignore
+                }
+            }
         }
         this.notifyListeners();
     }
@@ -26,19 +73,29 @@ export class HistoryManager {
      * @returns true if undo was performed, false if nothing to undo
      */
     async undo() {
-        const command = this.undoStack.pop();
-        if (!command) {
+        const tracked = this.undoStack.pop();
+        if (!tracked) {
             return false;
         }
         try {
-            await command.undo();
-            this.redoStack.push(command);
+            await tracked.command.undo();
+            // Mark as undone in DB
+            try {
+                const db = getDb();
+                await db.update(schema.operationHistory)
+                    .set({ isUndone: true })
+                    .where(eq(schema.operationHistory.id, tracked.dbId));
+            }
+            catch {
+                // ignore DB errors
+            }
+            this.redoStack.push(tracked);
             this.notifyListeners();
             return true;
         }
         catch (error) {
             // Re-add command to undo stack if undo fails
-            this.undoStack.push(command);
+            this.undoStack.push(tracked);
             throw error;
         }
     }
@@ -47,19 +104,29 @@ export class HistoryManager {
      * @returns true if redo was performed, false if nothing to redo
      */
     async redo() {
-        const command = this.redoStack.pop();
-        if (!command) {
+        const tracked = this.redoStack.pop();
+        if (!tracked) {
             return false;
         }
         try {
-            await command.execute();
-            this.undoStack.push(command);
+            await tracked.command.execute();
+            // Mark as not undone in DB
+            try {
+                const db = getDb();
+                await db.update(schema.operationHistory)
+                    .set({ isUndone: false })
+                    .where(eq(schema.operationHistory.id, tracked.dbId));
+            }
+            catch {
+                // ignore DB errors
+            }
+            this.undoStack.push(tracked);
             this.notifyListeners();
             return true;
         }
         catch (error) {
             // Re-add command to redo stack if redo fails
-            this.redoStack.push(command);
+            this.redoStack.push(tracked);
             throw error;
         }
     }
@@ -71,7 +138,7 @@ export class HistoryManager {
             undoCount: this.undoStack.length,
             redoCount: this.redoStack.length,
             lastCommandDescription: this.undoStack.length > 0
-                ? this.undoStack[this.undoStack.length - 1].description
+                ? this.undoStack[this.undoStack.length - 1].command.description
                 : null,
         };
     }
@@ -92,7 +159,7 @@ export class HistoryManager {
      */
     getUndoDescription() {
         return this.undoStack.length > 0
-            ? this.undoStack[this.undoStack.length - 1].description
+            ? this.undoStack[this.undoStack.length - 1].command.description
             : null;
     }
     /**
@@ -100,15 +167,22 @@ export class HistoryManager {
      */
     getRedoDescription() {
         return this.redoStack.length > 0
-            ? this.redoStack[this.redoStack.length - 1].description
+            ? this.redoStack[this.redoStack.length - 1].command.description
             : null;
     }
     /**
      * Clear all history
      */
-    clear() {
+    async clear() {
         this.undoStack = [];
         this.redoStack = [];
+        try {
+            const db = getDb();
+            await db.delete(schema.operationHistory);
+        }
+        catch {
+            // ignore DB errors
+        }
         this.notifyListeners();
     }
     /**
@@ -118,6 +192,56 @@ export class HistoryManager {
         this.listeners.add(listener);
         return () => this.listeners.delete(listener);
     }
+    async loadFromDb() {
+        const db = getDb();
+        // Load undo stack: non-undone operations, oldest first
+        const undoRows = await db
+            .select()
+            .from(schema.operationHistory)
+            .where(eq(schema.operationHistory.isUndone, false))
+            .orderBy(asc(schema.operationHistory.executedAt))
+            .limit(MAX_HISTORY_SIZE);
+        for (const row of undoRows) {
+            try {
+                const data = JSON.parse(row.commandData);
+                const command = deserializeCommand(row.commandType, data);
+                this.undoStack.push({ dbId: row.id, command });
+            }
+            catch {
+                // Skip commands that can't be deserialized
+            }
+        }
+        // Load redo stack: undone operations, most recent first (so most recent undo is on top)
+        const redoRows = await db
+            .select()
+            .from(schema.operationHistory)
+            .where(eq(schema.operationHistory.isUndone, true))
+            .orderBy(desc(schema.operationHistory.executedAt))
+            .limit(MAX_HISTORY_SIZE);
+        for (const row of redoRows) {
+            try {
+                const data = JSON.parse(row.commandData);
+                const command = deserializeCommand(row.commandType, data);
+                this.redoStack.push({ dbId: row.id, command });
+            }
+            catch {
+                // Skip commands that can't be deserialized
+            }
+        }
+    }
+    async clearRedoFromDb() {
+        if (this.redoStack.length === 0)
+            return;
+        try {
+            const db = getDb();
+            for (const tracked of this.redoStack) {
+                await db.delete(schema.operationHistory).where(eq(schema.operationHistory.id, tracked.dbId));
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
     notifyListeners() {
         for (const listener of this.listeners) {
             listener();

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

@@ -1,4 +1,4 @@
-import type { UndoableCommand } from '../types.js';
+import type { UndoableCommand, SerializedCommand } from '../types.js';
 import type { TaskStatus } from '../../../db/schema.js';
 interface ConvertToProjectParams {
     taskId: string;
@@ -15,5 +15,9 @@ export declare class ConvertToProjectCommand implements UndoableCommand {
     constructor(params: ConvertToProjectParams);
     execute(): Promise<void>;
     undo(): Promise<void>;
+    toJSON(): SerializedCommand;
+    static fromJSON(json: {
+        data: Record<string, unknown>;
+    }): ConvertToProjectCommand;
 }
 export {};

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

@@ -34,4 +34,17 @@ export class ConvertToProjectCommand {
         })
             .where(eq(schema.tasks.id, this.taskId));
     }
+    toJSON() {
+        return {
+            type: 'convert_to_project',
+            data: {
+                taskId: this.taskId,
+                originalStatus: this.originalStatus,
+                description: this.description,
+            },
+        };
+    }
+    static fromJSON(json) {
+        return new ConvertToProjectCommand(json.data);
+    }
 }

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

@@ -1,4 +1,4 @@
-import type { UndoableCommand } from '../types.js';
+import type { UndoableCommand, SerializedCommand } from '../types.js';
 import type { NewComment } from '../../../db/schema.js';
 interface CreateCommentParams {
     comment: NewComment;
@@ -14,5 +14,9 @@ export declare class CreateCommentCommand implements UndoableCommand {
     constructor(params: CreateCommentParams);
     execute(): Promise<void>;
     undo(): Promise<void>;
+    toJSON(): SerializedCommand;
+    static fromJSON(json: {
+        data: Record<string, unknown>;
+    }): CreateCommentCommand;
 }
 export {};

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

@@ -20,4 +20,26 @@ export class CreateCommentCommand {
         const db = getDb();
         await db.delete(schema.comments).where(eq(schema.comments.id, this.createdCommentId));
     }
+    toJSON() {
+        return {
+            type: 'create_comment',
+            data: {
+                comment: {
+                    ...this.comment,
+                    createdAt: this.comment.createdAt instanceof Date ? this.comment.createdAt.toISOString() : this.comment.createdAt,
+                },
+                description: this.description,
+            },
+        };
+    }
+    static fromJSON(json) {
+        const commentData = json.data.comment;
+        return new CreateCommentCommand({
+            comment: {
+                ...commentData,
+                createdAt: new Date(commentData.createdAt),
+            },
+            description: json.data.description,
+        });
+    }
 }

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

@@ -1,4 +1,4 @@
-import type { UndoableCommand } from '../types.js';
+import type { UndoableCommand, SerializedCommand } from '../types.js';
 import type { NewTask } from '../../../db/schema.js';
 interface CreateTaskParams {
     task: NewTask;
@@ -14,5 +14,9 @@ export declare class CreateTaskCommand implements UndoableCommand {
     constructor(params: CreateTaskParams);
     execute(): Promise<void>;
     undo(): Promise<void>;
+    toJSON(): SerializedCommand;
+    static fromJSON(json: {
+        data: Record<string, unknown>;
+    }): CreateTaskCommand;
 }
 export {};

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

@@ -18,7 +18,32 @@ export class CreateTaskCommand {
     }
     async undo() {
         const db = getDb();
-        // Delete the created task
         await db.delete(schema.tasks).where(eq(schema.tasks.id, this.createdTaskId));
     }
+    toJSON() {
+        return {
+            type: 'create_task',
+            data: {
+                task: {
+                    ...this.task,
+                    dueDate: this.task.dueDate instanceof Date ? this.task.dueDate.toISOString() : this.task.dueDate ?? null,
+                    createdAt: this.task.createdAt instanceof Date ? this.task.createdAt.toISOString() : this.task.createdAt,
+                    updatedAt: this.task.updatedAt instanceof Date ? this.task.updatedAt.toISOString() : this.task.updatedAt,
+                },
+                description: this.description,
+            },
+        };
+    }
+    static fromJSON(json) {
+        const taskData = json.data.task;
+        return new CreateTaskCommand({
+            task: {
+                ...taskData,
+                dueDate: taskData.dueDate ? new Date(taskData.dueDate) : null,
+                createdAt: new Date(taskData.createdAt),
+                updatedAt: new Date(taskData.updatedAt),
+            },
+            description: json.data.description,
+        });
+    }
 }

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

@@ -1,4 +1,4 @@
-import type { UndoableCommand } from '../types.js';
+import type { UndoableCommand, SerializedCommand } from '../types.js';
 import type { Comment } from '../../../db/schema.js';
 interface DeleteCommentParams {
     comment: Comment;
@@ -13,5 +13,9 @@ export declare class DeleteCommentCommand implements UndoableCommand {
     constructor(params: DeleteCommentParams);
     execute(): Promise<void>;
     undo(): Promise<void>;
+    toJSON(): SerializedCommand;
+    static fromJSON(json: {
+        data: Record<string, unknown>;
+    }): DeleteCommentCommand;
 }
 export {};

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

@@ -23,4 +23,26 @@ export class DeleteCommentCommand {
             createdAt: this.comment.createdAt,
         });
     }
+    toJSON() {
+        return {
+            type: 'delete_comment',
+            data: {
+                comment: {
+                    ...this.comment,
+                    createdAt: this.comment.createdAt.toISOString(),
+                },
+                description: this.description,
+            },
+        };
+    }
+    static fromJSON(json) {
+        const commentData = json.data.comment;
+        return new DeleteCommentCommand({
+            comment: {
+                ...commentData,
+                createdAt: new Date(commentData.createdAt),
+            },
+            description: json.data.description,
+        });
+    }
 }

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

@@ -1,8 +1,9 @@
-import type { UndoableCommand } from '../types.js';
-import type { Task } from '../../../db/schema.js';
+import type { UndoableCommand, SerializedCommand } from '../types.js';
+import type { Task, Comment } from '../../../db/schema.js';
 interface DeleteTaskParams {
     task: Task;
     description: string;
+    savedComments?: Comment[];
 }
 /**
  * Command to delete a task (and its comments)
@@ -14,5 +15,9 @@ export declare class DeleteTaskCommand implements UndoableCommand {
     constructor(params: DeleteTaskParams);
     execute(): Promise<void>;
     undo(): Promise<void>;
+    toJSON(): SerializedCommand;
+    static fromJSON(json: {
+        data: Record<string, unknown>;
+    }): DeleteTaskCommand;
 }
 export {};

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

@@ -10,6 +10,9 @@ export class DeleteTaskCommand {
     constructor(params) {
         this.task = params.task;
         this.description = params.description;
+        if (params.savedComments) {
+            this.savedComments = params.savedComments;
+        }
     }
     async execute() {
         const db = getDb();
@@ -35,6 +38,7 @@ export class DeleteTaskCommand {
             parentId: this.task.parentId,
             waitingFor: this.task.waitingFor,
             dueDate: this.task.dueDate,
+            completedAt: this.task.completedAt,
             createdAt: this.task.createdAt,
             updatedAt: this.task.updatedAt,
         });
@@ -48,4 +52,41 @@ export class DeleteTaskCommand {
             });
         }
     }
+    toJSON() {
+        return {
+            type: 'delete_task',
+            data: {
+                task: {
+                    ...this.task,
+                    dueDate: this.task.dueDate ? this.task.dueDate.toISOString() : null,
+                    completedAt: this.task.completedAt ? this.task.completedAt.toISOString() : null,
+                    createdAt: this.task.createdAt.toISOString(),
+                    updatedAt: this.task.updatedAt.toISOString(),
+                },
+                savedComments: this.savedComments.map(c => ({
+                    ...c,
+                    createdAt: c.createdAt.toISOString(),
+                })),
+                description: this.description,
+            },
+        };
+    }
+    static fromJSON(json) {
+        const taskData = json.data.task;
+        const commentsData = json.data.savedComments || [];
+        return new DeleteTaskCommand({
+            task: {
+                ...taskData,
+                dueDate: taskData.dueDate ? new Date(taskData.dueDate) : null,
+                completedAt: taskData.completedAt ? new Date(taskData.completedAt) : null,
+                createdAt: new Date(taskData.createdAt),
+                updatedAt: new Date(taskData.updatedAt),
+            },
+            savedComments: commentsData.map(c => ({
+                ...c,
+                createdAt: new Date(c.createdAt),
+            })),
+            description: json.data.description,
+        });
+    }
 }

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

@@ -1,4 +1,4 @@
-import type { UndoableCommand } from '../types.js';
+import type { UndoableCommand, SerializedCommand } from '../types.js';
 interface LinkTaskParams {
     taskId: string;
     fromParentId: string | null;
@@ -16,5 +16,9 @@ export declare class LinkTaskCommand implements UndoableCommand {
     constructor(params: LinkTaskParams);
     execute(): Promise<void>;
     undo(): Promise<void>;
+    toJSON(): SerializedCommand;
+    static fromJSON(json: {
+        data: Record<string, unknown>;
+    }): LinkTaskCommand;
 }
 export {};

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

@@ -34,4 +34,18 @@ export class LinkTaskCommand {
         })
             .where(eq(schema.tasks.id, this.taskId));
     }
+    toJSON() {
+        return {
+            type: 'link_task',
+            data: {
+                taskId: this.taskId,
+                fromParentId: this.fromParentId,
+                toParentId: this.toParentId,
+                description: this.description,
+            },
+        };
+    }
+    static fromJSON(json) {
+        return new LinkTaskCommand(json.data);
+    }
 }

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

@@ -1,4 +1,4 @@
-import type { UndoableCommand } from '../types.js';
+import type { UndoableCommand, SerializedCommand } from '../types.js';
 import type { TaskStatus } from '../../../db/schema.js';
 interface MoveTaskParams {
     taskId: string;
@@ -6,6 +6,7 @@ interface MoveTaskParams {
     toStatus: TaskStatus;
     fromWaitingFor: string | null;
     toWaitingFor: string | null;
+    fromCompletedAt: Date | null;
     description: string;
 }
 /**
@@ -18,8 +19,13 @@ export declare class MoveTaskCommand implements UndoableCommand {
     private readonly toStatus;
     private readonly fromWaitingFor;
     private readonly toWaitingFor;
+    private readonly fromCompletedAt;
     constructor(params: MoveTaskParams);
     execute(): Promise<void>;
     undo(): Promise<void>;
+    toJSON(): SerializedCommand;
+    static fromJSON(json: {
+        data: Record<string, unknown>;
+    }): MoveTaskCommand;
 }
 export {};