@doist/todoist-ai 2.2.2 → 3.0.0

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

package/dist/tools/__tests__/tasks-update-one.test.js

@@ -1,251 +0,0 @@
-import { jest } from '@jest/globals';
-import { tasksUpdateOne } from '../tasks-update-one.js';
-import { createMockTask } from '../test-helpers.js';
-// Mock the Todoist API
-const mockTodoistApi = {
-    updateTask: jest.fn(),
-    moveTasks: jest.fn(),
-};
-describe('tasks-update-one tool', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('updating task properties', () => {
-        it('should update task content and description', async () => {
-            // Mock API response extracted from recordings (Task type)
-            const mockApiResponse = createMockTask({
-                id: '8485093748',
-                content: 'Updated task content',
-                description: 'Updated task description',
-                url: 'https://todoist.com/showTask?id=8485093748',
-                addedAt: '2025-08-13T22:09:56.123456Z',
-            });
-            mockTodoistApi.updateTask.mockResolvedValue(mockApiResponse);
-            const result = await tasksUpdateOne.execute({
-                id: '8485093748',
-                content: 'Updated task content',
-                description: 'Updated task description',
-            }, mockTodoistApi);
-            // Verify API was called correctly
-            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('8485093748', {
-                content: 'Updated task content',
-                description: 'Updated task description',
-            });
-            // Verify result matches API response
-            expect(result).toEqual(mockApiResponse);
-        });
-        it('should update task priority and due date', async () => {
-            const mockApiResponse = createMockTask({
-                id: '8485093749',
-                content: 'Original task content',
-                labels: ['urgent'],
-                priority: 3,
-                url: 'https://todoist.com/showTask?id=8485093749',
-                addedAt: '2025-08-13T22:09:56.123456Z',
-                due: {
-                    date: '2025-08-20',
-                    isRecurring: false,
-                    lang: 'en',
-                    string: 'Aug 20',
-                    timezone: null,
-                },
-            });
-            mockTodoistApi.updateTask.mockResolvedValue(mockApiResponse);
-            const result = await tasksUpdateOne.execute({ id: '8485093749', priority: 3, dueString: 'Aug 20' }, mockTodoistApi);
-            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('8485093749', {
-                priority: 3,
-                dueString: 'Aug 20',
-            });
-            expect(result).toEqual(mockApiResponse);
-        });
-        it('should move task to different project', async () => {
-            const mockApiResponse = createMockTask({
-                id: '8485093750',
-                content: 'Task to move',
-                projectId: 'new-project-id',
-                url: 'https://todoist.com/showTask?id=8485093750',
-                addedAt: '2025-08-13T22:09:56.123456Z',
-            });
-            mockTodoistApi.moveTasks.mockResolvedValue([mockApiResponse]);
-            const result = await tasksUpdateOne.execute({ id: '8485093750', projectId: 'new-project-id' }, mockTodoistApi);
-            expect(mockTodoistApi.moveTasks).toHaveBeenCalledWith(['8485093750'], {
-                projectId: 'new-project-id',
-            });
-            expect(mockTodoistApi.updateTask).not.toHaveBeenCalled();
-            expect(result).toEqual(mockApiResponse);
-        });
-        it('should update task parent (create subtask relationship)', async () => {
-            const mockApiResponse = createMockTask({
-                id: '8485093751',
-                content: 'Subtask content',
-                parentId: 'parent-task-123',
-                url: 'https://todoist.com/showTask?id=8485093751',
-                addedAt: '2025-08-13T22:09:56.123456Z',
-            });
-            mockTodoistApi.moveTasks.mockResolvedValue([mockApiResponse]);
-            const result = await tasksUpdateOne.execute({ id: '8485093751', parentId: 'parent-task-123' }, mockTodoistApi);
-            expect(mockTodoistApi.moveTasks).toHaveBeenCalledWith(['8485093751'], {
-                parentId: 'parent-task-123',
-            });
-            expect(mockTodoistApi.updateTask).not.toHaveBeenCalled();
-            expect(result).toEqual(mockApiResponse);
-        });
-        it('should move task and update properties at once', async () => {
-            const movedTask = createMockTask({
-                id: '8485093752',
-                content: 'Task to move',
-                projectId: 'different-project-id',
-            });
-            const updatedTask = createMockTask({
-                id: '8485093752',
-                content: 'Completely updated task',
-                description: 'New description with details',
-                priority: 4,
-                projectId: 'different-project-id',
-                url: 'https://todoist.com/showTask?id=8485093752',
-                addedAt: '2025-08-13T22:09:56.123456Z',
-                due: {
-                    date: '2025-08-25',
-                    isRecurring: true,
-                    lang: 'en',
-                    string: 'every Friday',
-                    timezone: null,
-                },
-            });
-            mockTodoistApi.moveTasks.mockResolvedValue([movedTask]);
-            mockTodoistApi.updateTask.mockResolvedValue(updatedTask);
-            const result = await tasksUpdateOne.execute({
-                id: '8485093752',
-                content: 'Completely updated task',
-                description: 'New description with details',
-                priority: 4,
-                dueString: 'every Friday',
-                projectId: 'different-project-id',
-            }, mockTodoistApi);
-            // Should call moveTasks first for the projectId
-            expect(mockTodoistApi.moveTasks).toHaveBeenCalledWith(['8485093752'], {
-                projectId: 'different-project-id',
-            });
-            // Then call updateTask for the other properties
-            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('8485093752', {
-                content: 'Completely updated task',
-                description: 'New description with details',
-                priority: 4,
-                dueString: 'every Friday',
-            });
-            expect(result).toEqual(updatedTask);
-        });
-        it('should update task duration', async () => {
-            const mockApiResponse = createMockTask({
-                id: '8485093753',
-                content: 'Task with updated duration',
-                duration: { amount: 150, unit: 'minute' },
-                url: 'https://todoist.com/showTask?id=8485093753',
-                addedAt: '2025-08-13T22:09:56.123456Z',
-            });
-            mockTodoistApi.updateTask.mockResolvedValue(mockApiResponse);
-            const result = await tasksUpdateOne.execute({
-                id: '8485093753',
-                duration: '2h30m',
-            }, mockTodoistApi);
-            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('8485093753', {
-                duration: 150,
-                durationUnit: 'minute',
-            });
-            expect(result).toEqual(mockApiResponse);
-        });
-        it('should handle various duration formats', async () => {
-            const mockApiResponse = createMockTask({
-                id: '8485093754',
-                content: 'Test task',
-                duration: { amount: 120, unit: 'minute' },
-            });
-            mockTodoistApi.updateTask.mockResolvedValue(mockApiResponse);
-            // Test different duration formats
-            const testCases = [
-                { input: '2h', expectedMinutes: 120 },
-                { input: '90m', expectedMinutes: 90 },
-                { input: '1.5h', expectedMinutes: 90 },
-                { input: ' 2h 30m ', expectedMinutes: 150 },
-                { input: '2H30M', expectedMinutes: 150 },
-            ];
-            for (const testCase of testCases) {
-                mockTodoistApi.updateTask.mockClear();
-                await tasksUpdateOne.execute({
-                    id: '8485093754',
-                    duration: testCase.input,
-                }, mockTodoistApi);
-                expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('8485093754', expect.objectContaining({
-                    duration: testCase.expectedMinutes,
-                    durationUnit: 'minute',
-                }));
-            }
-        });
-        it('should update task with duration and move at once', async () => {
-            const movedTask = createMockTask({
-                id: '8485093755',
-                content: 'Task to move and update',
-                projectId: 'new-project-id',
-            });
-            const updatedTask = createMockTask({
-                id: '8485093755',
-                content: 'Updated task with duration',
-                duration: { amount: 120, unit: 'minute' },
-                projectId: 'new-project-id',
-            });
-            mockTodoistApi.moveTasks.mockResolvedValue([movedTask]);
-            mockTodoistApi.updateTask.mockResolvedValue(updatedTask);
-            const result = await tasksUpdateOne.execute({
-                id: '8485093755',
-                content: 'Updated task with duration',
-                duration: '2h',
-                projectId: 'new-project-id',
-            }, mockTodoistApi);
-            // Should call moveTasks first
-            expect(mockTodoistApi.moveTasks).toHaveBeenCalledWith(['8485093755'], {
-                projectId: 'new-project-id',
-            });
-            // Then call updateTask with duration
-            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('8485093755', {
-                content: 'Updated task with duration',
-                duration: 120,
-                durationUnit: 'minute',
-            });
-            expect(result).toEqual(updatedTask);
-        });
-    });
-    describe('error handling', () => {
-        it('should throw error for invalid duration format', async () => {
-            await expect(tasksUpdateOne.execute({
-                id: '8485093756',
-                duration: 'invalid',
-            }, mockTodoistApi)).rejects.toThrow('Task 8485093756: Invalid duration format "invalid"');
-        });
-        it('should throw error for duration exceeding 24 hours', async () => {
-            await expect(tasksUpdateOne.execute({
-                id: '8485093757',
-                duration: '25h',
-            }, mockTodoistApi)).rejects.toThrow('Task 8485093757: Invalid duration format "25h": Duration cannot exceed 24 hours (1440 minutes)');
-        });
-        it('should throw error when multiple move parameters are provided', async () => {
-            await expect(tasksUpdateOne.execute({ id: '8485093748', projectId: 'new-project', sectionId: 'new-section' }, mockTodoistApi)).rejects.toThrow('Only one of projectId, sectionId, or parentId can be specified at a time. ' +
-                'The Todoist API requires exactly one destination for move operations.');
-        });
-        it('should throw error when all three move parameters are provided', async () => {
-            await expect(tasksUpdateOne.execute({ id: '8485093748', projectId: 'p1', sectionId: 's1', parentId: 't1' }, mockTodoistApi)).rejects.toThrow('Only one of projectId, sectionId, or parentId can be specified at a time');
-        });
-        it.each([
-            {
-                error: 'API Error: Task not found',
-                params: { id: 'non-existent-task', content: 'Updated content' },
-            },
-            {
-                error: 'API Error: Invalid priority value',
-                params: { id: '8485093748', priority: 5 },
-            },
-        ])('should propagate $error', async ({ error, params }) => {
-            mockTodoistApi.updateTask.mockRejectedValue(new Error(error));
-            await expect(tasksUpdateOne.execute(params, mockTodoistApi)).rejects.toThrow(error);
-        });
-    });
-});

