@doist/todoist-ai 4.16.0 → 4.17.0

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

@@ -1,294 +0,0 @@
-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',
-                }),
-            ],
-            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',
-                }),
-            ],
-            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

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

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

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

@@ -1,217 +0,0 @@
-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: expect.arrayContaining([
-                    expect.objectContaining({
-                        id: 'existing-project-123',
-                        name: 'Updated Project Name',
-                    }),
-                ]),
-                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: expect.arrayContaining([
-                    expect.objectContaining({ id: 'project-1', name: 'Updated First Project' }),
-                    expect.objectContaining({
-                        id: 'project-2',
-                        name: 'Updated Second Project',
-                    }),
-                    expect.objectContaining({ id: 'project-3', name: 'Updated Third Project' }),
-                ]),
-                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

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

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

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