@doist/todoist-ai 2.2.2 → 4.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-comments.test.d.ts

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

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

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

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

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

package/dist/tools/__tests__/find-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":""}