@taskforcehq/taskforce 0.3.169 → 0.3.300

package/dist/TaskforceCore.CategoryFallback.test.js

@@ -29,6 +29,9 @@ function stubFetch(categories) {
         if (url.includes('/api/taskforce/config')) {
             return Promise.resolve({ ok: true, json: () => Promise.resolve(mockConfig) });
         }
+        if (url.includes('/api/taskforce/taxonomy-state')) {
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ categories, types: [], priorities: [], taxonomies: [] }) });
+        }
         if (url.includes('/api/taskforce/categories')) {
             return Promise.resolve({ ok: true, json: () => Promise.resolve({ categories }) });
         }
@@ -81,7 +84,7 @@ describe('Taskforce Category Handling', () => {
         render(_jsx(TaskforceCore, {}));
         await waitFor(() => {
             expect(screen.getByText('Test Project')).toBeInTheDocument();
-            expect(screen.getByTitle('Visible active tasks / total active tasks')).toHaveTextContent('0/1');
+            expect(screen.getByTitle('Open tasks matching current filters')).toHaveTextContent('0/1');
         });
     });
     it('remains stable when category ordering includes values before general', async () => {
@@ -92,7 +95,7 @@ describe('Taskforce Category Handling', () => {
         render(_jsx(TaskforceCore, {}));
         await waitFor(() => {
             expect(screen.getByText('Test Project')).toBeInTheDocument();
-            expect(screen.getByTitle('Visible active tasks / total active tasks')).toHaveTextContent('0/1');
+            expect(screen.getByTitle('Open tasks matching current filters')).toHaveTextContent('0/1');
         });
     });
 });

package/dist/TaskforceCore.filter-persistence.test.js

