@doist/todoist-ai 2.0.0 → 2.1.0

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

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

@@ -0,0 +1,192 @@
+import { jest } from '@jest/globals';
+import { getTasksByFilter } from '../../tool-helpers.js';
+import { tasksListByDate } from '../tasks-list-by-date.js';
+import { TEST_ERRORS, TEST_IDS, createMappedTask } from '../test-helpers.js';
+// Mock the tool helpers
+jest.mock('../../tool-helpers', () => ({
+    getTasksByFilter: jest.fn(),
+}));
+const mockGetTasksByFilter = getTasksByFilter;
+// Mock the Todoist API (not directly used by tasks-list-by-date, but needed for type)
+const mockTodoistApi = {};
+// Mock date-fns functions to make tests deterministic
+jest.mock('date-fns', () => ({
+    addDays: jest.fn(() => new Date('2025-08-16')), // Return predictable end date
+    formatISO: jest.fn((date, options) => {
+        if (typeof date === 'string') {
+            return date; // Return string dates as-is
+        }
+        if (options &&
+            typeof options === 'object' &&
+            'representation' in options &&
+            options.representation === 'date') {
+            return '2025-08-15'; // Return predictable date for 'today'
+        }
+        return '2025-08-16'; // Return predictable end date
+    }),
+}));
+describe('tasks-list-by-date tool', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Mock current date to make tests deterministic
+        jest.spyOn(Date, 'now').mockReturnValue(new Date('2025-08-15T10:00:00Z').getTime());
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    describe('listing overdue tasks', () => {
+        it.each([
+            { daysCount: 7, hasTasks: true, description: 'with tasks' },
+            { daysCount: 5, hasTasks: false, description: 'ignoring daysCount' },
+        ])('should handle overdue tasks $description', async ({ daysCount, hasTasks }) => {
+            const mockTasks = hasTasks
+                ? [
+                    createMappedTask({
+                        id: TEST_IDS.TASK_1,
+                        content: 'Overdue task',
+                        dueDate: '2025-08-10',
+                        priority: 2,
+                        labels: ['urgent'],
+                    }),
+                ]
+                : [];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await tasksListByDate.execute({ startDate: 'overdue', limit: 50, daysCount }, mockTodoistApi);
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: 'overdue',
+                cursor: undefined,
+                limit: 50,
+            });
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe('listing tasks by date range', () => {
+        it('should get tasks for today when startDate is "today"', async () => {
+            const mockTasks = [createMappedTask({ content: 'Today task', dueDate: '2025-08-15' })];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await tasksListByDate.execute({ startDate: 'today', limit: 50, daysCount: 7 }, mockTodoistApi);
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: expect.stringContaining('due after:') && expect.stringContaining('due before:'),
+                cursor: undefined,
+                limit: 50,
+            });
+            expect(result).toEqual(mockResponse);
+        });
+        it.each([
+            {
+                name: 'specific date',
+                params: { startDate: '2025-08-20', limit: 50, daysCount: 7 },
+                tasks: [createMappedTask({ content: 'Specific date task', dueDate: '2025-08-20' })],
+                cursor: null,
+            },
+            {
+                name: 'multiple days with pagination',
+                params: {
+                    startDate: '2025-08-20',
+                    daysCount: 3,
+                    limit: 20,
+                    cursor: 'current-cursor',
+                },
+                tasks: [
+                    createMappedTask({
+                        id: TEST_IDS.TASK_2,
+                        content: 'Multi-day task 1',
+                        dueDate: '2025-08-20',
+                    }),
+                    createMappedTask({
+                        id: TEST_IDS.TASK_3,
+                        content: 'Multi-day task 2',
+                        dueDate: '2025-08-21',
+                    }),
+                ],
+                cursor: 'next-page-cursor',
+            },
+        ])('should handle $name', async ({ params, tasks, cursor }) => {
+            const mockResponse = { tasks, nextCursor: cursor };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await tasksListByDate.execute(params, mockTodoistApi);
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: expect.stringContaining('2025-08-20'),
+                cursor: params.cursor || undefined,
+                limit: params.limit,
+            });
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe('pagination and limits', () => {
+        it.each([
+            {
+                name: 'pagination parameters',
+                params: {
+                    startDate: 'today',
+                    limit: 25,
+                    daysCount: 7,
+                    cursor: 'pagination-cursor',
+                },
+                expectedCursor: 'pagination-cursor',
+                expectedLimit: 25,
+            },
+            {
+                name: 'default values',
+                params: { startDate: '2025-08-15', limit: 50, daysCount: 7 },
+                expectedCursor: undefined,
+                expectedLimit: 50,
+            },
+        ])('should handle $name', async ({ params, expectedCursor, expectedLimit }) => {
+            const mockResponse = { tasks: [], nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            await tasksListByDate.execute(params, mockTodoistApi);
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: expect.any(String),
+                cursor: expectedCursor,
+                limit: expectedLimit,
+            });
+        });
+    });
+    describe('edge cases', () => {
+        it.each([
+            { name: 'empty results', daysCount: 7, shouldReturnResult: true },
+            { name: 'maximum daysCount', daysCount: 30, shouldReturnResult: false },
+            { name: 'minimum daysCount', daysCount: 1, shouldReturnResult: false },
+        ])('should handle $name', async ({ daysCount, shouldReturnResult }) => {
+            const mockResponse = { tasks: [], nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const startDate = daysCount === 7 ? 'today' : '2025-08-15';
+            const result = await tasksListByDate.execute({ startDate, limit: 50, daysCount }, mockTodoistApi);
+            expect(mockGetTasksByFilter).toHaveBeenCalledTimes(1);
+            if (shouldReturnResult) {
+                expect(result).toEqual(mockResponse);
+            }
+        });
+    });
+    describe('error handling', () => {
+        it.each([
+            {
+                error: TEST_ERRORS.INVALID_FILTER,
+                params: { startDate: 'today', limit: 50, daysCount: 7 },
+            },
+            {
+                error: TEST_ERRORS.API_RATE_LIMIT,
+                params: { startDate: 'overdue', limit: 50, daysCount: 7 },
+            },
+            {
+                error: TEST_ERRORS.INVALID_CURSOR,
+                params: {
+                    startDate: '2025-08-15',
+                    limit: 50,
+                    daysCount: 7,
+                    cursor: 'invalid-cursor',
+                },
+            },
+        ])('should propagate $error', async ({ error, params }) => {
+            mockGetTasksByFilter.mockRejectedValue(new Error(error));
+            await expect(tasksListByDate.execute(params, mockTodoistApi)).rejects.toThrow(error);
+        });
+    });
+});

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

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

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

@@ -0,0 +1 @@
+{"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-completed.test.js

@@ -0,0 +1,154 @@
+import { jest } from '@jest/globals';
+import { tasksListCompleted } from '../tasks-list-completed.js';
+import { createMockTask } from '../test-helpers.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    getCompletedTasksByCompletionDate: jest.fn(),
+    getCompletedTasksByDueDate: jest.fn(),
+};
+describe('tasks-list-completed tool', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('getting completed tasks by completion date (default)', () => {
+        it('should get completed tasks by completion date', async () => {
+            const mockCompletedTasks = [
+                createMockTask({
+                    id: '8485093748',
+                    content: 'Completed task 1',
+                    description: 'Task completed yesterday',
+                    completedAt: '2024-01-01T00:00:00Z',
+                    labels: ['work'],
+                    priority: 2,
+                    url: 'https://todoist.com/showTask?id=8485093748',
+                    addedAt: '2025-08-13T22:09:56.123456Z',
+                    due: {
+                        date: '2025-08-14',
+                        isRecurring: false,
+                        lang: 'en',
+                        string: 'Aug 14',
+                        timezone: null,
+                    },
+                }),
+            ];
+            mockTodoistApi.getCompletedTasksByCompletionDate.mockResolvedValue({
+                items: mockCompletedTasks,
+                nextCursor: null,
+            });
+            const result = await tasksListCompleted.execute({ getBy: 'completion', limit: 50, since: '2025-08-10', until: '2025-08-15' }, mockTodoistApi);
+            expect(mockTodoistApi.getCompletedTasksByCompletionDate).toHaveBeenCalledWith({
+                since: '2025-08-10',
+                until: '2025-08-15',
+                limit: 50,
+            });
+            expect(result).toEqual({
+                tasks: [
+                    expect.objectContaining({
+                        id: '8485093748',
+                        content: 'Completed task 1',
+                        description: 'Task completed yesterday',
+                        dueDate: '2025-08-14',
+                        priority: 2,
+                        labels: ['work'],
+                    }),
+                ],
+                nextCursor: null,
+            });
+        });
+        it('should handle explicit completion date query', async () => {
+            mockTodoistApi.getCompletedTasksByCompletionDate.mockResolvedValue({
+                items: [],
+                nextCursor: 'next-cursor',
+            });
+            const result = await tasksListCompleted.execute({
+                getBy: 'completion',
+                limit: 100,
+                since: '2025-08-01',
+                until: '2025-08-31',
+                projectId: 'specific-project-id',
+                cursor: 'current-cursor',
+            }, mockTodoistApi);
+            expect(mockTodoistApi.getCompletedTasksByCompletionDate).toHaveBeenCalledWith({
+                since: '2025-08-01',
+                until: '2025-08-31',
+                projectId: 'specific-project-id',
+                limit: 100,
+                cursor: 'current-cursor',
+            });
+            expect(result).toEqual({ tasks: [], nextCursor: 'next-cursor' });
+        });
+    });
+    describe('getting completed tasks by due date', () => {
+        it('should get completed tasks by due date', async () => {
+            const mockCompletedTasks = [
+                createMockTask({
+                    id: '8485093750',
+                    content: 'Task completed by due date',
+                    description: 'This task was due and completed',
+                    completedAt: '2024-01-01T00:00:00Z',
+                    labels: ['urgent'],
+                    priority: 3,
+                    url: 'https://todoist.com/showTask?id=8485093750',
+                    addedAt: '2025-08-13T22:09:58.123456Z',
+                    due: {
+                        date: '2025-08-15',
+                        isRecurring: true,
+                        lang: 'en',
+                        string: 'every Monday',
+                        timezone: null,
+                    },
+                }),
+            ];
+            mockTodoistApi.getCompletedTasksByDueDate.mockResolvedValue({
+                items: mockCompletedTasks,
+                nextCursor: null,
+            });
+            const result = await tasksListCompleted.execute({
+                getBy: 'due',
+                limit: 50,
+                since: '2025-08-10',
+                until: '2025-08-20',
+            }, mockTodoistApi);
+            expect(mockTodoistApi.getCompletedTasksByDueDate).toHaveBeenCalledWith({
+                since: '2025-08-10',
+                until: '2025-08-20',
+                limit: 50,
+            });
+            expect(mockTodoistApi.getCompletedTasksByCompletionDate).not.toHaveBeenCalled();
+            expect(result).toEqual({
+                tasks: [
+                    expect.objectContaining({
+                        id: '8485093750',
+                        content: 'Task completed by due date',
+                        description: 'This task was due and completed',
+                        dueDate: '2025-08-15',
+                        recurring: 'every Monday',
+                        priority: 3,
+                        labels: ['urgent'],
+                    }),
+                ],
+                nextCursor: null,
+            });
+        });
+    });
+    describe('error handling', () => {
+        it('should propagate completion date API errors', async () => {
+            const apiError = new Error('API Error: Invalid date range');
+            mockTodoistApi.getCompletedTasksByCompletionDate.mockRejectedValue(apiError);
+            await expect(tasksListCompleted.execute(
+            // invalid date range
+            { getBy: 'completion', limit: 50, since: '2025-08-31', until: '2025-08-01' }, mockTodoistApi)).rejects.toThrow('API Error: Invalid date range');
+        });
+        it('should propagate due date API errors', async () => {
+            const apiError = new Error('API Error: Project not found');
+            mockTodoistApi.getCompletedTasksByDueDate.mockRejectedValue(apiError);
+            await expect(tasksListCompleted.execute({
+                getBy: 'due',
+                limit: 50,
+                since: '2025-08-01',
+                until: '2025-08-31',
+                projectId: 'non-existent-project',
+            }, mockTodoistApi)).rejects.toThrow('API Error: Project not found');
+        });
+    });
+});

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

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

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

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