@taskforcehq/taskforce 0.3.311 → 0.3.313

package/dist/core/TaskAuditTimeline.test.js

@@ -1,319 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import Database from 'better-sqlite3';
-import { TaskforceCore } from './Taskforce';
-function makeCore() {
-    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-audit-timeline-'));
-    const core = new TaskforceCore({
-        projectRoot,
-        storagePath: path.join(projectRoot, '.taskforce')
-    });
-    return {
-        core,
-        cleanup: () => {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    };
-}
-describe('TaskforceCore task audit timeline', () => {
-    it('writes a task-created event and exposes it in the task activity feed', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const task = core.createTask({ title: 'Audit seed task', createdBy: 'user' }, { workspaceId: 'workspace-a', actorRef: 'user' });
-            const events = core.listTaskEvents(task.id, 'workspace-a');
-            const hydrated = core.getTask(task.id, 'workspace-a');
-            expect(events).toHaveLength(1);
-            expect(events[0]).toEqual(expect.objectContaining({
-                action: 'task-created',
-                actor: 'user',
-                actorType: 'human',
-            }));
-            expect(hydrated?.activity?.[0]).toEqual(expect.objectContaining({
-                type: 'event',
-                event: expect.objectContaining({ action: 'task-created' })
-            }));
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('records core task mutation events for update, scheduling, workstream relationships, attachments, comments, archive, and unarchive', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-a', name: 'Workspace A' });
-            const workstream = core.createWorkstream({ title: 'Tracked workstream' }, 'workspace-a');
-            const task = core.createTask({ title: 'Tracked task', createdBy: 'user' }, { workspaceId: 'workspace-a', actorRef: 'user' });
-            core.updateTask(task.id, { description: 'Updated body copy' }, 'workspace-a', { actorRef: 'user' });
-            core.updateTask(task.id, { status: 'in-progress' }, 'workspace-a', { actorRef: 'user' });
-            core.updateTask(task.id, { scheduledDate: '2026-03-24' }, 'workspace-a', { actorRef: 'user' });
-            core.updateTask(task.id, { workstreamId: workstream.id }, 'workspace-a', { actorRef: 'user' });
-            core.updateTask(task.id, {
-                attachments: [{ path: 'https://example.com/spec.md', caption: 'spec.md', timestamp: '2026-03-22T12:00:00.000Z' }]
-            }, 'workspace-a', { actorRef: 'user' });
-            core.addComment(task.id, 'This needs follow-up.', 'user', 'workspace-a', { actorRef: 'user' });
-            core.archiveTask(task.id, false, undefined, 'workspace-a', { actorRef: 'user', skipHierarchyCheck: true });
-            core.unarchiveTask(task.id, 'workspace-a', { actorRef: 'user' });
-            const actions = core.listTaskEvents(task.id, 'workspace-a').map((event) => event.action);
-            const commentEvent = core.listTaskEvents(task.id, 'workspace-a').find((event) => event.action === 'task-comment-added');
-            const hydrated = core.getTask(task.id, 'workspace-a');
-            expect(actions).toEqual(expect.arrayContaining([
-                'task-created',
-                'task-updated',
-                'task-status-changed',
-                'task-schedule-changed',
-                'task-relationship-changed',
-                'task-attachments-changed',
-                'task-comment-added',
-                'task-archived',
-                'task-unarchived'
-            ]));
-            expect(commentEvent?.details?.submittedAuthor).toBe('user');
-            expect(hydrated?.activity?.some((item) => item.type === 'event' && item.event.action === 'task-comment-added')).toBe(false);
-            expect(hydrated?.activity?.some((item) => item.type === 'comment' && item.comment.text === 'This needs follow-up.')).toBe(true);
-            expect(hydrated?.comments?.find((item) => item.text === 'This needs follow-up.')?.submittedAuthor).toBe('user');
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('does not write a duplicate task event for no-op updates', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const task = core.createTask({ title: 'No-op task', createdBy: 'user' }, { workspaceId: 'workspace-a', actorRef: 'user' });
-            const before = core.listTaskEvents(task.id, 'workspace-a').length;
-            core.updateTask(task.id, { title: 'No-op task' }, 'workspace-a', { actorRef: 'user' });
-            const after = core.listTaskEvents(task.id, 'workspace-a').length;
-            expect(after).toBe(before);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('suppresses task events when skipTaskEvents is explicitly true', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const task = core.createTask({ title: 'Autosave task', createdBy: 'user' }, { workspaceId: 'workspace-a', actorRef: 'user' });
-            core.updateTask(task.id, { description: 'Draft body' }, 'workspace-a', {
-                actorRef: 'user',
-                skipTaskEvents: true
-            });
-            const events = core.listTaskEvents(task.id, 'workspace-a');
-            const hydrated = core.getTask(task.id, 'workspace-a');
-            expect(events.map((event) => event.action)).toEqual(['task-created']);
-            expect(hydrated?.description).toBe('Draft body');
-            expect(hydrated?.activity?.some((item) => item.type === 'event' && item.event.action === 'task-updated')).toBe(false);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('suppresses title and description autosave events while preserving the saved task content', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const task = core.createTask({ title: 'Autosave title task', createdBy: 'user' }, { workspaceId: 'workspace-a', actorRef: 'user' });
-            core.updateTask(task.id, {
-                title: 'Autosave title task updated',
-                description: 'Draft body'
-            }, 'workspace-a', {
-                actorRef: 'user',
-                saveSource: 'autosave'
-            });
-            const events = core.listTaskEvents(task.id, 'workspace-a');
-            const hydrated = core.getTask(task.id, 'workspace-a');
-            expect(events.map((event) => event.action)).toEqual(['task-created']);
-            expect(hydrated?.title).toBe('Autosave title task updated');
-            expect(hydrated?.description).toBe('Draft body');
-            expect(hydrated?.activity?.some((item) => item.type === 'event' && item.event.action === 'task-updated')).toBe(false);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('keeps meaningful autosave updates in the activity feed while filtering noisy text changes', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const task = core.createTask({ title: 'Autosave assignee task', createdBy: 'user' }, { workspaceId: 'workspace-a', actorRef: 'user' });
-            core.updateTask(task.id, {
-                title: 'Autosave assignee task updated',
-                assignee: 'member-1'
-            }, 'workspace-a', {
-                actorRef: 'user',
-                saveSource: 'autosave'
-            });
-            const assignmentEvent = core.listTaskEvents(task.id, 'workspace-a').find((event) => event.action === 'task-updated' && event.details?.changes?.assignee);
-            expect(assignmentEvent).toEqual(expect.objectContaining({
-                action: 'task-updated',
-                details: {
-                    changes: {
-                        assignee: {
-                            from: 'unassigned',
-                            to: 'member-1',
-                        },
-                    },
-                },
-            }));
-            expect(assignmentEvent?.details?.changes?.title).toBeUndefined();
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('captures assignment changes in the core task update event details', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const task = core.createTask({ title: 'Assignment audit task', createdBy: 'user' }, { workspaceId: 'workspace-a', actorRef: 'user' });
-            core.updateTask(task.id, { assignee: 'member-1' }, 'workspace-a', { actorRef: 'user' });
-            const assignmentEvent = core.listTaskEvents(task.id, 'workspace-a').find((event) => event.action === 'task-updated' && event.details?.changes?.assignee);
-            expect(assignmentEvent).toEqual(expect.objectContaining({
-                action: 'task-updated',
-                details: {
-                    changes: {
-                        assignee: {
-                            from: 'unassigned',
-                            to: 'member-1',
-                        },
-                    },
-                },
-            }));
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('records initiative and workstream activity events and exposes them on hydrated planning entities', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-a', name: 'Workspace A' });
-            const initiative = core.createInitiative({ title: 'Planning initiative' }, 'workspace-a', { actorRef: 'user' });
-            const nestedInitiative = core.createInitiative({ title: 'Nested initiative' }, 'workspace-a', { actorRef: 'user' });
-            const workstream = core.createWorkstream({
-                title: 'Planning workstream',
-                initiativeId: initiative.id,
-            }, 'workspace-a', { actorRef: 'user' });
-            const siblingWorkstream = core.createWorkstream({
-                title: 'Sibling workstream',
-                initiativeId: initiative.id,
-            }, 'workspace-a', { actorRef: 'user' });
-            core.updateInitiative(initiative.id, {
-                description: 'Refined initiative description',
-                attachments: [{ path: 'https://example.com/initiative-spec.md', caption: 'initiative spec' }],
-            }, 'workspace-a', { actorRef: 'user' });
-            core.archiveInitiative(initiative.id, 'workspace-a', { actorRef: 'user' });
-            core.unarchiveInitiative(initiative.id, 'workspace-a', { actorRef: 'user' });
-            core.updateWorkstream(workstream.id, {
-                initiativeId: nestedInitiative.id,
-            }, 'workspace-a', { actorRef: 'user' });
-            core.archiveWorkstream(workstream.id, 'workspace-a', { actorRef: 'user' });
-            core.unarchiveWorkstream(workstream.id, 'workspace-a', { actorRef: 'user' });
-            const linkedTask = core.createTask({
-                title: 'Linked task',
-                createdBy: 'user',
-                workstreamId: workstream.id,
-            }, { workspaceId: 'workspace-a', actorRef: 'user' });
-            core.updateTask(linkedTask.id, { workstreamId: siblingWorkstream.id }, 'workspace-a', { actorRef: 'user' });
-            core.updateTask(linkedTask.id, { workstreamId: null }, 'workspace-a', { actorRef: 'user' });
-            const hydratedInitiative = core.getInitiative(initiative.id, 'workspace-a');
-            const hydratedWorkstream = core.getWorkstream(workstream.id, 'workspace-a');
-            const hydratedSiblingWorkstream = core.getWorkstream(siblingWorkstream.id, 'workspace-a');
-            const initiativeActions = (hydratedInitiative?.activity || [])
-                .filter((item) => item.type === 'event')
-                .map((item) => item.event.action);
-            const workstreamRelationshipEvent = (hydratedWorkstream?.activity || [])
-                .filter((item) => item.type === 'event')
-                .map((item) => item.event)
-                .find((event) => event.action === 'workstream-relationship-changed');
-            const workstreamActions = (hydratedWorkstream?.activity || [])
-                .filter((item) => item.type === 'event')
-                .map((item) => item.event.action);
-            const siblingWorkstreamActions = (hydratedSiblingWorkstream?.activity || [])
-                .filter((item) => item.type === 'event')
-                .map((item) => item.event.action);
-            const workstreamTaskAddedEvent = (hydratedWorkstream?.activity || [])
-                .filter((item) => item.type === 'event')
-                .map((item) => item.event)
-                .find((event) => event.action === 'workstream-task-added');
-            const workstreamTaskRemovedEvent = (hydratedWorkstream?.activity || [])
-                .filter((item) => item.type === 'event')
-                .map((item) => item.event)
-                .find((event) => event.action === 'workstream-task-removed');
-            expect(initiativeActions).toEqual(expect.arrayContaining([
-                'initiative-created',
-                'initiative-updated',
-                'initiative-archived',
-                'initiative-unarchived',
-            ]));
-            expect(workstreamActions).toEqual(expect.arrayContaining([
-                'workstream-created',
-                'workstream-relationship-changed',
-                'workstream-task-added',
-                'workstream-task-removed',
-                'workstream-archived',
-                'workstream-unarchived',
-            ]));
-            expect(siblingWorkstreamActions).toEqual(expect.arrayContaining([
-                'workstream-created',
-                'workstream-task-added',
-                'workstream-task-removed',
-            ]));
-            expect(workstreamRelationshipEvent?.details?.changes?.initiativeId).toEqual({
-                from: initiative.id,
-                to: nestedInitiative.id,
-            });
-            expect(workstreamTaskAddedEvent?.details?.taskId).toBe(linkedTask.id);
-            expect(workstreamTaskAddedEvent?.details?.taskTitle).toBe('Linked task');
-            expect(workstreamTaskAddedEvent?.details?.changes?.workstreamId).toEqual({
-                from: null,
-                to: workstream.id,
-            });
-            expect(workstreamTaskRemovedEvent?.details?.changes?.workstreamId).toEqual({
-                from: workstream.id,
-                to: siblingWorkstream.id,
-            });
-            expect(hydratedInitiative?.entityEvents?.every((event) => event.entityType === 'initiative')).toBe(true);
-            expect(hydratedWorkstream?.entityEvents?.every((event) => event.entityType === 'workstream')).toBe(true);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('repairs legacy comments tables so raw submitted authors can be stored', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const dbPath = path.join(core.getPaths().basePath, 'taskforce.db');
-            core.close();
-            const db = new Database(dbPath);
-            db.exec(`
-                ALTER TABLE comments RENAME TO comments_legacy;
-                CREATE TABLE comments (
-                    id TEXT PRIMARY KEY,
-                    tenant_id TEXT NOT NULL DEFAULT 'default',
-                    workspace_id TEXT NOT NULL DEFAULT 'default',
-                    task_id TEXT NOT NULL,
-                    text TEXT NOT NULL,
-                    author TEXT NOT NULL,
-                    timestamp TEXT NOT NULL,
-                    FOREIGN KEY(task_id) REFERENCES tasks(id) ON DELETE CASCADE
-                );
-                INSERT INTO comments (id, tenant_id, workspace_id, task_id, text, author, timestamp)
-                SELECT id, tenant_id, workspace_id, task_id, text, author, timestamp
-                FROM comments_legacy;
-                DROP TABLE comments_legacy;
-            `);
-            db.close();
-            const reopened = new TaskforceCore({
-                projectRoot: path.dirname(core.getPaths().basePath),
-                storagePath: core.getPaths().basePath
-            });
-            const columns = reopened.db.prepare(`PRAGMA table_info(comments)`).all()
-                .map((column) => column.name);
-            reopened.close();
-            expect(columns).toContain('submitted_author');
-        }
-        finally {
-            cleanup();
-        }
-    });
-});

package/dist/core/TaskTaxonomyValidation.test.d.ts

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