@doist/todoist-ai 2.2.2 → 4.0.0

package/dist/tools/__tests__/{overview.test.js → get-overview.test.js}

@@ -1,6 +1,7 @@
 import { jest } from '@jest/globals';
-import { overview } from '../overview.js';
-import { TEST_ERRORS, TEST_IDS, createMockProject, createMockSection, createMockTask, } from '../test-helpers.js';
+import { TEST_ERRORS, TEST_IDS, createMockProject, createMockSection, createMockTask, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { getOverview } from '../get-overview.js';
 // Mock the Todoist API
 const mockTodoistApi = {
     getProjects: jest.fn(),
@@ -8,7 +9,8 @@ const mockTodoistApi = {
     getSections: jest.fn(),
     getTasks: jest.fn(),
 };
-describe('overview tool', () => {
+const { GET_OVERVIEW } = ToolNames;
+describe(`${GET_OVERVIEW} tool`, () => {
     beforeEach(() => {
         jest.clearAllMocks();
     });
@@ -45,15 +47,42 @@ describe('overview tool', () => {
                 }
                 return Promise.resolve({ results: [], nextCursor: null });
             });
-            const result = await overview.execute({}, mockTodoistApi);
+            const result = await getOverview.execute({}, mockTodoistApi);
             expect(mockTodoistApi.getProjects).toHaveBeenCalledWith({});
             expect(mockTodoistApi.getSections).toHaveBeenCalledTimes(2); // Once for each project
-            // Use snapshot testing for complex markdown output
-            expect(result).toMatchSnapshot();
+            // Test text content with snapshot
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Test structured content sanity checks
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                type: 'account_overview',
+                inbox: expect.objectContaining({
+                    id: TEST_IDS.PROJECT_INBOX,
+                    name: 'Inbox',
+                    sections: expect.any(Array),
+                }),
+                projects: expect.any(Array),
+                totalProjects: 2,
+                totalSections: 1,
+                hasNestedProjects: false,
+            }));
+            expect(structuredContent.projects).toHaveLength(1); // Only non-inbox projects
         });
         it('should handle empty projects list', async () => {
             mockTodoistApi.getProjects.mockResolvedValue({ results: [], nextCursor: null });
-            expect(await overview.execute({}, mockTodoistApi)).toMatchSnapshot();
+            const result = await getOverview.execute({}, mockTodoistApi);
+            // Test text content with snapshot
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Test structured content sanity checks
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                type: 'account_overview',
+                inbox: null,
+                projects: [],
+                totalProjects: 0,
+                totalSections: 0,
+                hasNestedProjects: false,
+            }));
         });
     });
     describe('project overview (with projectId)', () => {
@@ -114,7 +143,7 @@ describe('overview tool', () => {
                 results: mockTasks,
                 nextCursor: null,
             });
-            const result = await overview.execute({ projectId: TEST_IDS.PROJECT_TEST }, mockTodoistApi);
+            const result = await getOverview.execute({ projectId: TEST_IDS.PROJECT_TEST }, mockTodoistApi);
             expect(mockTodoistApi.getProject).toHaveBeenCalledWith(TEST_IDS.PROJECT_TEST);
             expect(mockTodoistApi.getSections).toHaveBeenCalledWith({
                 projectId: TEST_IDS.PROJECT_TEST,
@@ -124,8 +153,26 @@ describe('overview tool', () => {
                 limit: 50,
                 cursor: undefined,
             });
-            // Use snapshot testing for complex markdown output
-            expect(result).toMatchSnapshot();
+            // Test text content with snapshot
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Test structured content sanity checks
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                type: 'project_overview',
+                project: expect.objectContaining({
+                    id: TEST_IDS.PROJECT_TEST,
+                    name: 'test-abc123def456-project',
+                }),
+                sections: expect.any(Array),
+                tasks: expect.any(Array),
+                stats: expect.objectContaining({
+                    totalTasks: 3,
+                    totalSections: 2,
+                    tasksWithoutSection: 1,
+                }),
+            }));
+            expect(structuredContent.sections).toHaveLength(2);
+            expect(structuredContent.tasks).toHaveLength(3);
         });
         it('should handle project with no tasks', async () => {
             const mockProject = createMockProject({
@@ -136,8 +183,25 @@ describe('overview tool', () => {
             mockTodoistApi.getProject.mockResolvedValue(mockProject);
             mockTodoistApi.getSections.mockResolvedValue({ results: [], nextCursor: null });
             mockTodoistApi.getTasks.mockResolvedValue({ results: [], nextCursor: null });
-            const result = await overview.execute({ projectId: 'empty-project-id' }, mockTodoistApi);
-            expect(result).toMatchSnapshot();
+            const result = await getOverview.execute({ projectId: 'empty-project-id' }, mockTodoistApi);
+            // Test text content with snapshot
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Test structured content sanity checks
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                type: 'project_overview',
+                project: expect.objectContaining({
+                    id: 'empty-project-id',
+                    name: 'Empty Project',
+                }),
+                sections: [],
+                tasks: [],
+                stats: expect.objectContaining({
+                    totalTasks: 0,
+                    totalSections: 0,
+                    tasksWithoutSection: 0,
+                }),
+            }));
         });
     });
     describe('error handling', () => {
@@ -157,7 +221,7 @@ describe('overview tool', () => {
         ])('should propagate API errors for $scenario', async ({ error, params, mockMethod }) => {
             const apiError = new Error(error);
             mockTodoistApi[mockMethod].mockRejectedValue(apiError);
-            await expect(overview.execute(params, mockTodoistApi)).rejects.toThrow(error);
+            await expect(getOverview.execute(params, mockTodoistApi)).rejects.toThrow(error);
         });
     });
 });

