@doist/todoist-ai 2.0.0 → 2.0.1

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,161 @@
+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);
+        });
+    });
+    describe('error handling', () => {
+        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.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteOne = void 0;
-const zod_1 = require("zod");
+import { z } from 'zod';
 const ArgsSchema = {
-    type: zod_1.z.enum(['project', 'section', 'task']).describe('The type of entity to delete.'),
-    id: zod_1.z.string().min(1).describe('The ID of the entity to delete.'),
+    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',
@@ -25,4 +22,4 @@ const deleteOne = {
         return { success: true };
     },
 };
-exports.deleteOne = deleteOne;
+export { deleteOne };

package/dist/tools/overview.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.overview = void 0;
-const zod_1 = require("zod");
-const tool_helpers_1 = require("../tool-helpers");
+import { z } from 'zod';
+import { isPersonalProject, mapTask } from '../tool-helpers.js';
 const ArgsSchema = {
-    projectId: zod_1.z
+    projectId: z
         .string()
         .min(1)
         .optional()
@@ -25,7 +22,7 @@ function buildProjectTree(projects) {
         const current = byId[p.id];
         if (!current)
             continue;
-        if ((0, tool_helpers_1.isPersonalProject)(p) && p.parentId) {
+        if (isPersonalProject(p) && p.parentId) {
             const parent = byId[p.parentId];
             if (parent) {
                 parent.children.push(current);
@@ -113,7 +110,7 @@ async function getAllTasksForProject(client, projectId) {
             limit: 50,
             cursor: cursor ?? undefined,
         });
-        allTasks = allTasks.concat(results.map(tool_helpers_1.mapTask));
+        allTasks = allTasks.concat(results.map(mapTask));
         cursor = nextCursor ?? undefined;
     } while (cursor);
     return allTasks;
@@ -125,8 +122,8 @@ async function getProjectSections(client, projectId) {
 // Account overview implementation
 async function generateAccountOverview(client) {
     const { results: projects } = await client.getProjects({});
-    const inbox = projects.find((p) => (0, tool_helpers_1.isPersonalProject)(p) && p.inboxProject === true);
-    const nonInbox = projects.filter((p) => !(0, tool_helpers_1.isPersonalProject)(p) || p.inboxProject !== true);
+    const inbox = projects.find((p) => isPersonalProject(p) && p.inboxProject === true);
+    const nonInbox = projects.filter((p) => !isPersonalProject(p) || p.inboxProject !== true);
     const tree = buildProjectTree(nonInbox);
     const allProjectIds = projects.map((p) => p.id);
     const sectionsByProject = await getSectionsByProject(client, allProjectIds);
@@ -202,4 +199,4 @@ const overview = {
         return await generateAccountOverview(client);
     },
 };
-exports.overview = overview;
+export { overview };

package/dist/tools/projects-list.js

@@ -1,21 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectsList = void 0;
-const zod_1 = require("zod");
-const tool_helpers_1 = require("../tool-helpers");
+import { z } from 'zod';
+import { mapProject } from '../tool-helpers.js';
 const ArgsSchema = {
-    search: zod_1.z
+    search: z
         .string()
         .optional()
         .describe('Search for a project by name (partial and case insensitive match). If omitted, all projects are returned.'),
-    limit: zod_1.z
+    limit: z
         .number()
         .int()
         .min(1)
         .max(100)
         .default(50)
         .describe('The maximum number of projects to return.'),
-    cursor: zod_1.z
+    cursor: z
         .string()
         .optional()
         .describe('The cursor to get the next page of projects (cursor is obtained from the previous call to this tool, with the same parameters).'),
@@ -34,9 +31,9 @@ const projectsList = {
             ? results.filter((project) => project.name.toLowerCase().includes(searchLower))
             : results;
         return {
-            projects: filtered.map(tool_helpers_1.mapProject),
+            projects: filtered.map(mapProject),
             nextCursor,
         };
     },
 };
-exports.projectsList = projectsList;
+export { projectsList };

package/dist/tools/projects-manage.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectsManage = void 0;
-const zod_1 = require("zod");
-const tool_helpers_1 = require("../tool-helpers");
+import { z } from 'zod';
+import { mapProject } from '../tool-helpers.js';
 const ArgsSchema = {
-    id: zod_1.z
+    id: z
         .string()
         .min(1)
         .optional()
         .describe('The ID of the project to update. If provided, updates the project. If omitted, creates a new project.'),
-    name: zod_1.z.string().min(1).describe('The name of the project.'),
+    name: z.string().min(1).describe('The name of the project.'),
 };
 const projectsManage = {
     name: 'projects-manage',
@@ -23,7 +20,7 @@ const projectsManage = {
         }
         // Create new project
         const project = await client.addProject({ name: args.name });
-        return (0, tool_helpers_1.mapProject)(project);
+        return mapProject(project);
     },
 };
-exports.projectsManage = projectsManage;
+export { projectsManage };