@taskforcehq/taskforce 0.3.311 → 0.3.313

package/dist/hooks/sync/useRecentSyncEvents.test.d.ts

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

package/dist/hooks/sync/useRecentSyncEvents.test.js

@@ -1,124 +0,0 @@
-import { renderHook, waitFor } from '@testing-library/react';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { capturePendingSyncEventsScrollRestore, restorePendingSyncEventsScrollRestore, useRecentSyncEvents, } from './useRecentSyncEvents';
-describe('useRecentSyncEvents', () => {
-    const fetchMock = vi.fn();
-    beforeEach(() => {
-        fetchMock.mockReset();
-        vi.stubGlobal('fetch', fetchMock);
-    });
-    afterEach(() => {
-        vi.unstubAllGlobals();
-    });
-    it('does not fetch recent sync events while the modal is closed', () => {
-        renderHook(() => useRecentSyncEvents({
-            isOpen: false,
-            workspaceId: 'workspace-1',
-            refreshKeys: ['a'],
-        }));
-        expect(fetchMock).not.toHaveBeenCalled();
-    });
-    it('loads recent sync events when the modal opens', async () => {
-        fetchMock.mockResolvedValue({
-            ok: true,
-            json: async () => ({
-                events: [{
-                        id: 1,
-                        occurredAt: '2026-04-18T12:00:00.000Z',
-                        eventType: 'pull',
-                        status: 'success',
-                    }],
-            }),
-        });
-        const { result } = renderHook(() => useRecentSyncEvents({
-            isOpen: true,
-            workspaceId: 'workspace-1',
-            refreshKeys: ['2026-04-18T12:00:00.000Z'],
-        }));
-        await waitFor(() => {
-            expect(result.current.syncRecentEventsLoading).toBe(false);
-            expect(result.current.syncRecentEvents).toHaveLength(1);
-        });
-        expect(fetchMock).toHaveBeenCalledWith('/api/taskforce/sync/events?workspace_id=workspace-1&limit=15', expect.objectContaining({
-            method: 'GET',
-            credentials: 'include',
-        }));
-        expect(result.current.syncRecentEventsError).toBeNull();
-    });
-    it('stores a readable error when the fetch fails', async () => {
-        fetchMock.mockResolvedValue({
-            ok: false,
-            status: 503,
-            json: async () => ({}),
-        });
-        const { result } = renderHook(() => useRecentSyncEvents({
-            isOpen: true,
-            workspaceId: 'workspace-1',
-            refreshKeys: ['2026-04-18T12:00:00.000Z'],
-        }));
-        await waitFor(() => {
-            expect(result.current.syncRecentEventsLoading).toBe(false);
-            expect(result.current.syncRecentEventsError).toBe('Failed to load sync events (503)');
-        });
-        expect(result.current.syncRecentEvents).toEqual([]);
-    });
-    it('merges refreshed events into the recent event list', async () => {
-        fetchMock
-            .mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                events: [{
-                        id: 1,
-                        occurredAt: '2026-04-18T12:00:00.000Z',
-                        eventType: 'pull',
-                        status: 'success',
-                    }],
-            }),
-        })
-            .mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                events: [{
-                        id: 2,
-                        occurredAt: '2026-04-18T12:01:00.000Z',
-                        eventType: 'push',
-                        status: 'success',
-                    }],
-            }),
-        });
-        const { result, rerender } = renderHook(({ refreshKey }) => useRecentSyncEvents({
-            isOpen: true,
-            workspaceId: 'workspace-1',
-            refreshKeys: [refreshKey],
-        }), {
-            initialProps: { refreshKey: 'first' },
-        });
-        await waitFor(() => {
-            expect(result.current.syncRecentEvents).toHaveLength(1);
-        });
-        rerender({ refreshKey: 'second' });
-        await waitFor(() => {
-            expect(result.current.syncRecentEvents).toHaveLength(2);
-        });
-    });
-    it('captures and restores list scroll offset when the event list grows', () => {
-        let scrollHeight = 100;
-        const listEl = document.createElement('div');
-        Object.defineProperty(listEl, 'scrollTop', {
-            value: 24,
-            writable: true,
-        });
-        Object.defineProperty(listEl, 'scrollHeight', {
-            get: () => scrollHeight,
-        });
-        const pendingRestore = capturePendingSyncEventsScrollRestore(listEl);
-        expect(pendingRestore).toEqual({
-            scrollTop: 24,
-            scrollHeight: 100,
-        });
-        scrollHeight = 140;
-        const result = restorePendingSyncEventsScrollRestore(listEl, pendingRestore);
-        expect(result).toBeNull();
-        expect(listEl.scrollTop).toBe(64);
-    });
-});

package/dist/hooks/sync/useSyncStatusActions.test.d.ts

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