@@ -0,0 +1,402 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen, waitFor, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { TaskforceCore } from './TaskforceCore';
+const baseConfig = {
+    storagePath: '.Taskforce',
+    shortcut: 'Alt+T',
+    projectName: 'Test Project',
+    runtimeMode: 'local',
+    workspaceId: 'default',
+    setupState: {
+        globalSetupState: 'complete',
+        workspaceSetupState: 'complete',
+        workspaceId: 'default'
+    }
+};
+const categories = [
+    { value: 'default', label: 'General' },
+    { value: 'product', label: 'Product' }
+];
+const tasks = [
+    {
+        id: 'task-default',
+        title: 'Default Task',
+        category: 'default',
+        type: 'task',
+        priority: 2,
+        status: 'task',
+        createdAt: '2026-03-18T10:00:00.000Z'
+    },
+    {
+        id: 'task-product',
+        title: 'Product Task',
+        category: 'product',
+        type: 'task',
+        priority: 2,
+        status: 'task',
+        createdAt: '2026-03-18T10:05:00.000Z'
+    }
+];
+const assigneeTasks = [
+    {
+        id: 'task-codex',
+        title: 'Codex Task',
+        category: 'default',
+        type: 'task',
+        priority: 2,
+        status: 'task',
+        assignee: 'ai-profile-codex',
+        createdAt: '2026-03-18T10:00:00.000Z'
+    },
+    {
+        id: 'task-member-1',
+        title: 'Alex Task',
+        category: 'default',
+        type: 'task',
+        priority: 2,
+        status: 'task',
+        assignee: 'member-1',
+        createdAt: '2026-03-18T10:05:00.000Z'
+    },
+    {
+        id: 'task-member-2',
+        title: 'Bailey Task',
+        category: 'default',
+        type: 'task',
+        priority: 2,
+        status: 'task',
+        assignee: 'member-2',
+        createdAt: '2026-03-18T10:10:00.000Z'
+    }
+];
+const defaultAssigneeOptions = [
+    { value: 'ai-profile-codex', label: 'Codex', kind: 'agent' },
+    { value: 'member-1', label: 'Alex Example', kind: 'member' },
+    { value: 'member-2', label: 'Bailey Example', kind: 'member' }
+];
+function createDeferredResponse() {
+    let resolve;
+    const promise = new Promise((res) => {
+        resolve = res;
+    });
+    return { promise, resolve };
+}
+function installFetchStub(persistedState, options) {
+    const deferredCategories = options?.delayCategories ? createDeferredResponse() : null;
+    const deferredAssignees = options?.delayAssigneeOptions ? createDeferredResponse() : null;
+    let currentTasks = options?.tasks ?? tasks;
+    let currentAssigneeOptions = options?.assigneeOptions ?? defaultAssigneeOptions;
+    vi.stubGlobal('fetch', vi.fn((url, init) => {
+        const method = String(init?.method || 'GET').toUpperCase();
+        if (url.includes('/api/taskforce/auth/runtime-config')) {
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'local' } }) });
+        }
+        if (url.includes('/api/taskforce/auth/session')) {
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ authenticated: false, authRequiredForApi: false, userId: 'anonymous', email: '', workspaceId: 'default' }) });
+        }
+        if (url.includes('/api/taskforce/config')) {
+            return Promise.resolve({
+                ok: true,
+                json: () => Promise.resolve(baseConfig)
+            });
+        }
+        if (url.includes('/api/taskforce/categories')) {
+            if (deferredCategories)
+                return deferredCategories.promise;
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ categories }) });
+        }
+        if (url.includes('/api/taskforce/types')) {
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ types: [{ value: 'task', label: 'Task' }] }) });
+        }
+        if (url.includes('/api/taskforce/priorities')) {
+            return Promise.resolve({
+                ok: true,
+                json: () => Promise.resolve({
+                    priorities: [
+                        { value: 1, label: 'Low' },
+                        { value: 2, label: 'Medium' },
+                        { value: 3, label: 'High' },
+                    ]
+                })
+            });
+        }
+        if (url.includes('/api/taskforce/approaches')) {
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ approaches: [] }) });
+        }
+        if (url.includes('/api/taskforce/specialists')) {
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ specialists: [] }) });
+        }
+        if (url.includes('/api/taskforce/taxonomies')) {
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ taxonomies: [] }) });
+        }
+        if (url.includes('/api/taskforce/workspace/assignee-options')) {
+            if (deferredAssignees)
+                return deferredAssignees.promise;
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ assignees: currentAssigneeOptions }) });
+        }
+        if (url.includes('/api/taskforce/tasks')) {
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: currentTasks }) });
+        }
+        if (url.includes('/api/taskforce/ui-state?key=app')) {
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true, state: persistedState }) });
+        }
+        if (url.includes('/api/taskforce/ui-state') && method === 'POST') {
+            const body = init?.body ? JSON.parse(String(init.body)) : {};
+            Object.assign(persistedState, body?.patch || body?.state || {});
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+        }
+        return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+    }));
+    return {
+        resolveCategories: () => {
+            deferredCategories?.resolve({ ok: true, json: () => Promise.resolve({ categories }) });
+        },
+        resolveAssigneeOptions: () => {
+            deferredAssignees?.resolve({ ok: true, json: () => Promise.resolve({ assignees: currentAssigneeOptions }) });
+        },
+        setAssigneeOptions: (next) => {
+            currentAssigneeOptions = next;
+        },
+        setTasks: (next) => {
+            currentTasks = next;
+        }
+    };
+}
+async function selectOnlyProductCategory(user) {
+    await user.click(screen.getByTitle('Toggle Filters'));
+    await user.click(screen.getByTitle('Filter by Category'));
+    const categoryMenuLabel = await screen.findByText('Toggle All');
+    const categoryMenu = categoryMenuLabel.closest('div')?.parentElement;
+    await user.click(within(categoryMenu).getByText('General'));
+}
+async function openAssigneeMenu(user) {
+    await user.click(screen.getByTitle('Toggle Filters'));
+    await user.click(screen.getByTitle('Filter by Assignee'));
+    const toggleAll = await screen.findByText('Toggle All');
+    return toggleAll.closest('div')?.parentElement;
+}
+describe('TaskforceCore category filter persistence', () => {
+    beforeEach(() => {
+        localStorage.clear();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('persists the selected category across repeated remounts', async () => {
+        const persistedState = {};
+        installFetchStub(persistedState);
+        const user = userEvent.setup();
+        const firstRender = render(_jsx(TaskforceCore, { mode: "standalone" }));
+        await waitFor(() => {
+            expect(screen.getByText('Default Task')).toBeInTheDocument();
+            expect(screen.getByText('Product Task')).toBeInTheDocument();
+        });
+        await selectOnlyProductCategory(user);
+        await waitFor(() => {
+            expect(screen.getByText('Product Task')).toBeInTheDocument();
+            expect(screen.queryByText('Default Task')).not.toBeInTheDocument();
+        });
+        expect(persistedState.filterCategories).toEqual(['product']);
+        firstRender.unmount();
+        render(_jsx(TaskforceCore, { mode: "standalone" }));
+        await waitFor(() => {
+            expect(screen.getByText('Product Task')).toBeInTheDocument();
+            expect(screen.queryByText('Default Task')).not.toBeInTheDocument();
+        });
+        expect(persistedState.filterCategories).toEqual(['product']);
+    });
+    it('does not overwrite the restored category when categories load after config', async () => {
+        const persistedState = {
+            hasInitedFilters: true,
+            filterCategories: ['product'],
+            filterTypes: ['task'],
+            filterPriorities: [1, 2, 3, 4],
+            filterStatus: ['task', 'on-hold', 'in-progress', 'review', 'done', 'cancelled']
+        };
+        const fetchControl = installFetchStub(persistedState, { delayCategories: true });
+        const firstRender = render(_jsx(TaskforceCore, { mode: "standalone" }));
+        await waitFor(() => {
+            expect(screen.getByText('Default Task')).toBeInTheDocument();
+            expect(screen.getByText('Product Task')).toBeInTheDocument();
+        });
+        expect(persistedState.filterCategories).toEqual(['product']);
+        fetchControl.resolveCategories();
+        await waitFor(() => {
+            expect(screen.getByText('Product Task')).toBeInTheDocument();
+            expect(screen.queryByText('Default Task')).not.toBeInTheDocument();
+        });
+        expect(persistedState.filterCategories).toEqual(['product']);
+        firstRender.unmount();
+        render(_jsx(TaskforceCore, { mode: "standalone" }));
+        await waitFor(() => {
+            expect(screen.getByText('Product Task')).toBeInTheDocument();
+            expect(screen.queryByText('Default Task')).not.toBeInTheDocument();
+        });
+        expect(persistedState.filterCategories).toEqual(['product']);
+    });
+    it('falls back to all categories when the saved category no longer exists', async () => {
+        const persistedState = {
+            filterCategories: ['missing-category']
+        };
+        installFetchStub(persistedState);
+        render(_jsx(TaskforceCore, { mode: "standalone" }));
+        await waitFor(() => {
+            expect(screen.getByText('Default Task')).toBeInTheDocument();
+            expect(screen.getByText('Product Task')).toBeInTheDocument();
+        });
+    });
+});
+describe('TaskforceCore assignee filter persistence', () => {
+    beforeEach(() => {
+        localStorage.clear();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('persists toggle-all across repeated remounts for dynamic assignee options', async () => {
+        const persistedState = {};
+        installFetchStub(persistedState, {
+            tasks: assigneeTasks
+        });
+        const user = userEvent.setup();
+        const firstRender = render(_jsx(TaskforceCore, { mode: "standalone" }));
+        await waitFor(() => {
+            expect(screen.getByText('Codex Task')).toBeInTheDocument();
+            expect(screen.getByText('Alex Task')).toBeInTheDocument();
+            expect(screen.getByText('Bailey Task')).toBeInTheDocument();
+        });
+        const assigneeMenu = await openAssigneeMenu(user);
+        await user.click(within(assigneeMenu).getByText('Alex Example'));
+        await waitFor(() => {
+            expect(screen.queryByText('Alex Task')).not.toBeInTheDocument();
+        });
+        await user.click(within(assigneeMenu).getByText('Toggle All'));
+        await waitFor(() => {
+            expect(screen.getByText('Codex Task')).toBeInTheDocument();
+            expect(screen.getByText('Alex Task')).toBeInTheDocument();
+            expect(screen.getByText('Bailey Task')).toBeInTheDocument();
+            expect(persistedState.filterAssigneesAllSelected).toBe(true);
+        });
+        firstRender.unmount();
+        render(_jsx(TaskforceCore, { mode: "standalone" }));
+        await waitFor(() => {
+            expect(screen.getByText('Codex Task')).toBeInTheDocument();
+            expect(screen.getByText('Alex Task')).toBeInTheDocument();
+            expect(screen.getByText('Bailey Task')).toBeInTheDocument();
+        });
+    });
+    it('restores all-assignees selection after assignee options load late and expands to new members', async () => {
+        const persistedState = {
+            hasInitedFilters: true,
+            filterAssignees: ['ai-profile-codex', 'member-1', 'member-2'],
+            filterAssigneesAllSelected: true,
+            filterCategories: ['default', 'product'],
+            filterTypes: ['task'],
+            filterPriorities: [1, 2, 3, 4],
+            filterStatus: ['task', 'on-hold', 'in-progress', 'review', 'done', 'cancelled']
+        };
+        const fetchControl = installFetchStub(persistedState, {
+            tasks: assigneeTasks,
+            delayAssigneeOptions: true
+        });
+        const firstRender = render(_jsx(TaskforceCore, { mode: "standalone" }));
+        await waitFor(() => {
+            expect(screen.getByText('Codex Task')).toBeInTheDocument();
+            expect(screen.getByText('Alex Task')).toBeInTheDocument();
+            expect(screen.getByText('Bailey Task')).toBeInTheDocument();
+        });
+        fetchControl.resolveAssigneeOptions();
+        await waitFor(() => {
+            expect(persistedState.filterAssigneesAllSelected).toBe(true);
+            expect(persistedState.filterAssignees).toEqual(['unassigned', 'ai-profile-codex', 'member-1', 'member-2']);
+        });
+        fetchControl.setAssigneeOptions([
+            ...defaultAssigneeOptions,
+            { value: 'member-3', label: 'Casey Example', kind: 'member' }
+        ]);
+        fetchControl.setTasks([
+            ...assigneeTasks,
+            {
+                id: 'task-member-3',
+                title: 'Casey Task',
+                category: 'default',
+                type: 'task',
+                priority: 2,
+                status: 'task',
+                assignee: 'member-3',
+                createdAt: '2026-03-18T10:15:00.000Z'
+            }
+        ]);
+        firstRender.unmount();
+        render(_jsx(TaskforceCore, { mode: "standalone" }));
+        await waitFor(() => {
+            expect(screen.getByText('Casey Task')).toBeInTheDocument();
+            expect(persistedState.filterAssigneesAllSelected).toBe(true);
+            expect(persistedState.filterAssignees).toEqual(['unassigned', 'ai-profile-codex', 'member-1', 'member-2', 'member-3']);
+        });
+    });
+    it('preserves a custom assignee subset across refresh', async () => {
+        const persistedState = {
+            hasInitedFilters: true,
+            filterAssignees: ['ai-profile-codex', 'member-1'],
+            filterAssigneesAllSelected: false,
+            filterCategories: ['default', 'product'],
+            filterTypes: ['task'],
+            filterPriorities: [1, 2, 3, 4],
+            filterStatus: ['task', 'on-hold', 'in-progress', 'review', 'done', 'cancelled']
+        };
+        installFetchStub(persistedState, {
+            tasks: assigneeTasks
+        });
+        render(_jsx(TaskforceCore, { mode: "standalone" }));
+        await waitFor(() => {
+            expect(screen.getByText('Codex Task')).toBeInTheDocument();
+            expect(screen.getByText('Alex Task')).toBeInTheDocument();
+            expect(screen.queryByText('Bailey Task')).not.toBeInTheDocument();
+        });
+    });
+    it('keeps a manually deselected assignee excluded instead of immediately restoring all assignees', async () => {
+        const persistedState = {};
+        installFetchStub(persistedState, {
+            tasks: assigneeTasks
+        });
+        const user = userEvent.setup();
+        render(_jsx(TaskforceCore, { mode: "standalone" }));
+        await waitFor(() => {
+            expect(screen.getByText('Codex Task')).toBeInTheDocument();
+            expect(screen.getByText('Alex Task')).toBeInTheDocument();
+            expect(screen.getByText('Bailey Task')).toBeInTheDocument();
+        });
+        const assigneeMenu = await openAssigneeMenu(user);
+        await user.click(within(assigneeMenu).getByText('Codex'));
+        await waitFor(() => {
+            expect(screen.queryByText('Codex Task')).not.toBeInTheDocument();
+            expect(screen.getByText('Alex Task')).toBeInTheDocument();
+            expect(screen.getByText('Bailey Task')).toBeInTheDocument();
+            expect(persistedState.filterAssigneesAllSelected).toBe(false);
+        });
+    });
+    it('falls back to all assignees when a saved custom subset no longer exists', async () => {
+        const persistedState = {
+            hasInitedFilters: true,
+            filterAssignees: ['member-missing'],
+            filterAssigneesAllSelected: false,
+            filterCategories: ['default', 'product'],
+            filterTypes: ['task'],
+            filterPriorities: [1, 2, 3, 4],
+            filterStatus: ['task', 'on-hold', 'in-progress', 'review', 'done', 'cancelled']
+        };
+        installFetchStub(persistedState, {
+            tasks: assigneeTasks
+        });
+        render(_jsx(TaskforceCore, { mode: "standalone" }));
+        await waitFor(() => {
+            expect(screen.getByText('Codex Task')).toBeInTheDocument();
+            expect(screen.getByText('Alex Task')).toBeInTheDocument();
+            expect(screen.getByText('Bailey Task')).toBeInTheDocument();
+            expect(persistedState.filterAssigneesAllSelected).toBe(true);
+        });
+    });
+});