hzl-core 2.3.0 → 2.4.0

package/dist/services/task-service.test.js

@@ -1,10 +1,15 @@
 // packages/hzl-core/src/services/task-service.test.ts
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { TaskService, AmbiguousPrefixError, InvalidDueMonthError, InvalidProgressError, InvalidStatusTransitionError, } from './task-service.js';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import Database from 'libsql';
+import { TaskService, AmbiguousPrefixError, InvalidDueMonthError, InvalidProgressError, InvalidStatusTransitionError, TaskNotFoundError, } from './task-service.js';
 import { ProjectService, ProjectNotFoundError } from './project-service.js';
 import { createTestDb } from '../db/test-utils.js';
 import { EventStore } from '../events/store.js';
 import { EventType, TaskStatus } from '../events/types.js';
+import { CACHE_SCHEMA_V1, EVENTS_SCHEMA_V2, PRAGMAS } from '../db/schema.js';
 import { ProjectionEngine } from '../projections/engine.js';
 import { TasksCurrentProjector } from '../projections/tasks-current.js';
 import { DependenciesProjector } from '../projections/dependencies.js';
@@ -12,6 +17,14 @@ import { TagsProjector } from '../projections/tags.js';
 import { CommentsCheckpointsProjector } from '../projections/comments-checkpoints.js';
 import { SearchProjector } from '../projections/search.js';
 import { ProjectsProjector } from '../projections/projects.js';
