@doist/todoist-ai 1.1.0 → 2.0.1

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

@@ -0,0 +1,140 @@
+import { jest } from '@jest/globals';
+import { projectsList } from '../projects-list.js';
+import { TEST_ERRORS, TEST_IDS, createMockApiResponse, createMockProject } from '../test-helpers.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    getProjects: jest.fn(),
+};
+describe('projects-list tool', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('listing all projects', () => {
+        it('should list all projects when no search parameter is provided', async () => {
+            const mockProjects = [
+                createMockProject({
+                    id: TEST_IDS.PROJECT_INBOX,
+                    name: 'Inbox',
+                    color: 'grey',
+                    inboxProject: true,
+                    childOrder: 0,
+                }),
+                createMockProject({
+                    id: TEST_IDS.PROJECT_TEST,
+                    name: 'test-abc123def456-project',
+                    color: 'charcoal',
+                    childOrder: 1,
+                }),
+                createMockProject({
+                    id: TEST_IDS.PROJECT_WORK,
+                    name: 'Work Project',
+                    color: 'blue',
+                    isFavorite: true,
+                    isShared: true,
+                    viewStyle: 'board',
+                    childOrder: 2,
+                    description: 'Important work tasks',
+                    canAssignTasks: true,
+                }),
+            ];
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await projectsList.execute({ limit: 50 }, mockTodoistApi);
+            // Verify API was called correctly
+            expect(mockTodoistApi.getProjects).toHaveBeenCalledWith({
+                limit: 50,
+                cursor: null,
+            });
+            // Verify result is properly mapped
+            expect(result).toEqual({
+                projects: [
+                    expect.objectContaining({
+                        id: TEST_IDS.PROJECT_INBOX,
+                        name: 'Inbox',
+                        color: 'grey',
+                        inboxProject: true,
+                    }),
+                    expect.objectContaining({
+                        id: TEST_IDS.PROJECT_TEST,
+                        name: 'test-abc123def456-project',
+                        color: 'charcoal',
+                    }),
+                    expect.objectContaining({
+                        id: TEST_IDS.PROJECT_WORK,
+                        name: 'Work Project',
+                        color: 'blue',
+                        isFavorite: true,
+                        isShared: true,
+                        viewStyle: 'board',
+                    }),
+                ],
+                nextCursor: null,
+            });
+        });
+        it('should handle pagination with limit and cursor', async () => {
+            const mockProject = createMockProject({
+                id: 'project-1',
+                name: 'First Project',
+                color: 'red',
+            });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse([mockProject], 'next-page-cursor'));
+            const result = await projectsList.execute({ limit: 10, cursor: 'current-page-cursor' }, mockTodoistApi);
+            expect(mockTodoistApi.getProjects).toHaveBeenCalledWith({
+                limit: 10,
+                cursor: 'current-page-cursor',
+            });
+            expect(result.projects).toHaveLength(1);
+            expect(result.projects[0]?.name).toBe('First Project');
+            expect(result.nextCursor).toBe('next-page-cursor');
+        });
+    });
+    describe('searching projects', () => {
+        it('should filter projects by search term (case insensitive)', async () => {
+            const mockProjects = [
+                createMockProject({
+                    id: TEST_IDS.PROJECT_WORK,
+                    name: 'Work Project',
+                    color: 'blue',
+                }),
+                createMockProject({
+                    id: 'personal-project-id',
+                    name: 'Personal Tasks',
+                    color: 'green',
+                }),
+                createMockProject({ id: 'hobby-project-id', name: 'Hobby Work', color: 'orange' }),
+            ];
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await projectsList.execute({ search: 'work', limit: 50 }, mockTodoistApi);
+            expect(mockTodoistApi.getProjects).toHaveBeenCalledWith({ limit: 50, cursor: null });
+            expect(result.projects).toHaveLength(2);
+            expect(result.projects.map((p) => p.name)).toEqual(['Work Project', 'Hobby Work']);
+        });
+        it.each([
+            {
+                search: 'nonexistent',
+                projects: ['Project One'],
+                expectedCount: 0,
+                description: 'no matches',
+            },
+            {
+                search: 'IMPORTANT',
+                projects: ['Important Project'],
+                expectedCount: 1,
+                description: 'case insensitive matching',
+            },
+        ])('should handle search with $description', async ({ search, projects, expectedCount }) => {
+            const mockProjects = projects.map((name) => createMockProject({ name }));
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await projectsList.execute({ search, limit: 50 }, mockTodoistApi);
+            expect(result.projects).toHaveLength(expectedCount);
+        });
+    });
+    describe('error handling', () => {
+        it.each([
+            { error: TEST_ERRORS.API_UNAUTHORIZED, params: { limit: 50 } },
+            { error: TEST_ERRORS.INVALID_CURSOR, params: { cursor: 'invalid-cursor', limit: 50 } },
+        ])('should propagate $error', async ({ error, params }) => {
+            mockTodoistApi.getProjects.mockRejectedValue(new Error(error));
+            await expect(projectsList.execute(params, mockTodoistApi)).rejects.toThrow(error);
+        });
+    });
+});

