@doist/todoist-ai 2.2.2 → 3.0.0

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

@@ -1,138 +0,0 @@
-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

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

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

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

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

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

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

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

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

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

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

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

package/dist/tools/__tests__/tasks-complete-multiple.test.js

@@ -1,146 +0,0 @@
-import { jest } from '@jest/globals';
-import { tasksCompleteMultiple } from '../tasks-complete-multiple.js';
-// Mock the Todoist API
-const mockTodoistApi = {
-    closeTask: jest.fn(),
-};
-describe('tasks-complete-multiple tool', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('completing multiple tasks', () => {
-        it('should complete all tasks successfully', async () => {
-            mockTodoistApi.closeTask.mockResolvedValue(true);
-            const result = await tasksCompleteMultiple.execute({ ids: ['task-1', 'task-2', 'task-3'] }, mockTodoistApi);
-            // Verify API was called for each task
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(3);
-            expect(mockTodoistApi.closeTask).toHaveBeenNthCalledWith(1, 'task-1');
-            expect(mockTodoistApi.closeTask).toHaveBeenNthCalledWith(2, 'task-2');
-            expect(mockTodoistApi.closeTask).toHaveBeenNthCalledWith(3, 'task-3');
-            // Verify all tasks were completed successfully
-            expect(result).toEqual({
-                success: true,
-                completed: ['task-1', 'task-2', 'task-3'],
-            });
-        });
-        it('should complete single task', async () => {
-            mockTodoistApi.closeTask.mockResolvedValue(true);
-            const result = await tasksCompleteMultiple.execute({ ids: ['8485093748'] }, mockTodoistApi);
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(1);
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledWith('8485093748');
-            expect(result).toEqual({
-                success: true,
-                completed: ['8485093748'],
-            });
-        });
-        it('should handle partial failures gracefully', async () => {
-            // Mock first and third tasks to succeed, second to fail
-            mockTodoistApi.closeTask
-                .mockResolvedValueOnce(true) // task-1 succeeds
-                .mockRejectedValueOnce(new Error('Task not found')) // task-2 fails
-                .mockResolvedValueOnce(true); // task-3 succeeds
-            const result = await tasksCompleteMultiple.execute({ ids: ['task-1', 'task-2', 'task-3'] }, mockTodoistApi);
-            // Verify API was called for all tasks despite failure
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(3);
-            expect(mockTodoistApi.closeTask).toHaveBeenNthCalledWith(1, 'task-1');
-            expect(mockTodoistApi.closeTask).toHaveBeenNthCalledWith(2, 'task-2');
-            expect(mockTodoistApi.closeTask).toHaveBeenNthCalledWith(3, 'task-3');
-            // Verify only successful completions are reported
-            expect(result).toEqual({
-                success: true,
-                completed: ['task-1', 'task-3'], // task-2 excluded due to failure
-            });
-        });
-        it('should handle all tasks failing', async () => {
-            const apiError = new Error('API Error: Network timeout');
-            mockTodoistApi.closeTask.mockRejectedValue(apiError);
-            const result = await tasksCompleteMultiple.execute({ ids: ['task-1', 'task-2'] }, mockTodoistApi);
-            // Verify API was attempted for all tasks
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(2);
-            // Verify no tasks were completed but still returns success
-            expect(result).toEqual({
-                success: true,
-                completed: [], // no tasks completed
-            });
-        });
-        it('should continue processing remaining tasks after failures', async () => {
-            // Mock various failure scenarios
-            mockTodoistApi.closeTask
-                .mockRejectedValueOnce(new Error('Task already completed'))
-                .mockRejectedValueOnce(new Error('Task not found'))
-                .mockResolvedValueOnce(true) // task-3 succeeds
-                .mockRejectedValueOnce(new Error('Permission denied'))
-                .mockResolvedValueOnce(true); // task-5 succeeds
-            const result = await tasksCompleteMultiple.execute({ ids: ['task-1', 'task-2', 'task-3', 'task-4', 'task-5'] }, mockTodoistApi);
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(5);
-            // Only tasks 3 and 5 should be in completed list
-            expect(result).toEqual({
-                success: true,
-                completed: ['task-3', 'task-5'],
-            });
-        });
-        it('should handle different types of API errors', async () => {
-            mockTodoistApi.closeTask
-                .mockRejectedValueOnce(new Error('Task not found'))
-                .mockRejectedValueOnce(new Error('Task already completed'))
-                .mockRejectedValueOnce(new Error('Permission denied'))
-                .mockRejectedValueOnce(new Error('Rate limit exceeded'));
-            const result = await tasksCompleteMultiple.execute({ ids: ['not-found', 'already-done', 'no-permission', 'rate-limited'] }, mockTodoistApi);
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(4);
-            // All should fail, but the tool should handle it gracefully
-            expect(result).toEqual({
-                success: true,
-                completed: [],
-            });
-        });
-    });
-    describe('mixed success and failure scenarios', () => {
-        it('should handle realistic mixed scenario', async () => {
-            // Simulate a realistic scenario with some tasks completing and others failing
-            mockTodoistApi.closeTask
-                .mockResolvedValueOnce(true) // regular task completion
-                .mockResolvedValueOnce(true) // another successful completion
-                .mockRejectedValueOnce(new Error('Task already completed')) // duplicate completion
-                .mockResolvedValueOnce(true) // successful completion
-                .mockRejectedValueOnce(new Error('Task not found')); // deleted task
-            const result = await tasksCompleteMultiple.execute({
-                ids: [
-                    '8485093748', // regular task
-                    '8485093749', // regular task
-                    '8485093750', // already completed
-                    '8485093751', // regular task
-                    '8485093752', // deleted task
-                ],
-            }, mockTodoistApi);
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(5);
-            expect(result).toEqual({
-                success: true,
-                completed: ['8485093748', '8485093749', '8485093751'],
-            });
-        });
-    });
-    describe('edge cases', () => {
-        it('should handle empty task completion (minimum one task required by schema)', async () => {
-            // Note: This test documents that the schema requires at least one task,
-            // so this scenario shouldn't occur in practice due to validation
-            mockTodoistApi.closeTask.mockResolvedValue(true);
-            const result = await tasksCompleteMultiple.execute({ ids: ['single-task'] }, mockTodoistApi);
-            expect(result).toEqual({
-                success: true,
-                completed: ['single-task'],
-            });
-        });
-        it('should handle tasks with special ID formats', async () => {
-            mockTodoistApi.closeTask.mockResolvedValue(true);
-            const result = await tasksCompleteMultiple.execute({ ids: ['proj_123_task_456', 'task-with-dashes', '1234567890'] }, mockTodoistApi);
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(3);
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledWith('proj_123_task_456');
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledWith('task-with-dashes');
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledWith('1234567890');
-            expect(result).toEqual({
-                success: true,
-                completed: ['proj_123_task_456', 'task-with-dashes', '1234567890'],
-            });
-        });
-    });
-});

