@taskforcehq/taskforce 0.3.169 → 0.3.300

package/dist/hooks/useTaskMutations.js

@@ -0,0 +1,472 @@
+import { useState, useCallback, useRef } from 'react';
+import { normalizeTaskFromApi } from '../utils/taskNormalization.js';
+export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks, setArchivedTasks, setDeletedTasks, setError, resetForm, setActiveTab, fetchTasks, fetchArchive, fetchDeletedTasks, mergeTaskFromServer, pushNotice, cloudAuthConfigured, runtimeMode, isAuthenticated, workspaceCloudSyncEnabled, buildWorkspaceSyncSignature, pushWorkspaceChangesToCloud, workspacePendingSignatureRef, workspaceDeletedTaskIdsRef, }) {
+    // Copy ID state + timer ref
+    const [copiedId, setCopiedId] = useState(null);
+    const copiedIdTimerRef = useRef(null);
+    const queueWorkspaceSyncFromAuthoritativeTaskState = useCallback((delayMs = 0) => {
+        if (!(cloudAuthConfigured && runtimeMode === 'local' && isAuthenticated && workspaceCloudSyncEnabled))
+            return;
+        if (typeof window === 'undefined')
+            return;
+        window.setTimeout(() => {
+            const signature = buildWorkspaceSyncSignature();
+            if (!signature)
+                return;
+            workspacePendingSignatureRef.current = signature;
+            void pushWorkspaceChangesToCloud(signature);
+        }, Math.max(0, delayMs));
+    }, [
+        cloudAuthConfigured,
+        runtimeMode,
+        isAuthenticated,
+        workspaceCloudSyncEnabled,
+        buildWorkspaceSyncSignature,
+        workspacePendingSignatureRef,
+        pushWorkspaceChangesToCloud
+    ]);
+    const requestDeletedEndpoint = useCallback(async (path, init) => {
+        let res = await fetch(`/api/taskforce/deleted${path}`, init);
+        if (res.status === 404) {
+            res = await fetch(`/api/taskforce/trash${path}`, init);
+        }
+        return res;
+    }, []);
+    const handleDelete = async (id, archive = false, options = {}) => {
+        if (!options.skipConfirm && !confirm('Move this task to Trash? You can restore it later.'))
+            return false;
+        const isArchivedTask = archive || archivedTasks.some((task) => task.id === id);
+        try {
+            const res = await fetch(`/api/taskforce/task/${id}`, { method: 'DELETE' });
+            if (!res.ok) {
+                const data = await res.json().catch(() => ({}));
+                const message = data.error || 'Failed to delete task.';
+                setError(message);
+                pushNotice(message, 'error');
+                return false;
+            }
+            const data = await res.json().catch(() => ({}));
+            const deletedRecord = data?.deleted && typeof data.deleted === 'object' && data.deleted.taskSnapshot
+                ? {
+                    ...data.deleted,
+                    taskSnapshot: normalizeTaskFromApi(data.deleted.taskSnapshot)
+                }
+                : null;
+            if (window.location.search.includes(id)) {
+                const url = new URL(window.location.href);
+                url.searchParams.delete('task');
+                window.history.pushState({}, '', url.toString());
+            }
+            if (isArchivedTask) {
+                setArchivedTasks(prev => prev.filter(t => t.id !== id));
+            }
+            else {
+                setTasks(prev => prev.filter(t => t.id !== id));
+            }
+            if (deletedRecord) {
+                setDeletedTasks(prev => [deletedRecord, ...prev.filter((entry) => entry.taskId !== id)]);
+            }
+            else {
+                await fetchDeletedTasks(true);
+            }
+            workspaceDeletedTaskIdsRef.current.add(id);
+            if (cloudAuthConfigured && runtimeMode === 'local' && isAuthenticated && workspaceCloudSyncEnabled) {
+                const signature = buildWorkspaceSyncSignature();
+                workspacePendingSignatureRef.current = signature;
+                void pushWorkspaceChangesToCloud(signature);
+            }
+            if (editingTaskId === id) {
+                resetForm();
+                setActiveTab('tasks');
+            }
+            setError('');
+            pushNotice('Task moved to Trash.', 'info');
+            return true;
+        }
+        catch (err) {
+            console.error('Failed to delete task:', err);
+            setError('Failed to delete task.');
+            pushNotice('Failed to delete task.', 'error');
+            return false;
+        }
+    };
+    const handleRestoreDeletedTask = useCallback(async (id) => {
+        try {
+            const res = await requestDeletedEndpoint(`/${id}/restore`, { method: 'POST' });
+            if (!res.ok) {
+                const data = await res.json().catch(() => ({}));
+                const message = data.error || 'Failed to restore deleted task.';
+                setError(message);
+                pushNotice(message, 'error');
+                return null;
+            }
+            const restoredTask = await res.json().catch(() => null);
+            if (restoredTask) {
+                mergeTaskFromServer(restoredTask);
+            }
+            else {
+                await fetchTasks(true);
+            }
+            setDeletedTasks((prev) => prev.filter((entry) => entry.id !== id && entry.taskId !== id));
+            workspaceDeletedTaskIdsRef.current.delete(id);
+            queueWorkspaceSyncFromAuthoritativeTaskState();
+            setError('');
+            pushNotice('Task restored from Trash.', 'info');
+            return restoredTask ? normalizeTaskFromApi(restoredTask) : null;
+        }
+        catch (err) {
+            console.error('Failed to restore deleted task:', err);
+            setError('Failed to restore deleted task.');
+            pushNotice('Failed to restore deleted task.', 'error');
+            return null;
+        }
+    }, [
+        fetchTasks,
+        mergeTaskFromServer,
+        pushNotice,
+        queueWorkspaceSyncFromAuthoritativeTaskState,
+        requestDeletedEndpoint,
+        setDeletedTasks,
+        setError
+    ]);
+    const handlePermanentlyDeleteDeletedTask = useCallback(async (id) => {
+        try {
+            const res = await requestDeletedEndpoint(`/${id}`, { method: 'DELETE' });
+            if (!res.ok) {
+                const data = await res.json().catch(() => ({}));
+                const message = data.error || 'Failed to permanently delete deleted task.';
+                setError(message);
+                pushNotice(message, 'error');
+                return false;
+            }
+            setDeletedTasks((prev) => prev.filter((entry) => entry.id !== id && entry.taskId !== id));
+            queueWorkspaceSyncFromAuthoritativeTaskState();
+            setError('');
+            pushNotice('Deleted task permanently removed.', 'info');
+            return true;
+        }
+        catch (err) {
+            console.error('Failed to permanently delete deleted task:', err);
+            setError('Failed to permanently delete deleted task.');
+            pushNotice('Failed to permanently delete deleted task.', 'error');
+            return false;
+        }
+    }, [
+        pushNotice,
+        queueWorkspaceSyncFromAuthoritativeTaskState,
+        requestDeletedEndpoint,
+        setDeletedTasks,
+        setError
+    ]);
+    const handleEmptyDeletedTasks = useCallback(async () => {
+        try {
+            const res = await requestDeletedEndpoint('/empty', { method: 'POST' });
+            if (!res.ok) {
+                const data = await res.json().catch(() => ({}));
+                const message = data.error || 'Failed to permanently delete deleted tasks.';
+                setError(message);
+                pushNotice(message, 'error');
+                return null;
+            }
+            const payload = await res.json().catch(() => ({}));
+            const deletedCount = Number(payload?.deleted || 0);
+            setDeletedTasks([]);
+            queueWorkspaceSyncFromAuthoritativeTaskState();
+            setError('');
+            pushNotice(deletedCount === 1 ? 'Deleted task permanently removed.' : `${deletedCount} deleted tasks permanently removed.`, 'info');
+            return deletedCount;
+        }
+        catch (err) {
+            console.error('Failed to empty deleted tasks:', err);
+            setError('Failed to permanently delete deleted tasks.');
+            pushNotice('Failed to permanently delete deleted tasks.', 'error');
+            return null;
+        }
+    }, [
+        pushNotice,
+        queueWorkspaceSyncFromAuthoritativeTaskState,
+        requestDeletedEndpoint,
+        setDeletedTasks,
+        setError
+    ]);
+    const handleUpdateTask = useCallback(async (id, updates) => {
+        const previousTasks = tasks;
+        const previousArchivedTasks = archivedTasks;
+        setTasks(prev => prev.map(t => t.id === id ? { ...t, ...updates } : t));
+        setArchivedTasks(prev => prev.map(t => t.id === id ? { ...t, ...updates } : t));
+        try {
+            const res = await fetch(`/api/taskforce/task/${id}`, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(updates),
+            });
+            if (!res.ok) {
+                const data = await res.json().catch(() => ({}));
+                const message = data.error || `Failed to update task ${id}.`;
+                setError(message);
+                pushNotice(message, 'error');
+                setTasks(previousTasks);
+                setArchivedTasks(previousArchivedTasks);
+                return;
+            }
+            const updatedTask = await res.json().catch(() => null);
+            mergeTaskFromServer(updatedTask);
+            // Attachment saves also depend on the canonical asset snapshot refresh. Give that
+            // snapshot a brief head start so the next push includes both task metadata and bytes.
+            queueWorkspaceSyncFromAuthoritativeTaskState(updates.attachments !== undefined ? 150 : 0);
+            setError('');
+        }
+        catch (err) {
+            console.error("Failed to update task", err);
+            const message = `Failed to update task ${id}.`;
+            setError(message);
+            pushNotice(message, 'error');
+            setTasks(previousTasks);
+            setArchivedTasks(previousArchivedTasks);
+        }
+    }, [tasks, archivedTasks, pushNotice, mergeTaskFromServer, queueWorkspaceSyncFromAuthoritativeTaskState]);
+    const handleToggleComplete = async (task) => {
+        const newStatus = task.status === 'done' ? 'task' : 'done';
+        try {
+            const completedAt = newStatus === 'done' ? new Date().toISOString() : undefined;
+            const res = await fetch(`/api/taskforce/task/${task.id}`, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ status: newStatus, completedAt }),
+            });
+            if (!res.ok) {
+                const data = await res.json().catch(() => ({}));
+                const message = data.error || 'Failed to update task status.';
+                setError(message);
+                pushNotice(message, 'error');
+                await fetchTasks(true);
+                return;
+            }
+            const updatedTask = await res.json().catch(() => null);
+            if (updatedTask) {
+                mergeTaskFromServer(updatedTask);
+                queueWorkspaceSyncFromAuthoritativeTaskState();
+            }
+            else {
+                await fetchTasks(true);
+                queueWorkspaceSyncFromAuthoritativeTaskState();
+            }
+            setError('');
+        }
+        catch (err) {
+            console.error("Failed to toggle complete", err);
+            setError('Failed to update task status.');
+            pushNotice('Failed to update task status.', 'error');
+            fetchTasks();
+        }
+    };
+    const handleToggleCancel = async (task) => {
+        const newStatus = task.status === 'cancelled' ? 'task' : 'cancelled';
+        try {
+            const res = await fetch(`/api/taskforce/task/${task.id}`, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ status: newStatus }),
+            });
+            if (!res.ok) {
+                const data = await res.json().catch(() => ({}));
+                const message = data.error || 'Failed to update task status.';
+                setError(message);
+                pushNotice(message, 'error');
+                await fetchTasks(true);
+                return;
+            }
+            const updatedTask = await res.json().catch(() => null);
+            if (updatedTask) {
+                mergeTaskFromServer(updatedTask);
+                queueWorkspaceSyncFromAuthoritativeTaskState();
+            }
+            else {
+                await fetchTasks(true);
+                queueWorkspaceSyncFromAuthoritativeTaskState();
+            }
+            setError('');
+        }
+        catch (err) {
+            console.error("Failed to toggle cancel", err);
+            setError('Failed to update task status.');
+            pushNotice('Failed to update task status.', 'error');
+            fetchTasks();
+        }
+    };
+    const handleToggleInProgress = async (task) => {
+        const newStatus = task.status === 'in-progress' ? 'task' : 'in-progress';
+        setTasks(prev => prev.map(t => t.id === task.id ? { ...t, status: newStatus } : t));
+        try {
+            const res = await fetch(`/api/taskforce/task/${task.id}`, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ status: newStatus }),
+            });
+            if (!res.ok) {
+                await fetchTasks(true);
+                return;
+            }
+            const updatedTask = await res.json().catch(() => null);
+            mergeTaskFromServer(updatedTask);
+            queueWorkspaceSyncFromAuthoritativeTaskState();
+        }
+        catch (err) {
+            fetchTasks();
+        }
+    };
+    const handleToggleReview = async (task) => {
+        const newStatus = task.status === 'review' ? 'task' : 'review';
+        setTasks(prev => prev.map(t => t.id === task.id ? { ...t, status: newStatus } : t));
+        try {
+            const res = await fetch(`/api/taskforce/task/${task.id}`, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ status: newStatus }),
+            });
+            if (!res.ok) {
+                await fetchTasks(true);
+                return;
+            }
+            const updatedTask = await res.json().catch(() => null);
+            mergeTaskFromServer(updatedTask);
+            queueWorkspaceSyncFromAuthoritativeTaskState();
+        }
+        catch (err) {
+            fetchTasks();
+        }
+    };
+    const handleArchiveTask = async (task) => {
+        try {
+            const isCancelled = task.status === 'cancelled';
+            const endpoint = isCancelled ? 'cancel' : 'complete';
+            const res = await fetch(`/api/taskforce/task/${task.id}/${endpoint}`, { method: 'POST' });
+            if (res.ok) {
+                const archivedTask = await res.json().catch(() => null);
+                const archivedResults = [];
+                if (archivedTask && typeof archivedTask === 'object') {
+                    archivedResults.push(archivedTask);
+                }
+                if (archivedResults.length > 0) {
+                    for (const archivedItem of archivedResults) {
+                        mergeTaskFromServer(archivedItem);
+                    }
+                    queueWorkspaceSyncFromAuthoritativeTaskState();
+                }
+                else {
+                    fetchArchive();
+                }
+                const archivedIdSet = new Set(archivedResults
+                    .map((item) => String(item?.id || '').trim())
+                    .filter((id) => id.length > 0));
+                if (editingTaskId && archivedIdSet.has(editingTaskId)) {
+                    resetForm();
+                    setActiveTab('tasks');
+                }
+            }
+            else {
+                const data = await res.json().catch(() => ({}));
+                const message = data.error || 'Failed to archive task.';
+                setError(message);
+                pushNotice(message, 'error');
+            }
+        }
+        catch (err) {
+            console.error("Failed to archive", err);
+            setError('Failed to archive task.');
+            pushNotice('Failed to archive task.', 'error');
+        }
+    };
+    const handleBulkArchive = async () => {
+        const completedOrCancelled = tasks.filter(t => t.status === 'done' || t.status === 'cancelled');
+        if (completedOrCancelled.length === 0)
+            return;
+        if (!confirm(`Archive ${completedOrCancelled.length} completed/cancelled tasks?`))
+            return;
+        try {
+            const res = await fetch('/api/taskforce/bulk-archive', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ ids: completedOrCancelled.map(t => t.id) })
+            });
+            if (res.ok) {
+                const data = await res.json();
+                const archivedResults = Array.isArray(data?.results?.archived) ? data.results.archived : [];
+                if (archivedResults.length > 0) {
+                    for (const archivedItem of archivedResults) {
+                        mergeTaskFromServer(archivedItem);
+                    }
+                    queueWorkspaceSyncFromAuthoritativeTaskState();
+                }
+                else {
+                    setTasks(prev => prev.filter(t => !(['done', 'cancelled'].includes(t.status))));
+                    fetchArchive();
+                }
+                pushNotice(`${data.archived || completedOrCancelled.length} tasks archived`, 'info');
+                setError('');
+            }
+            else {
+                const data = await res.json().catch(() => ({}));
+                const message = data.error || 'Failed to bulk archive tasks.';
+                setError(message);
+                pushNotice(message, 'error');
+            }
+        }
+        catch (err) {
+            console.error("Failed to bulk archive", err);
+            setError('Failed to bulk archive tasks.');
+            pushNotice('Failed to bulk archive tasks.', 'error');
+        }
+    };
+    const handleUnarchive = async (id) => {
+        try {
+            const res = await fetch(`/api/taskforce/task/${id}/unarchive`, { method: 'POST' });
+            if (res.ok) {
+                const restoredTask = await res.json().catch(() => null);
+                if (restoredTask) {
+                    mergeTaskFromServer(restoredTask);
+                    queueWorkspaceSyncFromAuthoritativeTaskState();
+                }
+                else {
+                    setArchivedTasks(prev => prev.filter(t => t.id !== id));
+                    await fetchTasks(true);
+                    queueWorkspaceSyncFromAuthoritativeTaskState();
+                }
+                setError('');
+                pushNotice('Task restored from archive.', 'info');
+            }
+        }
+        catch (err) {
+            console.error("Failed to unarchive", err);
+            setError('Failed to unarchive task.');
+            pushNotice('Failed to unarchive task.', 'error');
+        }
+    };
+    const handleCopyId = (e, id) => {
+        e.stopPropagation();
+        navigator.clipboard.writeText(id);
+        setCopiedId(id);
+        if (copiedIdTimerRef.current !== null)
+            window.clearTimeout(copiedIdTimerRef.current);
+        copiedIdTimerRef.current = window.setTimeout(() => { copiedIdTimerRef.current = null; setCopiedId(null); }, 2000);
+    };
+    return {
+        // Copy ID state
+        copiedId,
+        // Handlers
+        handleDelete,
+        handleUpdateTask,
+        handleToggleComplete,
+        handleToggleCancel,
+        handleToggleInProgress,
+        handleToggleReview,
+        handleArchiveTask,
+        handleBulkArchive,
+        handleUnarchive,
+        handleRestoreDeletedTask,
+        handlePermanentlyDeleteDeletedTask,
+        handleEmptyDeletedTasks,
+        handleCopyId,
+        queueWorkspaceSyncFromAuthoritativeTaskState,
+    };
+}