package/dist/tools/__tests__/projects-manage.test.d.ts

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

package/dist/tools/__tests__/projects-manage.test.d.ts.map

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

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

@@ -0,0 +1,106 @@
+import { jest } from '@jest/globals';
+import { projectsManage } from '../projects-manage.js';
+import { TEST_IDS, createMockProject } from '../test-helpers.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    addProject: jest.fn(),
+    updateProject: jest.fn(),
+};
+describe('projects-manage tool', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('creating a new project', () => {
+        it('should create a project and return mapped result', async () => {
+            const mockApiResponse = createMockProject({
+                id: TEST_IDS.PROJECT_TEST,
+                name: 'test-abc123def456-project',
+                childOrder: 1,
+                createdAt: '2024-01-01T00:00:00Z',
+            });
+            mockTodoistApi.addProject.mockResolvedValue(mockApiResponse);
+            const result = await projectsManage.execute({ name: 'test-abc123def456-project' }, mockTodoistApi);
+            // Verify API was called correctly
+            expect(mockTodoistApi.addProject).toHaveBeenCalledWith({
+                name: 'test-abc123def456-project',
+            });
+            // Verify result is properly mapped
+            expect(result).toEqual({
+                id: TEST_IDS.PROJECT_TEST,
+                name: 'test-abc123def456-project',
+                color: 'charcoal',
+                isFavorite: false,
+                isShared: false,
+                parentId: null,
+                inboxProject: false,
+                viewStyle: 'list',
+            });
+        });
+        it('should handle different project properties from API', async () => {
+            const mockApiResponse = createMockProject({
+                id: 'project-456',
+                name: 'My Blue Project',
+                color: 'blue',
+                isFavorite: true,
+                isShared: true,
+                parentId: 'parent-123',
+                viewStyle: 'board',
+                childOrder: 2,
+                description: 'A test project',
+                createdAt: '2024-01-01T00:00:00Z',
+            });
+            mockTodoistApi.addProject.mockResolvedValue(mockApiResponse);
+            const result = await projectsManage.execute({ name: 'My Blue Project' }, mockTodoistApi);
+            expect(mockTodoistApi.addProject).toHaveBeenCalledWith({ name: 'My Blue Project' });
+            expect(result).toEqual({
+                id: 'project-456',
+                name: 'My Blue Project',
+                color: 'blue',
+                isFavorite: true,
+                isShared: true,
+                parentId: 'parent-123',
+                inboxProject: false,
+                viewStyle: 'board',
+            });
+        });
+    });
+    describe('updating an existing project', () => {
+        it('should update a project when id is provided', async () => {
+            const mockApiResponse = {
+                url: 'https://todoist.com/projects/existing-project-123',
+                id: 'existing-project-123',
+                parentId: null,
+                isDeleted: false,
+                updatedAt: '2025-08-13T22:10:30.000000Z',
+                childOrder: 1,
+                description: '',
+                isCollapsed: false,
+                canAssignTasks: false,
+                color: 'red',
+                isFavorite: false,
+                isFrozen: false,
+                name: 'Updated Project Name',
+                viewStyle: 'list',
+                isArchived: false,
+                inboxProject: false,
+                isShared: false,
+                createdAt: '2024-01-01T00:00:00Z',
+                defaultOrder: 0,
+            };
+            mockTodoistApi.updateProject.mockResolvedValue(mockApiResponse);
+            const result = await projectsManage.execute({ id: 'existing-project-123', name: 'Updated Project Name' }, mockTodoistApi);
+            expect(mockTodoistApi.updateProject).toHaveBeenCalledWith('existing-project-123', {
+                name: 'Updated Project Name',
+            });
+            // Update returns raw project (not mapped) - this is the actual behavior
+            expect(result).toEqual(mockApiResponse);
+        });
+    });
+    describe('error handling', () => {
+        it('should propagate API errors', async () => {
+            const apiError = new Error('API Error: Project name is required');
+            mockTodoistApi.addProject.mockRejectedValue(apiError);
+            await expect(projectsManage.execute({ name: '' }, mockTodoistApi)).rejects.toThrow('API Error: Project name is required');
+        });
+    });
+});

