@taskforcehq/taskforce 0.3.311 → 0.3.313

package/dist/core/TaskTaxonomyValidation.test.js

@@ -1,440 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { TaskforceCore } from './Taskforce';
-function makeTempProjectRoot() {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-taxonomy-'));
-    fs.mkdirSync(root, { recursive: true });
-    return root;
-}
-describe('TaskforceCore taxonomy validation', () => {
-    it('falls back unresolved category and approach to default', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const task = core.createTask({
-            title: 'Taxonomy Fallback',
-            category: 'security',
-            approach: 'unknown-approach'
-        });
-        expect(task.category).toBe('default');
-        expect(task.approach).toBe('default');
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('resolves category and type aliases when provided in taxonomy metadata', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.updateCategories([{ value: 'ui-ux', label: 'UI/UX', aliases: ['design'] }]);
-        core.updateTypes([{ value: 'deliverable', label: 'Deliverable', aliases: ['artifact'] }]);
-        const task = core.createTask({
-            title: 'Alias Match',
-            category: 'design',
-            type: 'artifact'
-        });
-        expect(task.category).toBe('ui-ux');
-        expect(task.type).toBe('deliverable');
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('defaults omitted type to the active workspace type when task is not configured', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.createWorkspace({ workspaceId: 'workspace-2', name: 'Workspace 2' });
-        core.updateTypes([
-            { value: 'feature', label: 'Feature' },
-            { value: 'bug', label: 'Bug' },
-            { value: 'chore', label: 'Chore' }
-        ], 'workspace-2');
-        const task = core.createTask({
-            title: 'Workspace Type Default'
-        }, { workspaceId: 'workspace-2' });
-        expect(task.type).toBe('feature');
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('defaults omitted type to the first active workspace type when legacy task is unavailable', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.updateTypes([
-            { value: 'feature', label: 'Feature' },
-            { value: 'bug', label: 'Bug' },
-            { value: 'chore', label: 'Chore' }
-        ]);
-        const task = core.createTask({
-            title: 'Workspace default type'
-        });
-        expect(task.type).toBe('feature');
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('resolves custom taxonomy aliases for taxonomy keys and option values on create', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.updateTaxonomies([
-            {
-                id: 'review-status',
-                label: 'Review Status',
-                aliases: ['review route'],
-                widgetType: 'select',
-                isSystem: false,
-                multiSelect: false,
-                options: [
-                    { value: 'pending', label: 'Pending', aliases: ['queued'], status: 'active' },
-                    { value: 'legal-review', label: 'Legal Review', aliases: ['lawyer'], status: 'active' }
-                ]
-            }
-        ]);
-        const task = core.createTask({
-            title: 'Custom Alias Match',
-            taxonomies: {
-                'review route': 'lawyer'
-            }
-        });
-        expect(task.taxonomies).toEqual({
-            'review-status': 'legal-review'
-        });
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('resolves custom taxonomy aliases on update', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.updateTaxonomies([
-            {
-                id: 'channels',
-                label: 'Channels',
-                aliases: ['distribution channels'],
-                widgetType: 'select',
-                isSystem: false,
-                multiSelect: true,
-                options: [
-                    { value: 'email', label: 'Email', aliases: ['newsletter'], status: 'active' },
-                    { value: 'social', label: 'Social', aliases: ['social media'], status: 'active' }
-                ]
-            }
-        ]);
-        const task = core.createTask({ title: 'Custom Alias Update' });
-        const updated = core.updateTask(task.id, {
-            taxonomies: {
-                'distribution channels': ['newsletter', 'social media']
-            }
-        });
-        expect(updated?.taxonomies).toEqual({
-            channels: ['email', 'social']
-        });
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('rejects create when a required custom taxonomy is missing', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.updateTaxonomies([
-            {
-                id: 'review-status',
-                label: 'Review Status',
-                widgetType: 'select',
-                isSystem: false,
-                multiSelect: false,
-                isRequired: true,
-                options: [
-                    { value: 'pending', label: 'Pending', status: 'active' }
-                ]
-            }
-        ]);
-        expect(() => core.createTask({
-            title: 'Missing Required Taxonomy'
-        })).toThrowError(/Review Status/);
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('rejects update when a required custom taxonomy is cleared', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.updateTaxonomies([
-            {
-                id: 'review-status',
-                label: 'Review Status',
-                widgetType: 'select',
-                isSystem: false,
-                multiSelect: false,
-                isRequired: true,
-                options: [
-                    { value: 'pending', label: 'Pending', status: 'active' }
-                ]
-            }
-        ]);
-        const task = core.createTask({
-            title: 'Required Taxonomy Present',
-            taxonomies: { 'review-status': 'pending' }
-        });
-        expect(() => core.updateTask(task.id, {
-            taxonomies: {}
-        })).toThrowError(/Review Status/);
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('auto-reassigns removed categories to default', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.updateCategories([
-            { value: 'general', label: 'General' },
-            { value: 'custom', label: 'Custom' }
-        ]);
-        const task = core.createTask({
-            title: 'Reassign Test',
-            category: 'custom'
-        });
-        core.updateCategories([{ value: 'general', label: 'General' }]);
-        const reloaded = core.getTask(task.id);
-        expect(reloaded?.category).toBe('default');
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('preserves configured default category metadata when categories are rewritten without the default entry', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.updateCategories([
-            { value: 'default', label: 'Inbox Work', icon: 'Star', color: 'teal-500' },
-            { value: 'backend', label: 'Backend', icon: 'Folder', color: 'blue-500' }
-        ]);
-        core.updateCategories([
-            { value: 'backend', label: 'Backend', icon: 'Folder', color: 'blue-500' }
-        ]);
-        const categories = core.getCategories();
-        expect(categories[0]).toMatchObject({
-            value: 'default',
-            label: 'Inbox Work',
-            icon: 'Star',
-            color: 'teal-500'
-        });
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('uses built-in workflow defaults instead of config-backed approaches', () => {
-        const projectRoot = makeTempProjectRoot();
-        const taskforceDir = path.join(projectRoot, '.taskforce');
-        fs.mkdirSync(taskforceDir, { recursive: true });
-        fs.writeFileSync(path.join(taskforceDir, 'config.json'), JSON.stringify({
-            approaches: [
-                { value: 'custom-workflow', label: 'Custom Workflow' }
-            ]
-        }), 'utf-8');
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const workflows = core.getApproaches();
-        expect(workflows.map((entry) => entry.value)).toEqual([
-            'default',
-            'evaluate',
-            'collaborate',
-            'plan',
-            'review'
-        ]);
-        expect(workflows.some((entry) => entry.value === 'custom-workflow')).toBe(false);
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('stores workspace-owned taxonomy state in structured settings while preserving fallback defaults for untouched workspaces', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.updateCategories([{ value: 'general', label: 'General' }], 'workspace-a');
-        core.updateTypes([{ value: 'task', label: 'Task' }], 'workspace-a');
-        core.updatePriorities([{ value: 1, label: 'Low' }, { value: 2, label: 'Medium' }], 'workspace-a');
-        core.updateTaxonomies([
-            {
-                id: 'channel',
-                label: 'Channel',
-                options: [{ value: 'email', label: 'Email' }],
-                widgetType: 'select',
-                isSystem: false,
-                multiSelect: false
-            }
-        ], 'workspace-a');
-        const row = core.db.prepare(`
-            SELECT payload
-            FROM workspace_settings
-            WHERE tenant_id = ? AND workspace_id = ? AND settings_key = ?
-            LIMIT 1
-        `).get(core.tenantId, 'workspace-a', 'taxonomy_state');
-        expect(row?.payload).toBeTruthy();
-        expect(JSON.parse(String(row?.payload))).toMatchObject({
-            categories: [{ value: 'default', label: 'General' }, { value: 'general', label: 'General' }],
-            types: [{ value: 'task', label: 'Task' }],
-            taxonomies: [{ id: 'channel', label: 'Channel' }]
-        });
-        expect(JSON.parse(String(row?.payload)).priorities).toEqual(expect.arrayContaining([
-            expect.objectContaining({ value: 1, label: 'Low' }),
-            expect.objectContaining({ value: 2, label: 'Medium' })
-        ]));
-        expect(core.getTypes('workspace-b')[0]?.value).toBe('task');
-        expect(core.getTaxonomies('workspace-b')).toEqual([]);
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('seeds structured taxonomy state when a workspace is created', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.createWorkspace({ workspaceId: 'workspace-seeded', name: 'Seeded Workspace' });
-        const row = core.db.prepare(`
-            SELECT payload
-            FROM workspace_settings
-            WHERE tenant_id = ? AND workspace_id = ? AND settings_key = ?
-            LIMIT 1
-        `).get(core.tenantId, 'workspace-seeded', 'taxonomy_state');
-        expect(row?.payload).toBeTruthy();
-        expect(JSON.parse(String(row?.payload))).toMatchObject({
-            categories: expect.any(Array),
-            types: expect.any(Array),
-            priorities: expect.any(Array),
-            taxonomies: []
-        });
-        expect(JSON.parse(String(row?.payload))).toMatchObject({
-            categories: [{ value: 'default', label: 'General' }],
-            types: [
-                { value: 'task', label: 'Task' },
-                { value: 'deliverable', label: 'Deliverable' },
-                { value: 'issue', label: 'Issue' },
-                { value: 'idea', label: 'Idea' },
-                { value: 'review', label: 'Review' }
-            ],
-            priorities: [
-                { value: 1, label: 'Low' },
-                { value: 2, label: 'Medium' },
-                { value: 3, label: 'High' }
-            ]
-        });
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('seeds new workspaces from the configured default starter pack', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.db.prepare(`
-            INSERT INTO system_settings (tenant_id, settings_key, payload, updated_at)
-            VALUES (?, ?, ?, ?)
-            ON CONFLICT (tenant_id, settings_key) DO UPDATE SET
-                payload = excluded.payload,
-                updated_at = excluded.updated_at
-        `).run(core.tenantId, 'taxonomy_library_defaults', JSON.stringify({ defaultStarterPackId: 'software-development' }), new Date().toISOString());
-        core.createWorkspace({ workspaceId: 'workspace-software', name: 'Software Workspace' });
-        const state = core.getTaxonomyState('workspace-software');
-        expect((state.types || []).map((type) => type.value)).toEqual([
-            'feature',
-            'bug',
-            'chore',
-            'refactor',
-            'documentation'
-        ]);
-        expect((state.priorities || []).map((priority) => priority.value)).toEqual([1, 2, 3, 4]);
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('does not expose legacy taxonomy fields through getConfig once taxonomy state is DB-backed', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const configPath = path.join(projectRoot, '.taskforce', 'config.json');
-        fs.writeFileSync(configPath, JSON.stringify({
-            categories: [{ value: 'legacy', label: 'Legacy' }],
-            types: [{ value: 'legacy-type', label: 'Legacy Type' }],
-            priorities: [{ value: 9, label: 'Legacy Priority' }],
-            taxonomies: [{ id: 'legacy-taxonomy', label: 'Legacy Taxonomy' }],
-            checklistDropdownEnabled: true
-        }, null, 2));
-        const config = core.getConfig('default', 'user-a') || {};
-        expect(config.categories).toBeUndefined();
-        expect(config.types).toBeUndefined();
-        expect(config.priorities).toBeUndefined();
-        expect(config.taxonomies).toBeUndefined();
-        expect(config.checklistDropdownEnabled).toBe(true);
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('migrates legacy config-backed taxonomy data once and no longer depends on config for runtime state', () => {
-        const projectRoot = makeTempProjectRoot();
-        fs.mkdirSync(path.join(projectRoot, '.taskforce'), { recursive: true });
-        const configPath = path.join(projectRoot, '.taskforce', 'config.json');
-        fs.writeFileSync(configPath, JSON.stringify({
-            categories: [{ value: 'legacy', label: 'Legacy' }],
-            types: [{ value: 'legacy-type', label: 'Legacy Type' }],
-            priorities: [{ value: 9, label: 'Legacy Priority', color: 'red-500', icon: 'AlertTriangle' }],
-            taxonomies: [{ id: 'legacy-taxonomy', label: 'Legacy Taxonomy', widgetType: 'select', isSystem: false, multiSelect: false, options: [] }]
-        }, null, 2));
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const migratedState = core.getTaxonomyState('default');
-        expect((migratedState.categories || []).map((category) => (typeof category === 'string' ? category : category.value))).toEqual(['default', 'legacy']);
-        expect((migratedState.types || []).map((type) => type.value)).toEqual(['legacy-type']);
-        expect((migratedState.priorities || []).map((priority) => priority.value)).toEqual([9]);
-        expect((migratedState.taxonomies || []).map((taxonomy) => taxonomy.id)).toEqual(['legacy-taxonomy']);
-        core.close();
-        fs.writeFileSync(configPath, JSON.stringify({ checklistDropdownEnabled: true }, null, 2));
-        const reopened = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const persistedState = reopened.getTaxonomyState('default');
-        expect((persistedState.categories || []).map((category) => (typeof category === 'string' ? category : category.value))).toEqual(['default', 'legacy']);
-        expect((persistedState.types || []).map((type) => type.value)).toEqual(['legacy-type']);
-        expect((persistedState.priorities || []).map((priority) => priority.value)).toEqual([9]);
-        expect((persistedState.taxonomies || []).map((taxonomy) => taxonomy.id)).toEqual(['legacy-taxonomy']);
-        reopened.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('does not seed new workspaces from legacy config-backed taxonomy definitions', () => {
-        const projectRoot = makeTempProjectRoot();
-        fs.mkdirSync(path.join(projectRoot, '.taskforce'), { recursive: true });
-        const configPath = path.join(projectRoot, '.taskforce', 'config.json');
-        fs.writeFileSync(configPath, JSON.stringify({
-            categories: [{ value: 'legacy', label: 'Legacy' }],
-            types: [{ value: 'legacy-type', label: 'Legacy Type' }],
-            priorities: [{ value: 9, label: 'Legacy Priority' }],
-            taxonomies: [{ id: 'legacy-taxonomy', label: 'Legacy Taxonomy' }]
-        }, null, 2));
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.createWorkspace({ workspaceId: 'workspace-new', name: 'New Workspace' });
-        const state = core.getTaxonomyState('workspace-new');
-        expect((state.categories || []).map((category) => (typeof category === 'string' ? category : category.value))).toEqual(['default']);
-        expect((state.types || []).map((type) => type.value)).toEqual([
-            'task',
-            'deliverable',
-            'issue',
-            'idea',
-            'review'
-        ]);
-        expect((state.priorities || []).map((priority) => priority.value)).toEqual([1, 2, 3]);
-        expect(state.taxonomies || []).toEqual([]);
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('preserves existing first-class taxonomy sections when taxonomy state updates are partial', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.updateTaxonomyState({
-            categories: [
-                { value: 'default', label: 'General', icon: 'Inbox' },
-                { value: 'product', label: 'Product', icon: 'Layers', color: 'blue-500' }
-            ],
-            types: [
-                { value: 'feature', label: 'Feature', icon: 'Star', color: 'teal-500', status: 'active' },
-                { value: 'bug', label: 'Bug', icon: 'Bug', color: 'red-500', status: 'active' }
-            ],
-            priorities: [
-                { value: 1, label: 'Low', icon: 'ArrowDown', color: 'amber-200' },
-                { value: 2, label: 'Medium', icon: 'Minus', color: 'yellow-500' },
-                { value: 3, label: 'High', icon: 'ArrowUp', color: 'orange-500' },
-                { value: 4, label: 'Critical', icon: 'AlertTriangle', color: 'red-500' }
-            ],
-            taxonomies: []
-        }, 'workspace-safe');
-        core.updateTaxonomyState({
-            categories: [{ value: 'default', label: 'General', icon: 'Inbox' }],
-            priorities: [
-                { value: 1, label: 'Low', icon: 'ArrowDown', color: 'teal-500' },
-                { value: 2, label: 'Medium', icon: 'Minus', color: 'blue-500' },
-                { value: 3, label: 'High', icon: 'ArrowUp', color: 'amber-500' }
-            ],
-            taxonomies: []
-        }, 'workspace-safe');
-        const state = core.getTaxonomyState('workspace-safe');
-        expect((state.categories || []).map((category) => (typeof category === 'string' ? category : category.value))).toEqual(['default', 'product']);
-        expect((state.types || []).map((type) => type.value)).toEqual(['feature', 'bug']);
-        expect((state.priorities || []).map((priority) => priority.value)).toEqual([1, 2, 3, 4]);
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-});

package/dist/core/Taskforce.ids.test.d.ts

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