package/dist/hooks/sync/useSyncStatusActions.test.js

@@ -1,133 +0,0 @@
-import { act, renderHook, waitFor } from '@testing-library/react';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { useSyncStatusActions } from './useSyncStatusActions';
-function makeInput(overrides) {
-    return {
-        currentWorkspaceId: 'workspace-1',
-        syncStatusLabel: 'Healthy',
-        workspaceSyncSummary: 'Sync is healthy.',
-        workspaceSyncRecommendedAction: 'No action needed.',
-        formattedLastSyncTime: '4/17/2026, 10:32:47 PM',
-        formattedLastPullTime: '4/17/2026, 10:32:47 PM',
-        formattedLastPushTime: '4/17/2026, 10:31:45 PM',
-        workspaceSyncDiagnostics: {
-            aiProfileSnapshotCount: 1,
-            aiProfileSnapshotRawCount: 1,
-            lastPushedAiProfileCount: 1,
-            lastPushedAiProfileWatermarkCount: 1,
-            documentSnapshotCount: 2,
-            assetSnapshotCount: 3,
-            forceFullAiProfilePushQueued: false,
-        },
-        workspaceSyncPendingChanges: 4,
-        syncLastError: 'None',
-        workspaceSyncPhase: 'active',
-        referenceMismatchCount: 0,
-        syncRecentEvents: [],
-        loadRecentSyncEvents: vi.fn(async () => [{
-                occurredAt: '2026-04-18T01:33:06.044Z',
-                eventType: 'apply',
-                status: 'success',
-                changeCount: 200,
-                requestMs: 167,
-                statusCode: 0,
-            }]),
-        pushNotice: vi.fn(),
-        resetWorkspaceSyncCursorAndPull: vi.fn(async () => undefined),
-        workspaceSyncBusy: false,
-        ...overrides,
-    };
-}
-describe('useSyncStatusActions', () => {
-    beforeEach(() => {
-        vi.stubGlobal('navigator', {
-            clipboard: {
-                writeText: vi.fn(async () => undefined),
-            },
-        });
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-        vi.unstubAllGlobals();
-    });
-    it('copies the sync report using freshly loaded events when needed', async () => {
-        vi.useFakeTimers();
-        const input = makeInput();
-        const { result } = renderHook(() => useSyncStatusActions(input));
-        await act(async () => {
-            await result.current.handleCopySyncDetails();
-        });
-        expect(input.loadRecentSyncEvents).toHaveBeenCalledTimes(1);
-        expect(navigator.clipboard.writeText).toHaveBeenCalledWith(expect.stringContaining('Taskforce Sync Manager'));
-        expect(input.pushNotice).toHaveBeenCalledWith('Sync details copied to clipboard.', 'success');
-        expect(result.current.workspaceSyncCopied).toBe(true);
-        act(() => {
-            vi.advanceTimersByTime(1800);
-        });
-        expect(result.current.workspaceSyncCopied).toBe(false);
-    });
-    it('uses the current in-memory events instead of reloading when available', async () => {
-        const input = makeInput({
-            syncRecentEvents: [{
-                    occurredAt: '2026-04-18T01:33:18.371Z',
-                    eventType: 'apply',
-                    status: 'success',
-                    changeCount: 200,
-                    requestMs: 87,
-                    statusCode: 0,
-                }],
-        });
-        const { result } = renderHook(() => useSyncStatusActions(input));
-        await act(async () => {
-            await result.current.handleCopySyncDetails();
-        });
-        expect(input.loadRecentSyncEvents).not.toHaveBeenCalled();
-        expect(navigator.clipboard.writeText).toHaveBeenCalledWith(expect.stringContaining('2026-04-18T01:33:18.371Z apply succeeded'));
-    });
-    it('surfaces copy failures as an error notice', async () => {
-        const writeText = vi.fn(async () => {
-            throw new Error('clipboard unavailable');
-        });
-        vi.stubGlobal('navigator', {
-            clipboard: { writeText },
-        });
-        const input = makeInput();
-        const { result } = renderHook(() => useSyncStatusActions(input));
-        await act(async () => {
-            await result.current.handleCopySyncDetails();
-        });
-        expect(result.current.workspaceSyncCopied).toBe(false);
-        expect(input.pushNotice).toHaveBeenCalledWith('Failed to copy sync details.', 'error');
-    });
-    it('queues repair while sync is busy and runs it once the workspace becomes idle', async () => {
-        const input = makeInput({
-            workspaceSyncBusy: true,
-        });
-        const { result, rerender } = renderHook((props) => useSyncStatusActions(props), {
-            initialProps: input,
-        });
-        act(() => {
-            result.current.handleQueueOrRunRepairSync();
-        });
-        expect(result.current.workspaceSyncRepairQueued).toBe(true);
-        expect(input.resetWorkspaceSyncCursorAndPull).not.toHaveBeenCalled();
-        rerender({
-            ...input,
-            workspaceSyncBusy: false,
-        });
-        await waitFor(() => {
-            expect(input.resetWorkspaceSyncCursorAndPull).toHaveBeenCalledTimes(1);
-        });
-        expect(result.current.workspaceSyncRepairQueued).toBe(false);
-    });
-    it('runs repair immediately when the workspace is already idle', async () => {
-        const input = makeInput();
-        const { result } = renderHook(() => useSyncStatusActions(input));
-        act(() => {
-            result.current.handleQueueOrRunRepairSync();
-        });
-        await waitFor(() => {
-            expect(input.resetWorkspaceSyncCursorAndPull).toHaveBeenCalledTimes(1);
-        });
-    });
-});