package/dist/tools/delete-one.d.ts

@@ -1,17 +0,0 @@
-import { z } from 'zod';
-declare const deleteOne: {
-    name: string;
-    description: string;
-    parameters: {
-        type: z.ZodEnum<["project", "section", "task"]>;
-        id: z.ZodString;
-    };
-    execute(args: {
-        type: "project" | "section" | "task";
-        id: string;
-    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
-        success: boolean;
-    }>;
-};
-export { deleteOne };
-//# sourceMappingURL=delete-one.d.ts.map

package/dist/tools/delete-one.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"delete-one.d.ts","sourceRoot":"","sources":["../../src/tools/delete-one.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,QAAA,MAAM,SAAS;;;;;;;;;;;;;CAkB2B,CAAA;AAE1C,OAAO,EAAE,SAAS,EAAE,CAAA"}

package/dist/tools/delete-one.js

@@ -1,25 +0,0 @@
-import { z } from 'zod';
-const ArgsSchema = {
-    type: z.enum(['project', 'section', 'task']).describe('The type of entity to delete.'),
-    id: z.string().min(1).describe('The ID of the entity to delete.'),
-};
-const deleteOne = {
-    name: 'delete-one',
-    description: 'Delete a project, section, or task by its ID.',
-    parameters: ArgsSchema,
-    async execute(args, client) {
-        switch (args.type) {
-            case 'project':
-                await client.deleteProject(args.id);
-                break;
-            case 'section':
-                await client.deleteSection(args.id);
-                break;
-            case 'task':
-                await client.deleteTask(args.id);
-                break;
-        }
-        return { success: true };
-    },
-};
-export { deleteOne };