package/dist/tools/__tests__/sections-manage.test.d.ts

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

package/dist/tools/__tests__/sections-manage.test.d.ts.map

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

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

@@ -0,0 +1,138 @@
+import { jest } from '@jest/globals';
+import { sectionsManage } from '../sections-manage.js';
+import { TEST_IDS, createMockSection } from '../test-helpers.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    addSection: jest.fn(),
+    updateSection: jest.fn(),
+};
+describe('sections-manage tool', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('creating a new section', () => {
+        it('should create a section and return result', async () => {
+            const mockApiResponse = createMockSection({
+                id: TEST_IDS.SECTION_1,
+                projectId: TEST_IDS.PROJECT_TEST,
+                name: 'test-abc123def456-section',
+            });
+            mockTodoistApi.addSection.mockResolvedValue(mockApiResponse);
+            const result = await sectionsManage.execute({
+                name: 'test-abc123def456-section',
+                projectId: TEST_IDS.PROJECT_TEST,
+            }, mockTodoistApi);
+            // Verify API was called correctly
+            expect(mockTodoistApi.addSection).toHaveBeenCalledWith({
+                name: 'test-abc123def456-section',
+                projectId: TEST_IDS.PROJECT_TEST,
+            });
+            // Verify result matches API response
+            expect(result).toEqual(mockApiResponse);
+        });
+        it('should handle different section properties from API', async () => {
+            const mockApiResponse = createMockSection({
+                id: TEST_IDS.SECTION_2,
+                projectId: 'project-789',
+                sectionOrder: 2,
+                name: 'My Section Name',
+            });
+            mockTodoistApi.addSection.mockResolvedValue(mockApiResponse);
+            const result = await sectionsManage.execute({
+                name: 'My Section Name',
+                projectId: 'project-789',
+            }, mockTodoistApi);
+            expect(mockTodoistApi.addSection).toHaveBeenCalledWith({
+                name: 'My Section Name',
+                projectId: 'project-789',
+            });
+            expect(result).toEqual(mockApiResponse);
+        });
+        it('should return error when projectId is missing for new section', async () => {
+            const result = await sectionsManage.execute({
+                name: 'test-section',
+            }, mockTodoistApi);
+            // Should not call API when projectId is missing
+            expect(mockTodoistApi.addSection).not.toHaveBeenCalled();
+            // Should return error content
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Error: projectId is required when creating a new section (when id is not provided).',
+                    },
+                ],
+                isError: true,
+            });
+        });
+    });
+    describe('updating an existing section', () => {
+        it('should update a section when id is provided', async () => {
+            const mockApiResponse = {
+                id: 'existing-section-123',
+                projectId: '6cfCcrrCFg2xP94Q',
+                sectionOrder: 1,
+                userId: 'test-user',
+                addedAt: '2024-01-01T00:00:00Z',
+                updatedAt: '2024-01-01T00:00:00Z',
+                archivedAt: null,
+                isArchived: false,
+                isDeleted: false,
+                isCollapsed: false,
+                name: 'Updated Section Name',
+            };
+            mockTodoistApi.updateSection.mockResolvedValue(mockApiResponse);
+            const result = await sectionsManage.execute({
+                id: 'existing-section-123',
+                name: 'Updated Section Name',
+            }, mockTodoistApi);
+            expect(mockTodoistApi.updateSection).toHaveBeenCalledWith('existing-section-123', {
+                name: 'Updated Section Name',
+            });
+            expect(result).toEqual(mockApiResponse);
+        });
+        it('should update section without requiring projectId', async () => {
+            const mockApiResponse = {
+                id: 'section-update-test',
+                projectId: 'original-project-id',
+                sectionOrder: 3,
+                userId: 'test-user',
+                addedAt: '2024-01-01T00:00:00Z',
+                updatedAt: '2024-01-01T00:00:00Z',
+                archivedAt: null,
+                isArchived: false,
+                isDeleted: false,
+                isCollapsed: false,
+                name: 'Section New Name',
+            };
+            mockTodoistApi.updateSection.mockResolvedValue(mockApiResponse);
+            const result = await sectionsManage.execute({
+                id: 'section-update-test',
+                name: 'Section New Name',
+                // Note: projectId not provided for update
+            }, mockTodoistApi);
+            expect(mockTodoistApi.updateSection).toHaveBeenCalledWith('section-update-test', {
+                name: 'Section New Name',
+            });
+            expect(result).toEqual(mockApiResponse);
+        });
+    });
+    describe('error handling', () => {
+        it('should propagate API errors for section creation', async () => {
+            const apiError = new Error('API Error: Section name is required');
+            mockTodoistApi.addSection.mockRejectedValue(apiError);
+            await expect(sectionsManage.execute({
+                name: '',
+                projectId: '6cfCcrrCFg2xP94Q',
+            }, mockTodoistApi)).rejects.toThrow('API Error: Section name is required');
+        });
+        it('should propagate API errors for section updates', async () => {
+            const apiError = new Error('API Error: Section not found');
+            mockTodoistApi.updateSection.mockRejectedValue(apiError);
+            await expect(sectionsManage.execute({
+                id: 'non-existent-section',
+                name: 'Updated Name',
+            }, mockTodoistApi)).rejects.toThrow('API Error: Section not found');
+        });
+    });
+});

