opentasks 0.0.1 → 0.0.2

package/dist/graph/__tests__/sync.test.js

@@ -0,0 +1,129 @@
+/**
+ * Tests for Sync Manager
+ */
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { createSyncManager } from '../sync.js';
+describe('SyncManager', () => {
+    let storage;
+    let syncManager;
+    let flushCallback;
+    const config = {
+        debounceMs: 100,
+        maxDelayMs: 500,
+    };
+    beforeEach(() => {
+        vi.useFakeTimers();
+        // Create mock storage
+        const dirtyNodes = new Set();
+        storage = {
+            markDirty: vi.fn().mockImplementation(async (nodeId) => {
+                dirtyNodes.add(nodeId);
+            }),
+            getDirtyNodes: vi.fn().mockImplementation(async () => {
+                return Array.from(dirtyNodes);
+            }),
+            clearDirty: vi.fn().mockImplementation(async (nodeIds) => {
+                for (const id of nodeIds) {
+                    dirtyNodes.delete(id);
+                }
+            }),
+        };
+        flushCallback = vi.fn().mockResolvedValue(undefined);
+        syncManager = createSyncManager(config, storage, flushCallback);
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+        syncManager.cancel();
+    });
+    describe('markDirty', () => {
+        it('should track dirty nodes', () => {
+            syncManager.markDirty('s-abc1');
+            syncManager.markDirty('s-abc2');
+            expect(syncManager.hasPendingChanges()).toBe(true);
+        });
+    });
+    describe('scheduleFlush', () => {
+        it('should flush after debounce delay', async () => {
+            syncManager.markDirty('s-abc1');
+            syncManager.scheduleFlush();
+            expect(flushCallback).not.toHaveBeenCalled();
+            // Advance past debounce
+            await vi.advanceTimersByTimeAsync(config.debounceMs + 10);
+            expect(flushCallback).toHaveBeenCalled();
+        });
+        it('should reset debounce timer on multiple calls', async () => {
+            syncManager.markDirty('s-abc1');
+            syncManager.scheduleFlush();
+            // Advance halfway
+            await vi.advanceTimersByTimeAsync(config.debounceMs / 2);
+            syncManager.markDirty('s-abc2');
+            syncManager.scheduleFlush();
+            // Advance halfway again (would be past original debounce)
+            await vi.advanceTimersByTimeAsync(config.debounceMs / 2);
+            // Should not have flushed yet (debounce was reset)
+            expect(flushCallback).not.toHaveBeenCalled();
+            // Advance remaining time
+            await vi.advanceTimersByTimeAsync(config.debounceMs / 2 + 10);
+            expect(flushCallback).toHaveBeenCalled();
+        });
+        it('should force flush at max delay', async () => {
+            syncManager.markDirty('s-abc1');
+            syncManager.scheduleFlush();
+            // Keep resetting debounce but stay under max delay
+            // debounceMs = 100, maxDelayMs = 500
+            // Advance 80ms at a time, which is less than debounce
+            // After 4 iterations: 320ms total (still under 500ms max)
+            for (let i = 0; i < 4; i++) {
+                await vi.advanceTimersByTimeAsync(80);
+                syncManager.scheduleFlush();
+            }
+            // Should not have flushed yet (320ms < 500ms maxDelay)
+            expect(flushCallback).not.toHaveBeenCalled();
+            // Advance to max delay (need another 180ms to reach 500ms)
+            await vi.advanceTimersByTimeAsync(200);
+            expect(flushCallback).toHaveBeenCalled();
+        });
+    });
+    describe('flush', () => {
+        it('should flush immediately', async () => {
+            syncManager.markDirty('s-abc1');
+            await syncManager.flush();
+            expect(flushCallback).toHaveBeenCalled();
+        });
+        it('should clear pending changes after flush', async () => {
+            syncManager.markDirty('s-abc1');
+            await syncManager.flush();
+            expect(syncManager.hasPendingChanges()).toBe(false);
+        });
+        it('should not flush when no pending changes', async () => {
+            await syncManager.flush();
+            expect(flushCallback).not.toHaveBeenCalled();
+        });
+        it('should deduplicate concurrent flush calls', async () => {
+            syncManager.markDirty('s-abc1');
+            // Call flush multiple times concurrently
+            const promise1 = syncManager.flush();
+            const promise2 = syncManager.flush();
+            const promise3 = syncManager.flush();
+            await Promise.all([promise1, promise2, promise3]);
+            // Should only call flush callback once
+            expect(flushCallback).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('cancel', () => {
+        it('should cancel pending flush', async () => {
+            syncManager.markDirty('s-abc1');
+            syncManager.scheduleFlush();
+            syncManager.cancel();
+            // Advance past debounce
+            await vi.advanceTimersByTimeAsync(config.debounceMs + 10);
+            expect(flushCallback).not.toHaveBeenCalled();
+        });
+        it('should clear pending changes', () => {
+            syncManager.markDirty('s-abc1');
+            syncManager.cancel();
+            expect(syncManager.hasPendingChanges()).toBe(false);
+        });
+    });
+});
+//# sourceMappingURL=sync.test.js.map

package/dist/graph/__tests__/sync.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.test.js","sourceRoot":"","sources":["../../../src/graph/__tests__/sync.test.ts"],"names":[],"mappings":"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"}

package/dist/graph/__tests__/validation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validation.test.d.ts.map

package/dist/graph/__tests__/validation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.test.d.ts","sourceRoot":"","sources":["../../../src/graph/__tests__/validation.test.ts"],"names":[],"mappings":""}

package/dist/graph/__tests__/validation.test.js

@@ -0,0 +1,521 @@
+import { describe, it, expect } from 'vitest';
+import { createValidationService } from '../validation.js';
+describe('ValidationService', () => {
+    const service = createValidationService();
+    // =========================================================================
+    // Node Creation Validation
+    // =========================================================================
+    describe('validateCreateNode', () => {
+        describe('common fields', () => {
+            it('requires type', () => {
+                const input = { title: 'Test' };
+                const result = service.validateCreateNode(input);
+                expect(result.valid).toBe(false);
+                expect(result.errors).toContainEqual(expect.objectContaining({ code: 'REQUIRED', field: 'type' }));
+            });
+            it('rejects invalid type', () => {
+                const input = { type: 'invalid', title: 'Test' };
+                const result = service.validateCreateNode(input);
+                expect(result.valid).toBe(false);
+                expect(result.errors).toContainEqual(expect.objectContaining({ code: 'INVALID_TYPE', field: 'type' }));
+            });
+            it('requires title', () => {
+                const input = { type: 'spec' };
+                const result = service.validateCreateNode(input);
+                expect(result.valid).toBe(false);
+                expect(result.errors).toContainEqual(expect.objectContaining({ code: 'REQUIRED', field: 'title' }));
+            });
+            it('rejects empty title', () => {
+                const input = { type: 'spec', title: '' };
+                const result = service.validateCreateNode(input);
+                expect(result.valid).toBe(false);
+                expect(result.errors).toContainEqual(expect.objectContaining({ code: 'REQUIRED', field: 'title' }));
+            });
+            it('rejects title exceeding max length', () => {
+                const input = {
+                    type: 'spec',
+                    title: 'a'.repeat(501),
+                };
+                const result = service.validateCreateNode(input);
+                expect(result.valid).toBe(false);
+                expect(result.errors).toContainEqual(expect.objectContaining({ code: 'MAX_LENGTH', field: 'title' }));
+            });
+            it('rejects content exceeding max length', () => {
+                const input = {
+                    type: 'spec',
+                    title: 'Test',
+                    content: 'a'.repeat(100_001),
+                };
+                const result = service.validateCreateNode(input);
+                expect(result.valid).toBe(false);
+                expect(result.errors).toContainEqual(expect.objectContaining({ code: 'MAX_LENGTH', field: 'content' }));
+            });
+            it('rejects invalid priority (out of range)', () => {
+                const input = {
+                    type: 'spec',
+                    title: 'Test',
+                    priority: 5,
+                };
+                const result = service.validateCreateNode(input);
+                expect(result.valid).toBe(false);
+                expect(result.errors).toContainEqual(expect.objectContaining({ code: 'INVALID_RANGE', field: 'priority' }));
+            });
+            it('rejects negative priority', () => {
+                const input = {
+                    type: 'spec',
+                    title: 'Test',
+                    priority: -1,
+                };
+                const result = service.validateCreateNode(input);
+                expect(result.valid).toBe(false);
+                expect(result.errors).toContainEqual(expect.objectContaining({ code: 'INVALID_RANGE', field: 'priority' }));
+            });
+            it('accepts valid priority', () => {
+                const input = {
+                    type: 'spec',
+                    title: 'Test',
+                    priority: 2,
+                };
+                const result = service.validateCreateNode(input);
+                expect(result.valid).toBe(true);
+            });
+        });
+        describe('spec validation', () => {
+            it('accepts valid spec', () => {
+                const input = {
+                    type: 'spec',
+                    title: 'Test Spec',
+                    content: 'Some content',
+                };
+                const result = service.validateCreateNode(input);
+                expect(result.valid).toBe(true);
+                expect(result.errors).toHaveLength(0);
+            });
+            it('accepts spec with optional status', () => {
+                const input = {
+                    type: 'spec',
+                    title: 'Test Spec',
+                    status: 'draft',
+                };
+                const result = service.validateCreateNode(input);
+                expect(result.valid).toBe(true);
+            });
+        });
+        describe('issue validation', () => {
+            it('requires status for issues', () => {
+                const input = {
+                    type: 'issue',
+                    title: 'Test Issue',
+                };
+                const result = service.validateCreateNode(input);
+                expect(result.valid).toBe(false);
+                expect(result.errors).toContainEqual(expect.objectContaining({ code: 'REQUIRED', field: 'status' }));
+            });
+            it('accepts valid issue', () => {
+                const input = {
+                    type: 'issue',
+                    title: 'Test Issue',
+                    status: 'open',
+                };
+                const result = service.validateCreateNode(input);
+                expect(result.valid).toBe(true);
+            });
+            it('warns for non-standard status', () => {
+                const input = {
+                    type: 'issue',
+                    title: 'Test Issue',
+                    status: 'custom_status',
+                };
+                const result = service.validateCreateNode(input);
+                expect(result.valid).toBe(true); // Warnings don't fail validation
+                expect(result.warnings).toContainEqual(expect.objectContaining({
+                    code: 'NON_STANDARD_STATUS',
+                    field: 'status',
+                }));
+            });
+        });
+        describe('feedback validation', () => {
+            it('requires target_id for feedback', () => {
+                const input = {
+                    type: 'feedback',
+                    title: 'Test Feedback',
+                    feedback_type: 'comment',
+                };
+                const result = service.validateCreateNode(input);
+                expect(result.valid).toBe(false);
+                expect(result.errors).toContainEqual(expect.objectContaining({ code: 'REQUIRED', field: 'target_id' }));
+            });
+            it('requires feedback_type for feedback', () => {
+                const input = {
+                    type: 'feedback',
+                    title: 'Test Feedback',
+                    target_id: 's-abc123',
+                };
+                const result = service.validateCreateNode(input);
+                expect(result.valid).toBe(false);
+                expect(result.errors).toContainEqual(expect.objectContaining({ code: 'REQUIRED', field: 'feedback_type' }));
+            });
+            it('accepts valid feedback', () => {
+                const input = {
+                    type: 'feedback',
+                    title: 'Test Feedback',
+                    target_id: 's-abc123',
+                    feedback_type: 'comment',
+                };
+                const result = service.validateCreateNode(input);
+                expect(result.valid).toBe(true);
+            });
+        });
+        describe('external validation', () => {
+            it('requires uri for external', () => {
+                const input = {
+                    type: 'external',
+                    title: 'External Node',
+                    source: 'jira',
+                };
+                const result = service.validateCreateNode(input);
+                expect(result.valid).toBe(false);
+                expect(result.errors).toContainEqual(expect.objectContaining({ code: 'REQUIRED', field: 'uri' }));
+            });
+            it('requires source for external', () => {
+                const input = {
+                    type: 'external',
+                    title: 'External Node',
+                    uri: 'jira://PROJ-123',
+                };
+                const result = service.validateCreateNode(input);
+                expect(result.valid).toBe(false);
+                expect(result.errors).toContainEqual(expect.objectContaining({ code: 'REQUIRED', field: 'source' }));
+            });
+            it('accepts valid external node', () => {
+                const input = {
+                    type: 'external',
+                    title: 'External Node',
+                    uri: 'jira://PROJ-123',
+                    source: 'jira',
+                };
+                const result = service.validateCreateNode(input);
+                expect(result.valid).toBe(true);
+            });
+        });
+    });
+    // =========================================================================
+    // Node Update Validation
+    // =========================================================================
+    describe('validateUpdateNode', () => {
+        const existingIssue = {
+            id: 'i-test',
+            uuid: 'test-uuid',
+            type: 'issue',
+            title: 'Existing Issue',
+            status: 'open',
+            created_at: '2025-01-26T10:00:00Z',
+            updated_at: '2025-01-26T10:00:00Z',
+        };
+        it('accepts valid update', () => {
+            const result = service.validateUpdateNode(existingIssue, {
+                title: 'Updated Title',
+            });
+            expect(result.valid).toBe(true);
+        });
+        it('rejects title exceeding max length', () => {
+            const result = service.validateUpdateNode(existingIssue, {
+                title: 'a'.repeat(501),
+            });
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContainEqual(expect.objectContaining({ code: 'MAX_LENGTH', field: 'title' }));
+        });
+        it('warns for non-standard status on issues', () => {
+            const result = service.validateUpdateNode(existingIssue, {
+                status: 'custom',
+            });
+            expect(result.valid).toBe(true);
+            expect(result.warnings).toContainEqual(expect.objectContaining({ code: 'NON_STANDARD_STATUS' }));
+        });
+    });
+    // =========================================================================
+    // Edge Validation
+    // =========================================================================
+    describe('validateCreateEdge', () => {
+        const mockGetNode = async (id) => {
+            const nodes = {
+                's-spec1': {
+                    id: 's-spec1',
+                    uuid: 'spec-uuid',
+                    type: 'spec',
+                    title: 'Test Spec',
+                    created_at: '2025-01-26T10:00:00Z',
+                    updated_at: '2025-01-26T10:00:00Z',
+                },
+                'i-issue1': {
+                    id: 'i-issue1',
+                    uuid: 'issue-uuid',
+                    type: 'issue',
+                    title: 'Test Issue',
+                    status: 'open',
+                    created_at: '2025-01-26T10:00:00Z',
+                    updated_at: '2025-01-26T10:00:00Z',
+                },
+            };
+            return nodes[id] || null;
+        };
+        it('requires from_id', async () => {
+            const input = { to_id: 's-spec1', type: 'blocks' };
+            const result = await service.validateCreateEdge(input, mockGetNode);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContainEqual(expect.objectContaining({ code: 'REQUIRED', field: 'from_id' }));
+        });
+        it('requires to_id', async () => {
+            const input = { from_id: 'i-issue1', type: 'blocks' };
+            const result = await service.validateCreateEdge(input, mockGetNode);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContainEqual(expect.objectContaining({ code: 'REQUIRED', field: 'to_id' }));
+        });
+        it('requires type', async () => {
+            const input = { from_id: 'i-issue1', to_id: 's-spec1' };
+            const result = await service.validateCreateEdge(input, mockGetNode);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContainEqual(expect.objectContaining({ code: 'REQUIRED', field: 'type' }));
+        });
+        it('rejects self-reference', async () => {
+            const input = {
+                from_id: 'i-issue1',
+                to_id: 'i-issue1',
+                type: 'blocks',
+            };
+            const result = await service.validateCreateEdge(input, mockGetNode);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContainEqual(expect.objectContaining({ code: 'SELF_REFERENCE' }));
+        });
+        it('errors when source node not found', async () => {
+            const input = {
+                from_id: 'i-nonexistent',
+                to_id: 's-spec1',
+                type: 'implements',
+            };
+            const result = await service.validateCreateEdge(input, mockGetNode);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContainEqual(expect.objectContaining({ code: 'NOT_FOUND', field: 'from_id' }));
+        });
+        it('errors when target node not found', async () => {
+            const input = {
+                from_id: 'i-issue1',
+                to_id: 's-nonexistent',
+                type: 'implements',
+            };
+            const result = await service.validateCreateEdge(input, mockGetNode);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContainEqual(expect.objectContaining({ code: 'NOT_FOUND', field: 'to_id' }));
+        });
+        it('accepts valid edge', async () => {
+            const input = {
+                from_id: 'i-issue1',
+                to_id: 's-spec1',
+                type: 'implements',
+            };
+            const result = await service.validateCreateEdge(input, mockGetNode);
+            expect(result.valid).toBe(true);
+        });
+        it('warns when implements edge has non-issue source', async () => {
+            const input = {
+                from_id: 's-spec1',
+                to_id: 'i-issue1',
+                type: 'implements',
+            };
+            const result = await service.validateCreateEdge(input, mockGetNode);
+            expect(result.valid).toBe(true); // Warning, not error
+            expect(result.warnings).toContainEqual(expect.objectContaining({ code: 'IMPLEMENTS_FROM_NON_ISSUE' }));
+        });
+        it('warns when implements edge has non-spec target', async () => {
+            const input = {
+                from_id: 'i-issue1',
+                to_id: 'i-issue1',
+                type: 'implements',
+            };
+            // Note: This will hit self-reference first, so use different nodes
+            const getNodeWithTwoIssues = async (id) => {
+                const nodes = {
+                    'i-issue1': {
+                        id: 'i-issue1',
+                        uuid: 'issue-uuid-1',
+                        type: 'issue',
+                        title: 'Test Issue 1',
+                        status: 'open',
+                        created_at: '2025-01-26T10:00:00Z',
+                        updated_at: '2025-01-26T10:00:00Z',
+                    },
+                    'i-issue2': {
+                        id: 'i-issue2',
+                        uuid: 'issue-uuid-2',
+                        type: 'issue',
+                        title: 'Test Issue 2',
+                        status: 'open',
+                        created_at: '2025-01-26T10:00:00Z',
+                        updated_at: '2025-01-26T10:00:00Z',
+                    },
+                };
+                return nodes[id] || null;
+            };
+            const input2 = {
+                from_id: 'i-issue1',
+                to_id: 'i-issue2',
+                type: 'implements',
+            };
+            const result = await service.validateCreateEdge(input2, getNodeWithTwoIssues);
+            expect(result.valid).toBe(true);
+            expect(result.warnings).toContainEqual(expect.objectContaining({ code: 'IMPLEMENTS_TO_NON_SPEC' }));
+        });
+        it('allows external URIs without node lookup', async () => {
+            const input = {
+                from_id: 'i-issue1',
+                to_id: 'jira://PROJ-123',
+                type: 'references',
+            };
+            const result = await service.validateCreateEdge(input, mockGetNode);
+            expect(result.valid).toBe(true);
+        });
+    });
+    // =========================================================================
+    // Cycle Detection
+    // =========================================================================
+    describe('detectCycle', () => {
+        it('detects simple cycle (A→B, adding B→A)', async () => {
+            // A blocks B already exists
+            const getBlocksEdges = async (nodeId) => {
+                if (nodeId === 'i-b') {
+                    return []; // B doesn't block anything yet
+                }
+                if (nodeId === 'i-a') {
+                    return [
+                        {
+                            id: 'x-1',
+                            uuid: 'edge-uuid-1',
+                            from_id: 'i-a',
+                            to_id: 'i-b',
+                            type: 'blocks',
+                            created_at: '2025-01-26T10:00:00Z',
+                        },
+                    ];
+                }
+                return [];
+            };
+            // Adding B→A would create cycle
+            const result = await service.detectCycle('i-b', 'i-a', getBlocksEdges);
+            expect(result.hasCycle).toBe(true);
+            expect(result.cycle).toEqual(['i-b', 'i-a']);
+        });
+        it('detects transitive cycle (A→B→C, adding C→A)', async () => {
+            // A→B, B→C exists
+            const getBlocksEdges = async (nodeId) => {
+                const edges = {
+                    'i-a': [
+                        {
+                            id: 'x-1',
+                            uuid: 'edge-1',
+                            from_id: 'i-a',
+                            to_id: 'i-b',
+                            type: 'blocks',
+                            created_at: '2025-01-26T10:00:00Z',
+                        },
+                    ],
+                    'i-b': [
+                        {
+                            id: 'x-2',
+                            uuid: 'edge-2',
+                            from_id: 'i-b',
+                            to_id: 'i-c',
+                            type: 'blocks',
+                            created_at: '2025-01-26T10:00:00Z',
+                        },
+                    ],
+                    'i-c': [],
+                };
+                return edges[nodeId] || [];
+            };
+            // Adding C→A would create cycle
+            const result = await service.detectCycle('i-c', 'i-a', getBlocksEdges);
+            expect(result.hasCycle).toBe(true);
+            expect(result.cycle).toContain('i-a');
+            expect(result.cycle).toContain('i-b');
+            expect(result.cycle).toContain('i-c');
+        });
+        it('returns no cycle for valid edge', async () => {
+            // A→B exists
+            const getBlocksEdges = async (nodeId) => {
+                if (nodeId === 'i-a') {
+                    return [
+                        {
+                            id: 'x-1',
+                            uuid: 'edge-uuid-1',
+                            from_id: 'i-a',
+                            to_id: 'i-b',
+                            type: 'blocks',
+                            created_at: '2025-01-26T10:00:00Z',
+                        },
+                    ];
+                }
+                return [];
+            };
+            // Adding A→C is fine (no cycle)
+            const result = await service.detectCycle('i-a', 'i-c', getBlocksEdges);
+            expect(result.hasCycle).toBe(false);
+            expect(result.cycle).toBeUndefined();
+        });
+        it('handles no existing edges', async () => {
+            const getBlocksEdges = async () => [];
+            const result = await service.detectCycle('i-a', 'i-b', getBlocksEdges);
+            expect(result.hasCycle).toBe(false);
+        });
+        it('handles complex graph without cycle', async () => {
+            // Diamond: A→B, A→C, B→D, C→D
+            const getBlocksEdges = async (nodeId) => {
+                const edges = {
+                    'i-a': [
+                        {
+                            id: 'x-1',
+                            uuid: 'e1',
+                            from_id: 'i-a',
+                            to_id: 'i-b',
+                            type: 'blocks',
+                            created_at: '2025-01-26T10:00:00Z',
+                        },
+                        {
+                            id: 'x-2',
+                            uuid: 'e2',
+                            from_id: 'i-a',
+                            to_id: 'i-c',
+                            type: 'blocks',
+                            created_at: '2025-01-26T10:00:00Z',
+                        },
+                    ],
+                    'i-b': [
+                        {
+                            id: 'x-3',
+                            uuid: 'e3',
+                            from_id: 'i-b',
+                            to_id: 'i-d',
+                            type: 'blocks',
+                            created_at: '2025-01-26T10:00:00Z',
+                        },
+                    ],
+                    'i-c': [
+                        {
+                            id: 'x-4',
+                            uuid: 'e4',
+                            from_id: 'i-c',
+                            to_id: 'i-d',
+                            type: 'blocks',
+                            created_at: '2025-01-26T10:00:00Z',
+                        },
+                    ],
+                    'i-d': [],
+                };
+                return edges[nodeId] || [];
+            };
+            // Adding D→E is fine
+            const result = await service.detectCycle('i-d', 'i-e', getBlocksEdges);
+            expect(result.hasCycle).toBe(false);
+        });
+    });
+});
+//# sourceMappingURL=validation.test.js.map