@doist/todoist-ai 4.1.0 → 4.5.1

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-completed-tasks.test.js

@@ -37,7 +37,14 @@ describe(`${FIND_COMPLETED_TASKS} tool`, () => {
                 items: mockCompletedTasks,
                 nextCursor: null,
             });
-            const result = await findCompletedTasks.execute({ getBy: 'completion', limit: 50, since: '2025-08-10', until: '2025-08-15' }, mockTodoistApi);
+            const result = await findCompletedTasks.execute({
+                getBy: 'completion',
+                limit: 50,
+                since: '2025-08-10',
+                until: '2025-08-15',
+                labels: [],
+                labelsOperator: 'or',
+            }, mockTodoistApi);
             expect(mockTodoistApi.getCompletedTasksByCompletionDate).toHaveBeenCalledWith({
                 since: '2025-08-10',
                 until: '2025-08-15',
@@ -57,6 +64,8 @@ describe(`${FIND_COMPLETED_TASKS} tool`, () => {
                 until: '2025-08-31',
                 projectId: 'specific-project-id',
                 cursor: 'current-cursor',
+                labels: [],
+                labelsOperator: 'or',
             }, mockTodoistApi);
             expect(mockTodoistApi.getCompletedTasksByCompletionDate).toHaveBeenCalledWith({
                 since: '2025-08-01',
@@ -98,6 +107,8 @@ describe(`${FIND_COMPLETED_TASKS} tool`, () => {
                 limit: 50,
                 since: '2025-08-10',
                 until: '2025-08-20',
+                labels: [],
+                labelsOperator: 'or',
             }, mockTodoistApi);
             expect(mockTodoistApi.getCompletedTasksByDueDate).toHaveBeenCalledWith({
                 since: '2025-08-10',
@@ -108,13 +119,134 @@ describe(`${FIND_COMPLETED_TASKS} tool`, () => {
             expect(extractTextContent(result)).toMatchSnapshot();
         });
     });
+    describe('label filtering', () => {
+        it.each([
+            {
+                name: 'single label with OR operator',
+                params: {
+                    getBy: 'completion',
+                    since: '2025-08-01',
+                    until: '2025-08-31',
+                    limit: 50,
+                    labels: ['work'],
+                },
+                expectedMethod: 'getCompletedTasksByCompletionDate',
+                expectedFilter: '(@work)',
+            },
+            {
+                name: 'multiple labels with AND operator',
+                params: {
+                    getBy: 'due',
+                    since: '2025-08-01',
+                    until: '2025-08-31',
+                    limit: 50,
+                    labels: ['work', 'urgent'],
+                    labelsOperator: 'and',
+                },
+                expectedMethod: 'getCompletedTasksByDueDate',
+                expectedFilter: '(@work  &  @urgent)',
+            },
+            {
+                name: 'multiple labels with OR operator',
+                params: {
+                    getBy: 'completion',
+                    since: '2025-08-10',
+                    until: '2025-08-20',
+                    limit: 25,
+                    labels: ['personal', 'shopping'],
+                },
+                expectedMethod: 'getCompletedTasksByCompletionDate',
+                expectedFilter: '(@personal  |  @shopping)',
+            },
+        ])('should filter completed tasks by labels: $name', async ({ params, expectedMethod, expectedFilter }) => {
+            const mockCompletedTasks = [
+                createMockTask({
+                    id: '8485093748',
+                    content: 'Completed task with label',
+                    labels: params.labels,
+                    completedAt: '2024-01-01T00:00:00Z',
+                }),
+            ];
+            const mockResponse = { items: mockCompletedTasks, nextCursor: null };
+            const mockMethod = mockTodoistApi[expectedMethod];
+            mockMethod.mockResolvedValue(mockResponse);
+            const result = await findCompletedTasks.execute(params, mockTodoistApi);
+            expect(mockMethod).toHaveBeenCalledWith({
+                since: params.since,
+                until: params.until,
+                limit: params.limit,
+                filterQuery: expectedFilter,
+                filterLang: 'en',
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+        });
+        it('should handle empty labels array', async () => {
+            const params = {
+                getBy: 'completion',
+                since: '2025-08-01',
+                until: '2025-08-31',
+                limit: 50,
+                labels: [],
+                labelsOperator: 'or',
+            };
+            const mockResponse = { items: [], nextCursor: null };
+            mockTodoistApi.getCompletedTasksByCompletionDate.mockResolvedValue(mockResponse);
+            await findCompletedTasks.execute(params, mockTodoistApi);
+            expect(mockTodoistApi.getCompletedTasksByCompletionDate).toHaveBeenCalledWith({
+                since: params.since,
+                until: params.until,
+                limit: params.limit,
+            });
+        });
+        it('should combine other filters with label filters', async () => {
+            const params = {
+                getBy: 'due',
+                since: '2025-08-01',
+                until: '2025-08-31',
+                limit: 25,
+                projectId: 'test-project-id',
+                sectionId: 'test-section-id',
+                labels: ['important'],
+                labelsOperator: 'or',
+            };
+            const mockTasks = [
+                createMockTask({
+                    content: 'Important completed task',
+                    labels: ['important'],
+                    completedAt: '2024-01-01T00:00:00Z',
+                }),
+            ];
+            const mockResponse = { items: mockTasks, nextCursor: null };
+            mockTodoistApi.getCompletedTasksByDueDate.mockResolvedValue(mockResponse);
+            const result = await findCompletedTasks.execute(params, mockTodoistApi);
+            expect(mockTodoistApi.getCompletedTasksByDueDate).toHaveBeenCalledWith({
+                since: params.since,
+                until: params.until,
+                limit: params.limit,
+                projectId: params.projectId,
+                sectionId: params.sectionId,
+                filterQuery: '(@important)',
+                filterLang: 'en',
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+        });
+    });
     describe('error handling', () => {
         it('should propagate completion date API errors', async () => {
             const apiError = new Error('API Error: Invalid date range');
             mockTodoistApi.getCompletedTasksByCompletionDate.mockRejectedValue(apiError);
             await expect(findCompletedTasks.execute(
             // invalid date range
-            { getBy: 'completion', limit: 50, since: '2025-08-31', until: '2025-08-01' }, mockTodoistApi)).rejects.toThrow('API Error: Invalid date range');
+            {
+                getBy: 'completion',
+                limit: 50,
+                since: '2025-08-31',
+                until: '2025-08-01',
+                labels: [],
+                labelsOperator: 'or',
+            }, mockTodoistApi)).rejects.toThrow('API Error: Invalid date range');
         });
         it('should propagate due date API errors', async () => {
             const apiError = new Error('API Error: Project not found');
@@ -125,6 +257,8 @@ describe(`${FIND_COMPLETED_TASKS} tool`, () => {
                 since: '2025-08-01',
                 until: '2025-08-31',
                 projectId: 'non-existent-project',
+                labels: [],
+                labelsOperator: 'or',
             }, mockTodoistApi)).rejects.toThrow('API Error: Project not found');
         });
     });

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