package/dist/tools/__tests__/sections-search.test.d.ts

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

package/dist/tools/__tests__/sections-search.test.d.ts.map

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

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

@@ -0,0 +1,235 @@
+import { jest } from '@jest/globals';
+import { sectionsSearch } from '../sections-search.js';
+import { TEST_ERRORS, TEST_IDS, createMockSection } from '../test-helpers.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    getSections: jest.fn(),
+};
+describe('sections-search tool', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('listing all sections in a project', () => {
+        it('should list all sections when no search parameter is provided', async () => {
+            const mockSections = [
+                createMockSection({
+                    id: TEST_IDS.SECTION_1,
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    name: 'To Do',
+                }),
+                createMockSection({
+                    id: TEST_IDS.SECTION_2,
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    sectionOrder: 2,
+                    name: 'In Progress',
+                }),
+                createMockSection({
+                    id: 'section-789',
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    sectionOrder: 3,
+                    name: 'Done',
+                }),
+                createMockSection({
+                    id: 'section-999',
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    sectionOrder: 4,
+                    name: 'Backlog Items',
+                }),
+            ];
+            mockTodoistApi.getSections.mockResolvedValue({
+                results: mockSections,
+                nextCursor: null,
+            });
+            const result = await sectionsSearch.execute({ projectId: TEST_IDS.PROJECT_TEST }, mockTodoistApi);
+            // Verify API was called correctly
+            expect(mockTodoistApi.getSections).toHaveBeenCalledWith({
+                projectId: TEST_IDS.PROJECT_TEST,
+            });
+            // Verify result is properly mapped (simplified format)
+            expect(result).toEqual([
+                { id: TEST_IDS.SECTION_1, name: 'To Do' },
+                { id: TEST_IDS.SECTION_2, name: 'In Progress' },
+                { id: 'section-789', name: 'Done' },
+                { id: 'section-999', name: 'Backlog Items' },
+            ]);
+        });
+        it('should handle project with no sections', async () => {
+            mockTodoistApi.getSections.mockResolvedValue({
+                results: [],
+                nextCursor: null,
+            });
+            const result = await sectionsSearch.execute({ projectId: 'empty-project-id' }, mockTodoistApi);
+            expect(mockTodoistApi.getSections).toHaveBeenCalledWith({
+                projectId: 'empty-project-id',
+            });
+            expect(result).toEqual([]);
+        });
+    });
+    describe('searching sections by name', () => {
+        it('should filter sections by search term (case insensitive)', async () => {
+            const mockSections = [
+                createMockSection({
+                    id: TEST_IDS.SECTION_1,
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    name: 'To Do',
+                }),
+                createMockSection({
+                    id: TEST_IDS.SECTION_2,
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    sectionOrder: 2,
+                    name: 'In Progress',
+                }),
+                createMockSection({
+                    id: 'section-789',
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    sectionOrder: 3,
+                    name: 'Done',
+                }),
+                createMockSection({
+                    id: 'section-999',
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    sectionOrder: 4,
+                    name: 'Progress Review',
+                }),
+            ];
+            mockTodoistApi.getSections.mockResolvedValue({
+                results: mockSections,
+                nextCursor: null,
+            });
+            const result = await sectionsSearch.execute({
+                projectId: TEST_IDS.PROJECT_TEST,
+                search: 'progress',
+            }, mockTodoistApi);
+            expect(mockTodoistApi.getSections).toHaveBeenCalledWith({
+                projectId: TEST_IDS.PROJECT_TEST,
+            });
+            // Should return both "In Progress" and "Progress Review" (case insensitive partial match)
+            expect(result).toEqual([
+                { id: TEST_IDS.SECTION_2, name: 'In Progress' },
+                { id: 'section-999', name: 'Progress Review' },
+            ]);
+        });
+        it('should handle search with no matches', async () => {
+            const mockSections = [
+                createMockSection({
+                    id: TEST_IDS.SECTION_1,
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    name: 'To Do',
+                }),
+                createMockSection({
+                    id: TEST_IDS.SECTION_2,
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    sectionOrder: 2,
+                    name: 'In Progress',
+                }),
+            ];
+            mockTodoistApi.getSections.mockResolvedValue({
+                results: mockSections,
+                nextCursor: null,
+            });
+            const result = await sectionsSearch.execute({
+                projectId: TEST_IDS.PROJECT_TEST,
+                search: 'nonexistent',
+            }, mockTodoistApi);
+            expect(result).toEqual([]);
+        });
+        it('should handle case sensitive search correctly', async () => {
+            const mockSections = [
+                createMockSection({
+                    id: TEST_IDS.SECTION_1,
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    name: 'Important Tasks',
+                }),
+                createMockSection({
+                    id: TEST_IDS.SECTION_2,
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    sectionOrder: 2,
+                    name: 'Regular Work',
+                }),
+            ];
+            mockTodoistApi.getSections.mockResolvedValue({
+                results: mockSections,
+                nextCursor: null,
+            });
+            const result = await sectionsSearch.execute({
+                projectId: TEST_IDS.PROJECT_TEST,
+                search: 'IMPORTANT',
+            }, mockTodoistApi);
+            // Should match despite different case
+            expect(result).toHaveLength(1);
+            expect(result[0]).toEqual({ id: TEST_IDS.SECTION_1, name: 'Important Tasks' });
+        });
+        it('should handle partial matches correctly', async () => {
+            const mockSections = [
+                createMockSection({
+                    id: TEST_IDS.SECTION_1,
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    name: 'Development Tasks',
+                }),
+                createMockSection({
+                    id: TEST_IDS.SECTION_2,
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    sectionOrder: 2,
+                    name: 'Testing Tasks',
+                }),
+                createMockSection({
+                    id: 'section-789',
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    sectionOrder: 3,
+                    name: 'Deployment',
+                }),
+            ];
+            mockTodoistApi.getSections.mockResolvedValue({
+                results: mockSections,
+                nextCursor: null,
+            });
+            const result = await sectionsSearch.execute({
+                projectId: TEST_IDS.PROJECT_TEST,
+                search: 'task',
+            }, mockTodoistApi);
+            // Should match both sections with "task" in the name
+            expect(result).toEqual([
+                { id: TEST_IDS.SECTION_1, name: 'Development Tasks' },
+                { id: TEST_IDS.SECTION_2, name: 'Testing Tasks' },
+            ]);
+        });
+        it('should handle exact matches', async () => {
+            const mockSections = [
+                createMockSection({
+                    id: TEST_IDS.SECTION_1,
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    name: 'Done',
+                }),
+                createMockSection({
+                    id: TEST_IDS.SECTION_2,
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    sectionOrder: 2,
+                    name: 'Done Soon',
+                }),
+            ];
+            mockTodoistApi.getSections.mockResolvedValue({
+                results: mockSections,
+                nextCursor: null,
+            });
+            const result = await sectionsSearch.execute({
+                projectId: TEST_IDS.PROJECT_TEST,
+                search: 'done',
+            }, mockTodoistApi);
+            // Should match both sections containing "done"
+            expect(result).toEqual([
+                { id: TEST_IDS.SECTION_1, name: 'Done' },
+                { id: TEST_IDS.SECTION_2, name: 'Done Soon' },
+            ]);
+        });
+    });
+    describe('error handling', () => {
+        it.each([
+            { error: 'API Error: Project not found', projectId: 'non-existent-project' },
+            { error: TEST_ERRORS.API_UNAUTHORIZED, projectId: 'restricted-project' },
+            { error: 'API Error: Invalid project ID format', projectId: 'invalid-id-format' },
+        ])('should propagate $error', async ({ error, projectId }) => {
+            mockTodoistApi.getSections.mockRejectedValue(new Error(error));
+            await expect(sectionsSearch.execute({ projectId }, mockTodoistApi)).rejects.toThrow(error);
+        });
+    });
+});

package/dist/tools/__tests__/tasks-add-multiple.test.d.ts

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

package/dist/tools/__tests__/tasks-add-multiple.test.d.ts.map

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