@taskforcehq/taskforce 0.3.168

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

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

package/dist/core/Taskforce.ids.test.js

@@ -0,0 +1,168 @@
+import { describe, expect, it } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { TaskforceCore } from './Taskforce';
+function makeCore() {
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-id-test-'));
+    const core = new TaskforceCore({
+        projectRoot,
+        storagePath: path.join(projectRoot, '.taskforce')
+    });
+    return {
+        core,
+        cleanup: () => {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    };
+}
+describe('TaskforceCore id policy', () => {
+    it('rejects client-supplied task id for normal create', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            expect(() => core.createTask({
+                id: 'task-client-provided',
+                title: 'Should fail'
+            })).toThrowError(/task id is not allowed/i);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it('allows client-supplied task id in workspace sync snapshot apply path', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            const result = core.applyWorkspaceSyncSnapshot({
+                tasks: [
+                    {
+                        id: 'task-sync-imported',
+                        title: 'Imported',
+                        status: 'task'
+                    }
+                ]
+            }, 'workspace-test');
+            expect(result.created).toBe(1);
+            const task = core.getTask('task-sync-imported', 'workspace-test');
+            expect(task?.title).toBe('Imported');
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it('ignores stale incoming sync update when existing task is newer', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            core.applyWorkspaceSyncSnapshot({
+                tasks: [
+                    {
+                        id: 'task-sync-conflict-1',
+                        title: 'Local newer',
+                        status: 'task',
+                        createdAt: '2026-02-20T10:00:00.000Z'
+                    }
+                ]
+            }, 'workspace-test');
+            const staleResult = core.applyWorkspaceSyncSnapshot({
+                tasks: [
+                    {
+                        id: 'task-sync-conflict-1',
+                        title: 'Cloud stale',
+                        status: 'task',
+                        updatedAt: '2026-02-20T09:00:00.000Z'
+                    }
+                ]
+            }, 'workspace-test');
+            expect(staleResult.skipped).toBe(1);
+            const task = core.getTask('task-sync-conflict-1', 'workspace-test');
+            expect(task?.title).toBe('Local newer');
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it('applies newer incoming sync update when timestamp is later', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            core.applyWorkspaceSyncSnapshot({
+                tasks: [
+                    {
+                        id: 'task-sync-conflict-2',
+                        title: 'Old value',
+                        status: 'task',
+                        createdAt: '2026-02-20T10:00:00.000Z'
+                    }
+                ]
+            }, 'workspace-test');
+            const newerResult = core.applyWorkspaceSyncSnapshot({
+                tasks: [
+                    {
+                        id: 'task-sync-conflict-2',
+                        title: 'Newer value',
+                        status: 'in-progress',
+                        updatedAt: '2026-02-20T11:00:00.000Z'
+                    }
+                ]
+            }, 'workspace-test');
+            expect(newerResult.updated).toBe(1);
+            const task = core.getTask('task-sync-conflict-2', 'workspace-test');
+            expect(task?.title).toBe('Newer value');
+            expect(task?.status).toBe('in-progress');
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it('applies incoming sync update when timestamps are equal (deterministic tie behavior)', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            core.applyWorkspaceSyncSnapshot({
+                tasks: [
+                    {
+                        id: 'task-sync-conflict-3',
+                        title: 'Initial value',
+                        status: 'task',
+                        createdAt: '2026-02-20T10:00:00.000Z'
+                    }
+                ]
+            }, 'workspace-test');
+            const equalTimestampResult = core.applyWorkspaceSyncSnapshot({
+                tasks: [
+                    {
+                        id: 'task-sync-conflict-3',
+                        title: 'zz-incoming-same-timestamp',
+                        status: 'review',
+                        createdAt: '2026-02-20T10:00:00.000Z',
+                        updatedAt: '2026-02-20T10:00:00.000Z'
+                    }
+                ]
+            }, 'workspace-test');
+            expect(equalTimestampResult.updated).toBe(1);
+            const task = core.getTask('task-sync-conflict-3', 'workspace-test');
+            expect(task?.title).toBe('zz-incoming-same-timestamp');
+            expect(task?.status).toBe('review');
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it('resolves preferred workspace to the most active non-default workspace', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            core.applyWorkspaceSyncSnapshot({
+                tasks: [{ id: 'task-a', title: 'A', status: 'task' }]
+            }, 'workspace-small');
+            core.applyWorkspaceSyncSnapshot({
+                tasks: [
+                    { id: 'task-b1', title: 'B1', status: 'task' },
+                    { id: 'task-b2', title: 'B2', status: 'task' }
+                ]
+            }, 'workspace-large');
+            expect(core.resolvePreferredWorkspaceId({ allowDefault: true })).toBe('workspace-large');
+            expect(core.resolvePreferredWorkspaceId({ allowDefault: false })).toBe('workspace-large');
+        }
+        finally {
+            cleanup();
+        }
+    });
+});