@doist/todoist-ai 2.2.2 → 3.0.0

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

@@ -0,0 +1,334 @@
+import { jest } from '@jest/globals';
+import { getTasksByFilter } from '../../tool-helpers.js';
+import { TEST_ERRORS, TEST_IDS, TODAY, createMappedTask, createMockApiResponse, createMockTask, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { findTasks } from '../find-tasks.js';
+jest.mock('../../tool-helpers', () => {
+    const actual = jest.requireActual('../../tool-helpers');
+    return {
+        getTasksByFilter: jest.fn(),
+        mapTask: actual.mapTask,
+    };
+});
+const { FIND_TASKS, UPDATE_TASKS, FIND_COMPLETED_TASKS } = ToolNames;
+const mockGetTasksByFilter = getTasksByFilter;
+// Mock the Todoist API
+const mockTodoistApi = {
+    getTasks: jest.fn(),
+};
+describe(`${FIND_TASKS} tool`, () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('searching tasks', () => {
+        it('should search tasks and return results', async () => {
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'Task containing search term',
+                    description: 'Description with more details',
+                    labels: ['work'],
+                }),
+                createMappedTask({
+                    id: TEST_IDS.TASK_2,
+                    content: 'Another matching task',
+                    priority: 2,
+                    sectionId: TEST_IDS.SECTION_1,
+                }),
+            ];
+            const mockResponse = { tasks: mockTasks, nextCursor: 'cursor-for-next-page' };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasks.execute({
+                searchText: 'important meeting',
+                limit: 10,
+            }, mockTodoistApi);
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: 'search: important meeting',
+                cursor: undefined,
+                limit: 10,
+            });
+            // Verify result is a concise summary
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                tasks: expect.any(Array),
+                totalCount: 2,
+                hasMore: true,
+                nextCursor: 'cursor-for-next-page',
+                appliedFilters: {
+                    searchText: 'important meeting',
+                    limit: 10,
+                    cursor: undefined,
+                },
+            }));
+            expect(structuredContent).toEqual(expect.objectContaining({
+                tasks: expect.any(Array),
+            }));
+        });
+        it.each([
+            {
+                name: 'custom limit',
+                params: { searchText: 'project update', limit: 5 },
+                expectedQuery: 'search: project update',
+                expectedLimit: 5,
+                expectedCursor: undefined,
+            },
+            {
+                name: 'pagination cursor',
+                params: { searchText: 'follow up', limit: 20, cursor: 'cursor-from-first-page' },
+                expectedQuery: 'search: follow up',
+                expectedLimit: 20,
+                expectedCursor: 'cursor-from-first-page',
+            },
+        ])('should handle $name', async ({ params, expectedQuery, expectedLimit, expectedCursor }) => {
+            const mockTask = createMappedTask({ content: 'Test result' });
+            const mockResponse = { tasks: [mockTask], nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasks.execute(params, mockTodoistApi);
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: expectedQuery,
+                cursor: expectedCursor,
+                limit: expectedLimit,
+            });
+            // Verify result is a concise summary
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                tasks: expect.any(Array),
+                totalCount: 1,
+                hasMore: false,
+                nextCursor: null,
+                appliedFilters: expect.objectContaining({
+                    searchText: params.searchText,
+                    limit: expectedLimit,
+                }),
+            }));
+            expect(structuredContent).toEqual(expect.objectContaining({
+                tasks: expect.any(Array),
+            }));
+        });
+        it.each([
+            { searchText: '@work #urgent "exact phrase"', description: 'special characters' },
+            { searchText: 'nonexistent keyword', description: 'empty results' },
+        ])('should handle search with $description', async ({ searchText }) => {
+            const mockResponse = { tasks: [], nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasks.execute({ searchText, limit: 10 }, mockTodoistApi);
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: `search: ${searchText}`,
+                cursor: undefined,
+                limit: 10,
+            });
+            // Verify result is a concise summary
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content for empty results
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                tasks: [],
+                totalCount: 0,
+                hasMore: false,
+                nextCursor: null,
+                appliedFilters: expect.objectContaining({
+                    searchText: searchText,
+                }),
+            }));
+        });
+    });
+    describe('validation', () => {
+        it('should require at least one filter parameter', async () => {
+            await expect(findTasks.execute({ limit: 10 }, mockTodoistApi)).rejects.toThrow('At least one filter must be provided: searchText, projectId, sectionId, or parentId');
+        });
+    });
+    describe('container filtering', () => {
+        it.each([
+            {
+                name: 'project',
+                params: { projectId: TEST_IDS.PROJECT_TEST, limit: 10 },
+                expectedApiParam: { projectId: TEST_IDS.PROJECT_TEST },
+                tasks: [createMockTask({ content: 'Project task' })],
+            },
+            {
+                name: 'section',
+                params: { sectionId: TEST_IDS.SECTION_1, limit: 10 },
+                expectedApiParam: { sectionId: TEST_IDS.SECTION_1 },
+                tasks: [createMockTask({ content: 'Section task' })],
+            },
+            {
+                name: 'parent task',
+                params: { parentId: TEST_IDS.TASK_1, limit: 10 },
+                expectedApiParam: { parentId: TEST_IDS.TASK_1 },
+                tasks: [createMockTask({ content: 'Subtask' })],
+            },
+        ])('should find tasks in $name', async ({ params, expectedApiParam, tasks }) => {
+            mockTodoistApi.getTasks.mockResolvedValue(createMockApiResponse(tasks));
+            const result = await findTasks.execute(params, mockTodoistApi);
+            expect(mockTodoistApi.getTasks).toHaveBeenCalledWith({
+                limit: 10,
+                cursor: null,
+                ...expectedApiParam,
+            });
+            expect(extractTextContent(result)).toMatchSnapshot();
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                tasks: expect.any(Array),
+                totalCount: tasks.length,
+                hasMore: false,
+                appliedFilters: params,
+            }));
+        });
+        it('should handle combined search text and container filtering', async () => {
+            const tasks = [
+                createMockTask({
+                    id: '8485093749',
+                    content: 'relevant task',
+                    description: 'contains search term',
+                }),
+                createMockTask({
+                    id: '8485093750',
+                    content: 'other task',
+                    description: 'different content',
+                }),
+            ];
+            mockTodoistApi.getTasks.mockResolvedValue(createMockApiResponse(tasks));
+            const result = await findTasks.execute({
+                projectId: TEST_IDS.PROJECT_TEST,
+                searchText: 'relevant',
+                limit: 10,
+            }, mockTodoistApi);
+            expect(mockTodoistApi.getTasks).toHaveBeenCalledWith({
+                limit: 10,
+                cursor: null,
+                projectId: TEST_IDS.PROJECT_TEST,
+            });
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent.tasks).toHaveLength(1);
+            expect(structuredContent.tasks).toEqual([
+                expect.objectContaining({ content: 'relevant task' }),
+            ]);
+        });
+        it('should handle empty containers', async () => {
+            mockTodoistApi.getTasks.mockResolvedValue(createMockApiResponse([]));
+            const result = await findTasks.execute({
+                sectionId: 'empty-section',
+                limit: 10,
+            }, mockTodoistApi);
+            const textContent = extractTextContent(result);
+            expect(textContent).toContain('Section is empty');
+            expect(textContent).toContain('Tasks may be in other sections of the project');
+        });
+        it('should handle pagination with containers', async () => {
+            mockTodoistApi.getTasks.mockResolvedValue({
+                results: [],
+                nextCursor: 'next-cursor',
+            });
+            const result = await findTasks.execute({
+                projectId: TEST_IDS.PROJECT_TEST,
+                limit: 25,
+                cursor: 'current-cursor',
+            }, mockTodoistApi);
+            expect(mockTodoistApi.getTasks).toHaveBeenCalledWith({
+                limit: 25,
+                cursor: 'current-cursor',
+                projectId: TEST_IDS.PROJECT_TEST,
+            });
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent.hasMore).toBe(true);
+            expect(structuredContent.nextCursor).toBe('next-cursor');
+        });
+    });
+    describe('container error handling', () => {
+        it('should propagate API errors for container queries', async () => {
+            const apiError = new Error('API Error: Project not found');
+            mockTodoistApi.getTasks.mockRejectedValue(apiError);
+            await expect(findTasks.execute({ projectId: 'non-existent', limit: 10 }, mockTodoistApi)).rejects.toThrow('API Error: Project not found');
+        });
+    });
+    describe('next steps logic', () => {
+        it('should suggest different actions when hasOverdue is true', async () => {
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'Overdue search result',
+                    dueDate: '2025-08-10', // Past date
+                }),
+            ];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasks.execute({ searchText: 'overdue tasks', limit: 10 }, mockTodoistApi);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            // Should prioritize overdue tasks in next steps
+            expect(textContent).toContain(`Use ${UPDATE_TASKS} to modify priorities or due dates`);
+        });
+        it('should suggest today tasks when hasToday is true', async () => {
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'Task due today',
+                    dueDate: TODAY,
+                }),
+            ];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasks.execute({ searchText: 'today tasks', limit: 10 }, mockTodoistApi);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            // Should suggest today-focused actions
+            expect(textContent).toContain(`Use ${UPDATE_TASKS} to modify priorities or due dates`);
+        });
+        it('should provide different next steps for regular tasks', async () => {
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'Regular future task',
+                    dueDate: '2025-08-25', // Future date
+                }),
+            ];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasks.execute({ searchText: 'future tasks', limit: 10 }, mockTodoistApi);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain(`Use ${UPDATE_TASKS} to modify priorities or due dates`);
+        });
+        it('should provide helpful suggestions for empty search results', async () => {
+            const mockResponse = { tasks: [], nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasks.execute({ searchText: 'nonexistent', limit: 10 }, mockTodoistApi);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Try broader search terms');
+            expect(textContent).toContain(`Check completed tasks with ${FIND_COMPLETED_TASKS}`);
+            expect(textContent).toContain('Verify spelling and try partial words');
+        });
+    });
+    describe('error handling', () => {
+        it.each([
+            {
+                error: 'At least one filter must be provided: searchText, projectId, sectionId, or parentId',
+                params: { limit: 10 },
+                expectValidation: true,
+            },
+            {
+                error: TEST_ERRORS.API_RATE_LIMIT,
+                params: { searchText: 'any search term', limit: 10 },
+                expectValidation: false,
+            },
+            {
+                error: TEST_ERRORS.INVALID_CURSOR,
+                params: { searchText: 'test', cursor: 'invalid-cursor-format', limit: 10 },
+                expectValidation: false,
+            },
+        ])('should propagate $error', async ({ error, params, expectValidation }) => {
+            if (!expectValidation) {
+                mockGetTasksByFilter.mockRejectedValue(new Error(error));
+            }
+            await expect(findTasks.execute(params, mockTodoistApi)).rejects.toThrow(error);
+        });
+    });
+});

