@doist/todoist-ai 2.0.0 → 2.0.1

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,160 @@
+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: [],
+                }),
+            ]);
+        });
+    });
+    describe('error handling', () => {
+        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":""}

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

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

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

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

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