floq 1.4.1 → 1.6.0

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 {};

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

@@ -10,12 +10,14 @@ export class MoveTaskCommand {
     toStatus;
     fromWaitingFor;
     toWaitingFor;
+    fromCompletedAt;
     constructor(params) {
         this.taskId = params.taskId;
         this.fromStatus = params.fromStatus;
         this.toStatus = params.toStatus;
         this.fromWaitingFor = params.fromWaitingFor;
         this.toWaitingFor = params.toWaitingFor;
+        this.fromCompletedAt = params.fromCompletedAt;
         this.description = params.description;
     }
     async execute() {
@@ -25,6 +27,7 @@ export class MoveTaskCommand {
             .set({
             status: this.toStatus,
             waitingFor: this.toWaitingFor,
+            completedAt: this.toStatus === 'done' ? new Date() : null,
             updatedAt: new Date(),
         })
             .where(eq(schema.tasks.id, this.taskId));
@@ -36,8 +39,30 @@ export class MoveTaskCommand {
             .set({
             status: this.fromStatus,
             waitingFor: this.fromWaitingFor,
+            completedAt: this.fromCompletedAt,
             updatedAt: new Date(),
         })
             .where(eq(schema.tasks.id, this.taskId));
     }
+    toJSON() {
+        return {
+            type: 'move_task',
+            data: {
+                taskId: this.taskId,
+                fromStatus: this.fromStatus,
+                toStatus: this.toStatus,
+                fromWaitingFor: this.fromWaitingFor,
+                toWaitingFor: this.toWaitingFor,
+                fromCompletedAt: this.fromCompletedAt ? this.fromCompletedAt.toISOString() : null,
+                description: this.description,
+            },
+        };
+    }
+    static fromJSON(json) {
+        const data = json.data;
+        return new MoveTaskCommand({
+            ...data,
+            fromCompletedAt: data.fromCompletedAt ? new Date(data.fromCompletedAt) : null,
+        });
+    }
 }

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

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

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

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

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

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

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

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