@doist/todoist-ai 3.0.0 → 4.1.0

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

@@ -0,0 +1,242 @@
+import { jest } from '@jest/globals';
+import { extractStructuredContent, extractTextContent } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { findComments } from '../find-comments.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    getComment: jest.fn(),
+    getComments: jest.fn(),
+};
+const { FIND_COMMENTS } = ToolNames;
+const createMockComment = (overrides = {}) => ({
+    id: '12345',
+    content: 'Test comment content',
+    postedAt: '2024-01-01T12:00:00Z',
+    postedUid: 'user123',
+    taskId: 'task123',
+    projectId: undefined,
+    fileAttachment: null,
+    uidsToNotify: null,
+    reactions: null,
+    isDeleted: false,
+    ...overrides,
+});
+describe(`${FIND_COMMENTS} tool`, () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('finding comments by task', () => {
+        it('should find comments for a task', async () => {
+            const mockComments = [
+                createMockComment({ id: '1', content: 'First comment', taskId: 'task123' }),
+                createMockComment({ id: '2', content: 'Second comment', taskId: 'task123' }),
+            ];
+            mockTodoistApi.getComments.mockResolvedValue({
+                results: mockComments,
+                nextCursor: null,
+            });
+            const result = await findComments.execute({
+                taskId: 'task123',
+            }, mockTodoistApi);
+            expect(mockTodoistApi.getComments).toHaveBeenCalledWith({
+                taskId: 'task123',
+                cursor: null,
+                limit: 10,
+            });
+            // Verify result is a concise summary
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                comments: expect.arrayContaining([
+                    expect.objectContaining({ id: '1', content: 'First comment' }),
+                    expect.objectContaining({ id: '2', content: 'Second comment' }),
+                ]),
+                searchType: 'task',
+                searchId: 'task123',
+                hasMore: false,
+                nextCursor: null,
+                totalCount: 2,
+            }));
+        });
+        it('should handle pagination', async () => {
+            const mockComments = [createMockComment({ id: '1', content: 'Comment 1' })];
+            mockTodoistApi.getComments.mockResolvedValue({
+                results: mockComments,
+                nextCursor: 'next_page_token',
+            });
+            const result = await findComments.execute({
+                taskId: 'task123',
+                limit: 1,
+                cursor: 'current_cursor',
+            }, mockTodoistApi);
+            expect(mockTodoistApi.getComments).toHaveBeenCalledWith({
+                taskId: 'task123',
+                cursor: 'current_cursor',
+                limit: 1,
+            });
+            // Verify result includes pagination info
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content includes pagination
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                comments: expect.arrayContaining([
+                    expect.objectContaining({ id: '1', content: 'Comment 1' }),
+                ]),
+                searchType: 'task',
+                searchId: 'task123',
+                hasMore: true,
+                nextCursor: 'next_page_token',
+                totalCount: 1,
+            }));
+        });
+    });
+    describe('finding comments by project', () => {
+        it('should find comments for a project', async () => {
+            const mockComments = [
+                createMockComment({
+                    id: '1',
+                    content: 'Project comment',
+                    taskId: undefined,
+                    projectId: 'project456',
+                }),
+            ];
+            mockTodoistApi.getComments.mockResolvedValue({
+                results: mockComments,
+                nextCursor: null,
+            });
+            const result = await findComments.execute({
+                projectId: 'project456',
+            }, mockTodoistApi);
+            expect(mockTodoistApi.getComments).toHaveBeenCalledWith({
+                projectId: 'project456',
+                cursor: null,
+                limit: 10,
+            });
+            // Verify result is a concise summary
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                comments: expect.arrayContaining([
+                    expect.objectContaining({
+                        id: '1',
+                        content: 'Project comment',
+                        projectId: 'project456',
+                    }),
+                ]),
+                searchType: 'project',
+                searchId: 'project456',
+                hasMore: false,
+                nextCursor: null,
+                totalCount: 1,
+            }));
+        });
+    });
+    describe('finding single comment', () => {
+        it('should find comment by ID', async () => {
+            const mockComment = createMockComment({
+                id: 'comment789',
+                content: 'Single comment content',
+                taskId: 'task123',
+            });
+            mockTodoistApi.getComment.mockResolvedValue(mockComment);
+            const result = await findComments.execute({
+                commentId: 'comment789',
+            }, mockTodoistApi);
+            expect(mockTodoistApi.getComment).toHaveBeenCalledWith('comment789');
+            // Verify result is a concise summary
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                comments: expect.arrayContaining([
+                    expect.objectContaining({
+                        id: 'comment789',
+                        content: 'Single comment content',
+                        taskId: 'task123',
+                        fileAttachment: null,
+                    }),
+                ]),
+                searchType: 'single',
+                searchId: 'comment789',
+                hasMore: false,
+                nextCursor: null,
+                totalCount: 1,
+            }));
+        });
+        it('should handle comment with attachment', async () => {
+            const mockComment = createMockComment({
+                id: 'comment789',
+                content: 'Comment with file',
+                fileAttachment: {
+                    resourceType: 'file',
+                    fileName: 'document.pdf',
+                    fileUrl: 'https://example.com/document.pdf',
+                    fileType: 'application/pdf',
+                },
+            });
+            mockTodoistApi.getComment.mockResolvedValue(mockComment);
+            const result = await findComments.execute({
+                commentId: 'comment789',
+            }, mockTodoistApi);
+            // Verify result includes attachment info
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content includes attachment
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                comments: expect.arrayContaining([
+                    expect.objectContaining({
+                        id: 'comment789',
+                        content: 'Comment with file',
+                        fileAttachment: expect.objectContaining({
+                            resourceType: 'file',
+                            fileName: 'document.pdf',
+                            fileUrl: 'https://example.com/document.pdf',
+                            fileType: 'application/pdf',
+                        }),
+                    }),
+                ]),
+                searchType: 'single',
+                searchId: 'comment789',
+                hasMore: false,
+                nextCursor: null,
+                totalCount: 1,
+            }));
+        });
+    });
+    describe('validation', () => {
+        it('should throw error when no search parameter provided', async () => {
+            await expect(findComments.execute({}, mockTodoistApi)).rejects.toThrow('Must provide exactly one of: taskId, projectId, or commentId.');
+        });
+        it('should throw error when multiple search parameters provided', async () => {
+            await expect(findComments.execute({
+                taskId: 'task123',
+                projectId: 'project456',
+            }, mockTodoistApi)).rejects.toThrow('Cannot provide multiple search parameters.');
+        });
+    });
+    describe('empty results', () => {
+        it('should handle no comments found', async () => {
+            mockTodoistApi.getComments.mockResolvedValue({
+                results: [],
+                nextCursor: null,
+            });
+            const result = await findComments.execute({
+                taskId: 'task123',
+            }, mockTodoistApi);
+            // Verify result handles empty case
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                comments: [],
+                searchType: 'task',
+                searchId: 'task123',
+                hasMore: false,
+                nextCursor: null,
+                totalCount: 0,
+            }));
+        });
+    });
+});

package/dist/tools/__tests__/find-sections.test.js

@@ -6,7 +6,7 @@ import { findSections } from '../find-sections.js';
 const mockTodoistApi = {
     getSections: jest.fn(),
 };
-const { FIND_SECTIONS, MANAGE_SECTIONS } = ToolNames;
+const { FIND_SECTIONS, ADD_SECTIONS } = ToolNames;
 describe(`${FIND_SECTIONS} tool`, () => {
     beforeEach(() => {
         jest.clearAllMocks();
@@ -74,7 +74,7 @@ describe(`${FIND_SECTIONS} tool`, () => {
             const textContent = extractTextContent(result);
             expect(textContent).toMatchSnapshot();
             expect(textContent).toContain('Project has no sections yet');
-            expect(textContent).toContain(`Use ${MANAGE_SECTIONS} to create sections`);
+            expect(textContent).toContain(`Use ${ADD_SECTIONS} to create sections`);
             // Verify structured content
             const structuredContent = extractStructuredContent(result);
             expect(structuredContent.sections).toHaveLength(0);

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