@doist/todoist-ai 2.2.2 → 3.0.0

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

@@ -0,0 +1,206 @@
+import { jest } from '@jest/globals';
+import { extractTextContent } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { completeTasks } from '../complete-tasks.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    closeTask: jest.fn(),
+};
+const { COMPLETE_TASKS, GET_OVERVIEW } = ToolNames;
+describe(`${COMPLETE_TASKS} tool`, () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('completing multiple tasks', () => {
+        it('should complete all tasks successfully', async () => {
+            mockTodoistApi.closeTask.mockResolvedValue(true);
+            const result = await completeTasks.execute({ ids: ['task-1', 'task-2', 'task-3'] }, mockTodoistApi);
+            // Verify API was called for each task
+            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(3);
+            expect(mockTodoistApi.closeTask).toHaveBeenNthCalledWith(1, 'task-1');
+            expect(mockTodoistApi.closeTask).toHaveBeenNthCalledWith(2, 'task-2');
+            expect(mockTodoistApi.closeTask).toHaveBeenNthCalledWith(3, 'task-3');
+            // Verify result is a concise summary
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content
+            const { structuredContent } = result;
+            expect(structuredContent).toEqual(expect.objectContaining({
+                completed: ['task-1', 'task-2', 'task-3'],
+                failures: [],
+                totalRequested: 3,
+                successCount: 3,
+                failureCount: 0,
+            }));
+        });
+        it('should complete single task', async () => {
+            mockTodoistApi.closeTask.mockResolvedValue(true);
+            const result = await completeTasks.execute({ ids: ['8485093748'] }, mockTodoistApi);
+            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(1);
+            expect(mockTodoistApi.closeTask).toHaveBeenCalledWith('8485093748');
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content
+            const { structuredContent } = result;
+            expect(structuredContent).toEqual(expect.objectContaining({
+                completed: ['8485093748'],
+                failures: [],
+                totalRequested: 1,
+                successCount: 1,
+                failureCount: 0,
+            }));
+        });
+        it('should handle partial failures gracefully', async () => {
+            // Mock first and third tasks to succeed, second to fail
+            mockTodoistApi.closeTask
+                .mockResolvedValueOnce(true) // task-1 succeeds
+                .mockRejectedValueOnce(new Error('Task not found')) // task-2 fails
+                .mockResolvedValueOnce(true); // task-3 succeeds
+            const result = await completeTasks.execute({ ids: ['task-1', 'task-2', 'task-3'] }, mockTodoistApi);
+            // Verify API was called for all tasks despite failure
+            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(3);
+            expect(mockTodoistApi.closeTask).toHaveBeenNthCalledWith(1, 'task-1');
+            expect(mockTodoistApi.closeTask).toHaveBeenNthCalledWith(2, 'task-2');
+            expect(mockTodoistApi.closeTask).toHaveBeenNthCalledWith(3, 'task-3');
+            // Verify only successful completions are reported
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content with partial failures
+            const { structuredContent } = result;
+            expect(structuredContent).toEqual(expect.objectContaining({
+                completed: ['task-1', 'task-3'],
+                failures: [
+                    expect.objectContaining({
+                        item: 'task-2',
+                        error: 'Task not found',
+                    }),
+                ],
+                totalRequested: 3,
+                successCount: 2,
+                failureCount: 1,
+            }));
+        });
+        it('should handle all tasks failing', async () => {
+            const apiError = new Error('API Error: Network timeout');
+            mockTodoistApi.closeTask.mockRejectedValue(apiError);
+            const result = await completeTasks.execute({ ids: ['task-1', 'task-2'] }, mockTodoistApi);
+            // Verify API was attempted for all tasks
+            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(2);
+            // Verify no tasks were completed but still returns success
+            expect(extractTextContent(result)).toMatchSnapshot();
+        });
+        it('should continue processing remaining tasks after failures', async () => {
+            // Mock various failure scenarios
+            mockTodoistApi.closeTask
+                .mockRejectedValueOnce(new Error('Task already completed'))
+                .mockRejectedValueOnce(new Error('Task not found'))
+                .mockResolvedValueOnce(true) // task-3 succeeds
+                .mockRejectedValueOnce(new Error('Permission denied'))
+                .mockResolvedValueOnce(true); // task-5 succeeds
+            const result = await completeTasks.execute({ ids: ['task-1', 'task-2', 'task-3', 'task-4', 'task-5'] }, mockTodoistApi);
+            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(5);
+            // Only tasks 3 and 5 should be in completed list
+            expect(extractTextContent(result)).toMatchSnapshot();
+        });
+        it('should handle different types of API errors', async () => {
+            mockTodoistApi.closeTask
+                .mockRejectedValueOnce(new Error('Task not found'))
+                .mockRejectedValueOnce(new Error('Task already completed'))
+                .mockRejectedValueOnce(new Error('Permission denied'))
+                .mockRejectedValueOnce(new Error('Rate limit exceeded'));
+            const result = await completeTasks.execute({ ids: ['not-found', 'already-done', 'no-permission', 'rate-limited'] }, mockTodoistApi);
+            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(4);
+            // All should fail, but the tool should handle it gracefully
+            expect(extractTextContent(result)).toMatchSnapshot();
+        });
+    });
+    describe('mixed success and failure scenarios', () => {
+        it('should handle realistic mixed scenario', async () => {
+            // Simulate a realistic scenario with some tasks completing and others failing
+            mockTodoistApi.closeTask
+                .mockResolvedValueOnce(true) // regular task completion
+                .mockResolvedValueOnce(true) // another successful completion
+                .mockRejectedValueOnce(new Error('Task already completed')) // duplicate completion
+                .mockResolvedValueOnce(true) // successful completion
+                .mockRejectedValueOnce(new Error('Task not found')); // deleted task
+            const result = await completeTasks.execute({
+                ids: [
+                    '8485093748', // regular task
+                    '8485093749', // regular task
+                    '8485093750', // already completed
+                    '8485093751', // regular task
+                    '8485093752', // deleted task
+                ],
+            }, mockTodoistApi);
+            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(5);
+            expect(extractTextContent(result)).toMatchSnapshot();
+        });
+    });
+    describe('next steps logic validation', () => {
+        it('should suggest overdue tasks when all tasks complete successfully', async () => {
+            mockTodoistApi.closeTask.mockResolvedValue(true);
+            const result = await completeTasks.execute({ ids: ['task-1', 'task-2'] }, mockTodoistApi);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain("Use find-tasks-by-date('overdue')");
+        });
+        it('should suggest reviewing failures when mixed results', async () => {
+            mockTodoistApi.closeTask
+                .mockResolvedValueOnce(true)
+                .mockRejectedValueOnce(new Error('Task not found'));
+            const result = await completeTasks.execute({ ids: ['task-1', 'task-2'] }, mockTodoistApi);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Review failed completions and retry if needed');
+        });
+        it('should suggest checking IDs when all tasks fail', async () => {
+            mockTodoistApi.closeTask.mockRejectedValue(new Error('Task not found'));
+            const result = await completeTasks.execute({ ids: ['bad-id-1', 'bad-id-2'] }, mockTodoistApi);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Check task IDs and permissions, then retry');
+            expect(textContent).not.toContain(`Use ${GET_OVERVIEW} tool`); // Should only show retry message
+        });
+    });
+    describe('error message truncation', () => {
+        it('should truncate failure messages after 3 errors', async () => {
+            mockTodoistApi.closeTask
+                .mockRejectedValueOnce(new Error('Error 1'))
+                .mockRejectedValueOnce(new Error('Error 2'))
+                .mockRejectedValueOnce(new Error('Error 3'))
+                .mockRejectedValueOnce(new Error('Error 4'))
+                .mockRejectedValueOnce(new Error('Error 5'));
+            const result = await completeTasks.execute({ ids: ['task-1', 'task-2', 'task-3', 'task-4', 'task-5'] }, mockTodoistApi);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('+2 more'); // 5 total failures, showing first 3, so +2 more
+            expect(textContent).not.toContain('Error 4'); // Should not show 4th error
+            expect(textContent).not.toContain('Error 5'); // Should not show 5th error
+        });
+        it('should not show truncation message for exactly 3 errors', async () => {
+            mockTodoistApi.closeTask
+                .mockRejectedValueOnce(new Error('Error 1'))
+                .mockRejectedValueOnce(new Error('Error 2'))
+                .mockRejectedValueOnce(new Error('Error 3'));
+            const result = await completeTasks.execute({ ids: ['task-1', 'task-2', 'task-3'] }, mockTodoistApi);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).not.toContain('more'); // Should not show truncation
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle empty task completion (minimum one task required by schema)', async () => {
+            // Note: This test documents that the schema requires at least one task,
+            // so this scenario shouldn't occur in practice due to validation
+            mockTodoistApi.closeTask.mockResolvedValue(true);
+            const result = await completeTasks.execute({ ids: ['single-task'] }, mockTodoistApi);
+            expect(extractTextContent(result)).toMatchSnapshot();
+        });
+        it('should handle tasks with special ID formats', async () => {
+            mockTodoistApi.closeTask.mockResolvedValue(true);
+            const result = await completeTasks.execute({ ids: ['proj_123_task_456', 'task-with-dashes', '1234567890'] }, mockTodoistApi);
+            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(3);
+            expect(mockTodoistApi.closeTask).toHaveBeenCalledWith('proj_123_task_456');
+            expect(mockTodoistApi.closeTask).toHaveBeenCalledWith('task-with-dashes');
+            expect(mockTodoistApi.closeTask).toHaveBeenCalledWith('1234567890');
+            expect(extractTextContent(result)).toMatchSnapshot();
+        });
+    });
+});

