@doist/todoist-ai 2.0.0 → 2.1.0

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":""}

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

@@ -0,0 +1,274 @@
+import { jest } from '@jest/globals';
+import { tasksAddMultiple } from '../tasks-add-multiple.js';
+import { createMockTask } from '../test-helpers.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    addTask: jest.fn(),
+};
+describe('tasks-add-multiple tool', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('adding multiple tasks', () => {
+        it('should add multiple tasks and return mapped results', async () => {
+            // Mock API responses extracted from recordings (Task type)
+            const mockApiResponse1 = createMockTask({
+                id: '8485093748',
+                content: 'First task content',
+                url: 'https://todoist.com/showTask?id=8485093748',
+                addedAt: '2025-08-13T22:09:56.123456Z',
+            });
+            const mockApiResponse2 = createMockTask({
+                id: '8485093749',
+                content: 'Second task content',
+                description: 'Task description',
+                labels: ['work', 'urgent'],
+                childOrder: 2,
+                priority: 2,
+                url: 'https://todoist.com/showTask?id=8485093749',
+                addedAt: '2025-08-13T22:09:57.123456Z',
+                due: {
+                    date: '2025-08-15',
+                    isRecurring: false,
+                    lang: 'en',
+                    string: 'Aug 15',
+                    timezone: null,
+                },
+            });
+            mockTodoistApi.addTask
+                .mockResolvedValueOnce(mockApiResponse1)
+                .mockResolvedValueOnce(mockApiResponse2);
+            const result = await tasksAddMultiple.execute({
+                projectId: '6cfCcrrCFg2xP94Q',
+                tasks: [
+                    { content: 'First task content' },
+                    {
+                        content: 'Second task content',
+                        description: 'Task description',
+                        priority: 2,
+                        dueString: 'Aug 15',
+                    },
+                ],
+            }, mockTodoistApi);
+            // Verify API was called correctly for each task
+            expect(mockTodoistApi.addTask).toHaveBeenCalledTimes(2);
+            expect(mockTodoistApi.addTask).toHaveBeenNthCalledWith(1, {
+                content: 'First task content',
+                projectId: '6cfCcrrCFg2xP94Q',
+                sectionId: undefined,
+                parentId: undefined,
+            });
+            expect(mockTodoistApi.addTask).toHaveBeenNthCalledWith(2, {
+                content: 'Second task content',
+                description: 'Task description',
+                priority: 2,
+                dueString: 'Aug 15',
+                projectId: '6cfCcrrCFg2xP94Q',
+                sectionId: undefined,
+                parentId: undefined,
+            });
+            // Verify result is properly mapped
+            expect(result).toEqual([
+                expect.objectContaining({
+                    id: '8485093748',
+                    content: 'First task content',
+                    description: '',
+                    labels: [],
+                }),
+                expect.objectContaining({
+                    id: '8485093749',
+                    content: 'Second task content',
+                    description: 'Task description',
+                    dueDate: '2025-08-15',
+                    priority: 2,
+                    labels: ['work', 'urgent'],
+                }),
+            ]);
+        });
+        it('should handle tasks with section and parent IDs', async () => {
+            const mockApiResponse = createMockTask({
+                id: '8485093750',
+                content: 'Subtask content',
+                description: 'Subtask description',
+                priority: 3,
+                sectionId: 'section-123',
+                parentId: 'parent-task-456',
+                url: 'https://todoist.com/showTask?id=8485093750',
+                addedAt: '2025-08-13T22:09:58.123456Z',
+            });
+            mockTodoistApi.addTask.mockResolvedValue(mockApiResponse);
+            const result = await tasksAddMultiple.execute({
+                projectId: '6cfCcrrCFg2xP94Q',
+                sectionId: 'section-123',
+                parentId: 'parent-task-456',
+                tasks: [
+                    {
+                        content: 'Subtask content',
+                        description: 'Subtask description',
+                        priority: 3,
+                    },
+                ],
+            }, mockTodoistApi);
+            expect(mockTodoistApi.addTask).toHaveBeenCalledWith({
+                content: 'Subtask content',
+                description: 'Subtask description',
+                priority: 3,
+                projectId: '6cfCcrrCFg2xP94Q',
+                sectionId: 'section-123',
+                parentId: 'parent-task-456',
+            });
+            expect(result).toEqual([
+                expect.objectContaining({
+                    id: '8485093750',
+                    content: 'Subtask content',
+                    description: 'Subtask description',
+                    priority: 3,
+                    sectionId: 'section-123',
+                    parentId: 'parent-task-456',
+                    labels: [],
+                }),
+            ]);
+        });
+        it('should add tasks with duration', async () => {
+            const mockApiResponse1 = createMockTask({
+                id: '8485093752',
+                content: 'Task with 2 hour duration',
+                duration: { amount: 120, unit: 'minute' },
+                url: 'https://todoist.com/showTask?id=8485093752',
+                addedAt: '2025-08-13T22:09:56.123456Z',
+            });
+            const mockApiResponse2 = createMockTask({
+                id: '8485093753',
+                content: 'Task with 45 minute duration',
+                duration: { amount: 45, unit: 'minute' },
+                url: 'https://todoist.com/showTask?id=8485093753',
+                addedAt: '2025-08-13T22:09:57.123456Z',
+            });
+            mockTodoistApi.addTask
+                .mockResolvedValueOnce(mockApiResponse1)
+                .mockResolvedValueOnce(mockApiResponse2);
+            const result = await tasksAddMultiple.execute({
+                projectId: '6cfCcrrCFg2xP94Q',
+                tasks: [
+                    {
+                        content: 'Task with 2 hour duration',
+                        duration: '2h',
+                    },
+                    {
+                        content: 'Task with 45 minute duration',
+                        duration: '45m',
+                    },
+                ],
+            }, mockTodoistApi);
+            // Verify API was called with parsed duration
+            expect(mockTodoistApi.addTask).toHaveBeenNthCalledWith(1, {
+                content: 'Task with 2 hour duration',
+                projectId: '6cfCcrrCFg2xP94Q',
+                sectionId: undefined,
+                parentId: undefined,
+                duration: 120,
+                durationUnit: 'minute',
+            });
+            expect(mockTodoistApi.addTask).toHaveBeenNthCalledWith(2, {
+                content: 'Task with 45 minute duration',
+                projectId: '6cfCcrrCFg2xP94Q',
+                sectionId: undefined,
+                parentId: undefined,
+                duration: 45,
+                durationUnit: 'minute',
+            });
+            // Verify result includes formatted duration
+            expect(result).toEqual([
+                expect.objectContaining({
+                    id: '8485093752',
+                    content: 'Task with 2 hour duration',
+                    duration: '2h',
+                }),
+                expect.objectContaining({
+                    id: '8485093753',
+                    content: 'Task with 45 minute duration',
+                    duration: '45m',
+                }),
+            ]);
+        });
+        it('should handle various duration formats', async () => {
+            const mockApiResponse = createMockTask({
+                id: '8485093754',
+                content: 'Task with combined duration',
+                duration: { amount: 150, unit: 'minute' },
+                url: 'https://todoist.com/showTask?id=8485093754',
+                addedAt: '2025-08-13T22:09:56.123456Z',
+            });
+            mockTodoistApi.addTask.mockResolvedValue(mockApiResponse);
+            // Test different duration formats
+            const testCases = [
+                { input: '2h30m', expectedMinutes: 150 },
+                { input: '1.5h', expectedMinutes: 90 },
+                { input: ' 90m ', expectedMinutes: 90 },
+                { input: '2H30M', expectedMinutes: 150 },
+            ];
+            for (const testCase of testCases) {
+                mockTodoistApi.addTask.mockClear();
+                await tasksAddMultiple.execute({
+                    tasks: [
+                        {
+                            content: 'Test task',
+                            duration: testCase.input,
+                        },
+                    ],
+                }, mockTodoistApi);
+                expect(mockTodoistApi.addTask).toHaveBeenCalledWith(expect.objectContaining({
+                    duration: testCase.expectedMinutes,
+                    durationUnit: 'minute',
+                }));
+            }
+        });
+    });
+    describe('error handling', () => {
+        it('should throw error for invalid duration format', async () => {
+            await expect(tasksAddMultiple.execute({
+                tasks: [
+                    {
+                        content: 'Task with invalid duration',
+                        duration: 'invalid',
+                    },
+                ],
+            }, mockTodoistApi)).rejects.toThrow('Task "Task with invalid duration": Invalid duration format "invalid"');
+        });
+        it('should throw error for duration exceeding 24 hours', async () => {
+            await expect(tasksAddMultiple.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)');
+        });
+        it('should propagate API errors', async () => {
+            const apiError = new Error('API Error: Task content is required');
+            mockTodoistApi.addTask.mockRejectedValue(apiError);
+            await expect(tasksAddMultiple.execute({ tasks: [{ content: '' }] }, mockTodoistApi)).rejects.toThrow(apiError.message);
+        });
+        it('should handle partial failures when adding multiple tasks', async () => {
+            const mockApiResponse = createMockTask({
+                id: '8485093751',
+                content: 'First task content',
+                url: 'https://todoist.com/showTask?id=8485093751',
+                addedAt: '2025-08-13T22:09:59.123456Z',
+            });
+            const apiError = new Error('API Error: Second task failed');
+            mockTodoistApi.addTask
+                .mockResolvedValueOnce(mockApiResponse)
+                .mockRejectedValueOnce(apiError);
+            await expect(tasksAddMultiple.execute({
+                tasks: [
+                    { content: 'First task content' },
+                    { content: 'Second task content' },
+                ],
+            }, mockTodoistApi)).rejects.toThrow('API Error: Second task failed');
+            // Verify first task was attempted
+            expect(mockTodoistApi.addTask).toHaveBeenCalledTimes(2);
+        });
+    });
+});

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

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

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

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