+function registerProjectors(engine) {
+    engine.register(new TasksCurrentProjector());
+    engine.register(new DependenciesProjector());
+    engine.register(new TagsProjector());
+    engine.register(new CommentsCheckpointsProjector());
+    engine.register(new SearchProjector());
+    engine.register(new ProjectsProjector());
+}
 describe('TaskService', () => {
     let db;
     let eventStore;
@@ -23,12 +36,7 @@ describe('TaskService', () => {
         // Schema applied by createTestDb
         eventStore = new EventStore(db);
         projectionEngine = new ProjectionEngine(db);
-        projectionEngine.register(new TasksCurrentProjector());
-        projectionEngine.register(new DependenciesProjector());
-        projectionEngine.register(new TagsProjector());
-        projectionEngine.register(new CommentsCheckpointsProjector());
-        projectionEngine.register(new SearchProjector());
-        projectionEngine.register(new ProjectsProjector());
+        registerProjectors(projectionEngine);
         projectService = new ProjectService(db, eventStore, projectionEngine);
         projectService.ensureInboxExists();
         projectService.createProject('project-a');
@@ -264,6 +272,60 @@ describe('TaskService', () => {
             expect(moved.project).toBe('target');
         });
     });
+    describe('setStatus transition rules', () => {
+        const allStatuses = Object.values(TaskStatus);
+        const createTaskInStatus = (status) => {
+            const task = taskService.createTask({ title: `Status ${status}`, project: 'inbox' });
+            switch (status) {
+                case TaskStatus.Backlog:
+                    return task;
+                case TaskStatus.Ready:
+                    return taskService.setStatus(task.task_id, TaskStatus.Ready);
+                case TaskStatus.InProgress:
+                    taskService.setStatus(task.task_id, TaskStatus.Ready);
+                    return taskService.claimTask(task.task_id, { author: 'agent-1' });
+                case TaskStatus.Blocked:
+                    taskService.setStatus(task.task_id, TaskStatus.Ready);
+                    taskService.claimTask(task.task_id, { author: 'agent-1' });
+                    return taskService.blockTask(task.task_id);
+                case TaskStatus.Done:
+                    taskService.setStatus(task.task_id, TaskStatus.Ready);
+                    taskService.claimTask(task.task_id, { author: 'agent-1' });
+                    return taskService.completeTask(task.task_id);
+                case TaskStatus.Archived:
+                    return taskService.archiveTask(task.task_id);
+            }
+        };
+        it('allows any transition except from archived', () => {
+            const nonArchived = allStatuses.filter(s => s !== TaskStatus.Archived);
+            for (const fromStatus of nonArchived) {
+                for (const toStatus of allStatuses) {
+                    if (fromStatus === toStatus)
+                        continue; // skip self-transitions (tested separately)
+                    const task = createTaskInStatus(fromStatus);
+                    const updated = taskService.setStatus(task.task_id, toStatus);
+                    expect(updated.status).toBe(toStatus);
+                }
+            }
+        });
+        it('throws InvalidStatusTransitionError when transitioning from archived', () => {
+            const nonArchived = allStatuses.filter(s => s !== TaskStatus.Archived);
+            for (const toStatus of nonArchived) {
+                const task = createTaskInStatus(TaskStatus.Archived);
+                expect(() => taskService.setStatus(task.task_id, toStatus)).toThrow(InvalidStatusTransitionError);
+            }
+        });
+        it('no-ops on self-transition (returns task, no new event)', () => {
+            for (const status of allStatuses) {
+                const task = createTaskInStatus(status);
+                const eventsBefore = eventStore.getByTaskId(task.task_id);
+                const result = taskService.setStatus(task.task_id, status);
+                const eventsAfter = eventStore.getByTaskId(task.task_id);
+                expect(result.status).toBe(status);
+                expect(eventsAfter.length).toBe(eventsBefore.length);
+            }
+        });
+    });
     describe('claimTask', () => {
         it('claims a ready task with no dependencies', () => {
             const task = taskService.createTask({ title: 'Ready task', project: 'inbox' });
@@ -299,19 +361,48 @@ describe('TaskService', () => {
             const claimed = taskService.claimTask(task.task_id, { lease_until: leaseUntil });
             expect(claimed.lease_until).toBe(leaseUntil);
         });
-        it('throws if task is not in ready status', () => {
+        it('claims a task from backlog status', () => {
             const task = taskService.createTask({ title: 'Backlog task', project: 'inbox' });
+            const claimed = taskService.claimTask(task.task_id, { author: 'agent-1' });
+            expect(claimed.status).toBe(TaskStatus.InProgress);
+        });
+        it('claims a task from in_progress status (re-claim)', () => {
+            const task = taskService.createTask({ title: 'Test', project: 'inbox' });
+            taskService.setStatus(task.task_id, TaskStatus.Ready);
+            taskService.claimTask(task.task_id, { author: 'agent-1' });
+            const reclaimed = taskService.claimTask(task.task_id, { author: 'agent-2' });
+            expect(reclaimed.status).toBe(TaskStatus.InProgress);
+        });
+        it('claims a task from blocked status', () => {
+            const task = taskService.createTask({ title: 'Test', project: 'inbox' });
+            taskService.setStatus(task.task_id, TaskStatus.Ready);
+            taskService.claimTask(task.task_id, { author: 'agent-1' });
+            taskService.blockTask(task.task_id);
+            const claimed = taskService.claimTask(task.task_id, { author: 'agent-2' });
+            expect(claimed.status).toBe(TaskStatus.InProgress);
+        });
+        it('throws when claiming a done task', () => {
+            const task = taskService.createTask({ title: 'Test', project: 'inbox' });
+            taskService.setStatus(task.task_id, TaskStatus.Ready);
+            taskService.claimTask(task.task_id);
+            taskService.completeTask(task.task_id);
             expect(() => taskService.claimTask(task.task_id)).toThrow(/not claimable/i);
         });
-        it('throws if task has incomplete dependencies', () => {
+        it('throws when claiming an archived task', () => {
+            const task = taskService.createTask({ title: 'Test', project: 'inbox' });
+            taskService.archiveTask(task.task_id);
+            expect(() => taskService.claimTask(task.task_id)).toThrow(/not claimable/i);
+        });
+        it('allows claiming a task with incomplete dependencies', () => {
             const dep = taskService.createTask({ title: 'Incomplete dep', project: 'inbox' });
             const task = taskService.createTask({
-                title: 'Blocked task',
+                title: 'Dependent task',
                 project: 'inbox',
                 depends_on: [dep.task_id],
             });
             taskService.setStatus(task.task_id, TaskStatus.Ready);
-            expect(() => taskService.claimTask(task.task_id)).toThrow(/dependencies not done/i);
+            const claimed = taskService.claimTask(task.task_id, { author: 'agent-1' });
+            expect(claimed.status).toBe(TaskStatus.InProgress);
         });
     });
     describe('claimNext', () => {
@@ -837,6 +928,53 @@ describe('TaskService', () => {
             expect(() => taskService.listTasks({ dueMonth: 'bad-month' })).toThrow(InvalidDueMonthError);
             expect(() => taskService.listTasks({ dueMonth: '2026-00' })).toThrow(InvalidDueMonthError);
         });
+        it('listTasks includes tags', () => {
+            taskService.createTask({ title: 'Tagged task', project: 'project-a', tags: ['bug', 'urgent'] });
+            const tasks = taskService.listTasks({ sinceDays: 7 });
+            const found = tasks.find((t) => t.title === 'Tagged task');
+            expect(found).toBeDefined();
+            expect(found.tags).toEqual(['bug', 'urgent']);
+        });
+        it('listTasks returns empty tags array for untagged tasks', () => {
+            taskService.createTask({ title: 'No tags', project: 'project-a' });
+            const tasks = taskService.listTasks({ sinceDays: 7 });
+            const found = tasks.find((t) => t.title === 'No tags');
+            expect(found).toBeDefined();
+            expect(found.tags).toEqual([]);
+        });
+        it('listTasks filters by tag', () => {
+            projectService.createProject('test-project');
+            taskService.createTask({ title: 'Bug task', project: 'test-project', tags: ['bug'] });
+            taskService.createTask({ title: 'Feature task', project: 'test-project', tags: ['feature'] });
+            taskService.createTask({ title: 'Both', project: 'test-project', tags: ['bug', 'feature'] });
+            const bugTasks = taskService.listTasks({ sinceDays: 7, tag: 'bug' });
+            expect(bugTasks.map((t) => t.title).sort()).toEqual(['Both', 'Bug task']);
+            const featureTasks = taskService.listTasks({ sinceDays: 7, tag: 'feature' });
+            expect(featureTasks.map((t) => t.title).sort()).toEqual(['Both', 'Feature task']);
+        });
+    });
+    describe('getTagCounts', () => {
+        it('getTagCounts returns distinct tags with counts', () => {
+            projectService.createProject('test-project');
+            taskService.createTask({ title: 'A', project: 'test-project', tags: ['bug', 'urgent'] });
+            taskService.createTask({ title: 'B', project: 'test-project', tags: ['bug'] });
+            taskService.createTask({ title: 'C', project: 'test-project', tags: ['feature'] });
+            const counts = taskService.getTagCounts();
+            expect(counts).toEqual([
+                { tag: 'bug', count: 2 },
+                { tag: 'feature', count: 1 },
+                { tag: 'urgent', count: 1 },
+            ]);
+        });
+        it('getTagCounts excludes archived tasks', () => {
+            projectService.createProject('test-project');
+            const id = taskService.createTask({ title: 'A', project: 'test-project', tags: ['old'] });
+            taskService.claimTask(id.task_id);
+            taskService.completeTask(id.task_id);
+            taskService.archiveTask(id.task_id);
+            const counts = taskService.getTagCounts();
+            expect(counts.find((c) => c.tag === 'old')).toBeUndefined();
+        });
     });
     describe('getBlockedByMap', () => {
         it('returns empty map when no tasks are blocked', () => {
@@ -1024,6 +1162,60 @@ describe('TaskService', () => {
             expect(deps).toEqual([]);
         });
     });
+    describe('updateTask', () => {
+        it('updates multiple fields and persists task_updated events through service layer', () => {
+            const task = taskService.createTask({
+                title: 'Original',
+                project: 'inbox',
+                description: 'old',
+                links: ['a.md'],
+                tags: ['old'],
+                priority: 0,
+            });
+            const updated = taskService.updateTask(task.task_id, {
+                title: 'Updated',
+                description: 'new',
+                links: ['b.md'],
+                tags: ['new'],
+                priority: 2,
+            }, { author: 'agent-x' });
+            expect(updated.title).toBe('Updated');
+            expect(updated.description).toBe('new');
+            expect(updated.links).toEqual(['b.md']);
+            expect(updated.tags).toEqual(['new']);
+            expect(updated.priority).toBe(2);
+            const updateEvents = eventStore
+                .getByTaskId(task.task_id)
+                .filter((event) => event.type === EventType.TaskUpdated);
+            expect(updateEvents).toHaveLength(5);
+            expect(updateEvents.every((event) => event.author === 'agent-x')).toBe(true);
+        });
+        it('skips unchanged values (including arrays)', () => {
+            const task = taskService.createTask({
+                title: 'No change',
+                project: 'inbox',
+                description: 'same',
+                links: ['same.md'],
+                tags: ['same'],
+                priority: 1,
+            });
+            const updated = taskService.updateTask(task.task_id, {
+                title: 'No change',
+                description: 'same',
+                links: ['same.md'],
+                tags: ['same'],
+                priority: 1,
+            });
+            expect(updated.title).toBe('No change');
+            const updateEvents = eventStore
+                .getByTaskId(task.task_id)
+                .filter((event) => event.type === EventType.TaskUpdated);
+            expect(updateEvents).toHaveLength(0);
+        });
+        it('throws TaskNotFoundError for unknown task', () => {
+            expect(() => taskService.updateTask('TASK_UNKNOWN', { title: 'nope' })).toThrow(TaskNotFoundError);
+        });
+    });
     describe('getTaskTitlesByIds', () => {
         it('returns empty map for empty input', () => {
             const map = taskService.getTaskTitlesByIds([]);
@@ -1366,6 +1558,8 @@ describe('TaskService', () => {
         });
         it('sets progress to 100 when setStatus transitions task to done', () => {
             const task = taskService.createTask({ title: 'Test', project: 'inbox' });
+            taskService.setStatus(task.task_id, TaskStatus.Ready);
+            taskService.setStatus(task.task_id, TaskStatus.InProgress);
             taskService.setProgress(task.task_id, 20);
             const completed = taskService.setStatus(task.task_id, TaskStatus.Done);
             expect(completed.status).toBe(TaskStatus.Done);
@@ -1602,9 +1796,19 @@ describe('TaskService', () => {
             taskServiceWithEventsDb = new TaskService(db, eventStore, projectionEngine, projectService, db // eventsDb
             );
         });
-        it('throws when eventsDb not provided', () => {
-            // taskService doesn't have eventsDb
-            expect(() => taskService.pruneEligible({ project: 'inbox', olderThanDays: 1 })).toThrow('eventsDb not provided');
+        it('uses single-DB fallback when eventsDb is not provided', () => {
+            const task = taskService.createTask({ title: 'Single DB prune', project: 'inbox' });
+            taskService.setStatus(task.task_id, TaskStatus.Ready);
+            taskService.claimTask(task.task_id);
+            taskService.completeTask(task.task_id);
+            db.prepare('UPDATE tasks_current SET terminal_at = ? WHERE task_id = ?').run('2020-01-01T00:00:00Z', task.task_id);
+            const result = taskService.pruneEligible({ project: 'inbox', olderThanDays: 30 });
+            expect(result.count).toBe(1);
+            const eventsAfter = db
+                .prepare('SELECT COUNT(*) as cnt FROM events WHERE task_id = ?')
+                .get(task.task_id);
+            expect(eventsAfter.cnt).toBe(0);
+            expect(taskService.getTaskById(task.task_id)).toBeNull();
         });
         it('returns empty result when no eligible tasks', () => {
             const result = taskServiceWithEventsDb.pruneEligible({
@@ -1779,6 +1983,95 @@ describe('TaskService', () => {
             expect(taskServiceWithEventsDb.getTaskById(taskB.task_id)).toBeNull();
             expect(taskServiceWithEventsDb.getTaskById(taskC.task_id)).toBeNull();
         });
+        it('rolls back event deletion when projection deletion fails in split DB attach mode', () => {
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hzl-prune-atomic-'));
+            const cachePath = path.join(tempDir, 'cache.db');
+            const eventsPath = path.join(tempDir, 'events.db');
+            const cacheDb = new Database(cachePath);
+            const eventsDb = new Database(eventsPath);
+            try {
+                cacheDb.exec(PRAGMAS);
+                eventsDb.exec(PRAGMAS);
+                cacheDb.exec(CACHE_SCHEMA_V1);
+                eventsDb.exec(EVENTS_SCHEMA_V2);
+                const splitEventStore = new EventStore(eventsDb);
+                const splitProjectionEngine = new ProjectionEngine(cacheDb, eventsDb);
+                registerProjectors(splitProjectionEngine);
+                const splitProjectService = new ProjectService(cacheDb, splitEventStore, splitProjectionEngine);
+                splitProjectService.ensureInboxExists();
+                const splitTaskService = new TaskService(cacheDb, splitEventStore, splitProjectionEngine, splitProjectService, eventsDb);
+                const task = splitTaskService.createTask({ title: 'Split DB task', project: 'inbox' });
+                splitTaskService.setStatus(task.task_id, TaskStatus.Ready);
+                splitTaskService.claimTask(task.task_id);
+                splitTaskService.completeTask(task.task_id);
+                cacheDb.prepare('UPDATE tasks_current SET terminal_at = ? WHERE task_id = ?').run('2020-01-01T00:00:00Z', task.task_id);
+                const eventsBefore = eventsDb
+                    .prepare('SELECT COUNT(*) as cnt FROM events WHERE task_id = ?')
+                    .get(task.task_id);
+                expect(eventsBefore.cnt).toBeGreaterThan(0);
+                const originalDeleteProjections = splitTaskService.deleteTasksFromProjections;
+                splitTaskService.deleteTasksFromProjections = () => {
+                    throw new Error('simulated projection failure');
+                };
+                expect(() => splitTaskService.pruneEligible({ project: 'inbox', olderThanDays: 30 })).toThrow('simulated projection failure');
+                splitTaskService.deleteTasksFromProjections = originalDeleteProjections;
+                const eventsAfterFailure = eventsDb
+                    .prepare('SELECT COUNT(*) as cnt FROM events WHERE task_id = ?')
+                    .get(task.task_id);
+                expect(eventsAfterFailure.cnt).toBe(eventsBefore.cnt);
+                expect(cacheDb.prepare('SELECT 1 FROM tasks_current WHERE task_id = ?').get(task.task_id)).toBeDefined();
+            }
+            finally {
+                cacheDb.close();
+                eventsDb.close();
+                fs.rmSync(tempDir, { recursive: true, force: true });
+            }
+        });
+        it('recovers projection cleanup from prune journal when fallback path is interrupted', () => {
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hzl-prune-journal-'));
+            const cachePath = path.join(tempDir, 'cache.db');
+            const cacheDb = new Database(cachePath);
+            const eventsDb = new Database(':memory:');
+            const journalPath = path.join(tempDir, 'prune-journal.json');
+            try {
+                cacheDb.exec(PRAGMAS);
+                eventsDb.exec(PRAGMAS);
+                cacheDb.exec(CACHE_SCHEMA_V1);
+                eventsDb.exec(EVENTS_SCHEMA_V2);
+                const splitEventStore = new EventStore(eventsDb);
+                const splitProjectionEngine = new ProjectionEngine(cacheDb, eventsDb);
+                registerProjectors(splitProjectionEngine);
+                const splitProjectService = new ProjectService(cacheDb, splitEventStore, splitProjectionEngine);
+                splitProjectService.ensureInboxExists();
+                const splitTaskService = new TaskService(cacheDb, splitEventStore, splitProjectionEngine, splitProjectService, eventsDb);
+                const task = splitTaskService.createTask({ title: 'Journal fallback task', project: 'inbox' });
+                splitTaskService.setStatus(task.task_id, TaskStatus.Ready);
+                splitTaskService.claimTask(task.task_id);
+                splitTaskService.completeTask(task.task_id);
+                cacheDb.prepare('UPDATE tasks_current SET terminal_at = ? WHERE task_id = ?').run('2020-01-01T00:00:00Z', task.task_id);
+                const originalDeleteProjections = splitTaskService.deleteTasksFromProjections;
+                splitTaskService.deleteTasksFromProjections = () => {
+                    throw new Error('simulated crash after events delete');
+                };
+                expect(() => splitTaskService.pruneEligible({ project: 'inbox', olderThanDays: 30 })).toThrow('simulated crash after events delete');
+                splitTaskService.deleteTasksFromProjections = originalDeleteProjections;
+                const eventsAfterCrash = eventsDb
+                    .prepare('SELECT COUNT(*) as cnt FROM events WHERE task_id = ?')
+                    .get(task.task_id);
+                expect(eventsAfterCrash.cnt).toBe(0);
+                expect(cacheDb.prepare('SELECT 1 FROM tasks_current WHERE task_id = ?').get(task.task_id)).toBeDefined();
+                expect(fs.existsSync(journalPath)).toBe(true);
+                // Constructor-time recovery should finish projection cleanup.
+                new TaskService(cacheDb, splitEventStore, splitProjectionEngine, splitProjectService, eventsDb);
+                expect(cacheDb.prepare('SELECT 1 FROM tasks_current WHERE task_id = ?').get(task.task_id)).toBeUndefined();
+                expect(fs.existsSync(journalPath)).toBe(false);
+            }
+            finally {
+                cacheDb.close();
+                eventsDb.close();
+                fs.rmSync(tempDir, { recursive: true, force: true });
+            }
+        });
     });
     describe('getBlockedByForTasks', () => {
         it('returns empty map for empty input', () => {
@@ -1835,7 +2128,9 @@ describe('TaskService', () => {
                 project: 'inbox',
                 depends_on: [dep.task_id],
             });
-            // Force task to done status directly (bypassing dep check)
+            // Force task to done status directly via setStatus (bypassing dep check)
+            taskService.setStatus(task.task_id, TaskStatus.Ready);
+            taskService.setStatus(task.task_id, TaskStatus.InProgress);
             taskService.setStatus(task.task_id, TaskStatus.Done);
             const result = taskService.getBlockedByForTasks([task.task_id]);
             expect(result.has(task.task_id)).toBe(false);
@@ -1854,6 +2149,7 @@ describe('TaskService', () => {
                 project: 'inbox',
                 depends_on: [dep.task_id],
             });
+            taskService.setStatus(inProgressTask.task_id, TaskStatus.Ready);
             taskService.setStatus(inProgressTask.task_id, TaskStatus.InProgress);
             const result = taskService.getBlockedByForTasks([readyTask.task_id, inProgressTask.task_id]);
             expect(result.has(readyTask.task_id)).toBe(true);
@@ -1996,6 +2292,8 @@ describe('TaskService', () => {
                 onDone: { url: 'http://127.0.0.1:18789/events/inject' },
             });
             const task = hookTaskService.createTask({ title: 'Set status done', project: 'inbox' });
+            hookTaskService.setStatus(task.task_id, TaskStatus.Ready);
+            hookTaskService.setStatus(task.task_id, TaskStatus.InProgress);
             hookTaskService.setStatus(task.task_id, TaskStatus.Done);
             const count = db.prepare('SELECT COUNT(*) as count FROM hook_outbox WHERE payload LIKE ?')
                 .get(`%"task_id":"${task.task_id}"%`).count;