package/dist/hooks/useTaskMutations.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/useTaskMutations.test.js

@@ -0,0 +1,80 @@
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { useTaskMutations } from './useTaskMutations';
+describe('useTaskMutations', () => {
+    beforeEach(() => {
+        vi.stubGlobal('fetch', vi.fn());
+    });
+    afterEach(() => {
+        vi.unstubAllGlobals();
+        vi.clearAllMocks();
+    });
+    it('clears pending delete ids when a deleted task is restored', async () => {
+        const fetchMock = vi.mocked(fetch);
+        fetchMock.mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: async () => ({
+                id: 'task-1',
+                title: 'Restored task',
+                description: 'Restored description',
+                category: 'general',
+                type: 'task',
+                priority: 2,
+                complexity: 3,
+                status: 'task',
+                createdAt: '2026-04-03T10:00:00.000Z',
+                updatedAt: '2026-04-03T10:05:00.000Z'
+            })
+        });
+        const setTasks = vi.fn();
+        const setArchivedTasks = vi.fn();
+        const setDeletedTasks = vi.fn();
+        const setError = vi.fn();
+        const resetForm = vi.fn();
+        const setActiveTab = vi.fn();
+        const fetchTasks = vi.fn();
+        const fetchArchive = vi.fn();
+        const fetchDeletedTasks = vi.fn();
+        const mergeTaskFromServer = vi.fn();
+        const pushNotice = vi.fn();
+        const buildWorkspaceSyncSignature = vi.fn(() => 'sig-1');
+        const pushWorkspaceChangesToCloud = vi.fn();
+        const workspacePendingSignatureRef = { current: null };
+        const workspaceDeletedTaskIdsRef = { current: new Set(['task-1']) };
+        const { result } = renderHook(() => useTaskMutations({
+            tasks: [],
+            archivedTasks: [],
+            editingTaskId: null,
+            setTasks,
+            setArchivedTasks,
+            setDeletedTasks,
+            setError,
+            resetForm,
+            setActiveTab,
+            fetchTasks,
+            fetchArchive,
+            fetchDeletedTasks,
+            mergeTaskFromServer,
+            pushNotice,
+            cloudAuthConfigured: true,
+            runtimeMode: 'local',
+            isAuthenticated: true,
+            workspaceCloudSyncEnabled: true,
+            buildWorkspaceSyncSignature,
+            pushWorkspaceChangesToCloud,
+            workspacePendingSignatureRef,
+            workspaceDeletedTaskIdsRef,
+        }));
+        await act(async () => {
+            await result.current.handleRestoreDeletedTask('task-1');
+        });
+        await waitFor(() => {
+            expect(workspaceDeletedTaskIdsRef.current.has('task-1')).toBe(false);
+        });
+        expect(mergeTaskFromServer).toHaveBeenCalledWith(expect.objectContaining({ id: 'task-1' }));
+        expect(buildWorkspaceSyncSignature).toHaveBeenCalled();
+        expect(pushWorkspaceChangesToCloud).toHaveBeenCalledWith('sig-1');
+        expect(setDeletedTasks).toHaveBeenCalled();
+    });
+});

package/dist/hooks/useTaskforce.contract.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/useTaskforce.contract.test.js

@@ -0,0 +1,7 @@
+import { describe, expect, it } from 'vitest';
+const matchesReturnType = true;
+describe('useTaskforce contract', () => {
+    it('exports a result alias that matches the hook return shape', () => {
+        expect(matchesReturnType).toBe(true);
+    });
+});