vellum 0.0.16 → 0.2.0

package/src/__tests__/task-tools.test.ts

@@ -0,0 +1,602 @@
+import { describe, test, expect, beforeEach, afterAll, mock } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const testDir = mkdtempSync(join(tmpdir(), 'task-tools-test-'));
+
+mock.module('../util/platform.js', () => ({
+  getDataDir: () => testDir,
+  isMacOS: () => process.platform === 'darwin',
+  isLinux: () => process.platform === 'linux',
+  isWindows: () => process.platform === 'win32',
+  getSocketPath: () => join(testDir, 'test.sock'),
+  getPidPath: () => join(testDir, 'test.pid'),
+  getDbPath: () => join(testDir, 'test.db'),
+  getLogPath: () => join(testDir, 'test.log'),
+  ensureDataDir: () => {},
+  migrateToDataLayout: () => {},
+  migrateToWorkspaceLayout: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+mock.module('../config/loader.js', () => ({
+  getConfig: () => ({ memory: {} }),
+}));
+
+mock.module('./indexer.js', () => ({
+  indexMessageNow: () => {},
+}));
+
+import type { Database } from 'bun:sqlite';
+import { initializeDb, getDb } from '../memory/db.js';
+import { createTask, createTaskRun } from '../tasks/task-store.js';
+import { createWorkItem } from '../work-items/work-item-store.js';
+import { taskSaveTool } from '../tools/tasks/task-save.js';
+import { taskRunTool } from '../tools/tasks/task-run.js';
+import { taskListTool } from '../tools/tasks/task-list.js';
+import { taskListShowTool } from '../tools/tasks/work-item-list.js';
+import { taskListAddTool } from '../tools/tasks/work-item-enqueue.js';
+import { taskDeleteTool } from '../tools/tasks/task-delete.js';
+import type { ToolContext } from '../tools/types.js';
+
+initializeDb();
+
+afterAll(() => {
+  try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
+});
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function getRawDb(): Database {
+  return (getDb() as unknown as { $client: Database }).$client;
+}
+
+function createTestConversation(id: string): string {
+  const raw = getRawDb();
+  const now = Date.now();
+  raw.query(
+    `INSERT INTO conversations (id, title, created_at, updated_at, thread_type, memory_scope_id) VALUES (?, 'Test', ?, ?, 'standard', 'default')`,
+  ).run(id, now, now);
+  return id;
+}
+
+function addTestMessage(conversationId: string, role: string, content: string): void {
+  const raw = getRawDb();
+  const id = crypto.randomUUID();
+  const now = Date.now();
+  raw.query(
+    `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES (?, ?, ?, ?, ?)`,
+  ).run(id, conversationId, role, content, now);
+}
+
+const stubContext: ToolContext = {
+  workingDir: '/tmp',
+  sessionId: 'test-session',
+  conversationId: 'test-conversation',
+};
+
+// ── task_save ────────────────────────────────────────────────────────
+
+describe('task_save tool', () => {
+  beforeEach(() => {
+    const raw = getRawDb();
+    raw.run('DELETE FROM task_runs');
+    raw.run('DELETE FROM tasks');
+    raw.run('DELETE FROM messages');
+    raw.run('DELETE FROM conversations');
+  });
+
+  test('creates a task from a conversation', async () => {
+    const convId = createTestConversation('conv-save-1');
+    addTestMessage(convId, 'user', 'Please summarize the document');
+    addTestMessage(
+      convId,
+      'assistant',
+      JSON.stringify([
+        { type: 'tool_use', id: 'tu1', name: 'file_read', input: { path: '/tmp/doc.txt' } },
+      ]),
+    );
+    addTestMessage(convId, 'assistant', 'Here is the summary...');
+
+    const result = await taskSaveTool.execute(
+      { conversation_id: convId },
+      stubContext,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Task saved successfully');
+    expect(result.content).toContain('Please summarize the document');
+    expect(result.content).toContain('file_read');
+  });
+
+  test('uses title override when provided', async () => {
+    const convId = createTestConversation('conv-save-2');
+    addTestMessage(convId, 'user', 'Read and analyze the logs');
+    addTestMessage(convId, 'assistant', 'Done!');
+
+    const result = await taskSaveTool.execute(
+      { conversation_id: convId, title: 'My Custom Title' },
+      stubContext,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('My Custom Title');
+  });
+
+  test('uses context conversation_id when missing', async () => {
+    const convId = createTestConversation(stubContext.conversationId);
+    addTestMessage(convId, 'user', 'Summarize the report');
+    addTestMessage(convId, 'assistant', 'Done.');
+
+    const result = await taskSaveTool.execute({}, stubContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Task saved successfully');
+    expect(result.content).toContain('Summarize the report');
+  });
+
+  test('returns error for nonexistent conversation', async () => {
+    const result = await taskSaveTool.execute(
+      { conversation_id: 'nonexistent' },
+      stubContext,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('No messages found');
+  });
+});
+
+// ── task_run ─────────────────────────────────────────────────────────
+
+describe('task_run tool', () => {
+  beforeEach(() => {
+    const raw = getRawDb();
+    raw.run('DELETE FROM task_runs');
+    raw.run('DELETE FROM tasks');
+    raw.run('DELETE FROM messages');
+    raw.run('DELETE FROM conversations');
+  });
+
+  test('resolves task by name (fuzzy match)', async () => {
+    createTask({
+      title: 'Summarize Document',
+      template: 'Please summarize {{file_path}}',
+      inputSchema: { type: 'object', properties: { file_path: { type: 'string', description: 'The file path' } } },
+      requiredTools: ['file_read'],
+    });
+
+    const result = await taskRunTool.execute(
+      { task_name: 'summarize', inputs: { file_path: '/tmp/report.txt' } },
+      stubContext,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Summarize Document');
+    expect(result.content).toContain('Please summarize /tmp/report.txt');
+  });
+
+  test('resolves task by ID', async () => {
+    const task = createTask({
+      title: 'Deploy App',
+      template: 'Deploy the application to {{url}}',
+      inputSchema: { type: 'object', properties: { url: { type: 'string', description: 'URL' } } },
+    });
+
+    const result = await taskRunTool.execute(
+      { task_id: task.id, inputs: { url: 'https://prod.example.com' } },
+      stubContext,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Deploy App');
+    expect(result.content).toContain('Deploy the application to https://prod.example.com');
+  });
+
+  test('returns error when task not found by name', async () => {
+    createTask({
+      title: 'Existing Task',
+      template: 'Do something',
+    });
+
+    const result = await taskRunTool.execute(
+      { task_name: 'nonexistent' },
+      stubContext,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('No task template matching "nonexistent" found');
+    expect(result.content).toContain('Existing Task');
+  });
+
+  test('returns error when task not found by ID', async () => {
+    const result = await taskRunTool.execute(
+      { task_id: 'bad-id' },
+      stubContext,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('No task found with ID "bad-id"');
+  });
+
+  test('renders template with inputs', async () => {
+    createTask({
+      title: 'Multi-input Task',
+      template: 'Read {{file_path}} and post to {{url}}',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          file_path: { type: 'string', description: 'File' },
+          url: { type: 'string', description: 'URL' },
+        },
+      },
+    });
+
+    const result = await taskRunTool.execute(
+      {
+        task_name: 'multi-input',
+        inputs: { file_path: '/home/user/data.csv', url: 'https://api.example.com/upload' },
+      },
+      stubContext,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Read /home/user/data.csv and post to https://api.example.com/upload');
+  });
+
+  test('returns error when required inputs are missing', async () => {
+    createTask({
+      title: 'Input Required Task',
+      template: 'Process {{file_path}}',
+      inputSchema: {
+        type: 'object',
+        properties: { file_path: { type: 'string', description: 'File' } },
+      },
+    });
+
+    const result = await taskRunTool.execute(
+      { task_name: 'input required' },
+      stubContext,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Missing required inputs: file_path');
+  });
+
+  test('returns error when neither task_name nor task_id provided', async () => {
+    const result = await taskRunTool.execute({}, stubContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('At least one of task_name or task_id must be provided');
+  });
+
+  test('returns error with helpful message when no tasks exist', async () => {
+    const result = await taskRunTool.execute(
+      { task_name: 'anything' },
+      stubContext,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('No task templates found');
+  });
+
+  test('includes required tools in output', async () => {
+    createTask({
+      title: 'Tools Task',
+      template: 'Do the thing',
+      requiredTools: ['file_read', 'bash'],
+    });
+
+    const result = await taskRunTool.execute(
+      { task_name: 'tools' },
+      stubContext,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Required tools: file_read, bash');
+  });
+});
+
+// ── task_list ────────────────────────────────────────────────────────
+
+describe('task_list tool', () => {
+  beforeEach(() => {
+    const raw = getRawDb();
+    raw.run('DELETE FROM task_runs');
+    raw.run('DELETE FROM tasks');
+    raw.run('DELETE FROM messages');
+    raw.run('DELETE FROM conversations');
+  });
+
+  test('returns formatted list of tasks', async () => {
+    createTask({
+      title: 'Task Alpha',
+      template: 'Do alpha things',
+      requiredTools: ['file_read'],
+    });
+    createTask({
+      title: 'Task Beta',
+      template: 'Do beta {{file_path}}',
+      inputSchema: {
+        type: 'object',
+        properties: { file_path: { type: 'string', description: 'File' } },
+      },
+      requiredTools: ['file_read', 'file_write'],
+    });
+
+    const result = await taskListTool.execute({}, stubContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Found 2 task template(s)');
+    expect(result.content).toContain('Task Alpha');
+    expect(result.content).toContain('Task Beta');
+    expect(result.content).toContain('file_read');
+    expect(result.content).toContain('file_write');
+    expect(result.content).toContain('file_path');
+    expect(result.content).toContain('Tip: To see your active Tasks (work items in the queue), use the task_list_show tool.');
+  });
+
+  test('returns empty message when no tasks exist', async () => {
+    const result = await taskListTool.execute({}, stubContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('No task templates found');
+    expect(result.content).toContain('Tip: To see your active Tasks (work items in the queue), use the task_list_show tool.');
+  });
+
+  test('shows task status and creation date', async () => {
+    createTask({
+      title: 'Dated Task',
+      template: 'Something',
+    });
+
+    const result = await taskListTool.execute({}, stubContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Status: active');
+    expect(result.content).toContain('Created:');
+  });
+});
+
+// ── task_list_show ───────────────────────────────────────────────────
+
+describe('task_list_show tool', () => {
+  beforeEach(() => {
+    const raw = getRawDb();
+    raw.run('DELETE FROM work_items');
+    raw.run('DELETE FROM task_runs');
+    raw.run('DELETE FROM tasks');
+  });
+
+  test('lists work items when they exist', async () => {
+    const task = createTask({ title: 'My Task', template: 'Do it' });
+    createWorkItem({ taskId: task.id, title: 'Work Item Alpha', priorityTier: 0 });
+    createWorkItem({ taskId: task.id, title: 'Work Item Beta', notes: 'some notes', priorityTier: 1 });
+
+    const result = await taskListShowTool.execute({}, stubContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Found 2 work item(s)');
+    expect(result.content).toContain('Work Item Alpha');
+    expect(result.content).toContain('Work Item Beta');
+    expect(result.content).toContain('Status: queued');
+    expect(result.content).toContain('Notes: some notes');
+  });
+
+  test('returns empty message when no work items', async () => {
+    const result = await taskListShowTool.execute({}, stubContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('No Tasks found');
+  });
+
+  test('filters by status when status param is provided', async () => {
+    const task = createTask({ title: 'Filter Task', template: 'Do it' });
+    createWorkItem({ taskId: task.id, title: 'Queued Item', priorityTier: 1 });
+    const raw = getRawDb();
+    // Create a second work item and manually set its status to 'done'
+    const doneItem = createWorkItem({ taskId: task.id, title: 'Done Item', priorityTier: 1 });
+    raw.query('UPDATE work_items SET status = ? WHERE id = ?').run('done', doneItem.id);
+
+    const resultQueued = await taskListShowTool.execute({ status: 'queued' }, stubContext);
+    expect(resultQueued.isError).toBe(false);
+    expect(resultQueued.content).toContain('Found 1 work item(s)');
+    expect(resultQueued.content).toContain('Queued Item');
+    expect(resultQueued.content).not.toContain('Done Item');
+
+    const resultDone = await taskListShowTool.execute({ status: 'done' }, stubContext);
+    expect(resultDone.isError).toBe(false);
+    expect(resultDone.content).toContain('Found 1 work item(s)');
+    expect(resultDone.content).toContain('Done Item');
+    expect(resultDone.content).not.toContain('Queued Item');
+  });
+});
+
+// ── task_list_add ────────────────────────────────────────────────────
+
+describe('task_list_add tool', () => {
+  beforeEach(() => {
+    const raw = getRawDb();
+    raw.run('DELETE FROM work_items');
+    raw.run('DELETE FROM task_runs');
+    raw.run('DELETE FROM tasks');
+  });
+
+  test('successfully enqueues by task_id', async () => {
+    const task = createTask({ title: 'Deploy Service', template: 'deploy it' });
+
+    const result = await taskListAddTool.execute({ task_id: task.id }, stubContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Enqueued work item');
+    expect(result.content).toContain('Deploy Service');
+    expect(result.content).toContain('Status: queued');
+  });
+
+  test('successfully enqueues by task_name (case-insensitive match)', async () => {
+    createTask({ title: 'Run Database Migration', template: 'migrate' });
+
+    const result = await taskListAddTool.execute({ task_name: 'database migration' }, stubContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Enqueued work item');
+    expect(result.content).toContain('Run Database Migration');
+  });
+
+  test('returns disambiguation when multiple name matches', async () => {
+    createTask({ title: 'Deploy Frontend', template: 'deploy fe' });
+    createTask({ title: 'Deploy Backend', template: 'deploy be' });
+
+    const result = await taskListAddTool.execute({ task_name: 'deploy' }, stubContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Multiple task definitions match');
+    expect(result.content).toContain('Deploy Frontend');
+    expect(result.content).toContain('Deploy Backend');
+  });
+
+  test('returns error when no matching task found', async () => {
+    createTask({ title: 'Existing Task', template: 'do something' });
+
+    const result = await taskListAddTool.execute({ task_name: 'nonexistent' }, stubContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('No task definition found matching "nonexistent"');
+  });
+
+  test('returns error when no identifiers provided at all', async () => {
+    const result = await taskListAddTool.execute({}, stubContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('You must provide either task_id, task_name, or title');
+  });
+
+  test('creates ad-hoc work item with just title (no task_id or task_name)', async () => {
+    const result = await taskListAddTool.execute(
+      { title: 'Check Gmail' },
+      stubContext,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Enqueued work item');
+    expect(result.content).toContain('Check Gmail');
+    expect(result.content).toContain('Status: queued');
+    // Ad-hoc items should not show "Task definition:" line
+    expect(result.content).not.toContain('Task definition:');
+  });
+
+  test('ad-hoc work item with notes and priority', async () => {
+    const result = await taskListAddTool.execute(
+      {
+        title: 'Buy groceries',
+        notes: 'Milk, eggs, bread',
+        priority_tier: 1,
+      },
+      stubContext,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Buy groceries');
+    expect(result.content).toContain('Notes: Milk, eggs, bread');
+    expect(result.content).toContain('Priority: medium');
+  });
+
+  test('ad-hoc work item shows up in task_list_show', async () => {
+    await taskListAddTool.execute(
+      { title: 'Call dentist' },
+      stubContext,
+    );
+
+    const listResult = await taskListShowTool.execute({}, stubContext);
+
+    expect(listResult.isError).toBe(false);
+    expect(listResult.content).toContain('Call dentist');
+  });
+
+  test('applies optional overrides (title, notes, priority_tier)', async () => {
+    const task = createTask({ title: 'Generic Task', template: 'do it' });
+
+    const result = await taskListAddTool.execute(
+      {
+        task_id: task.id,
+        title: 'Custom Title Override',
+        notes: 'Important context here',
+        priority_tier: 0,
+      },
+      stubContext,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Custom Title Override');
+    expect(result.content).toContain('Notes: Important context here');
+    expect(result.content).toContain('Priority: high');
+  });
+});
+
+// ── task_delete ──────────────────────────────────────────────────────
+
+describe('task_delete tool', () => {
+  beforeEach(() => {
+    const raw = getRawDb();
+    raw.run('DELETE FROM work_items');
+    raw.run('DELETE FROM task_runs');
+    raw.run('DELETE FROM tasks');
+  });
+
+  test('successfully deletes a single task', async () => {
+    const task = createTask({ title: 'Doomed Task', template: 'bye' });
+
+    const result = await taskDeleteTool.execute({ task_ids: [task.id] }, stubContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Deleted task: Doomed Task');
+  });
+
+  test('successfully deletes multiple tasks', async () => {
+    const t1 = createTask({ title: 'Task One', template: 'one' });
+    const t2 = createTask({ title: 'Task Two', template: 'two' });
+
+    const result = await taskDeleteTool.execute({ task_ids: [t1.id, t2.id] }, stubContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Deleted 2 task(s)');
+    expect(result.content).toContain('Task One');
+    expect(result.content).toContain('Task Two');
+  });
+
+  test('returns error for non-existent task ID', async () => {
+    const result = await taskDeleteTool.execute({ task_ids: ['nonexistent-id'] }, stubContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('No task found with ID nonexistent-id');
+  });
+
+  test('cascades deletion to associated task runs and work items', async () => {
+    const task = createTask({ title: 'Parent Task', template: 'parent' });
+    createTaskRun(task.id);
+    createWorkItem({ taskId: task.id, title: 'Child Work Item' });
+
+    const raw = getRawDb();
+    // Verify the associated records exist before deletion
+    const runsBefore = raw.query('SELECT COUNT(*) as count FROM task_runs WHERE task_id = ?').get(task.id) as { count: number };
+    const itemsBefore = raw.query('SELECT COUNT(*) as count FROM work_items WHERE task_id = ?').get(task.id) as { count: number };
+    expect(runsBefore.count).toBe(1);
+    expect(itemsBefore.count).toBe(1);
+
+    const result = await taskDeleteTool.execute({ task_ids: [task.id] }, stubContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Deleted task: Parent Task');
+
+    // Verify cascade: associated records should be gone
+    const runsAfter = raw.query('SELECT COUNT(*) as count FROM task_runs WHERE task_id = ?').get(task.id) as { count: number };
+    const itemsAfter = raw.query('SELECT COUNT(*) as count FROM work_items WHERE task_id = ?').get(task.id) as { count: number };
+    expect(runsAfter.count).toBe(0);
+    expect(itemsAfter.count).toBe(0);
+  });
+});