package/dist/tools/__tests__/delete-object.test.d.ts

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

package/dist/tools/__tests__/delete-object.test.d.ts.map

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

package/dist/tools/__tests__/{delete-one.test.js → delete-object.test.js}

@@ -1,85 +1,105 @@
 import { jest } from '@jest/globals';
-import { deleteOne } from '../delete-one.js';
+import { extractTextContent } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { deleteObject } from '../delete-object.js';
 // Mock the Todoist API
 const mockTodoistApi = {
     deleteProject: jest.fn(),
     deleteSection: jest.fn(),
     deleteTask: jest.fn(),
 };
-describe('delete-one tool', () => {
+const { FIND_PROJECTS, FIND_TASKS_BY_DATE, DELETE_OBJECT } = ToolNames;
+describe(`${DELETE_OBJECT} tool`, () => {
     beforeEach(() => {
         jest.clearAllMocks();
     });
     describe('deleting projects', () => {
         it('should delete a project by ID', async () => {
             mockTodoistApi.deleteProject.mockResolvedValue(true);
-            const result = await deleteOne.execute({ type: 'project', id: '6cfCcrrCFg2xP94Q' }, mockTodoistApi);
-            // Verify API was called correctly
+            const result = await deleteObject.execute({ type: 'project', id: '6cfCcrrCFg2xP94Q' }, mockTodoistApi);
             expect(mockTodoistApi.deleteProject).toHaveBeenCalledWith('6cfCcrrCFg2xP94Q');
             expect(mockTodoistApi.deleteSection).not.toHaveBeenCalled();
             expect(mockTodoistApi.deleteTask).not.toHaveBeenCalled();
-            // Verify success response
-            expect(result).toEqual({ success: true });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Deleted project: id=6cfCcrrCFg2xP94Q');
+            expect(textContent).toContain(`Use ${FIND_PROJECTS} to see remaining projects`);
+            expect(result.structuredContent).toEqual({
+                deletedEntity: {
+                    type: 'project',
+                    id: '6cfCcrrCFg2xP94Q',
+                },
+                success: true,
+            });
         });
         it('should propagate project deletion errors', async () => {
             const apiError = new Error('API Error: Cannot delete project with tasks');
             mockTodoistApi.deleteProject.mockRejectedValue(apiError);
-            await expect(deleteOne.execute({ type: 'project', id: 'project-with-tasks' }, mockTodoistApi)).rejects.toThrow('API Error: Cannot delete project with tasks');
+            await expect(deleteObject.execute({ type: 'project', id: 'project-with-tasks' }, mockTodoistApi)).rejects.toThrow('API Error: Cannot delete project with tasks');
         });
     });
     describe('deleting sections', () => {
         it('should delete a section by ID', async () => {
             mockTodoistApi.deleteSection.mockResolvedValue(true);
-            const result = await deleteOne.execute({ type: 'section', id: 'section-123' }, mockTodoistApi);
-            // Verify API was called correctly
+            const result = await deleteObject.execute({ type: 'section', id: 'section-123' }, mockTodoistApi);
             expect(mockTodoistApi.deleteSection).toHaveBeenCalledWith('section-123');
             expect(mockTodoistApi.deleteProject).not.toHaveBeenCalled();
             expect(mockTodoistApi.deleteTask).not.toHaveBeenCalled();
-            // Verify success response
-            expect(result).toEqual({ success: true });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Deleted section: id=section-123');
+            expect(textContent).toContain(`Use ${ToolNames.FIND_SECTIONS} to see remaining sections`);
+            expect(result.structuredContent).toEqual({
+                deletedEntity: { type: 'section', id: 'section-123' },
+                success: true,
+            });
         });
         it('should propagate section deletion errors', async () => {
             const apiError = new Error('API Error: Section not found');
             mockTodoistApi.deleteSection.mockRejectedValue(apiError);
-            await expect(deleteOne.execute({ type: 'section', id: 'non-existent-section' }, mockTodoistApi)).rejects.toThrow('API Error: Section not found');
+            await expect(deleteObject.execute({ type: 'section', id: 'non-existent-section' }, mockTodoistApi)).rejects.toThrow('API Error: Section not found');
         });
     });
     describe('deleting tasks', () => {
         it('should delete a task by ID', async () => {
             mockTodoistApi.deleteTask.mockResolvedValue(true);
-            const result = await deleteOne.execute({ type: 'task', id: '8485093748' }, mockTodoistApi);
-            // Verify API was called correctly
+            const result = await deleteObject.execute({ type: 'task', id: '8485093748' }, mockTodoistApi);
             expect(mockTodoistApi.deleteTask).toHaveBeenCalledWith('8485093748');
             expect(mockTodoistApi.deleteProject).not.toHaveBeenCalled();
             expect(mockTodoistApi.deleteSection).not.toHaveBeenCalled();
-            // Verify success response
-            expect(result).toEqual({ success: true });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Deleted task: id=8485093748');
+            expect(textContent).toContain(`Use ${FIND_TASKS_BY_DATE} to see remaining tasks`);
+            expect(result.structuredContent).toEqual({
+                deletedEntity: { type: 'task', id: '8485093748' },
+                success: true,
+            });
         });
         it('should propagate task deletion errors', async () => {
             const apiError = new Error('API Error: Task not found');
             mockTodoistApi.deleteTask.mockRejectedValue(apiError);
-            await expect(deleteOne.execute({ type: 'task', id: 'non-existent-task' }, mockTodoistApi)).rejects.toThrow('API Error: Task not found');
+            await expect(deleteObject.execute({ type: 'task', id: 'non-existent-task' }, mockTodoistApi)).rejects.toThrow('API Error: Task not found');
         });
         it('should handle permission errors', async () => {
             const apiError = new Error('API Error: Insufficient permissions to delete task');
             mockTodoistApi.deleteTask.mockRejectedValue(apiError);
-            await expect(deleteOne.execute({ type: 'task', id: 'restricted-task' }, mockTodoistApi)).rejects.toThrow('API Error: Insufficient permissions to delete task');
+            await expect(deleteObject.execute({ type: 'task', id: 'restricted-task' }, mockTodoistApi)).rejects.toThrow('API Error: Insufficient permissions to delete task');
         });
     });
     describe('type validation', () => {
         it('should handle all supported entity types', async () => {
-            // Test all three supported types work correctly
             mockTodoistApi.deleteProject.mockResolvedValue(true);
             mockTodoistApi.deleteSection.mockResolvedValue(true);
             mockTodoistApi.deleteTask.mockResolvedValue(true);
             // Delete project
-            await deleteOne.execute({ type: 'project', id: 'proj-1' }, mockTodoistApi);
+            await deleteObject.execute({ type: 'project', id: 'proj-1' }, mockTodoistApi);
             expect(mockTodoistApi.deleteProject).toHaveBeenCalledWith('proj-1');
             // Delete section
-            await deleteOne.execute({ type: 'section', id: 'sect-1' }, mockTodoistApi);
+            await deleteObject.execute({ type: 'section', id: 'sect-1' }, mockTodoistApi);
             expect(mockTodoistApi.deleteSection).toHaveBeenCalledWith('sect-1');
             // Delete task
-            await deleteOne.execute({ type: 'task', id: 'task-1' }, mockTodoistApi);
+            await deleteObject.execute({ type: 'task', id: 'task-1' }, mockTodoistApi);
             expect(mockTodoistApi.deleteTask).toHaveBeenCalledWith('task-1');
             // Verify each API method was called exactly once
             expect(mockTodoistApi.deleteProject).toHaveBeenCalledTimes(1);

package/dist/tools/__tests__/find-completed-tasks.test.d.ts

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

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

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

package/dist/tools/__tests__/{tasks-list-completed.test.js → find-completed-tasks.test.js}

@@ -1,12 +1,14 @@
 import { jest } from '@jest/globals';
-import { tasksListCompleted } from '../tasks-list-completed.js';
-import { createMockTask } from '../test-helpers.js';
+import { createMockTask, extractTextContent } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { findCompletedTasks } from '../find-completed-tasks.js';
 // Mock the Todoist API
 const mockTodoistApi = {
     getCompletedTasksByCompletionDate: jest.fn(),
     getCompletedTasksByDueDate: jest.fn(),
 };
-describe('tasks-list-completed tool', () => {
+const { FIND_COMPLETED_TASKS } = ToolNames;
+describe(`${FIND_COMPLETED_TASKS} tool`, () => {
     beforeEach(() => {
         jest.clearAllMocks();
     });
@@ -35,32 +37,20 @@ describe('tasks-list-completed tool', () => {
                 items: mockCompletedTasks,
                 nextCursor: null,
             });
-            const result = await tasksListCompleted.execute({ getBy: 'completion', limit: 50, since: '2025-08-10', until: '2025-08-15' }, mockTodoistApi);
+            const result = await findCompletedTasks.execute({ getBy: 'completion', limit: 50, since: '2025-08-10', until: '2025-08-15' }, mockTodoistApi);
             expect(mockTodoistApi.getCompletedTasksByCompletionDate).toHaveBeenCalledWith({
                 since: '2025-08-10',
                 until: '2025-08-15',
                 limit: 50,
             });
-            expect(result).toEqual({
-                tasks: [
-                    expect.objectContaining({
-                        id: '8485093748',
-                        content: 'Completed task 1',
-                        description: 'Task completed yesterday',
-                        dueDate: '2025-08-14',
-                        priority: 2,
-                        labels: ['work'],
-                    }),
-                ],
-                nextCursor: null,
-            });
+            expect(extractTextContent(result)).toMatchSnapshot();
         });
         it('should handle explicit completion date query', async () => {
             mockTodoistApi.getCompletedTasksByCompletionDate.mockResolvedValue({
                 items: [],
                 nextCursor: 'next-cursor',
             });
-            const result = await tasksListCompleted.execute({
+            const result = await findCompletedTasks.execute({
                 getBy: 'completion',
                 limit: 100,
                 since: '2025-08-01',
@@ -75,7 +65,7 @@ describe('tasks-list-completed tool', () => {
                 limit: 100,
                 cursor: 'current-cursor',
             });
-            expect(result).toEqual({ tasks: [], nextCursor: 'next-cursor' });
+            expect(extractTextContent(result)).toMatchSnapshot();
         });
     });
     describe('getting completed tasks by due date', () => {
@@ -103,7 +93,7 @@ describe('tasks-list-completed tool', () => {
                 items: mockCompletedTasks,
                 nextCursor: null,
             });
-            const result = await tasksListCompleted.execute({
+            const result = await findCompletedTasks.execute({
                 getBy: 'due',
                 limit: 50,
                 since: '2025-08-10',
@@ -115,34 +105,21 @@ describe('tasks-list-completed tool', () => {
                 limit: 50,
             });
             expect(mockTodoistApi.getCompletedTasksByCompletionDate).not.toHaveBeenCalled();
-            expect(result).toEqual({
-                tasks: [
-                    expect.objectContaining({
-                        id: '8485093750',
-                        content: 'Task completed by due date',
-                        description: 'This task was due and completed',
-                        dueDate: '2025-08-15',
-                        recurring: 'every Monday',
-                        priority: 3,
-                        labels: ['urgent'],
-                    }),
-                ],
-                nextCursor: null,
-            });
+            expect(extractTextContent(result)).toMatchSnapshot();
         });
     });
     describe('error handling', () => {
         it('should propagate completion date API errors', async () => {
             const apiError = new Error('API Error: Invalid date range');
             mockTodoistApi.getCompletedTasksByCompletionDate.mockRejectedValue(apiError);
-            await expect(tasksListCompleted.execute(
+            await expect(findCompletedTasks.execute(
             // invalid date range
             { getBy: 'completion', limit: 50, since: '2025-08-31', until: '2025-08-01' }, mockTodoistApi)).rejects.toThrow('API Error: Invalid date range');
         });
         it('should propagate due date API errors', async () => {
             const apiError = new Error('API Error: Project not found');
             mockTodoistApi.getCompletedTasksByDueDate.mockRejectedValue(apiError);
-            await expect(tasksListCompleted.execute({
+            await expect(findCompletedTasks.execute({
                 getBy: 'due',
                 limit: 50,
                 since: '2025-08-01',

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

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

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

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

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

@@ -1,11 +1,13 @@
 import { jest } from '@jest/globals';
-import { projectsList } from '../projects-list.js';
-import { TEST_ERRORS, TEST_IDS, createMockApiResponse, createMockProject } from '../test-helpers.js';
+import { TEST_ERRORS, TEST_IDS, createMockApiResponse, createMockProject, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { findProjects } from '../find-projects.js';
 // Mock the Todoist API
 const mockTodoistApi = {
     getProjects: jest.fn(),
 };
-describe('projects-list tool', () => {
+const { FIND_PROJECTS } = ToolNames;
+describe(`${FIND_PROJECTS} tool`, () => {
     beforeEach(() => {
         jest.clearAllMocks();
     });
@@ -38,37 +40,27 @@ describe('projects-list tool', () => {
                 }),
             ];
             mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
-            const result = await projectsList.execute({ limit: 50 }, mockTodoistApi);
+            const result = await findProjects.execute({ limit: 50 }, mockTodoistApi);
             // Verify API was called correctly
             expect(mockTodoistApi.getProjects).toHaveBeenCalledWith({
                 limit: 50,
                 cursor: null,
             });
-            // Verify result is properly mapped
-            expect(result).toEqual({
-                projects: [
-                    expect.objectContaining({
-                        id: TEST_IDS.PROJECT_INBOX,
-                        name: 'Inbox',
-                        color: 'grey',
-                        inboxProject: true,
-                    }),
-                    expect.objectContaining({
-                        id: TEST_IDS.PROJECT_TEST,
-                        name: 'test-abc123def456-project',
-                        color: 'charcoal',
-                    }),
-                    expect.objectContaining({
-                        id: TEST_IDS.PROJECT_WORK,
-                        name: 'Work Project',
-                        color: 'blue',
-                        isFavorite: true,
-                        isShared: true,
-                        viewStyle: 'board',
-                    }),
-                ],
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                projects: expect.any(Array),
+                totalCount: 3,
+                hasMore: false,
                 nextCursor: null,
-            });
+                appliedFilters: {
+                    search: undefined,
+                    limit: 50,
+                    cursor: undefined,
+                },
+            }));
+            expect(structuredContent.projects).toHaveLength(3);
         });
         it('should handle pagination with limit and cursor', async () => {
             const mockProject = createMockProject({
@@ -77,14 +69,23 @@ describe('projects-list tool', () => {
                 color: 'red',
             });
             mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse([mockProject], 'next-page-cursor'));
-            const result = await projectsList.execute({ limit: 10, cursor: 'current-page-cursor' }, mockTodoistApi);
+            const result = await findProjects.execute({ limit: 10, cursor: 'current-page-cursor' }, mockTodoistApi);
             expect(mockTodoistApi.getProjects).toHaveBeenCalledWith({
                 limit: 10,
                 cursor: 'current-page-cursor',
             });
-            expect(result.projects).toHaveLength(1);
-            expect(result.projects[0]?.name).toBe('First Project');
-            expect(result.nextCursor).toBe('next-page-cursor');
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent.projects).toHaveLength(1);
+            expect(structuredContent.totalCount).toBe(1);
+            expect(structuredContent.hasMore).toBe(true);
+            expect(structuredContent.nextCursor).toBe('next-page-cursor');
+            expect(structuredContent.appliedFilters).toEqual({
+                search: undefined,
+                limit: 10,
+                cursor: 'current-page-cursor',
+            });
         });
     });
     describe('searching projects', () => {
@@ -103,10 +104,20 @@ describe('projects-list tool', () => {
                 createMockProject({ id: 'hobby-project-id', name: 'Hobby Work', color: 'orange' }),
             ];
             mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
-            const result = await projectsList.execute({ search: 'work', limit: 50 }, mockTodoistApi);
+            const result = await findProjects.execute({ search: 'work', limit: 50 }, mockTodoistApi);
             expect(mockTodoistApi.getProjects).toHaveBeenCalledWith({ limit: 50, cursor: null });
-            expect(result.projects).toHaveLength(2);
-            expect(result.projects.map((p) => p.name)).toEqual(['Work Project', 'Hobby Work']);
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content with search filter
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent.projects).toHaveLength(2); // Should match filtered results
+            expect(structuredContent.totalCount).toBe(2);
+            expect(structuredContent.hasMore).toBe(false);
+            expect(structuredContent.nextCursor).toBeNull();
+            expect(structuredContent.appliedFilters).toEqual({
+                search: 'work',
+                limit: 50,
+                cursor: undefined,
+            });
         });
         it.each([
             {
@@ -121,11 +132,16 @@ describe('projects-list tool', () => {
                 expectedCount: 1,
                 description: 'case insensitive matching',
             },
-        ])('should handle search with $description', async ({ search, projects, expectedCount }) => {
+        ])('should handle search with $description', async ({ search, projects }) => {
             const mockProjects = projects.map((name) => createMockProject({ name }));
             mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
-            const result = await projectsList.execute({ search, limit: 50 }, mockTodoistApi);
-            expect(result.projects).toHaveLength(expectedCount);
+            const result = await findProjects.execute({ search, limit: 50 }, mockTodoistApi);
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                appliedFilters: expect.objectContaining({ search }),
+            }));
         });
     });
     describe('error handling', () => {
@@ -134,7 +150,7 @@ describe('projects-list tool', () => {
             { error: TEST_ERRORS.INVALID_CURSOR, params: { cursor: 'invalid-cursor', limit: 50 } },
         ])('should propagate $error', async ({ error, params }) => {
             mockTodoistApi.getProjects.mockRejectedValue(new Error(error));
-            await expect(projectsList.execute(params, mockTodoistApi)).rejects.toThrow(error);
+            await expect(findProjects.execute(params, mockTodoistApi)).rejects.toThrow(error);
         });
     });
 });

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

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

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

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