floq 0.2.3 → 0.3.1

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

@@ -0,0 +1,18 @@
+import type { UndoableCommand } from '../types.js';
+import type { Task } from '../../../db/schema.js';
+interface DeleteTaskParams {
+    task: Task;
+    description: string;
+}
+/**
+ * Command to delete a task (and its comments)
+ */
+export declare class DeleteTaskCommand implements UndoableCommand {
+    readonly description: string;
+    private readonly task;
+    private savedComments;
+    constructor(params: DeleteTaskParams);
+    execute(): Promise<void>;
+    undo(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,51 @@
+import { eq } from 'drizzle-orm';
+import { getDb, schema } from '../../../db/index.js';
+/**
+ * Command to delete a task (and its comments)
+ */
+export class DeleteTaskCommand {
+    description;
+    task;
+    savedComments = [];
+    constructor(params) {
+        this.task = params.task;
+        this.description = params.description;
+    }
+    async execute() {
+        const db = getDb();
+        // Save comments before deleting
+        this.savedComments = await db
+            .select()
+            .from(schema.comments)
+            .where(eq(schema.comments.taskId, this.task.id));
+        // Delete comments first
+        await db.delete(schema.comments).where(eq(schema.comments.taskId, this.task.id));
+        // Delete the task
+        await db.delete(schema.tasks).where(eq(schema.tasks.id, this.task.id));
+    }
+    async undo() {
+        const db = getDb();
+        // Restore the task
+        await db.insert(schema.tasks).values({
+            id: this.task.id,
+            title: this.task.title,
+            description: this.task.description,
+            status: this.task.status,
+            isProject: this.task.isProject,
+            parentId: this.task.parentId,
+            waitingFor: this.task.waitingFor,
+            dueDate: this.task.dueDate,
+            createdAt: this.task.createdAt,
+            updatedAt: this.task.updatedAt,
+        });
+        // Restore comments
+        for (const comment of this.savedComments) {
+            await db.insert(schema.comments).values({
+                id: comment.id,
+                taskId: comment.taskId,
+                content: comment.content,
+                createdAt: comment.createdAt,
+            });
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+import type { UndoableCommand } from '../types.js';
+interface LinkTaskParams {
+    taskId: string;
+    fromParentId: string | null;
+    toParentId: string | null;
+    description: string;
+}
+/**
+ * Command to link/unlink a task to a project
+ */
+export declare class LinkTaskCommand implements UndoableCommand {
+    readonly description: string;
+    private readonly taskId;
+    private readonly fromParentId;
+    private readonly toParentId;
+    constructor(params: LinkTaskParams);
+    execute(): Promise<void>;
+    undo(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,37 @@
+import { eq } from 'drizzle-orm';
+import { getDb, schema } from '../../../db/index.js';
+/**
+ * Command to link/unlink a task to a project
+ */
+export class LinkTaskCommand {
+    description;
+    taskId;
+    fromParentId;
+    toParentId;
+    constructor(params) {
+        this.taskId = params.taskId;
+        this.fromParentId = params.fromParentId;
+        this.toParentId = params.toParentId;
+        this.description = params.description;
+    }
+    async execute() {
+        const db = getDb();
+        await db
+            .update(schema.tasks)
+            .set({
+            parentId: this.toParentId,
+            updatedAt: new Date(),
+        })
+            .where(eq(schema.tasks.id, this.taskId));
+    }
+    async undo() {
+        const db = getDb();
+        await db
+            .update(schema.tasks)
+            .set({
+            parentId: this.fromParentId,
+            updatedAt: new Date(),
+        })
+            .where(eq(schema.tasks.id, this.taskId));
+    }
+}

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

@@ -0,0 +1,25 @@
+import type { UndoableCommand } from '../types.js';
+import type { TaskStatus } from '../../../db/schema.js';
+interface MoveTaskParams {
+    taskId: string;
+    fromStatus: TaskStatus;
+    toStatus: TaskStatus;
+    fromWaitingFor: string | null;
+    toWaitingFor: string | null;
+    description: string;
+}
+/**
+ * Command to move a task to a different status
+ */
+export declare class MoveTaskCommand implements UndoableCommand {
+    readonly description: string;
+    private readonly taskId;
+    private readonly fromStatus;
+    private readonly toStatus;
+    private readonly fromWaitingFor;
+    private readonly toWaitingFor;
+    constructor(params: MoveTaskParams);
+    execute(): Promise<void>;
+    undo(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,43 @@
+import { eq } from 'drizzle-orm';
+import { getDb, schema } from '../../../db/index.js';
+/**
+ * Command to move a task to a different status
+ */
+export class MoveTaskCommand {
+    description;
+    taskId;
+    fromStatus;
+    toStatus;
+    fromWaitingFor;
+    toWaitingFor;
+    constructor(params) {
+        this.taskId = params.taskId;
+        this.fromStatus = params.fromStatus;
+        this.toStatus = params.toStatus;
+        this.fromWaitingFor = params.fromWaitingFor;
+        this.toWaitingFor = params.toWaitingFor;
+        this.description = params.description;
+    }
+    async execute() {
+        const db = getDb();
+        await db
+            .update(schema.tasks)
+            .set({
+            status: this.toStatus,
+            waitingFor: this.toWaitingFor,
+            updatedAt: new Date(),
+        })
+            .where(eq(schema.tasks.id, this.taskId));
+    }
+    async undo() {
+        const db = getDb();
+        await db
+            .update(schema.tasks)
+            .set({
+            status: this.fromStatus,
+            waitingFor: this.fromWaitingFor,
+            updatedAt: new Date(),
+        })
+            .where(eq(schema.tasks.id, this.taskId));
+    }
+}

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

@@ -0,0 +1,7 @@
+export { CreateTaskCommand } from './CreateTaskCommand.js';
+export { DeleteTaskCommand } from './DeleteTaskCommand.js';
+export { MoveTaskCommand } from './MoveTaskCommand.js';
+export { LinkTaskCommand } from './LinkTaskCommand.js';
+export { ConvertToProjectCommand } from './ConvertToProjectCommand.js';
+export { CreateCommentCommand } from './CreateCommentCommand.js';
+export { DeleteCommentCommand } from './DeleteCommentCommand.js';

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

@@ -0,0 +1,7 @@
+export { CreateTaskCommand } from './CreateTaskCommand.js';
+export { DeleteTaskCommand } from './DeleteTaskCommand.js';
+export { MoveTaskCommand } from './MoveTaskCommand.js';
+export { LinkTaskCommand } from './LinkTaskCommand.js';
+export { ConvertToProjectCommand } from './ConvertToProjectCommand.js';
+export { CreateCommentCommand } from './CreateCommentCommand.js';
+export { DeleteCommentCommand } from './DeleteCommentCommand.js';

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

@@ -0,0 +1,6 @@
+export type { UndoableCommand, HistoryState } from './types.js';
+export { MAX_HISTORY_SIZE } from './types.js';
+export { HistoryManager, getHistoryManager } from './HistoryManager.js';
+export { HistoryProvider, useHistoryContext } from './HistoryContext.js';
+export { useHistory } from './useHistory.js';
+export { CreateTaskCommand, DeleteTaskCommand, MoveTaskCommand, LinkTaskCommand, ConvertToProjectCommand, CreateCommentCommand, DeleteCommentCommand, } from './commands/index.js';

package/dist/ui/history/index.js

@@ -0,0 +1,8 @@
+export { MAX_HISTORY_SIZE } from './types.js';
+// Manager
+export { HistoryManager, getHistoryManager } from './HistoryManager.js';
+// React integration
+export { HistoryProvider, useHistoryContext } from './HistoryContext.js';
+export { useHistory } from './useHistory.js';
+// Commands
+export { CreateTaskCommand, DeleteTaskCommand, MoveTaskCommand, LinkTaskCommand, ConvertToProjectCommand, CreateCommentCommand, DeleteCommentCommand, } from './commands/index.js';

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

@@ -0,0 +1,26 @@
+/**
+ * Interface for undoable commands (Command Pattern)
+ */
+export interface UndoableCommand {
+    /** Human-readable description of the command for display */
+    readonly description: string;
+    /** Execute the command */
+    execute(): Promise<void>;
+    /** Undo the command (reverse the operation) */
+    undo(): Promise<void>;
+}
+/**
+ * State of the history manager
+ */
+export interface HistoryState {
+    /** Number of commands that can be undone */
+    undoCount: number;
+    /** Number of commands that can be redone */
+    redoCount: number;
+    /** Description of the last executed command (if any) */
+    lastCommandDescription: string | null;
+}
+/**
+ * Maximum number of commands to keep in history
+ */
+export declare const MAX_HISTORY_SIZE = 50;

package/dist/ui/history/types.js

@@ -0,0 +1,4 @@
+/**
+ * Maximum number of commands to keep in history
+ */
+export const MAX_HISTORY_SIZE = 50;

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

@@ -0,0 +1,24 @@
+import type { UndoableCommand } from './types.js';
+/**
+ * Hook for undo/redo functionality
+ */
+export declare function useHistory(): {
+    /** 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>;
+    /** Whether undo is available */
+    canUndo: boolean;
+    /** Whether redo is available */
+    canRedo: boolean;
+    /** Number of commands that can be undone */
+    undoCount: number;
+    /** Number of commands that can be redone */
+    redoCount: number;
+    /** Description of what would be undone */
+    undoDescription: string | null;
+    /** Description of what would be redone */
+    redoDescription: string | null;
+};

package/dist/ui/history/useHistory.js

@@ -0,0 +1,31 @@
+import { useCallback } from 'react';
+import { useHistoryContext } from './HistoryContext.js';
+/**
+ * Hook for undo/redo functionality
+ */
+export function useHistory() {
+    const { execute, undo, redo, canUndo, canRedo, state, undoDescription, redoDescription } = useHistoryContext();
+    const executeCommand = useCallback(async (command) => {
+        await execute(command);
+    }, [execute]);
+    return {
+        /** Execute a command and add to history */
+        execute: executeCommand,
+        /** Undo the last command */
+        undo,
+        /** Redo the last undone command */
+        redo,
+        /** Whether undo is available */
+        canUndo,
+        /** Whether redo is available */
+        canRedo,
+        /** Number of commands that can be undone */
+        undoCount: state.undoCount,
+        /** Number of commands that can be redone */
+        redoCount: state.redoCount,
+        /** Description of what would be undone */
+        undoDescription,
+        /** Description of what would be redone */
+        redoDescription,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "floq",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "Floq - Getting Things Done Task Manager with MS-DOS style themes",
   "type": "module",
   "main": "dist/index.js",
@@ -33,9 +33,9 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/polidog/gtd-cli.git"
+    "url": "git+https://github.com/polidog/floq.git"
   },
-  "homepage": "https://github.com/polidog/gtd-cli#readme",
+  "homepage": "https://github.com/polidog/floq#readme",
   "dependencies": {
     "@libsql/client": "^0.17.0",
     "better-sqlite3": "^11.7.0",