package/dist/tools/__tests__/update-comments.test.d.ts

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

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

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

package/dist/tools/__tests__/update-comments.test.js

@@ -0,0 +1,296 @@
+import { jest } from '@jest/globals';
+import { extractStructuredContent, extractTextContent } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { updateComments } from '../update-comments.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    updateComment: jest.fn(),
+};
+const { UPDATE_COMMENTS } = ToolNames;
+const createMockComment = (overrides = {}) => ({
+    id: '12345',
+    content: 'Updated comment content',
+    postedAt: '2024-01-01T12:00:00Z',
+    postedUid: 'user123',
+    taskId: 'task123',
+    projectId: undefined,
+    fileAttachment: null,
+    uidsToNotify: null,
+    reactions: null,
+    isDeleted: false,
+    ...overrides,
+});
+describe(`${UPDATE_COMMENTS} tool`, () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should update comment content', async () => {
+        const mockComment = createMockComment({
+            id: '98765',
+            content: 'Updated content here',
+            taskId: 'task456',
+        });
+        mockTodoistApi.updateComment.mockResolvedValue(mockComment);
+        const result = await updateComments.execute({
+            comments: [
+                {
+                    id: '98765',
+                    content: 'Updated content here',
+                },
+            ],
+        }, mockTodoistApi);
+        expect(mockTodoistApi.updateComment).toHaveBeenCalledWith('98765', {
+            content: 'Updated content here',
+        });
+        // Verify result is a concise summary
+        expect(extractTextContent(result)).toMatchSnapshot();
+        // Verify structured content
+        const structuredContent = extractStructuredContent(result);
+        expect(structuredContent).toEqual(expect.objectContaining({
+            comments: [
+                expect.objectContaining({
+                    id: '98765',
+                    content: 'Updated content here',
+                    taskId: 'task456',
+                    fileAttachment: null,
+                }),
+            ],
+            totalCount: 1,
+            updatedCommentIds: ['98765'],
+            appliedOperations: {
+                updateCount: 1,
+            },
+        }));
+    });
+    it('should handle project comment', async () => {
+        const mockComment = createMockComment({
+            id: '98767',
+            content: 'Updated project comment',
+            taskId: undefined,
+            projectId: 'project789',
+        });
+        mockTodoistApi.updateComment.mockResolvedValue(mockComment);
+        const result = await updateComments.execute({
+            comments: [
+                {
+                    id: '98767',
+                    content: 'Updated project comment',
+                },
+            ],
+        }, mockTodoistApi);
+        // Verify result is a concise summary
+        expect(extractTextContent(result)).toMatchSnapshot();
+        // Verify structured content
+        const structuredContent = extractStructuredContent(result);
+        expect(structuredContent).toEqual(expect.objectContaining({
+            comments: [
+                expect.objectContaining({
+                    id: '98767',
+                    content: 'Updated project comment',
+                    taskId: undefined,
+                    projectId: 'project789',
+                    fileAttachment: null,
+                }),
+            ],
+            totalCount: 1,
+            updatedCommentIds: ['98767'],
+            appliedOperations: {
+                updateCount: 1,
+            },
+        }));
+    });
+    describe('bulk operations', () => {
+        it('should update multiple comments from different entities (task + project)', async () => {
+            const mockTaskComment = createMockComment({
+                id: '11111',
+                content: 'Updated task comment',
+                taskId: 'task123',
+                projectId: undefined,
+            });
+            const mockProjectComment = createMockComment({
+                id: '22222',
+                content: 'Updated project comment',
+                taskId: undefined,
+                projectId: 'project456',
+            });
+            mockTodoistApi.updateComment
+                .mockResolvedValueOnce(mockTaskComment)
+                .mockResolvedValueOnce(mockProjectComment);
+            const result = await updateComments.execute({
+                comments: [
+                    { id: '11111', content: 'Updated task comment' },
+                    { id: '22222', content: 'Updated project comment' },
+                ],
+            }, mockTodoistApi);
+            expect(mockTodoistApi.updateComment).toHaveBeenCalledTimes(2);
+            expect(mockTodoistApi.updateComment).toHaveBeenCalledWith('11111', {
+                content: 'Updated task comment',
+            });
+            expect(mockTodoistApi.updateComment).toHaveBeenCalledWith('22222', {
+                content: 'Updated project comment',
+            });
+            // Verify result is a concise summary
+            expect(extractTextContent(result)).toMatchSnapshot();
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                comments: [
+                    expect.objectContaining({
+                        id: '11111',
+                        content: 'Updated task comment',
+                        taskId: 'task123',
+                    }),
+                    expect.objectContaining({
+                        id: '22222',
+                        content: 'Updated project comment',
+                        projectId: 'project456',
+                    }),
+                ],
+                totalCount: 2,
+                updatedCommentIds: ['11111', '22222'],
+                appliedOperations: {
+                    updateCount: 2,
+                },
+            }));
+        });
+        it('should update multiple comments from different tasks', async () => {
+            const mockComment1 = createMockComment({
+                id: '33333',
+                content: 'Updated first task comment',
+                taskId: 'task111',
+            });
+            const mockComment2 = createMockComment({
+                id: '44444',
+                content: 'Updated second task comment',
+                taskId: 'task222',
+            });
+            mockTodoistApi.updateComment
+                .mockResolvedValueOnce(mockComment1)
+                .mockResolvedValueOnce(mockComment2);
+            const result = await updateComments.execute({
+                comments: [
+                    { id: '33333', content: 'Updated first task comment' },
+                    { id: '44444', content: 'Updated second task comment' },
+                ],
+            }, mockTodoistApi);
+            expect(mockTodoistApi.updateComment).toHaveBeenCalledTimes(2);
+            // Verify result is a concise summary
+            expect(extractTextContent(result)).toMatchSnapshot();
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                comments: expect.arrayContaining([
+                    expect.objectContaining({
+                        id: '33333',
+                        content: 'Updated first task comment',
+                        taskId: 'task111',
+                    }),
+                    expect.objectContaining({
+                        id: '44444',
+                        content: 'Updated second task comment',
+                        taskId: 'task222',
+                    }),
+                ]),
+                totalCount: 2,
+                updatedCommentIds: ['33333', '44444'],
+                appliedOperations: {
+                    updateCount: 2,
+                },
+            }));
+        });
+        it('should update multiple comments from the same task', async () => {
+            const mockComment1 = createMockComment({
+                id: '55555',
+                content: 'Updated first comment on same task',
+                taskId: 'task999',
+            });
+            const mockComment2 = createMockComment({
+                id: '66666',
+                content: 'Updated second comment on same task',
+                taskId: 'task999',
+            });
+            mockTodoistApi.updateComment
+                .mockResolvedValueOnce(mockComment1)
+                .mockResolvedValueOnce(mockComment2);
+            const result = await updateComments.execute({
+                comments: [
+                    { id: '55555', content: 'Updated first comment on same task' },
+                    { id: '66666', content: 'Updated second comment on same task' },
+                ],
+            }, mockTodoistApi);
+            expect(mockTodoistApi.updateComment).toHaveBeenCalledTimes(2);
+            expect(mockTodoistApi.updateComment).toHaveBeenCalledWith('55555', {
+                content: 'Updated first comment on same task',
+            });
+            expect(mockTodoistApi.updateComment).toHaveBeenCalledWith('66666', {
+                content: 'Updated second comment on same task',
+            });
+            // Verify result is a concise summary
+            expect(extractTextContent(result)).toMatchSnapshot();
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                comments: expect.arrayContaining([
+                    expect.objectContaining({
+                        id: '55555',
+                        content: 'Updated first comment on same task',
+                        taskId: 'task999',
+                    }),
+                    expect.objectContaining({
+                        id: '66666',
+                        content: 'Updated second comment on same task',
+                        taskId: 'task999',
+                    }),
+                ]),
+                totalCount: 2,
+                updatedCommentIds: ['55555', '66666'],
+                appliedOperations: {
+                    updateCount: 2,
+                },
+            }));
+        });
+        it('should update multiple comments from the same project', async () => {
+            const mockComment1 = createMockComment({
+                id: '77777',
+                content: 'Updated first project comment',
+                taskId: undefined,
+                projectId: 'project888',
+            });
+            const mockComment2 = createMockComment({
+                id: '88888',
+                content: 'Updated second project comment',
+                taskId: undefined,
+                projectId: 'project888',
+            });
+            mockTodoistApi.updateComment
+                .mockResolvedValueOnce(mockComment1)
+                .mockResolvedValueOnce(mockComment2);
+            const result = await updateComments.execute({
+                comments: [
+                    { id: '77777', content: 'Updated first project comment' },
+                    { id: '88888', content: 'Updated second project comment' },
+                ],
+            }, mockTodoistApi);
+            expect(mockTodoistApi.updateComment).toHaveBeenCalledTimes(2);
+            // Verify result is a concise summary
+            expect(extractTextContent(result)).toMatchSnapshot();
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                comments: expect.arrayContaining([
+                    expect.objectContaining({
+                        id: '77777',
+                        content: 'Updated first project comment',
+                        projectId: 'project888',
+                    }),
+                    expect.objectContaining({
+                        id: '88888',
+                        content: 'Updated second project comment',
+                        projectId: 'project888',
+                    }),
+                ]),
+                totalCount: 2,
+                updatedCommentIds: ['77777', '88888'],
+                appliedOperations: {
+                    updateCount: 2,
+                },
+            }));
+        });
+    });
+});

