@doist/todoist-ai 2.2.2 → 4.0.0

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.d.ts

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

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

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

package/dist/tools/__tests__/{tasks-add-multiple.test.js → add-tasks.test.js}

@@ -1,11 +1,13 @@
 import { jest } from '@jest/globals';
-import { tasksAddMultiple } from '../tasks-add-multiple.js';
-import { createMockTask } from '../test-helpers.js';
+import { TODAY, createMockTask, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { addTasks } from '../add-tasks.js';
 // Mock the Todoist API
 const mockTodoistApi = {
     addTask: jest.fn(),
 };
-describe('tasks-add-multiple tool', () => {
+const { ADD_TASKS, GET_OVERVIEW } = ToolNames;
+describe(`${ADD_TASKS} tool`, () => {
     beforeEach(() => {
         jest.clearAllMocks();
     });
@@ -38,15 +40,15 @@ describe('tasks-add-multiple tool', () => {
             mockTodoistApi.addTask
                 .mockResolvedValueOnce(mockApiResponse1)
                 .mockResolvedValueOnce(mockApiResponse2);
-            const result = await tasksAddMultiple.execute({
-                projectId: '6cfCcrrCFg2xP94Q',
+            const result = await addTasks.execute({
                 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);
@@ -67,23 +69,18 @@ describe('tasks-add-multiple tool', () => {
                 sectionId: undefined,
                 parentId: undefined,
             });
-            // Verify result is properly mapped
-            expect(result).toEqual([
-                expect.objectContaining({
-                    id: '8485093748',
-                    content: 'First task content',
-                    description: '',
-                    labels: [],
-                }),
-                expect.objectContaining({
-                    id: '8485093749',
-                    content: 'Second task content',
-                    description: 'Task description',
-                    dueDate: '2025-08-15',
-                    priority: 2,
-                    labels: ['work', 'urgent'],
-                }),
-            ]);
+            // Verify result is a concise summary
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent.tasks).toHaveLength(2);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                totalCount: 2,
+                tasks: expect.arrayContaining([
+                    expect.objectContaining({ id: '8485093748' }),
+                    expect.objectContaining({ id: '8485093749' }),
+                ]),
+            }));
         });
         it('should handle tasks with section and parent IDs', async () => {
             const mockApiResponse = createMockTask({
@@ -97,15 +94,15 @@ describe('tasks-add-multiple tool', () => {
                 addedAt: '2025-08-13T22:09:58.123456Z',
             });
             mockTodoistApi.addTask.mockResolvedValue(mockApiResponse);
-            const result = await tasksAddMultiple.execute({
-                projectId: '6cfCcrrCFg2xP94Q',
-                sectionId: 'section-123',
-                parentId: 'parent-task-456',
+            const result = await addTasks.execute({
                 tasks: [
                     {
                         content: 'Subtask content',
                         description: 'Subtask description',
                         priority: 3,
+                        projectId: '6cfCcrrCFg2xP94Q',
+                        sectionId: 'section-123',
+                        parentId: 'parent-task-456',
                     },
                 ],
             }, mockTodoistApi);
@@ -117,17 +114,14 @@ describe('tasks-add-multiple tool', () => {
                 sectionId: 'section-123',
                 parentId: 'parent-task-456',
             });
-            expect(result).toEqual([
-                expect.objectContaining({
-                    id: '8485093750',
-                    content: 'Subtask content',
-                    description: 'Subtask description',
-                    priority: 3,
-                    sectionId: 'section-123',
-                    parentId: 'parent-task-456',
-                    labels: [],
-                }),
-            ]);
+            // Verify result is a concise summary
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                totalCount: 1,
+                tasks: expect.arrayContaining([expect.objectContaining({ id: '8485093750' })]),
+            }));
         });
         it('should add tasks with duration', async () => {
             const mockApiResponse1 = createMockTask({
@@ -147,16 +141,17 @@ describe('tasks-add-multiple tool', () => {
             mockTodoistApi.addTask
                 .mockResolvedValueOnce(mockApiResponse1)
                 .mockResolvedValueOnce(mockApiResponse2);
-            const result = await tasksAddMultiple.execute({
-                projectId: '6cfCcrrCFg2xP94Q',
+            const result = await addTasks.execute({
                 tasks: [
                     {
                         content: 'Task with 2 hour duration',
                         duration: '2h',
+                        projectId: '6cfCcrrCFg2xP94Q',
                     },
                     {
                         content: 'Task with 45 minute duration',
                         duration: '45m',
+                        projectId: '6cfCcrrCFg2xP94Q',
                     },
                 ],
             }, mockTodoistApi);
@@ -177,19 +172,18 @@ describe('tasks-add-multiple tool', () => {
                 duration: 45,
                 durationUnit: 'minute',
             });
-            // Verify result includes formatted duration
-            expect(result).toEqual([
-                expect.objectContaining({
-                    id: '8485093752',
-                    content: 'Task with 2 hour duration',
-                    duration: '2h',
-                }),
-                expect.objectContaining({
-                    id: '8485093753',
-                    content: 'Task with 45 minute duration',
-                    duration: '45m',
-                }),
-            ]);
+            // Verify result is a concise summary
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent.tasks).toHaveLength(2);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                totalCount: 2,
+                tasks: expect.arrayContaining([
+                    expect.objectContaining({ id: '8485093752' }),
+                    expect.objectContaining({ id: '8485093753' }),
+                ]),
+            }));
         });
         it('should handle various duration formats', async () => {
             const mockApiResponse = createMockTask({
@@ -209,14 +203,7 @@ describe('tasks-add-multiple tool', () => {
             ];
             for (const testCase of testCases) {
                 mockTodoistApi.addTask.mockClear();
-                await tasksAddMultiple.execute({
-                    tasks: [
-                        {
-                            content: 'Test task',
-                            duration: testCase.input,
-                        },
-                    ],
-                }, mockTodoistApi);
+                await addTasks.execute({ tasks: [{ content: 'Test task', duration: testCase.input }] }, mockTodoistApi);
                 expect(mockTodoistApi.addTask).toHaveBeenCalledWith(expect.objectContaining({
                     duration: testCase.expectedMinutes,
                     durationUnit: 'minute',
@@ -226,29 +213,15 @@ describe('tasks-add-multiple tool', () => {
     });
     describe('error handling', () => {
         it('should throw error for invalid duration format', async () => {
-            await expect(tasksAddMultiple.execute({
-                tasks: [
-                    {
-                        content: 'Task with invalid duration',
-                        duration: 'invalid',
-                    },
-                ],
-            }, mockTodoistApi)).rejects.toThrow('Task "Task with invalid duration": Invalid duration format "invalid"');
+            await expect(addTasks.execute({ tasks: [{ content: 'Task with invalid duration', duration: 'invalid' }] }, mockTodoistApi)).rejects.toThrow('Task "Task with invalid duration": Invalid duration format "invalid"');
         });
         it('should throw error for duration exceeding 24 hours', async () => {
-            await expect(tasksAddMultiple.execute({
-                tasks: [
-                    {
-                        content: 'Task with too long duration',
-                        duration: '25h',
-                    },
-                ],
-            }, mockTodoistApi)).rejects.toThrow('Task "Task with too long duration": Invalid duration format "25h": Duration cannot exceed 24 hours (1440 minutes)');
+            await expect(addTasks.execute({ tasks: [{ content: 'Task with too long duration', duration: '25h' }] }, mockTodoistApi)).rejects.toThrow('Task "Task with too long duration": Invalid duration format "25h": Duration cannot exceed 24 hours (1440 minutes)');
         });
         it('should propagate API errors', async () => {
             const apiError = new Error('API Error: Task content is required');
             mockTodoistApi.addTask.mockRejectedValue(apiError);
-            await expect(tasksAddMultiple.execute({ tasks: [{ content: '' }] }, mockTodoistApi)).rejects.toThrow(apiError.message);
+            await expect(addTasks.execute({ tasks: [{ content: '' }] }, mockTodoistApi)).rejects.toThrow(apiError.message);
         });
         it('should handle partial failures when adding multiple tasks', async () => {
             const mockApiResponse = createMockTask({
@@ -261,7 +234,7 @@ describe('tasks-add-multiple tool', () => {
             mockTodoistApi.addTask
                 .mockResolvedValueOnce(mockApiResponse)
                 .mockRejectedValueOnce(apiError);
-            await expect(tasksAddMultiple.execute({
+            await expect(addTasks.execute({
                 tasks: [
                     { content: 'First task content' },
                     { content: 'Second task content' },
@@ -271,4 +244,41 @@ describe('tasks-add-multiple tool', () => {
             expect(mockTodoistApi.addTask).toHaveBeenCalledTimes(2);
         });
     });
+    describe('next steps logic', () => {
+        it('should suggest find-tasks-by-date for today when hasToday is true', async () => {
+            const mockApiResponse = createMockTask({
+                id: '8485093755',
+                content: 'Task due today',
+                url: 'https://todoist.com/showTask?id=8485093755',
+                addedAt: '2025-08-13T22:09:56.123456Z',
+                due: {
+                    date: TODAY,
+                    isRecurring: false,
+                    lang: 'en',
+                    string: 'today',
+                    timezone: null,
+                },
+            });
+            mockTodoistApi.addTask.mockResolvedValue(mockApiResponse);
+            const result = await addTasks.execute({ tasks: [{ content: 'Task due today', dueString: 'today' }] }, mockTodoistApi);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain(`Use ${GET_OVERVIEW} to see your updated project organization`);
+        });
+        it('should suggest overview tool when no hasToday context', async () => {
+            const mockApiResponse = createMockTask({
+                id: '8485093756',
+                content: 'Regular task',
+                url: 'https://todoist.com/showTask?id=8485093756',
+                addedAt: '2025-08-13T22:09:56.123456Z',
+            });
+            mockTodoistApi.addTask.mockResolvedValue(mockApiResponse);
+            const result = await addTasks.execute({
+                tasks: [{ content: 'Regular task', projectId: '6cfCcrrCFg2xP94Q' }],
+            }, mockTodoistApi);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain(`Use ${GET_OVERVIEW} to see your updated project organization`);
+        });
+    });
 });

package/dist/tools/__tests__/complete-tasks.test.d.ts

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

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

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