@doist/todoist-ai 4.4.0 → 4.5.1

package/dist/tools/__tests__/add-sections.test.js

@@ -1,5 +1,5 @@
 import { jest } from '@jest/globals';
-import { TEST_IDS, createMockSection, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { createMockSection, extractStructuredContent, extractTextContent, TEST_IDS, } from '../../utils/test-helpers.js';
 import { ToolNames } from '../../utils/tool-names.js';
 import { addSections } from '../add-sections.js';
 // Mock the Todoist API

package/dist/tools/__tests__/add-tasks.test.js

@@ -1,5 +1,5 @@
 import { jest } from '@jest/globals';
-import { TODAY, createMockTask, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { createMockTask, extractStructuredContent, extractTextContent, TODAY, } from '../../utils/test-helpers.js';
 import { ToolNames } from '../../utils/tool-names.js';
 import { addTasks } from '../add-tasks.js';
 // Mock the Todoist API
@@ -42,11 +42,14 @@ describe(`${ADD_TASKS} tool`, () => {
                 .mockResolvedValueOnce(mockApiResponse2);
             const result = await addTasks.execute({
                 tasks: [
-                    { content: 'First task content', projectId: '6cfCcrrCFg2xP94Q' },
+                    {
+                        content: 'First task content',
+                        projectId: '6cfCcrrCFg2xP94Q',
+                    },
                     {
                         content: 'Second task content',
                         description: 'Task description',
-                        priority: 2,
+                        priority: 'p2',
                         dueString: 'Aug 15',
                         projectId: '6cfCcrrCFg2xP94Q',
                     },
@@ -63,7 +66,7 @@ describe(`${ADD_TASKS} tool`, () => {
             expect(mockTodoistApi.addTask).toHaveBeenNthCalledWith(2, {
                 content: 'Second task content',
                 description: 'Task description',
-                priority: 2,
+                priority: 3,
                 dueString: 'Aug 15',
                 projectId: '6cfCcrrCFg2xP94Q',
                 sectionId: undefined,
@@ -99,7 +102,7 @@ describe(`${ADD_TASKS} tool`, () => {
                     {
                         content: 'Subtask content',
                         description: 'Subtask description',
-                        priority: 3,
+                        priority: 'p3',
                         projectId: '6cfCcrrCFg2xP94Q',
                         sectionId: 'section-123',
                         parentId: 'parent-task-456',
@@ -109,7 +112,7 @@ describe(`${ADD_TASKS} tool`, () => {
             expect(mockTodoistApi.addTask).toHaveBeenCalledWith({
                 content: 'Subtask content',
                 description: 'Subtask description',
-                priority: 3,
+                priority: 2,
                 projectId: '6cfCcrrCFg2xP94Q',
                 sectionId: 'section-123',
                 parentId: 'parent-task-456',
@@ -203,7 +206,15 @@ describe(`${ADD_TASKS} tool`, () => {
             ];
             for (const testCase of testCases) {
                 mockTodoistApi.addTask.mockClear();
-                await addTasks.execute({ tasks: [{ content: 'Test task', duration: testCase.input }] }, mockTodoistApi);
+                await addTasks.execute({
+                    tasks: [
+                        {
+                            content: 'Test task',
+                            duration: testCase.input,
+                            projectId: '6cfCcrrCFg2xP94Q',
+                        },
+                    ],
+                }, mockTodoistApi);
                 expect(mockTodoistApi.addTask).toHaveBeenCalledWith(expect.objectContaining({
                     duration: testCase.expectedMinutes,
                     durationUnit: 'minute',
@@ -213,15 +224,31 @@ describe(`${ADD_TASKS} tool`, () => {
     });
     describe('error handling', () => {
         it('should throw error for invalid duration format', async () => {
-            await expect(addTasks.execute({ tasks: [{ content: 'Task with invalid duration', duration: 'invalid' }] }, mockTodoistApi)).rejects.toThrow('Task "Task with invalid duration": Invalid duration format "invalid"');
+            await expect(addTasks.execute({
+                tasks: [
+                    {
+                        content: 'Task with invalid duration',
+                        duration: 'invalid',
+                        projectId: '6cfCcrrCFg2xP94Q',
+                    },
+                ],
+            }, mockTodoistApi)).rejects.toThrow('Task "Task with invalid duration": Invalid duration format "invalid"');
         });
         it('should throw error for duration exceeding 24 hours', async () => {
-            await expect(addTasks.execute({ tasks: [{ content: 'Task with too long duration', duration: '25h' }] }, mockTodoistApi)).rejects.toThrow('Task "Task with too long duration": Invalid duration format "25h": Duration cannot exceed 24 hours (1440 minutes)');
+            await expect(addTasks.execute({
+                tasks: [
+                    {
+                        content: 'Task with too long duration',
+                        duration: '25h',
+                        projectId: '6cfCcrrCFg2xP94Q',
+                    },
+                ],
+            }, mockTodoistApi)).rejects.toThrow('Task "Task with too long duration": Invalid duration format "25h": Duration cannot exceed 24 hours (1440 minutes)');
         });
         it('should propagate API errors', async () => {
             const apiError = new Error('API Error: Task content is required');
             mockTodoistApi.addTask.mockRejectedValue(apiError);
-            await expect(addTasks.execute({ tasks: [{ content: '' }] }, mockTodoistApi)).rejects.toThrow(apiError.message);
+            await expect(addTasks.execute({ tasks: [{ content: '', projectId: '6cfCcrrCFg2xP94Q' }] }, mockTodoistApi)).rejects.toThrow(apiError.message);
         });
         it('should handle partial failures when adding multiple tasks', async () => {
             const mockApiResponse = createMockTask({
@@ -236,8 +263,8 @@ describe(`${ADD_TASKS} tool`, () => {
                 .mockRejectedValueOnce(apiError);
             await expect(addTasks.execute({
                 tasks: [
-                    { content: 'First task content' },
-                    { content: 'Second task content' },
+                    { content: 'First task content', projectId: '6cfCcrrCFg2xP94Q' },
+                    { content: 'Second task content', projectId: '6cfCcrrCFg2xP94Q' },
                 ],
             }, mockTodoistApi)).rejects.toThrow('API Error: Second task failed');
             // Verify first task was attempted
@@ -246,6 +273,8 @@ describe(`${ADD_TASKS} tool`, () => {
     });
     describe('next steps logic', () => {
         it('should suggest find-tasks-by-date for today when hasToday is true', async () => {
+            // Clear any leftover mocks from previous tests
+            mockTodoistApi.addTask.mockClear();
             const mockApiResponse = createMockTask({
                 id: '8485093755',
                 content: 'Task due today',
@@ -260,12 +289,22 @@ describe(`${ADD_TASKS} tool`, () => {
                 },
             });
             mockTodoistApi.addTask.mockResolvedValue(mockApiResponse);
-            const result = await addTasks.execute({ tasks: [{ content: 'Task due today', dueString: 'today' }] }, mockTodoistApi);
+            const result = await addTasks.execute({
+                tasks: [
+                    {
+                        content: 'Task due today',
+                        dueString: 'today',
+                        projectId: '6cfCcrrCFg2xP94Q',
+                    },
+                ],
+            }, mockTodoistApi);
             const textContent = extractTextContent(result);
             expect(textContent).toMatchSnapshot();
             expect(textContent).toContain(`Use ${GET_OVERVIEW} to see your updated project organization`);
         });
         it('should suggest overview tool when no hasToday context', async () => {
+            // Clear any leftover mocks from previous tests
+            mockTodoistApi.addTask.mockClear();
             const mockApiResponse = createMockTask({
                 id: '8485093756',
                 content: 'Regular task',

package/dist/tools/__tests__/assignment-integration.test.d.ts

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

package/dist/tools/__tests__/assignment-integration.test.d.ts.map

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

package/dist/tools/__tests__/assignment-integration.test.js

@@ -0,0 +1,415 @@
+import { createMockProject, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { addTasks } from '../add-tasks.js';
+import { findProjectCollaborators } from '../find-project-collaborators.js';
+import { manageAssignments } from '../manage-assignments.js';
+import { updateTasks } from '../update-tasks.js';
+// Mock the assignment validator
+jest.mock('../../utils/assignment-validator.js', () => ({
+    assignmentValidator: {
+        validateTaskCreationAssignment: jest.fn(),
+        validateTaskUpdateAssignment: jest.fn(),
+        validateBulkAssignment: jest.fn(),
+    },
+}));
+// Mock the user resolver
+jest.mock('../../utils/user-resolver.js', () => ({
+    userResolver: {
+        resolveUser: jest.fn(),
+        getProjectCollaborators: jest.fn(),
+    },
+}));
+describe('Assignment Integration Tests', () => {
+    let mockTodoistApi;
+    const mockValidUser = {
+        userId: 'user-123',
+        name: 'John Doe',
+        email: 'john@example.com',
+    };
+    const mockTask = {
+        id: 'task-123',
+        content: 'Test task',
+        projectId: 'project-123',
+        sectionId: null,
+        parentId: null,
+        priority: 1,
+        labels: [],
+        description: '',
+        url: 'https://todoist.com/showTask?id=task-123',
+        noteCount: 0,
+        addedByUid: 'creator-123',
+        addedAt: new Date().toISOString(),
+        deadline: null,
+        responsibleUid: null,
+        assignedByUid: null,
+        isCollapsed: false,
+        isDeleted: false,
+        duration: null,
+        checked: false,
+        updatedAt: new Date().toISOString(),
+        due: null,
+        dayOrder: 0,
+        userId: 'creator-123',
+        completedAt: null,
+        childOrder: 1,
+    };
+    const mockProject = createMockProject({
+        id: 'project-123',
+        name: 'Test Project',
+        color: 'blue',
+        isShared: true,
+        canAssignTasks: true,
+        url: 'https://todoist.com/showProject?id=project-123',
+    });
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockTodoistApi = {
+            addTask: jest.fn(),
+            updateTask: jest.fn(),
+            getTask: jest.fn(),
+            getProjects: jest.fn(),
+            getProject: jest.fn(),
+        };
+        // Mock assignment validator responses
+        const mockAssignmentValidator = require('../../utils/assignment-validator.js').assignmentValidator;
+        mockAssignmentValidator.validateTaskCreationAssignment.mockResolvedValue({
+            isValid: true,
+            resolvedUser: mockValidUser,
+        });
+        mockAssignmentValidator.validateTaskUpdateAssignment.mockResolvedValue({
+            isValid: true,
+            resolvedUser: mockValidUser,
+        });
+        mockAssignmentValidator.validateBulkAssignment.mockResolvedValue([
+            { isValid: true, resolvedUser: mockValidUser },
+            { isValid: true, resolvedUser: mockValidUser },
+            { isValid: true, resolvedUser: mockValidUser },
+        ]);
+        // Mock user resolver
+        const mockUserResolver = require('../../utils/user-resolver.js').userResolver;
+        mockUserResolver.resolveUser.mockResolvedValue(mockValidUser);
+        mockUserResolver.getProjectCollaborators.mockResolvedValue([
+            { id: 'user-123', name: 'John Doe', email: 'john@example.com' },
+            { id: 'user-456', name: 'Jane Smith', email: 'jane@example.com' },
+        ]);
+        // Mock API responses
+        mockTodoistApi.getProjects.mockResolvedValue({
+            results: [mockProject],
+            nextCursor: null,
+        });
+        mockTodoistApi.getProject.mockResolvedValue(mockProject);
+        mockTodoistApi.addTask.mockResolvedValue({ ...mockTask, responsibleUid: 'user-123' });
+        mockTodoistApi.updateTask.mockResolvedValue({ ...mockTask, responsibleUid: 'user-123' });
+        mockTodoistApi.getTask.mockResolvedValue(mockTask);
+    });
+    describe('Task Creation with Assignment', () => {
+        it('should assign task during creation', async () => {
+            const result = await addTasks.execute({
+                tasks: [
+                    {
+                        content: 'New assigned task',
+                        projectId: 'project-123',
+                        responsibleUser: 'john@example.com',
+                    },
+                ],
+            }, mockTodoistApi);
+            expect(mockTodoistApi.addTask).toHaveBeenCalledWith(expect.objectContaining({
+                content: 'New assigned task',
+                projectId: 'project-123',
+                assigneeId: 'user-123', // Should be resolved user ID
+            }));
+            expect(extractTextContent(result)).toContain('Added 1 task');
+        });
+        it('should validate assignment before creating task', async () => {
+            const mockAssignmentValidator = require('../../utils/assignment-validator.js').assignmentValidator;
+            mockAssignmentValidator.validateTaskCreationAssignment.mockResolvedValueOnce({
+                isValid: false,
+                error: {
+                    message: 'User not found in project collaborators',
+                    suggestions: ['Use find-project-collaborators to see valid assignees'],
+                },
+            });
+            await expect(addTasks.execute({
+                tasks: [
+                    {
+                        content: 'Invalid assignment task',
+                        projectId: 'project-123',
+                        responsibleUser: 'nonexistent@example.com',
+                    },
+                ],
+            }, mockTodoistApi)).rejects.toThrow('Task "Invalid assignment task": User not found in project collaborators. Use find-project-collaborators to see valid assignees');
+            expect(mockTodoistApi.addTask).not.toHaveBeenCalled();
+        });
+        it('should handle assignment for subtasks', async () => {
+            mockTodoistApi.getTask.mockResolvedValueOnce({
+                ...mockTask,
+                id: 'parent-123',
+                projectId: 'project-123',
+            });
+            await addTasks.execute({
+                tasks: [
+                    {
+                        content: 'Subtask with assignment',
+                        parentId: 'parent-123',
+                        responsibleUser: 'john@example.com',
+                    },
+                ],
+            }, mockTodoistApi);
+            expect(mockTodoistApi.addTask).toHaveBeenCalledWith(expect.objectContaining({
+                content: 'Subtask with assignment',
+                parentId: 'parent-123',
+                assigneeId: 'user-123',
+            }));
+        });
+    });
+    describe('Task Update with Assignment', () => {
+        it('should update task assignment', async () => {
+            const result = await updateTasks.execute({
+                tasks: [
+                    {
+                        id: 'task-123',
+                        responsibleUser: 'jane@example.com',
+                    },
+                ],
+            }, mockTodoistApi);
+            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('task-123', expect.objectContaining({
+                assigneeId: 'user-123',
+            }));
+            expect(extractTextContent(result)).toContain('Updated 1 task');
+        });
+        it('should unassign task when responsibleUser is null', async () => {
+            await updateTasks.execute({
+                tasks: [
+                    {
+                        id: 'task-123',
+                        responsibleUser: null,
+                    },
+                ],
+            }, mockTodoistApi);
+            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('task-123', expect.objectContaining({
+                assigneeId: null,
+            }));
+        });
+        it('should validate assignment changes', async () => {
+            const mockAssignmentValidator = require('../../utils/assignment-validator.js').assignmentValidator;
+            mockAssignmentValidator.validateTaskUpdateAssignment.mockResolvedValueOnce({
+                isValid: false,
+                error: {
+                    message: 'User cannot be assigned to this project',
+                },
+            });
+            await expect(updateTasks.execute({
+                tasks: [
+                    {
+                        id: 'task-123',
+                        responsibleUser: 'invalid@example.com',
+                    },
+                ],
+            }, mockTodoistApi)).rejects.toThrow('Task task-123: User cannot be assigned to this project');
+            expect(mockTodoistApi.updateTask).not.toHaveBeenCalled();
+        });
+    });
+    describe('Bulk Assignment Operations', () => {
+        beforeEach(() => {
+            mockTodoistApi.getTask
+                .mockResolvedValueOnce({ ...mockTask, id: 'task-1' })
+                .mockResolvedValueOnce({ ...mockTask, id: 'task-2' })
+                .mockResolvedValueOnce({ ...mockTask, id: 'task-3' });
+        });
+        it('should perform bulk assignment', async () => {
+            const result = await manageAssignments.execute({
+                operation: 'assign',
+                taskIds: ['task-1', 'task-2', 'task-3'],
+                responsibleUser: 'john@example.com',
+                dryRun: false,
+            }, mockTodoistApi);
+            expect(mockTodoistApi.updateTask).toHaveBeenCalledTimes(3);
+            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('task-1', {
+                assigneeId: 'user-123',
+            });
+            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('task-2', {
+                assigneeId: 'user-123',
+            });
+            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('task-3', {
+                assigneeId: 'user-123',
+            });
+            expect(extractTextContent(result)).toContain('3 tasks were successfully assigned');
+        });
+        it('should perform bulk unassignment', async () => {
+            const result = await manageAssignments.execute({
+                operation: 'unassign',
+                taskIds: ['task-1', 'task-2'],
+                dryRun: false,
+            }, mockTodoistApi);
+            expect(mockTodoistApi.updateTask).toHaveBeenCalledTimes(2);
+            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('task-1', {
+                assigneeId: null,
+            });
+            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('task-2', {
+                assigneeId: null,
+            });
+            expect(extractTextContent(result)).toContain('2 tasks were successfully unassigned');
+        });
+        it('should handle dry-run mode', async () => {
+            // Mock validation for 2 tasks
+            const mockAssignmentValidator = require('../../utils/assignment-validator.js').assignmentValidator;
+            mockAssignmentValidator.validateBulkAssignment.mockResolvedValueOnce([
+                { isValid: true, resolvedUser: mockValidUser },
+                { isValid: true, resolvedUser: mockValidUser },
+            ]);
+            const result = await manageAssignments.execute({
+                operation: 'assign',
+                taskIds: ['task-1', 'task-2'],
+                responsibleUser: 'john@example.com',
+                dryRun: true,
+            }, mockTodoistApi);
+            expect(mockTodoistApi.updateTask).not.toHaveBeenCalled();
+            expect(extractTextContent(result)).toContain('Dry Run: Bulk assign operation');
+            expect(extractTextContent(result)).toContain('2 tasks would be successfully assigned');
+        });
+        it('should handle mixed success and failure results', async () => {
+            // Mock validation for 3 tasks - 2 valid, 1 invalid
+            const mockAssignmentValidator = require('../../utils/assignment-validator.js').assignmentValidator;
+            mockAssignmentValidator.validateBulkAssignment.mockResolvedValueOnce([
+                { isValid: true, resolvedUser: mockValidUser },
+                { isValid: false, error: { message: 'API Error' } },
+                { isValid: true, resolvedUser: mockValidUser },
+            ]);
+            mockTodoistApi.updateTask
+                .mockResolvedValueOnce({ ...mockTask, id: 'task-1' })
+                .mockResolvedValueOnce({ ...mockTask, id: 'task-3' });
+            const result = await manageAssignments.execute({
+                operation: 'assign',
+                taskIds: ['task-1', 'task-2', 'task-3'],
+                responsibleUser: 'john@example.com',
+                dryRun: false,
+            }, mockTodoistApi);
+            expect(extractTextContent(result)).toContain('2 tasks were successfully assigned');
+            expect(extractTextContent(result)).toContain('1 task failed');
+            expect(extractTextContent(result)).toContain('API Error');
+        });
+    });
+    describe('Project Collaborators Discovery', () => {
+        it('should find project collaborators', async () => {
+            const result = await findProjectCollaborators.execute({
+                projectId: 'project-123',
+            }, mockTodoistApi);
+            expect(extractTextContent(result)).toContain('Project collaborators');
+            expect(extractTextContent(result)).toContain('John Doe (john@example.com)');
+            expect(extractTextContent(result)).toContain('Jane Smith (jane@example.com)');
+            expect(extractStructuredContent(result).collaborators).toHaveLength(2);
+        });
+        it('should filter collaborators by search term', async () => {
+            const result = await findProjectCollaborators.execute({
+                projectId: 'project-123',
+                searchTerm: 'John',
+            }, mockTodoistApi);
+            expect(extractTextContent(result)).toContain('matching "John"');
+        });
+        it('should handle non-shared projects', async () => {
+            mockTodoistApi.getProject.mockResolvedValueOnce({ ...mockProject, isShared: false });
+            const result = await findProjectCollaborators.execute({
+                projectId: 'project-123',
+            }, mockTodoistApi);
+            expect(extractTextContent(result)).toContain('is not shared and has no collaborators');
+            expect(extractStructuredContent(result).collaborators).toHaveLength(0);
+        });
+        it('should handle project not found', async () => {
+            mockTodoistApi.getProject.mockRejectedValueOnce(new Error('Project not found'));
+            await expect(findProjectCollaborators.execute({
+                projectId: 'nonexistent-project',
+            }, mockTodoistApi)).rejects.toThrow('Failed to access project "nonexistent-project"');
+        });
+    });
+    describe('Error Handling and Edge Cases', () => {
+        it('should handle assignment validation errors gracefully', async () => {
+            const mockAssignmentValidator = require('../../utils/assignment-validator.js').assignmentValidator;
+            mockAssignmentValidator.validateTaskCreationAssignment.mockResolvedValueOnce({
+                isValid: false,
+                error: {
+                    message: 'Project not shared',
+                    suggestions: ['Share the project to enable assignments'],
+                },
+            });
+            await expect(addTasks.execute({
+                tasks: [
+                    {
+                        content: 'Task in unshared project',
+                        projectId: 'project-123',
+                        responsibleUser: 'john@example.com',
+                    },
+                ],
+            }, mockTodoistApi)).rejects.toThrow('Task "Task in unshared project": Project not shared. Share the project to enable assignments');
+        });
+        it('should handle inbox assignment restriction', async () => {
+            await expect(addTasks.execute({
+                tasks: [
+                    {
+                        content: 'Inbox task with assignment',
+                        responsibleUser: 'john@example.com',
+                    },
+                ],
+            }, mockTodoistApi)).rejects.toThrow('Task "Inbox task with assignment": Cannot assign tasks without specifying project context. Please specify a projectId, sectionId, or parentId.');
+        });
+        it('should handle parent task not found', async () => {
+            mockTodoistApi.getTask.mockRejectedValueOnce(new Error('Task not found'));
+            await expect(addTasks.execute({
+                tasks: [
+                    {
+                        content: 'Subtask with bad parent',
+                        parentId: 'nonexistent-parent',
+                        responsibleUser: 'john@example.com',
+                    },
+                ],
+            }, mockTodoistApi)).rejects.toThrow('Task "Subtask with bad parent": Parent task "nonexistent-parent" not found');
+        });
+        it('should require responsibleUser for assign operations', async () => {
+            await expect(manageAssignments.execute({
+                operation: 'assign',
+                taskIds: ['task-1'],
+                dryRun: false,
+            }, mockTodoistApi)).rejects.toThrow('assign operation requires responsibleUser parameter');
+        });
+        it('should require responsibleUser for reassign operations', async () => {
+            await expect(manageAssignments.execute({
+                operation: 'reassign',
+                taskIds: ['task-1'],
+                dryRun: false,
+            }, mockTodoistApi)).rejects.toThrow('reassign operation requires responsibleUser parameter');
+        });
+    });
+    describe('End-to-End Assignment Workflows', () => {
+        it('should support complete assignment lifecycle', async () => {
+            // 1. Create assigned task
+            const createResult = await addTasks.execute({
+                tasks: [
+                    {
+                        content: 'Task for lifecycle test',
+                        projectId: 'project-123',
+                        responsibleUser: 'john@example.com',
+                    },
+                ],
+            }, mockTodoistApi);
+            expect(extractTextContent(createResult)).toContain('Added 1 task');
+            // 2. Update assignment
+            const updateResult = await updateTasks.execute({
+                tasks: [
+                    {
+                        id: 'task-123',
+                        responsibleUser: 'jane@example.com',
+                    },
+                ],
+            }, mockTodoistApi);
+            expect(extractTextContent(updateResult)).toContain('Updated 1 task');
+            // 3. Unassign task
+            const unassignResult = await updateTasks.execute({
+                tasks: [
+                    {
+                        id: 'task-123',
+                        responsibleUser: null,
+                    },
+                ],
+            }, mockTodoistApi);
+            expect(extractTextContent(unassignResult)).toContain('Updated 1 task');
+        });
+    });
+});

package/dist/tools/__tests__/find-projects.test.js

@@ -1,5 +1,5 @@
 import { jest } from '@jest/globals';
-import { TEST_ERRORS, TEST_IDS, createMockApiResponse, createMockProject, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { createMockApiResponse, createMockProject, extractStructuredContent, extractTextContent, TEST_ERRORS, TEST_IDS, } from '../../utils/test-helpers.js';
 import { ToolNames } from '../../utils/tool-names.js';
 import { findProjects } from '../find-projects.js';
 // Mock the Todoist API

package/dist/tools/__tests__/find-sections.test.js

@@ -1,5 +1,5 @@
 import { jest } from '@jest/globals';
-import { TEST_ERRORS, TEST_IDS, createMockSection, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { createMockSection, extractStructuredContent, extractTextContent, TEST_ERRORS, TEST_IDS, } from '../../utils/test-helpers.js';
 import { ToolNames } from '../../utils/tool-names.js';
 import { findSections } from '../find-sections.js';
 // Mock the Todoist API

package/dist/tools/__tests__/find-tasks-by-date.test.js

@@ -1,6 +1,6 @@
 import { jest } from '@jest/globals';
 import { getTasksByFilter } from '../../tool-helpers.js';
-import { TEST_ERRORS, TEST_IDS, createMappedTask, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { createMappedTask, extractStructuredContent, extractTextContent, TEST_ERRORS, TEST_IDS, } from '../../utils/test-helpers.js';
 import { ToolNames } from '../../utils/tool-names.js';
 import { findTasksByDate } from '../find-tasks-by-date.js';
 // Mock the tool helpers

package/dist/tools/__tests__/find-tasks.test.js

@@ -1,6 +1,6 @@
 import { jest } from '@jest/globals';
 import { getTasksByFilter } from '../../tool-helpers.js';
-import { TEST_ERRORS, TEST_IDS, TODAY, createMappedTask, createMockApiResponse, createMockTask, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { createMappedTask, createMockApiResponse, createMockTask, extractStructuredContent, extractTextContent, TEST_ERRORS, TEST_IDS, TODAY, } from '../../utils/test-helpers.js';
 import { ToolNames } from '../../utils/tool-names.js';
 import { findTasks } from '../find-tasks.js';
 jest.mock('../../tool-helpers', () => {
@@ -147,7 +147,7 @@ describe(`${FIND_TASKS} tool`, () => {
     });
     describe('validation', () => {
         it('should require at least one filter parameter', async () => {
-            await expect(findTasks.execute({ limit: 10 }, mockTodoistApi)).rejects.toThrow('At least one filter must be provided: searchText, projectId, sectionId, parentId, or labels');
+            await expect(findTasks.execute({ limit: 10 }, mockTodoistApi)).rejects.toThrow('At least one filter must be provided: searchText, projectId, sectionId, parentId, responsibleUser, or labels');
         });
     });
     describe('container filtering', () => {
@@ -550,7 +550,7 @@ describe(`${FIND_TASKS} tool`, () => {
     describe('error handling', () => {
         it.each([
             {
-                error: 'At least one filter must be provided: searchText, projectId, sectionId, parentId, or labels',
+                error: 'At least one filter must be provided: searchText, projectId, sectionId, parentId, responsibleUser, or labels',
                 params: { limit: 10 },
                 expectValidation: true,
             },

package/dist/tools/__tests__/get-overview.test.js

@@ -1,5 +1,5 @@
 import { jest } from '@jest/globals';
-import { TEST_ERRORS, TEST_IDS, createMockProject, createMockSection, createMockTask, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { createMockProject, createMockSection, createMockTask, extractStructuredContent, extractTextContent, TEST_ERRORS, TEST_IDS, } from '../../utils/test-helpers.js';
 import { ToolNames } from '../../utils/tool-names.js';
 import { getOverview } from '../get-overview.js';
 // Mock the Todoist API