package/dist/tools/__tests__/tasks-list-by-date.test.d.ts

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

package/dist/tools/__tests__/tasks-list-by-date.test.d.ts.map

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

package/dist/tools/__tests__/tasks-list-completed.test.d.ts

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

package/dist/tools/__tests__/tasks-list-completed.test.d.ts.map

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

package/dist/tools/__tests__/tasks-list-for-container.test.d.ts

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

package/dist/tools/__tests__/tasks-list-for-container.test.d.ts.map

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

package/dist/tools/__tests__/tasks-list-for-container.test.js

@@ -1,232 +0,0 @@
-import { jest } from '@jest/globals';
-import { tasksListForContainer } from '../tasks-list-for-container.js';
-import { TEST_IDS, createMockApiResponse, createMockTask } from '../test-helpers.js';
-// Mock the Todoist API
-const mockTodoistApi = {
-    getTasks: jest.fn(),
-};
-describe('tasks-list-for-container tool', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('container types', () => {
-        it.each([
-            {
-                name: 'project',
-                type: 'project',
-                id: TEST_IDS.PROJECT_TEST,
-                expectedParam: { projectId: TEST_IDS.PROJECT_TEST },
-                tasks: [createMockTask({ content: 'Project task' })],
-            },
-            {
-                name: 'section',
-                type: 'section',
-                id: TEST_IDS.SECTION_1,
-                expectedParam: { sectionId: TEST_IDS.SECTION_1 },
-                tasks: [createMockTask({ content: 'Section task' })],
-            },
-            {
-                name: 'parent task',
-                type: 'parent',
-                id: TEST_IDS.TASK_1,
-                expectedParam: { parentId: TEST_IDS.TASK_1 },
-                tasks: [createMockTask({ content: 'Subtask' })],
-            },
-        ])('should get tasks for $name', async ({ type, id, expectedParam, tasks }) => {
-            mockTodoistApi.getTasks.mockResolvedValue(createMockApiResponse(tasks));
-            const result = await tasksListForContainer.execute({ type, id, limit: 10 }, mockTodoistApi);
-            expect(mockTodoistApi.getTasks).toHaveBeenCalledWith({
-                limit: 10,
-                cursor: null,
-                ...expectedParam,
-            });
-            expect(result.tasks).toHaveLength(1);
-            expect(result.nextCursor).toBeNull();
-        });
-    });
-    describe('getting tasks for a section', () => {
-        it('should get tasks for a specific section', async () => {
-            const mockTasks = [
-                createMockTask({
-                    id: '8485093751',
-                    content: 'Section task 1',
-                    description: 'Task in specific section',
-                    labels: ['urgent'],
-                    childOrder: 1,
-                    priority: 3,
-                    projectId: '6cfCcrrCFg2xP94Q',
-                    sectionId: 'section-123',
-                    url: 'https://todoist.com/showTask?id=8485093751',
-                    addedAt: '2025-08-13T22:09:59.123456Z',
-                    due: {
-                        date: '2025-08-16',
-                        isRecurring: true,
-                        lang: 'en',
-                        string: 'every week',
-                        timezone: null,
-                    },
-                }),
-            ];
-            mockTodoistApi.getTasks.mockResolvedValue({ results: mockTasks, nextCursor: null });
-            const result = await tasksListForContainer.execute({ type: 'section', id: 'section-123', limit: 15 }, mockTodoistApi);
-            expect(mockTodoistApi.getTasks).toHaveBeenCalledWith({
-                limit: 15,
-                cursor: null,
-                sectionId: 'section-123',
-            });
-            expect(result).toEqual({
-                tasks: [
-                    expect.objectContaining({
-                        id: '8485093751',
-                        content: 'Section task 1',
-                        description: 'Task in specific section',
-                        dueDate: '2025-08-16',
-                        recurring: 'every week',
-                        priority: 3,
-                        sectionId: 'section-123',
-                        labels: ['urgent'],
-                    }),
-                ],
-                nextCursor: null,
-            });
-        });
-        it('should handle empty section', async () => {
-            mockTodoistApi.getTasks.mockResolvedValue({ results: [], nextCursor: null });
-            const result = await tasksListForContainer.execute({ type: 'section', id: 'empty-section-id', limit: 10 }, mockTodoistApi);
-            expect(mockTodoistApi.getTasks).toHaveBeenCalledWith({
-                limit: 10,
-                cursor: null,
-                sectionId: 'empty-section-id',
-            });
-            expect(result).toEqual({ tasks: [], nextCursor: null });
-        });
-    });
-    describe('getting subtasks for a parent task', () => {
-        it('should get subtasks for a specific parent task', async () => {
-            const mockSubtasks = [
-                createMockTask({
-                    id: '8485093752',
-                    content: 'Subtask 1',
-                    description: 'First subtask',
-                    childOrder: 1,
-                    priority: 1,
-                    projectId: '6cfCcrrCFg2xP94Q',
-                    parentId: 'parent-task-123',
-                    url: 'https://todoist.com/showTask?id=8485093752',
-                    addedAt: '2025-08-13T22:10:00.123456Z',
-                }),
-                createMockTask({
-                    id: '8485093753',
-                    content: 'Subtask 2',
-                    description: 'Second subtask',
-                    labels: ['follow-up'],
-                    childOrder: 2,
-                    priority: 2,
-                    projectId: '6cfCcrrCFg2xP94Q',
-                    parentId: 'parent-task-123',
-                    url: 'https://todoist.com/showTask?id=8485093753',
-                    addedAt: '2025-08-13T22:10:01.123456Z',
-                    due: {
-                        date: '2025-08-18',
-                        isRecurring: false,
-                        lang: 'en',
-                        string: 'Aug 18',
-                        timezone: null,
-                    },
-                }),
-            ];
-            mockTodoistApi.getTasks.mockResolvedValue({ results: mockSubtasks, nextCursor: null });
-            const result = await tasksListForContainer.execute({ type: 'parent', id: 'parent-task-123', limit: 10 }, mockTodoistApi);
-            expect(mockTodoistApi.getTasks).toHaveBeenCalledWith({
-                parentId: 'parent-task-123',
-                cursor: null,
-                limit: 10,
-            });
-            expect(result).toEqual({
-                tasks: [
-                    expect.objectContaining({
-                        id: '8485093752',
-                        content: 'Subtask 1',
-                        description: 'First subtask',
-                        parentId: 'parent-task-123',
-                        labels: [],
-                    }),
-                    expect.objectContaining({
-                        id: '8485093753',
-                        content: 'Subtask 2',
-                        description: 'Second subtask',
-                        dueDate: '2025-08-18',
-                        parentId: 'parent-task-123',
-                        priority: 2,
-                        labels: ['follow-up'],
-                    }),
-                ],
-                nextCursor: null,
-            });
-        });
-        it('should handle parent task with no subtasks', async () => {
-            mockTodoistApi.getTasks.mockResolvedValue({ results: [], nextCursor: null });
-            const result = await tasksListForContainer.execute({ type: 'parent', id: 'parent-with-no-subtasks', limit: 10 }, mockTodoistApi);
-            expect(mockTodoistApi.getTasks).toHaveBeenCalledWith({
-                parentId: 'parent-with-no-subtasks',
-                cursor: null,
-                limit: 10,
-            });
-            expect(result).toEqual({ tasks: [], nextCursor: null });
-        });
-    });
-    describe('pagination and limits', () => {
-        it('should handle custom limit and cursor', async () => {
-            mockTodoistApi.getTasks.mockResolvedValue({ results: [], nextCursor: 'next-cursor' });
-            const result = await tasksListForContainer.execute({ type: 'section', id: 'test-section', limit: 25, cursor: 'current-cursor' }, mockTodoistApi);
-            expect(mockTodoistApi.getTasks).toHaveBeenCalledWith({
-                limit: 25,
-                cursor: 'current-cursor',
-                sectionId: 'test-section',
-            });
-            expect(result.nextCursor).toBe('next-cursor');
-        });
-    });
-    describe('container type validation', () => {
-        it('should handle all container types correctly', async () => {
-            mockTodoistApi.getTasks.mockResolvedValue({ results: [], nextCursor: null });
-            // Test project container
-            await tasksListForContainer.execute({ type: 'project', id: 'proj-1', limit: 10 }, mockTodoistApi);
-            expect(mockTodoistApi.getTasks).toHaveBeenLastCalledWith(expect.objectContaining({ projectId: 'proj-1' }));
-            // Test section container
-            await tasksListForContainer.execute({ type: 'section', id: 'sect-1', limit: 10 }, mockTodoistApi);
-            expect(mockTodoistApi.getTasks).toHaveBeenLastCalledWith(expect.objectContaining({ sectionId: 'sect-1' }));
-            // Test parent container
-            await tasksListForContainer.execute({ type: 'parent', id: 'parent-1', limit: 10 }, mockTodoistApi);
-            expect(mockTodoistApi.getTasks).toHaveBeenLastCalledWith(expect.objectContaining({ parentId: 'parent-1' }));
-            expect(mockTodoistApi.getTasks).toHaveBeenCalledTimes(3);
-        });
-    });
-    describe('error handling', () => {
-        it('should propagate API errors for project queries', async () => {
-            const apiError = new Error('API Error: Project not found');
-            mockTodoistApi.getTasks.mockRejectedValue(apiError);
-            await expect(tasksListForContainer.execute({ type: 'project', id: 'non-existent-project', limit: 10 }, mockTodoistApi)).rejects.toThrow('API Error: Project not found');
-        });
-        it('should propagate API errors for section queries', async () => {
-            const apiError = new Error('API Error: Section not found');
-            mockTodoistApi.getTasks.mockRejectedValue(apiError);
-            await expect(tasksListForContainer.execute({ type: 'section', id: 'non-existent-section', limit: 10 }, mockTodoistApi)).rejects.toThrow('API Error: Section not found');
-        });
-        it('should propagate API errors for parent task queries', async () => {
-            const apiError = new Error('API Error: Parent task not found');
-            mockTodoistApi.getTasks.mockRejectedValue(apiError);
-            await expect(tasksListForContainer.execute({ type: 'parent', id: 'non-existent-parent', limit: 10 }, mockTodoistApi)).rejects.toThrow('API Error: Parent task not found');
-        });
-        it('should handle permission errors', async () => {
-            const permissionError = new Error('API Error: Insufficient permissions');
-            mockTodoistApi.getTasks.mockRejectedValue(permissionError);
-            await expect(tasksListForContainer.execute({ type: 'project', id: 'restricted-project', limit: 10 }, mockTodoistApi)).rejects.toThrow('API Error: Insufficient permissions');
-        });
-        it('should handle cursor validation errors', async () => {
-            const cursorError = new Error('API Error: Invalid cursor');
-            mockTodoistApi.getTasks.mockRejectedValue(cursorError);
-            await expect(tasksListForContainer.execute({ type: 'project', id: 'test-project', cursor: 'invalid-cursor', limit: 10 }, mockTodoistApi)).rejects.toThrow('API Error: Invalid cursor');
-        });
-    });
-});

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

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

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

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