@doist/todoist-ai 2.2.2 → 4.0.0

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

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

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

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

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

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

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

@@ -1,245 +0,0 @@
-import { jest } from '@jest/globals';
-import { tasksOrganizeMultiple } from '../tasks-organize-multiple.js';
-import { TEST_IDS, createMockTask } from '../test-helpers.js';
-// Mock the Todoist API
-const mockTodoistApi = {
-    updateTask: jest.fn(),
-    moveTasks: jest.fn(),
-};
-describe('tasks-organize-multiple tool', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('organizing multiple tasks', () => {
-        it('should move multiple tasks to the same destination', async () => {
-            const sectionId = '6cfPqr9xgvmgW6J0';
-            const mockResponses = [
-                createMockTask({ id: '6cPuJm79x4QhMwR4', content: 'First task', sectionId }),
-                createMockTask({ id: '6cPHJj2MV4HMj92W', content: 'Second task', sectionId }),
-            ];
-            // Each task should be moved individually to avoid bulk operation issues
-            mockTodoistApi.moveTasks
-                .mockResolvedValueOnce([mockResponses[0]])
-                .mockResolvedValueOnce([mockResponses[1]]);
-            const result = await tasksOrganizeMultiple.execute({
-                tasks: [
-                    { id: '6cPHJm59x4WhMwR4', sectionId },
-                    { id: '6cPHJj2MV4HMj92W', sectionId },
-                ],
-            }, mockTodoistApi);
-            // Should call moveTasks twice, once for each task individually
-            expect(mockTodoistApi.moveTasks).toHaveBeenCalledTimes(2);
-            expect(mockTodoistApi.moveTasks).toHaveBeenNthCalledWith(1, ['6cPHJm59x4WhMwR4'], {
-                sectionId,
-            });
-            expect(mockTodoistApi.moveTasks).toHaveBeenNthCalledWith(2, ['6cPHJj2MV4HMj92W'], {
-                sectionId,
-            });
-            expect(mockTodoistApi.updateTask).not.toHaveBeenCalled();
-            expect(result).toEqual(mockResponses);
-        });
-        it('should move multiple tasks with different destinations', async () => {
-            const { TASK_1, TASK_2, TASK_3 } = TEST_IDS;
-            const mockResponses = [
-                createMockTask({ id: TASK_1, content: 'Task 1', projectId: 'new-project-id' }),
-                createMockTask({ id: TASK_2, content: 'Task 2', sectionId: 'new-section-id' }),
-                createMockTask({ id: TASK_3, content: 'Task 3', parentId: 'parent-task-123' }),
-            ];
-            // Each task should be moved individually
-            mockTodoistApi.moveTasks
-                .mockResolvedValueOnce([mockResponses[0]])
-                .mockResolvedValueOnce([mockResponses[1]])
-                .mockResolvedValueOnce([mockResponses[2]]);
-            const result = await tasksOrganizeMultiple.execute({
-                tasks: [
-                    { id: '8485093748', projectId: 'new-project-id' },
-                    { id: '8485093749', sectionId: 'new-section-id' },
-                    { id: '8485093750', parentId: 'parent-task-123' },
-                ],
-            }, mockTodoistApi);
-            // Verify API was called correctly - 3 individual move calls
-            expect(mockTodoistApi.moveTasks).toHaveBeenCalledTimes(3);
-            expect(mockTodoistApi.moveTasks).toHaveBeenNthCalledWith(1, ['8485093748'], {
-                projectId: 'new-project-id',
-            });
-            expect(mockTodoistApi.moveTasks).toHaveBeenNthCalledWith(2, ['8485093749'], {
-                sectionId: 'new-section-id',
-            });
-            expect(mockTodoistApi.moveTasks).toHaveBeenNthCalledWith(3, ['8485093750'], {
-                parentId: 'parent-task-123',
-            });
-            expect(mockTodoistApi.updateTask).not.toHaveBeenCalled();
-            // Verify results are returned in the correct order
-            expect(result).toEqual(mockResponses);
-        });
-        it('should handle single task organization', async () => {
-            const mockTaskResponse = createMockTask({
-                id: '8485093751',
-                content: 'Single task update',
-                sectionId: 'target-section',
-                url: 'https://todoist.com/showTask?id=8485093751',
-                addedAt: '2025-08-13T22:09:59.123456Z',
-            });
-            mockTodoistApi.moveTasks.mockResolvedValue([mockTaskResponse]);
-            const result = await tasksOrganizeMultiple.execute({ tasks: [{ id: '8485093751', sectionId: 'target-section' }] }, mockTodoistApi);
-            expect(mockTodoistApi.moveTasks).toHaveBeenCalledTimes(1);
-            expect(mockTodoistApi.moveTasks).toHaveBeenCalledWith(['8485093751'], {
-                sectionId: 'target-section',
-            });
-            expect(mockTodoistApi.updateTask).not.toHaveBeenCalled();
-            expect(result).toEqual([mockTaskResponse]);
-        });
-        it('should handle complex reorganization scenario', async () => {
-            // Simulate moving tasks to different destinations (one move param per task)
-            const mockResponses = [
-                createMockTask({
-                    id: 'task-1',
-                    content: 'Task moved to new project',
-                    projectId: 'project-new',
-                    url: 'https://todoist.com/showTask?id=task-1',
-                    addedAt: '2025-08-13T22:10:00.123456Z',
-                }),
-                createMockTask({
-                    id: 'task-2',
-                    content: 'Task made into subtask',
-                    parentId: 'task-1',
-                    url: 'https://todoist.com/showTask?id=task-2',
-                    addedAt: '2025-08-13T22:10:01.123456Z',
-                }),
-                createMockTask({
-                    id: 'task-3',
-                    content: 'Task moved to section',
-                    sectionId: 'section-new',
-                    url: 'https://todoist.com/showTask?id=task-3',
-                    addedAt: '2025-08-13T22:10:02.123456Z',
-                }),
-            ];
-            // Each task should be moved individually
-            mockTodoistApi.moveTasks
-                .mockResolvedValueOnce([mockResponses[0]])
-                .mockResolvedValueOnce([mockResponses[1]])
-                .mockResolvedValueOnce([mockResponses[2]]);
-            const result = await tasksOrganizeMultiple.execute({
-                tasks: [
-                    { id: 'task-1', projectId: 'project-new' },
-                    { id: 'task-2', parentId: 'task-1' },
-                    { id: 'task-3', sectionId: 'section-new' },
-                ],
-            }, mockTodoistApi);
-            // Verify API was called correctly - 3 individual move calls
-            expect(mockTodoistApi.moveTasks).toHaveBeenCalledTimes(3);
-            expect(mockTodoistApi.moveTasks).toHaveBeenNthCalledWith(1, ['task-1'], {
-                projectId: 'project-new',
-            });
-            expect(mockTodoistApi.moveTasks).toHaveBeenNthCalledWith(2, ['task-2'], {
-                parentId: 'task-1',
-            });
-            expect(mockTodoistApi.moveTasks).toHaveBeenNthCalledWith(3, ['task-3'], {
-                sectionId: 'section-new',
-            });
-            expect(mockTodoistApi.updateTask).not.toHaveBeenCalled();
-            expect(result).toEqual(mockResponses);
-        });
-    });
-    describe('order management', () => {
-        it('should skip tasks with only order changes (no move operations)', async () => {
-            const result = await tasksOrganizeMultiple.execute({
-                tasks: [
-                    { id: 'task-a', order: 3 }, // Only order, no move params
-                    { id: 'task-b', order: 1 }, // Only order, no move params
-                    { id: 'task-c', order: 2 }, // Only order, no move params
-                ],
-            }, mockTodoistApi);
-            // No API calls should be made since only order is specified (no projectId/sectionId/parentId)
-            expect(mockTodoistApi.moveTasks).not.toHaveBeenCalled();
-            expect(mockTodoistApi.updateTask).not.toHaveBeenCalled();
-            // Returns empty array since no moves were processed
-            expect(result).toEqual([]);
-        });
-    });
-    describe('partial updates', () => {
-        it('should handle move operations with single parameters', async () => {
-            const mockResponse = createMockTask({
-                id: '8485093752',
-                content: 'Minimal update task',
-                projectId: 'new-project-only',
-                url: 'https://todoist.com/showTask?id=8485093752',
-                addedAt: '2025-08-13T22:10:07.123456Z',
-            });
-            mockTodoistApi.moveTasks.mockResolvedValue([mockResponse]);
-            const result = await tasksOrganizeMultiple.execute({
-                tasks: [
-                    {
-                        id: '8485093752',
-                        projectId: 'new-project-only',
-                        // Only updating projectId (move operation)
-                    },
-                ],
-            }, mockTodoistApi);
-            expect(mockTodoistApi.moveTasks).toHaveBeenCalledWith(['8485093752'], {
-                projectId: 'new-project-only',
-            });
-            expect(mockTodoistApi.updateTask).not.toHaveBeenCalled();
-            expect(result).toEqual([mockResponse]);
-        });
-        it('should handle empty updates (only id provided)', async () => {
-            const result = await tasksOrganizeMultiple.execute({ tasks: [{ id: '8485093753' }] }, mockTodoistApi);
-            // No API calls should be made since no move parameters are provided
-            expect(mockTodoistApi.moveTasks).not.toHaveBeenCalled();
-            expect(mockTodoistApi.updateTask).not.toHaveBeenCalled();
-            // Returns empty array since no moves were processed
-            expect(result).toEqual([]);
-        });
-    });
-    describe('error handling', () => {
-        it('should throw error when task has multiple move parameters', async () => {
-            await expect(tasksOrganizeMultiple.execute({
-                tasks: [
-                    { id: 'task-1', projectId: 'new-project', sectionId: 'new-section' },
-                ],
-            }, mockTodoistApi)).rejects.toThrow('Task task-1: Only one of projectId, sectionId, or parentId can be specified at a time');
-        });
-        it('should propagate API errors for individual task moves', async () => {
-            const apiError = new Error('API Error: Task not found');
-            mockTodoistApi.moveTasks.mockRejectedValue(apiError);
-            await expect(tasksOrganizeMultiple.execute({ tasks: [{ id: 'non-existent-task', projectId: 'some-project' }] }, mockTodoistApi)).rejects.toThrow('API Error: Task not found');
-        });
-        it('should fail fast on first error (not continue with remaining tasks)', async () => {
-            const apiError = new Error('API Error: Invalid project ID');
-            mockTodoistApi.moveTasks.mockRejectedValue(apiError);
-            await expect(tasksOrganizeMultiple.execute({
-                tasks: [
-                    { id: 'task-1', projectId: 'invalid-project' },
-                    { id: 'task-2', projectId: 'valid-project' },
-                ],
-            }, mockTodoistApi)).rejects.toThrow('API Error: Invalid project ID');
-            // Should only attempt the first move
-            expect(mockTodoistApi.moveTasks).toHaveBeenCalledTimes(1);
-            expect(mockTodoistApi.moveTasks).toHaveBeenCalledWith(['task-1'], {
-                projectId: 'invalid-project',
-            });
-        });
-        it('should handle validation errors', async () => {
-            const validationError = new Error('API Error: Invalid section ID');
-            mockTodoistApi.moveTasks.mockRejectedValue(validationError);
-            await expect(tasksOrganizeMultiple.execute({ tasks: [{ id: 'task-1', sectionId: 'invalid-section-format' }] }, mockTodoistApi)).rejects.toThrow('API Error: Invalid section ID');
-        });
-        it('should handle permission errors', async () => {
-            const permissionError = new Error('API Error: Insufficient permissions to move task');
-            mockTodoistApi.moveTasks.mockRejectedValue(permissionError);
-            await expect(tasksOrganizeMultiple.execute({ tasks: [{ id: 'restricted-task', projectId: 'restricted-project' }] }, mockTodoistApi)).rejects.toThrow('API Error: Insufficient permissions to move task');
-        });
-        it('should handle circular parent dependency errors', async () => {
-            const circularError = new Error('API Error: Circular dependency detected');
-            mockTodoistApi.moveTasks.mockRejectedValue(circularError);
-            await expect(tasksOrganizeMultiple.execute({
-                tasks: [
-                    {
-                        id: 'task-parent',
-                        parentId: 'task-child', // This would create a circular dependency
-                    },
-                ],
-            }, mockTodoistApi)).rejects.toThrow('API Error: Circular dependency detected');
-        });
-    });
-});