package/dist/tools/__tests__/get-overview.test.d.ts

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

package/dist/tools/__tests__/get-overview.test.d.ts.map

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

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

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

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

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

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

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

package/dist/tools/__tests__/{projects-manage.test.js → manage-projects.test.js}

@@ -1,12 +1,14 @@
 import { jest } from '@jest/globals';
-import { projectsManage } from '../projects-manage.js';
-import { TEST_IDS, createMockProject } from '../test-helpers.js';
+import { TEST_IDS, createMockProject, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { manageProjects } from '../manage-projects.js';
 // Mock the Todoist API
 const mockTodoistApi = {
     addProject: jest.fn(),
     updateProject: jest.fn(),
 };
-describe('projects-manage tool', () => {
+const { ADD_TASKS, FIND_PROJECTS, MANAGE_PROJECTS, MANAGE_SECTIONS } = ToolNames;
+describe(`${MANAGE_PROJECTS} tool`, () => {
     beforeEach(() => {
         jest.clearAllMocks();
     });
@@ -19,22 +21,25 @@ describe('projects-manage tool', () => {
                 createdAt: '2024-01-01T00:00:00Z',
             });
             mockTodoistApi.addProject.mockResolvedValue(mockApiResponse);
-            const result = await projectsManage.execute({ name: 'test-abc123def456-project' }, mockTodoistApi);
+            const result = await manageProjects.execute({ name: 'test-abc123def456-project' }, mockTodoistApi);
             // Verify API was called correctly
             expect(mockTodoistApi.addProject).toHaveBeenCalledWith({
                 name: 'test-abc123def456-project',
             });
-            // Verify result is properly mapped
-            expect(result).toEqual({
-                id: TEST_IDS.PROJECT_TEST,
-                name: 'test-abc123def456-project',
-                color: 'charcoal',
-                isFavorite: false,
-                isShared: false,
-                parentId: null,
-                inboxProject: false,
-                viewStyle: 'list',
-            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Created project: 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({
+                project: expect.objectContaining({
+                    id: TEST_IDS.PROJECT_TEST,
+                    name: 'test-abc123def456-project',
+                }),
+                operation: 'created',
+            }));
         });
         it('should handle different project properties from API', async () => {
             const mockApiResponse = createMockProject({
@@ -50,18 +55,13 @@ describe('projects-manage tool', () => {
                 createdAt: '2024-01-01T00:00:00Z',
             });
             mockTodoistApi.addProject.mockResolvedValue(mockApiResponse);
-            const result = await projectsManage.execute({ name: 'My Blue Project' }, mockTodoistApi);
+            const result = await manageProjects.execute({ name: 'My Blue Project' }, mockTodoistApi);
             expect(mockTodoistApi.addProject).toHaveBeenCalledWith({ name: 'My Blue Project' });
-            expect(result).toEqual({
-                id: 'project-456',
-                name: 'My Blue Project',
-                color: 'blue',
-                isFavorite: true,
-                isShared: true,
-                parentId: 'parent-123',
-                inboxProject: false,
-                viewStyle: 'board',
-            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Created project: My Blue Project');
+            expect(textContent).toContain('id=project-456');
+            expect(textContent).toContain(`Use ${MANAGE_SECTIONS} to organize this project`);
         });
     });
     describe('updating an existing project', () => {
@@ -88,19 +88,22 @@ describe('projects-manage tool', () => {
                 defaultOrder: 0,
             };
             mockTodoistApi.updateProject.mockResolvedValue(mockApiResponse);
-            const result = await projectsManage.execute({ id: 'existing-project-123', name: 'Updated Project Name' }, mockTodoistApi);
+            const result = await manageProjects.execute({ id: 'existing-project-123', name: 'Updated Project Name' }, mockTodoistApi);
             expect(mockTodoistApi.updateProject).toHaveBeenCalledWith('existing-project-123', {
                 name: 'Updated Project Name',
             });
-            // Update returns raw project (not mapped) - this is the actual behavior
-            expect(result).toEqual(mockApiResponse);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Updated project: Updated Project Name');
+            expect(textContent).toContain('id=existing-project-123');
+            expect(textContent).toContain(`Use ${FIND_PROJECTS} to see all projects`);
         });
     });
     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(projectsManage.execute({ name: '' }, mockTodoistApi)).rejects.toThrow('API Error: Project name is required');
+            await expect(manageProjects.execute({ name: '' }, mockTodoistApi)).rejects.toThrow('API Error: Project name is required');
         });
     });
 });

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

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

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

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