@doist/todoist-ai 3.0.0 → 4.1.0

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

@@ -0,0 +1,241 @@
+import { jest } from '@jest/globals';
+import { extractStructuredContent, extractTextContent } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { addComments } from '../add-comments.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    addComment: jest.fn(),
+};
+const { ADD_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(`${ADD_COMMENTS} tool`, () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('adding comments to tasks', () => {
+        it('should add comment to task', async () => {
+            const mockComment = createMockComment({
+                id: '98765',
+                content: 'This is a task comment',
+                taskId: 'task456',
+            });
+            mockTodoistApi.addComment.mockResolvedValue(mockComment);
+            const result = await addComments.execute({ comments: [{ taskId: 'task456', content: 'This is a task comment' }] }, mockTodoistApi);
+            expect(mockTodoistApi.addComment).toHaveBeenCalledWith({
+                content: 'This is a task comment',
+                taskId: 'task456',
+            });
+            // 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: 'This is a task comment',
+                        taskId: 'task456',
+                    }),
+                ],
+                totalCount: 1,
+                addedCommentIds: ['98765'],
+            }));
+        });
+    });
+    describe('adding comments to projects', () => {
+        it('should add comment to project', async () => {
+            const mockComment = createMockComment({
+                id: '98767',
+                content: 'This is a project comment',
+                taskId: undefined,
+                projectId: 'project789',
+            });
+            mockTodoistApi.addComment.mockResolvedValue(mockComment);
+            const result = await addComments.execute({ comments: [{ projectId: 'project789', content: 'This is a project comment' }] }, mockTodoistApi);
+            expect(mockTodoistApi.addComment).toHaveBeenCalledWith({
+                content: 'This is a project comment',
+                projectId: 'project789',
+            });
+            // 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: 'This is a project comment',
+                        taskId: undefined,
+                        projectId: 'project789',
+                    }),
+                ],
+                totalCount: 1,
+                addedCommentIds: ['98767'],
+            }));
+        });
+    });
+    describe('bulk operations', () => {
+        it('should add multiple comments to different entities (task + project)', async () => {
+            const mockTaskComment = createMockComment({
+                id: '11111',
+                content: 'Task comment',
+                taskId: 'task123',
+                projectId: undefined,
+            });
+            const mockProjectComment = createMockComment({
+                id: '22222',
+                content: 'Project comment',
+                taskId: undefined,
+                projectId: 'project456',
+            });
+            mockTodoistApi.addComment
+                .mockResolvedValueOnce(mockTaskComment)
+                .mockResolvedValueOnce(mockProjectComment);
+            const result = await addComments.execute({
+                comments: [
+                    { taskId: 'task123', content: 'Task comment' },
+                    { projectId: 'project456', content: 'Project comment' },
+                ],
+            }, mockTodoistApi);
+            expect(mockTodoistApi.addComment).toHaveBeenCalledTimes(2);
+            expect(mockTodoistApi.addComment).toHaveBeenCalledWith({
+                content: 'Task comment',
+                taskId: 'task123',
+            });
+            expect(mockTodoistApi.addComment).toHaveBeenCalledWith({
+                content: 'Project comment',
+                projectId: 'project456',
+            });
+            // 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: 'Task comment',
+                        taskId: 'task123',
+                    }),
+                    expect.objectContaining({
+                        id: '22222',
+                        content: 'Project comment',
+                        projectId: 'project456',
+                    }),
+                ],
+                totalCount: 2,
+                addedCommentIds: ['11111', '22222'],
+            }));
+        });
+        it('should add multiple comments to different tasks', async () => {
+            const mockComment1 = createMockComment({
+                id: '33333',
+                content: 'First task comment',
+                taskId: 'task111',
+            });
+            const mockComment2 = createMockComment({
+                id: '44444',
+                content: 'Second task comment',
+                taskId: 'task222',
+            });
+            mockTodoistApi.addComment
+                .mockResolvedValueOnce(mockComment1)
+                .mockResolvedValueOnce(mockComment2);
+            const result = await addComments.execute({
+                comments: [
+                    { taskId: 'task111', content: 'First task comment' },
+                    { taskId: 'task222', content: 'Second task comment' },
+                ],
+            }, mockTodoistApi);
+            expect(mockTodoistApi.addComment).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: 'First task comment',
+                        taskId: 'task111',
+                    }),
+                    expect.objectContaining({
+                        id: '44444',
+                        content: 'Second task comment',
+                        taskId: 'task222',
+                    }),
+                ]),
+                totalCount: 2,
+                addedCommentIds: ['33333', '44444'],
+            }));
+        });
+        it('should add multiple comments to the same task', async () => {
+            const mockComment1 = createMockComment({
+                id: '55555',
+                content: 'First comment on same task',
+                taskId: 'task999',
+            });
+            const mockComment2 = createMockComment({
+                id: '66666',
+                content: 'Second comment on same task',
+                taskId: 'task999',
+            });
+            mockTodoistApi.addComment
+                .mockResolvedValueOnce(mockComment1)
+                .mockResolvedValueOnce(mockComment2);
+            const result = await addComments.execute({
+                comments: [
+                    { taskId: 'task999', content: 'First comment on same task' },
+                    { taskId: 'task999', content: 'Second comment on same task' },
+                ],
+            }, mockTodoistApi);
+            expect(mockTodoistApi.addComment).toHaveBeenCalledTimes(2);
+            expect(mockTodoistApi.addComment).toHaveBeenCalledWith({
+                content: 'First comment on same task',
+                taskId: 'task999',
+            });
+            expect(mockTodoistApi.addComment).toHaveBeenCalledWith({
+                content: 'Second comment on same task',
+                taskId: 'task999',
+            });
+            // 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: 'First comment on same task',
+                        taskId: 'task999',
+                    }),
+                    expect.objectContaining({
+                        id: '66666',
+                        content: 'Second comment on same task',
+                        taskId: 'task999',
+                    }),
+                ]),
+                totalCount: 2,
+                addedCommentIds: ['55555', '66666'],
+            }));
+        });
+    });
+    describe('validation', () => {
+        it('should throw error when neither taskId nor projectId provided', async () => {
+            await expect(addComments.execute({ comments: [{ content: 'Test comment' }] }, mockTodoistApi)).rejects.toThrow('Comment 1: Either taskId or projectId must be provided.');
+        });
+        it('should throw error when both taskId and projectId provided', async () => {
+            const comment = { taskId: 'task123', projectId: 'project456', content: 'Test comment' };
+            await expect(addComments.execute({ comments: [comment] }, mockTodoistApi)).rejects.toThrow('Comment 1: Cannot provide both taskId and projectId. Choose one.');
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,152 @@
+import { jest } from '@jest/globals';
+import { TEST_IDS, createMockProject, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { addProjects } from '../add-projects.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    addProject: jest.fn(),
+};
+const { ADD_TASKS, ADD_PROJECTS, ADD_SECTIONS } = ToolNames;
+describe(`${ADD_PROJECTS} tool`, () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('creating a single project', () => {
+        it('should create a project and return mapped result', async () => {
+            const mockApiResponse = createMockProject({
+                id: TEST_IDS.PROJECT_TEST,
+                name: 'test-abc123def456-project',
+                childOrder: 1,
+                createdAt: '2024-01-01T00:00:00Z',
+            });
+            mockTodoistApi.addProject.mockResolvedValue(mockApiResponse);
+            const result = await addProjects.execute({ projects: [{ name: 'test-abc123def456-project' }] }, mockTodoistApi);
+            // Verify API was called correctly
+            expect(mockTodoistApi.addProject).toHaveBeenCalledWith({
+                name: 'test-abc123def456-project',
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Added 1 project:');
+            expect(textContent).toContain('test-abc123def456-project');
+            expect(textContent).toContain(`id=${TEST_IDS.PROJECT_TEST}`);
+            expect(textContent).toContain(`Use ${ADD_TASKS} to add your first tasks`);
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                projects: [
+                    expect.objectContaining({
+                        id: TEST_IDS.PROJECT_TEST,
+                        name: 'test-abc123def456-project',
+                    }),
+                ],
+                totalCount: 1,
+            }));
+        });
+        it('should handle different project properties from API', async () => {
+            const mockApiResponse = createMockProject({
+                id: 'project-456',
+                name: 'My Blue Project',
+                color: 'blue',
+                isFavorite: true,
+                isShared: true,
+                parentId: 'parent-123',
+                viewStyle: 'board',
+                childOrder: 2,
+                description: 'A test project',
+                createdAt: '2024-01-01T00:00:00Z',
+            });
+            mockTodoistApi.addProject.mockResolvedValue(mockApiResponse);
+            const result = await addProjects.execute({ projects: [{ name: 'My Blue Project' }] }, mockTodoistApi);
+            expect(mockTodoistApi.addProject).toHaveBeenCalledWith({
+                name: 'My Blue Project',
+                isFavorite: undefined,
+                viewStyle: undefined,
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Added 1 project:');
+            expect(textContent).toContain('My Blue Project');
+            expect(textContent).toContain('id=project-456');
+            expect(textContent).toContain(`Use ${ADD_SECTIONS} to organize new project`);
+        });
+        it('should create project with isFavorite and viewStyle options', async () => {
+            const mockApiResponse = createMockProject({
+                id: 'project-789',
+                name: 'Board Project',
+                isFavorite: true,
+                viewStyle: 'board',
+            });
+            mockTodoistApi.addProject.mockResolvedValue(mockApiResponse);
+            const result = await addProjects.execute({ projects: [{ name: 'Board Project', isFavorite: true, viewStyle: 'board' }] }, mockTodoistApi);
+            expect(mockTodoistApi.addProject).toHaveBeenCalledWith({
+                name: 'Board Project',
+                isFavorite: true,
+                viewStyle: 'board',
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Added 1 project:');
+            expect(textContent).toContain('Board Project');
+            expect(textContent).toContain('id=project-789');
+        });
+    });
+    describe('creating multiple projects', () => {
+        it('should create multiple projects and return mapped results', async () => {
+            const mockProjects = [
+                createMockProject({ id: 'project-1', name: 'First Project' }),
+                createMockProject({ id: 'project-2', name: 'Second Project' }),
+                createMockProject({ id: 'project-3', name: 'Third Project' }),
+            ];
+            const [project1, project2, project3] = mockProjects;
+            mockTodoistApi.addProject
+                .mockResolvedValueOnce(project1)
+                .mockResolvedValueOnce(project2)
+                .mockResolvedValueOnce(project3);
+            const result = await addProjects.execute({
+                projects: [
+                    { name: 'First Project' },
+                    { name: 'Second Project' },
+                    { name: 'Third Project' },
+                ],
+            }, mockTodoistApi);
+            // Verify API was called correctly for each project
+            expect(mockTodoistApi.addProject).toHaveBeenCalledTimes(3);
+            expect(mockTodoistApi.addProject).toHaveBeenNthCalledWith(1, { name: 'First Project' });
+            expect(mockTodoistApi.addProject).toHaveBeenNthCalledWith(2, { name: 'Second Project' });
+            expect(mockTodoistApi.addProject).toHaveBeenNthCalledWith(3, { name: 'Third Project' });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Added 3 projects:');
+            expect(textContent).toContain('First Project (id=project-1)');
+            expect(textContent).toContain('Second Project (id=project-2)');
+            expect(textContent).toContain('Third Project (id=project-3)');
+            expect(textContent).toContain(`Use ${ADD_SECTIONS} to organize these projects`);
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                projects: mockProjects,
+                totalCount: 3,
+            }));
+        });
+    });
+    describe('error handling', () => {
+        it('should propagate API errors', async () => {
+            const apiError = new Error('API Error: Project name is required');
+            mockTodoistApi.addProject.mockRejectedValue(apiError);
+            await expect(addProjects.execute({ projects: [{ name: '' }] }, mockTodoistApi)).rejects.toThrow('API Error: Project name is required');
+        });
+        it('should handle partial failures in multiple projects', async () => {
+            const mockProject = createMockProject({
+                id: 'project-1',
+                name: 'First Project',
+            });
+            mockTodoistApi.addProject
+                .mockResolvedValueOnce(mockProject)
+                .mockRejectedValueOnce(new Error('API Error: Invalid project name'));
+            await expect(addProjects.execute({
+                projects: [{ name: 'First Project' }, { name: 'Invalid' }],
+            }, mockTodoistApi)).rejects.toThrow('API Error: Invalid project name');
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,181 @@
+import { jest } from '@jest/globals';
+import { TEST_IDS, createMockSection, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { addSections } from '../add-sections.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    addSection: jest.fn(),
+};
+const { ADD_TASKS, ADD_SECTIONS, FIND_TASKS } = ToolNames;
+describe(`${ADD_SECTIONS} tool`, () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('creating a single section', () => {
+        it('should create a section and return mapped result', async () => {
+            const mockApiResponse = createMockSection({
+                id: TEST_IDS.SECTION_1,
+                projectId: TEST_IDS.PROJECT_TEST,
+                name: 'test-abc123def456-section',
+            });
+            mockTodoistApi.addSection.mockResolvedValue(mockApiResponse);
+            const result = await addSections.execute({
+                sections: [
+                    { name: 'test-abc123def456-section', projectId: TEST_IDS.PROJECT_TEST },
+                ],
+            }, mockTodoistApi);
+            // Verify API was called correctly
+            expect(mockTodoistApi.addSection).toHaveBeenCalledWith({
+                name: 'test-abc123def456-section',
+                projectId: TEST_IDS.PROJECT_TEST,
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Added 1 section:');
+            expect(textContent).toContain('test-abc123def456-section');
+            expect(textContent).toContain(`id=${TEST_IDS.SECTION_1}`);
+            expect(textContent).toContain(`Use ${ADD_TASKS} with sectionId`);
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                sections: [
+                    expect.objectContaining({
+                        id: TEST_IDS.SECTION_1,
+                        name: 'test-abc123def456-section',
+                    }),
+                ],
+                totalCount: 1,
+            }));
+        });
+        it('should handle different section properties from API', async () => {
+            const mockApiResponse = createMockSection({
+                id: TEST_IDS.SECTION_2,
+                projectId: 'project-789',
+                sectionOrder: 2,
+                name: 'My Section Name',
+            });
+            mockTodoistApi.addSection.mockResolvedValue(mockApiResponse);
+            const result = await addSections.execute({ sections: [{ name: 'My Section Name', projectId: 'project-789' }] }, mockTodoistApi);
+            expect(mockTodoistApi.addSection).toHaveBeenCalledWith({
+                name: 'My Section Name',
+                projectId: 'project-789',
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Added 1 section:');
+            expect(textContent).toContain('My Section Name');
+            expect(textContent).toContain(`id=${TEST_IDS.SECTION_2}`);
+            expect(textContent).toContain(`Use ${FIND_TASKS} with sectionId`);
+        });
+    });
+    describe('creating multiple sections', () => {
+        it('should create multiple sections and return mapped results', async () => {
+            const mockSections = [
+                createMockSection({
+                    id: 'section-1',
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    name: 'First Section',
+                }),
+                createMockSection({
+                    id: 'section-2',
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    name: 'Second Section',
+                }),
+                createMockSection({
+                    id: 'section-3',
+                    projectId: 'different-project',
+                    name: 'Third Section',
+                }),
+            ];
+            const [section1, section2, section3] = mockSections;
+            mockTodoistApi.addSection
+                .mockResolvedValueOnce(section1)
+                .mockResolvedValueOnce(section2)
+                .mockResolvedValueOnce(section3);
+            const result = await addSections.execute({
+                sections: [
+                    { name: 'First Section', projectId: TEST_IDS.PROJECT_TEST },
+                    { name: 'Second Section', projectId: TEST_IDS.PROJECT_TEST },
+                    { name: 'Third Section', projectId: 'different-project' },
+                ],
+            }, mockTodoistApi);
+            // Verify API was called correctly for each section
+            expect(mockTodoistApi.addSection).toHaveBeenCalledTimes(3);
+            expect(mockTodoistApi.addSection).toHaveBeenNthCalledWith(1, {
+                name: 'First Section',
+                projectId: TEST_IDS.PROJECT_TEST,
+            });
+            expect(mockTodoistApi.addSection).toHaveBeenNthCalledWith(2, {
+                name: 'Second Section',
+                projectId: TEST_IDS.PROJECT_TEST,
+            });
+            expect(mockTodoistApi.addSection).toHaveBeenNthCalledWith(3, {
+                name: 'Third Section',
+                projectId: 'different-project',
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Added 3 sections:');
+            expect(textContent).toContain('First Section (id=section-1, projectId=');
+            expect(textContent).toContain('Second Section (id=section-2, projectId=');
+            expect(textContent).toContain('Third Section (id=section-3, projectId=different-project)');
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                sections: mockSections,
+                totalCount: 3,
+            }));
+        });
+        it('should handle sections for the same project', async () => {
+            const mockSections = [
+                createMockSection({
+                    id: 'section-1',
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    name: 'To Do',
+                }),
+                createMockSection({
+                    id: 'section-2',
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    name: 'In Progress',
+                }),
+            ];
+            const [section1, section2] = mockSections;
+            mockTodoistApi.addSection
+                .mockResolvedValueOnce(section1)
+                .mockResolvedValueOnce(section2);
+            const result = await addSections.execute({
+                sections: [
+                    { name: 'To Do', projectId: TEST_IDS.PROJECT_TEST },
+                    { name: 'In Progress', projectId: TEST_IDS.PROJECT_TEST },
+                ],
+            }, mockTodoistApi);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Added 2 sections:');
+            expect(textContent).toContain(`Use ${ADD_TASKS} to add tasks to these new sections`);
+        });
+    });
+    describe('error handling', () => {
+        it('should propagate API errors', async () => {
+            const apiError = new Error('API Error: Section name is required');
+            mockTodoistApi.addSection.mockRejectedValue(apiError);
+            await expect(addSections.execute({ sections: [{ name: '', projectId: TEST_IDS.PROJECT_TEST }] }, mockTodoistApi)).rejects.toThrow('API Error: Section name is required');
+        });
+        it('should handle partial failures in multiple sections', async () => {
+            const mockSection = createMockSection({
+                id: 'section-1',
+                projectId: TEST_IDS.PROJECT_TEST,
+                name: 'First Section',
+            });
+            mockTodoistApi.addSection
+                .mockResolvedValueOnce(mockSection)
+                .mockRejectedValueOnce(new Error('API Error: Invalid project ID'));
+            await expect(addSections.execute({
+                sections: [
+                    { name: 'First Section', projectId: TEST_IDS.PROJECT_TEST },
+                    { name: 'Second Section', projectId: 'invalid-project' },
+                ],
+            }, mockTodoistApi)).rejects.toThrow('API Error: Invalid project ID');
+        });
+    });
+});

package/dist/tools/__tests__/add-tasks.test.js

@@ -41,14 +41,14 @@ describe(`${ADD_TASKS} tool`, () => {
                 .mockResolvedValueOnce(mockApiResponse1)
                 .mockResolvedValueOnce(mockApiResponse2);
             const result = await addTasks.execute({
-                projectId: '6cfCcrrCFg2xP94Q',
                 tasks: [
-                    { content: 'First task content' },
+                    { content: 'First task content', projectId: '6cfCcrrCFg2xP94Q' },
                     {
                         content: 'Second task content',
                         description: 'Task description',
                         priority: 2,
                         dueString: 'Aug 15',
+                        projectId: '6cfCcrrCFg2xP94Q',
                     },
                 ],
             }, mockTodoistApi);
@@ -95,14 +95,14 @@ describe(`${ADD_TASKS} tool`, () => {
             });
             mockTodoistApi.addTask.mockResolvedValue(mockApiResponse);
             const result = await addTasks.execute({
-                projectId: '6cfCcrrCFg2xP94Q',
-                sectionId: 'section-123',
-                parentId: 'parent-task-456',
                 tasks: [
                     {
                         content: 'Subtask content',
                         description: 'Subtask description',
                         priority: 3,
+                        projectId: '6cfCcrrCFg2xP94Q',
+                        sectionId: 'section-123',
+                        parentId: 'parent-task-456',
                     },
                 ],
             }, mockTodoistApi);
@@ -142,10 +142,17 @@ describe(`${ADD_TASKS} tool`, () => {
                 .mockResolvedValueOnce(mockApiResponse1)
                 .mockResolvedValueOnce(mockApiResponse2);
             const result = await addTasks.execute({
-                projectId: '6cfCcrrCFg2xP94Q',
                 tasks: [
-                    { content: 'Task with 2 hour duration', duration: '2h' },
-                    { content: 'Task with 45 minute duration', duration: '45m' },
+                    {
+                        content: 'Task with 2 hour duration',
+                        duration: '2h',
+                        projectId: '6cfCcrrCFg2xP94Q',
+                    },
+                    {
+                        content: 'Task with 45 minute duration',
+                        duration: '45m',
+                        projectId: '6cfCcrrCFg2xP94Q',
+                    },
                 ],
             }, mockTodoistApi);
             // Verify API was called with parsed duration
@@ -267,8 +274,7 @@ describe(`${ADD_TASKS} tool`, () => {
             });
             mockTodoistApi.addTask.mockResolvedValue(mockApiResponse);
             const result = await addTasks.execute({
-                projectId: '6cfCcrrCFg2xP94Q',
-                tasks: [{ content: 'Regular task' }],
+                tasks: [{ content: 'Regular task', projectId: '6cfCcrrCFg2xP94Q' }],
             }, mockTodoistApi);
             const textContent = extractTextContent(result);
             expect(textContent).toMatchSnapshot();

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

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

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

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