@doist/todoist-ai 2.0.0 → 2.0.1

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

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

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

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

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

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