package/dist/hooks/sync/useSyncStatusControls.test.d.ts

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

package/dist/hooks/sync/useSyncStatusControls.test.js

@@ -1,88 +0,0 @@
-import { act, renderHook, waitFor } from '@testing-library/react';
-import { describe, expect, it, vi } from 'vitest';
-import { useSyncStatusControls } from './useSyncStatusControls';
-function makeInput(overrides) {
-    return {
-        canManageWorkspaceSync: true,
-        workspaceCloudSyncEnabled: false,
-        saveWorkspaceCloudSyncSettings: vi.fn(async () => ({ success: true })),
-        ...overrides,
-    };
-}
-describe('useSyncStatusControls', () => {
-    it('opens and closes the sync status modal', () => {
-        const { result } = renderHook(() => useSyncStatusControls(makeInput()));
-        act(() => {
-            result.current.openSyncStatusModal();
-        });
-        expect(result.current.showSyncStatusModal).toBe(true);
-        act(() => {
-            result.current.closeSyncStatusModal();
-        });
-        expect(result.current.showSyncStatusModal).toBe(false);
-    });
-    it('shows the warning before enabling sync from a local-only workspace', async () => {
-        const input = makeInput({
-            workspaceCloudSyncEnabled: false,
-        });
-        const { result } = renderHook(() => useSyncStatusControls(input));
-        await act(async () => {
-            await result.current.handleWorkspaceSyncToggle(true);
-        });
-        expect(result.current.showSyncEnableWarning).toBe(true);
-        expect(input.saveWorkspaceCloudSyncSettings).not.toHaveBeenCalled();
-    });
-    it('confirms the warning and then persists enabling sync', async () => {
-        const input = makeInput({
-            workspaceCloudSyncEnabled: false,
-        });
-        const { result } = renderHook(() => useSyncStatusControls(input));
-        await act(async () => {
-            await result.current.handleWorkspaceSyncToggle(true);
-        });
-        act(() => {
-            result.current.confirmSyncEnableWarning();
-        });
-        await waitFor(() => {
-            expect(input.saveWorkspaceCloudSyncSettings).toHaveBeenCalledWith({ enabled: true });
-        });
-        expect(result.current.showSyncEnableWarning).toBe(false);
-    });
-    it('disables sync immediately without showing the warning', async () => {
-        const input = makeInput({
-            workspaceCloudSyncEnabled: true,
-        });
-        const { result } = renderHook(() => useSyncStatusControls(input));
-        await act(async () => {
-            await result.current.handleWorkspaceSyncToggle(false);
-        });
-        expect(result.current.showSyncEnableWarning).toBe(false);
-        expect(input.saveWorkspaceCloudSyncSettings).toHaveBeenCalledWith({ enabled: false });
-    });
-    it('stores toggle errors from failed sync setting updates', async () => {
-        const input = makeInput({
-            workspaceCloudSyncEnabled: true,
-            saveWorkspaceCloudSyncSettings: vi.fn(async () => ({
-                success: false,
-                error: 'Cloud sync settings could not be updated.',
-            })),
-        });
-        const { result } = renderHook(() => useSyncStatusControls(input));
-        await act(async () => {
-            await result.current.handleWorkspaceSyncToggle(false);
-        });
-        expect(result.current.workspaceSyncError).toBe('Cloud sync settings could not be updated.');
-        expect(result.current.syncControlBusy).toBe(false);
-    });
-    it('does not persist sync settings when sync controls are unavailable', async () => {
-        const input = makeInput({
-            canManageWorkspaceSync: false,
-            workspaceCloudSyncEnabled: true,
-        });
-        const { result } = renderHook(() => useSyncStatusControls(input));
-        await act(async () => {
-            await result.current.handleWorkspaceSyncToggle(false);
-        });
-        expect(input.saveWorkspaceCloudSyncSettings).not.toHaveBeenCalled();
-    });
-});

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

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