package/dist/tools/__tests__/tasks-search.test.d.ts

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

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

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

package/dist/tools/__tests__/tasks-search.test.js

@@ -1,106 +0,0 @@
-import { jest } from '@jest/globals';
-import { getTasksByFilter } from '../../tool-helpers.js';
-import { tasksSearch } from '../tasks-search.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-search, but needed for type)
-const mockTodoistApi = {};
-describe('tasks-search tool', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('searching tasks', () => {
-        it('should search tasks and return results', async () => {
-            const mockTasks = [
-                createMappedTask({
-                    id: TEST_IDS.TASK_1,
-                    content: 'Task containing search term',
-                    description: 'Description with more details',
-                    labels: ['work'],
-                }),
-                createMappedTask({
-                    id: TEST_IDS.TASK_2,
-                    content: 'Another matching task',
-                    priority: 2,
-                    sectionId: TEST_IDS.SECTION_1,
-                }),
-            ];
-            const mockResponse = { tasks: mockTasks, nextCursor: 'cursor-for-next-page' };
-            mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await tasksSearch.execute({
-                searchText: 'important meeting',
-                limit: 10,
-            }, mockTodoistApi);
-            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
-                client: mockTodoistApi,
-                query: 'search: important meeting',
-                cursor: undefined,
-                limit: 10,
-            });
-            expect(result).toEqual(mockResponse);
-        });
-        it.each([
-            {
-                name: 'custom limit',
-                params: { searchText: 'project update', limit: 5 },
-                expectedQuery: 'search: project update',
-                expectedLimit: 5,
-                expectedCursor: undefined,
-            },
-            {
-                name: 'pagination cursor',
-                params: { searchText: 'follow up', limit: 20, cursor: 'cursor-from-first-page' },
-                expectedQuery: 'search: follow up',
-                expectedLimit: 20,
-                expectedCursor: 'cursor-from-first-page',
-            },
-        ])('should handle $name', async ({ params, expectedQuery, expectedLimit, expectedCursor }) => {
-            const mockTask = createMappedTask({ content: 'Test result' });
-            const mockResponse = { tasks: [mockTask], nextCursor: null };
-            mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await tasksSearch.execute(params, mockTodoistApi);
-            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
-                client: mockTodoistApi,
-                query: expectedQuery,
-                cursor: expectedCursor,
-                limit: expectedLimit,
-            });
-            expect(result).toEqual(mockResponse);
-        });
-        it.each([
-            { searchText: '@work #urgent "exact phrase"', description: 'special characters' },
-            { searchText: 'nonexistent keyword', description: 'empty results' },
-        ])('should handle search with $description', async ({ searchText }) => {
-            const mockResponse = { tasks: [], nextCursor: null };
-            mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await tasksSearch.execute({ searchText, limit: 10 }, mockTodoistApi);
-            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
-                client: mockTodoistApi,
-                query: `search: ${searchText}`,
-                cursor: undefined,
-                limit: 10,
-            });
-            expect(result).toEqual(mockResponse);
-        });
-    });
-    describe('error handling', () => {
-        it.each([
-            { error: 'Invalid filter query: search: ', params: { searchText: '', limit: 10 } },
-            {
-                error: TEST_ERRORS.API_RATE_LIMIT,
-                params: { searchText: 'any search term', limit: 10 },
-            },
-            {
-                error: TEST_ERRORS.INVALID_CURSOR,
-                params: { searchText: 'test', cursor: 'invalid-cursor-format', limit: 10 },
-            },
-        ])('should propagate $error', async ({ error, params }) => {
-            mockGetTasksByFilter.mockRejectedValue(new Error(error));
-            await expect(tasksSearch.execute(params, mockTodoistApi)).rejects.toThrow(error);
-        });
-    });
-});

package/dist/tools/__tests__/tasks-update-one.test.d.ts

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

package/dist/tools/__tests__/tasks-update-one.test.d.ts.map

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