package/dist/tools/__tests__/update-projects.test.d.ts

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

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

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

package/dist/tools/__tests__/update-projects.test.js

@@ -0,0 +1,205 @@
+import { jest } from '@jest/globals';
+import { createMockProject, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { updateProjects } from '../update-projects.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    updateProject: jest.fn(),
+};
+const { FIND_PROJECTS, UPDATE_PROJECTS, GET_OVERVIEW } = ToolNames;
+describe(`${UPDATE_PROJECTS} tool`, () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('updating a single project', () => {
+        it('should update a project when id and name are provided', async () => {
+            const mockApiResponse = {
+                url: 'https://todoist.com/projects/existing-project-123',
+                id: 'existing-project-123',
+                parentId: null,
+                isDeleted: false,
+                updatedAt: '2025-08-13T22:10:30.000000Z',
+                childOrder: 1,
+                description: '',
+                isCollapsed: false,
+                canAssignTasks: false,
+                color: 'red',
+                isFavorite: false,
+                isFrozen: false,
+                name: 'Updated Project Name',
+                viewStyle: 'list',
+                isArchived: false,
+                inboxProject: false,
+                isShared: false,
+                createdAt: '2024-01-01T00:00:00Z',
+                defaultOrder: 0,
+            };
+            mockTodoistApi.updateProject.mockResolvedValue(mockApiResponse);
+            const result = await updateProjects.execute({ projects: [{ id: 'existing-project-123', name: 'Updated Project Name' }] }, mockTodoistApi);
+            expect(mockTodoistApi.updateProject).toHaveBeenCalledWith('existing-project-123', {
+                name: 'Updated Project Name',
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Updated 1 project:');
+            expect(textContent).toContain('Updated Project Name (id=existing-project-123)');
+            expect(textContent).toContain(`Use ${GET_OVERVIEW} with projectId=existing-project-123`);
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                projects: [mockApiResponse],
+                totalCount: 1,
+                updatedProjectIds: ['existing-project-123'],
+                appliedOperations: {
+                    updateCount: 1,
+                    skippedCount: 0,
+                },
+            }));
+        });
+        it('should update project with isFavorite and viewStyle options', async () => {
+            const mockApiResponse = {
+                url: 'https://todoist.com/projects/project-123',
+                id: 'project-123',
+                parentId: null,
+                isDeleted: false,
+                updatedAt: '2025-08-13T22:10:30.000000Z',
+                childOrder: 1,
+                description: '',
+                isCollapsed: false,
+                canAssignTasks: false,
+                color: 'red',
+                isFavorite: true,
+                isFrozen: false,
+                name: 'Updated Favorite Project',
+                viewStyle: 'board',
+                isArchived: false,
+                inboxProject: false,
+                isShared: false,
+                createdAt: '2024-01-01T00:00:00Z',
+                defaultOrder: 0,
+            };
+            mockTodoistApi.updateProject.mockResolvedValue(mockApiResponse);
+            const result = await updateProjects.execute({
+                projects: [
+                    {
+                        id: 'project-123',
+                        name: 'Updated Favorite Project',
+                        isFavorite: true,
+                        viewStyle: 'board',
+                    },
+                ],
+            }, mockTodoistApi);
+            expect(mockTodoistApi.updateProject).toHaveBeenCalledWith('project-123', {
+                name: 'Updated Favorite Project',
+                isFavorite: true,
+                viewStyle: 'board',
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Updated 1 project:');
+            expect(textContent).toContain('Updated Favorite Project (id=project-123)');
+        });
+    });
+    describe('updating multiple projects', () => {
+        it('should update multiple projects and return mapped results', async () => {
+            const mockProjects = [
+                createMockProject({ id: 'project-1', name: 'Updated First Project' }),
+                createMockProject({ id: 'project-2', name: 'Updated Second Project' }),
+                createMockProject({ id: 'project-3', name: 'Updated Third Project' }),
+            ];
+            const [project1, project2, project3] = mockProjects;
+            mockTodoistApi.updateProject
+                .mockResolvedValueOnce(project1)
+                .mockResolvedValueOnce(project2)
+                .mockResolvedValueOnce(project3);
+            const result = await updateProjects.execute({
+                projects: [
+                    { id: 'project-1', name: 'Updated First Project' },
+                    { id: 'project-2', name: 'Updated Second Project' },
+                    { id: 'project-3', name: 'Updated Third Project' },
+                ],
+            }, mockTodoistApi);
+            // Verify API was called correctly for each project
+            expect(mockTodoistApi.updateProject).toHaveBeenCalledTimes(3);
+            expect(mockTodoistApi.updateProject).toHaveBeenNthCalledWith(1, 'project-1', {
+                name: 'Updated First Project',
+            });
+            expect(mockTodoistApi.updateProject).toHaveBeenNthCalledWith(2, 'project-2', {
+                name: 'Updated Second Project',
+            });
+            expect(mockTodoistApi.updateProject).toHaveBeenNthCalledWith(3, 'project-3', {
+                name: 'Updated Third Project',
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Updated 3 projects:');
+            expect(textContent).toContain('Updated First Project (id=project-1)');
+            expect(textContent).toContain('Updated Second Project (id=project-2)');
+            expect(textContent).toContain('Updated Third Project (id=project-3)');
+            expect(textContent).toContain(`Use ${FIND_PROJECTS} to see all projects`);
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                projects: mockProjects,
+                totalCount: 3,
+                updatedProjectIds: ['project-1', 'project-2', 'project-3'],
+                appliedOperations: {
+                    updateCount: 3,
+                    skippedCount: 0,
+                },
+            }));
+        });
+        it('should skip projects with no updates and report correctly', async () => {
+            const mockProject = createMockProject({
+                id: 'project-1',
+                name: 'Updated Project',
+            });
+            mockTodoistApi.updateProject.mockResolvedValue(mockProject);
+            const result = await updateProjects.execute({
+                projects: [
+                    { id: 'project-1', name: 'Updated Project' },
+                    { id: 'project-2' }, // No name provided, should be skipped
+                ],
+            }, mockTodoistApi);
+            // Should only call API once for the project with actual updates
+            expect(mockTodoistApi.updateProject).toHaveBeenCalledTimes(1);
+            expect(mockTodoistApi.updateProject).toHaveBeenCalledWith('project-1', {
+                name: 'Updated Project',
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Updated 1 project (1 skipped - no changes):');
+            expect(textContent).toContain('Updated Project (id=project-1)');
+            // Verify structured content reflects skipped count
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                appliedOperations: {
+                    updateCount: 1,
+                    skippedCount: 1,
+                },
+            }));
+        });
+    });
+    describe('error handling', () => {
+        it('should propagate API errors', async () => {
+            const apiError = new Error('API Error: Project not found');
+            mockTodoistApi.updateProject.mockRejectedValue(apiError);
+            await expect(updateProjects.execute({ projects: [{ id: 'nonexistent', name: 'New Name' }] }, mockTodoistApi)).rejects.toThrow('API Error: Project not found');
+        });
+        it('should handle partial failures in multiple projects', async () => {
+            const mockProject = createMockProject({
+                id: 'project-1',
+                name: 'Updated Project',
+            });
+            mockTodoistApi.updateProject
+                .mockResolvedValueOnce(mockProject)
+                .mockRejectedValueOnce(new Error('API Error: Project not found'));
+            await expect(updateProjects.execute({
+                projects: [
+                    { id: 'project-1', name: 'Updated Project' },
+                    { id: 'nonexistent', name: 'New Name' },
+                ],
+            }, mockTodoistApi)).rejects.toThrow('API Error: Project not found');
+        });
+    });
+});

package/dist/tools/__tests__/update-sections.test.d.ts

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

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

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