@doist/todoist-ai 4.9.3 → 4.10.0

package/dist/tools/__tests__/fetch.test.js

@@ -0,0 +1,275 @@
+import { jest } from '@jest/globals';
+import { createMockProject, createMockTask, TEST_IDS } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { fetch } from '../fetch.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    getTask: jest.fn(),
+    getProject: jest.fn(),
+};
+const { FETCH } = ToolNames;
+describe(`${FETCH} tool`, () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('fetching tasks', () => {
+        it('should fetch a task by composite ID and return full content', async () => {
+            const mockTask = createMockTask({
+                id: TEST_IDS.TASK_1,
+                content: 'Important meeting with team',
+                description: 'Discuss project roadmap and timeline',
+                labels: ['work', 'urgent'],
+                priority: 2,
+                projectId: TEST_IDS.PROJECT_WORK,
+                sectionId: TEST_IDS.SECTION_1,
+                due: {
+                    date: '2025-10-15',
+                    isRecurring: false,
+                    datetime: null,
+                    string: '2025-10-15',
+                    timezone: null,
+                    lang: 'en',
+                },
+            });
+            mockTodoistApi.getTask.mockResolvedValue(mockTask);
+            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
+            // Verify API was called correctly
+            expect(mockTodoistApi.getTask).toHaveBeenCalledWith(TEST_IDS.TASK_1);
+            // Verify result structure
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0]?.type).toBe('text');
+            // Parse the JSON response
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse).toEqual({
+                id: `task:${TEST_IDS.TASK_1}`,
+                title: 'Important meeting with team',
+                text: 'Important meeting with team\n\nDescription: Discuss project roadmap and timeline\nDue: 2025-10-15\nLabels: work, urgent',
+                url: `https://app.todoist.com/app/task/${TEST_IDS.TASK_1}`,
+                metadata: {
+                    priority: 2,
+                    projectId: TEST_IDS.PROJECT_WORK,
+                    sectionId: TEST_IDS.SECTION_1,
+                    parentId: null,
+                    recurring: false,
+                    duration: null,
+                    responsibleUid: null,
+                    assignedByUid: null,
+                },
+            });
+        });
+        it('should fetch a task without optional fields', async () => {
+            const mockTask = createMockTask({
+                id: TEST_IDS.TASK_2,
+                content: 'Simple task',
+                description: '',
+                labels: [],
+                due: null,
+            });
+            mockTodoistApi.getTask.mockResolvedValue(mockTask);
+            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_2}` }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.title).toBe('Simple task');
+            expect(jsonResponse.text).toBe('Simple task');
+            expect(jsonResponse.metadata).toEqual({
+                priority: 1,
+                projectId: TEST_IDS.PROJECT_TEST,
+                sectionId: null,
+                parentId: null,
+                recurring: false,
+                duration: null,
+                responsibleUid: null,
+                assignedByUid: null,
+            });
+        });
+        it('should handle tasks with recurring due dates', async () => {
+            const mockTask = createMockTask({
+                id: TEST_IDS.TASK_3,
+                content: 'Weekly meeting',
+                due: {
+                    date: '2025-10-15',
+                    isRecurring: true,
+                    datetime: null,
+                    string: 'every monday',
+                    timezone: null,
+                    lang: 'en',
+                },
+            });
+            mockTodoistApi.getTask.mockResolvedValue(mockTask);
+            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_3}` }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.metadata.recurring).toBe('every monday');
+        });
+        it('should handle tasks with duration', async () => {
+            const mockTask = createMockTask({
+                id: TEST_IDS.TASK_1,
+                content: 'Task with duration',
+                duration: {
+                    amount: 90,
+                    unit: 'minute',
+                },
+            });
+            mockTodoistApi.getTask.mockResolvedValue(mockTask);
+            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.metadata.duration).toBe('1h30m');
+        });
+        it('should handle tasks with assignments', async () => {
+            const mockTask = createMockTask({
+                id: TEST_IDS.TASK_1,
+                content: 'Assigned task',
+                responsibleUid: 'user-123',
+                assignedByUid: 'user-456',
+            });
+            mockTodoistApi.getTask.mockResolvedValue(mockTask);
+            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.metadata.responsibleUid).toBe('user-123');
+            expect(jsonResponse.metadata.assignedByUid).toBe('user-456');
+        });
+    });
+    describe('fetching projects', () => {
+        it('should fetch a project by composite ID and return full content', async () => {
+            const mockProject = createMockProject({
+                id: TEST_IDS.PROJECT_WORK,
+                name: 'Work Project',
+                color: 'blue',
+                isFavorite: true,
+                isShared: true,
+                viewStyle: 'board',
+                parentId: null,
+                inboxProject: false,
+            });
+            mockTodoistApi.getProject.mockResolvedValue(mockProject);
+            const result = await fetch.execute({ id: `project:${TEST_IDS.PROJECT_WORK}` }, mockTodoistApi);
+            // Verify API was called correctly
+            expect(mockTodoistApi.getProject).toHaveBeenCalledWith(TEST_IDS.PROJECT_WORK);
+            // Verify result structure
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0]?.type).toBe('text');
+            // Parse the JSON response
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse).toEqual({
+                id: `project:${TEST_IDS.PROJECT_WORK}`,
+                title: 'Work Project',
+                text: 'Work Project\n\nShared project\nFavorite: Yes',
+                url: `https://app.todoist.com/app/project/${TEST_IDS.PROJECT_WORK}`,
+                metadata: {
+                    color: 'blue',
+                    isFavorite: true,
+                    isShared: true,
+                    parentId: null,
+                    inboxProject: false,
+                    viewStyle: 'board',
+                },
+            });
+        });
+        it('should fetch a project without optional flags', async () => {
+            const mockProject = createMockProject({
+                id: TEST_IDS.PROJECT_TEST,
+                name: 'Simple Project',
+                isFavorite: false,
+                isShared: false,
+            });
+            mockTodoistApi.getProject.mockResolvedValue(mockProject);
+            const result = await fetch.execute({ id: `project:${TEST_IDS.PROJECT_TEST}` }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.title).toBe('Simple Project');
+            expect(jsonResponse.text).toBe('Simple Project');
+            expect(jsonResponse.metadata.isFavorite).toBe(false);
+            expect(jsonResponse.metadata.isShared).toBe(false);
+        });
+        it('should fetch inbox project', async () => {
+            const mockProject = createMockProject({
+                id: TEST_IDS.PROJECT_INBOX,
+                name: 'Inbox',
+                inboxProject: true,
+            });
+            mockTodoistApi.getProject.mockResolvedValue(mockProject);
+            const result = await fetch.execute({ id: `project:${TEST_IDS.PROJECT_INBOX}` }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.metadata.inboxProject).toBe(true);
+        });
+        it('should fetch project with parent ID', async () => {
+            const mockProject = createMockProject({
+                id: 'sub-project-id',
+                name: 'Sub Project',
+                parentId: TEST_IDS.PROJECT_WORK,
+            });
+            mockTodoistApi.getProject.mockResolvedValue(mockProject);
+            const result = await fetch.execute({ id: 'project:sub-project-id' }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.metadata.parentId).toBe(TEST_IDS.PROJECT_WORK);
+        });
+    });
+    describe('error handling', () => {
+        it('should return error response for invalid ID format (missing colon)', async () => {
+            const result = await fetch.execute({ id: 'invalid-id' }, mockTodoistApi);
+            expect(result.isError).toBe(true);
+            expect(result.content[0]?.text).toContain('Invalid ID format');
+        });
+        it('should return error response for invalid ID format (missing type)', async () => {
+            const result = await fetch.execute({ id: ':8485093748' }, mockTodoistApi);
+            expect(result.isError).toBe(true);
+            expect(result.content[0]?.text).toContain('Invalid ID format');
+        });
+        it('should return error response for invalid ID format (missing object ID)', async () => {
+            const result = await fetch.execute({ id: 'task:' }, mockTodoistApi);
+            expect(result.isError).toBe(true);
+            expect(result.content[0]?.text).toContain('Invalid ID format');
+        });
+        it('should return error response for invalid type', async () => {
+            const result = await fetch.execute({ id: 'section:123' }, mockTodoistApi);
+            expect(result.isError).toBe(true);
+            expect(result.content[0]?.text).toContain('Invalid ID format');
+        });
+        it('should return error response for task fetch failure', async () => {
+            mockTodoistApi.getTask.mockRejectedValue(new Error('Task not found'));
+            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
+            expect(result.isError).toBe(true);
+            expect(result.content[0]?.text).toBe('Task not found');
+        });
+        it('should return error response for project fetch failure', async () => {
+            mockTodoistApi.getProject.mockRejectedValue(new Error('Project not found'));
+            const result = await fetch.execute({ id: `project:${TEST_IDS.PROJECT_WORK}` }, mockTodoistApi);
+            expect(result.isError).toBe(true);
+            expect(result.content[0]?.text).toBe('Project not found');
+        });
+    });
+    describe('OpenAI MCP spec compliance', () => {
+        it('should return exactly one content item with type "text"', async () => {
+            const mockTask = createMockTask({ id: TEST_IDS.TASK_1, content: 'Test' });
+            mockTodoistApi.getTask.mockResolvedValue(mockTask);
+            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0]?.type).toBe('text');
+        });
+        it('should return valid JSON string in text field', async () => {
+            const mockTask = createMockTask({ id: TEST_IDS.TASK_1, content: 'Test' });
+            mockTodoistApi.getTask.mockResolvedValue(mockTask);
+            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
+            expect(() => JSON.parse(result.content[0]?.text ?? '{}')).not.toThrow();
+        });
+        it('should include all required fields (id, title, text, url)', async () => {
+            const mockTask = createMockTask({ id: TEST_IDS.TASK_1, content: 'Test' });
+            mockTodoistApi.getTask.mockResolvedValue(mockTask);
+            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse).toHaveProperty('id');
+            expect(jsonResponse).toHaveProperty('title');
+            expect(jsonResponse).toHaveProperty('text');
+            expect(jsonResponse).toHaveProperty('url');
+            expect(typeof jsonResponse.id).toBe('string');
+            expect(typeof jsonResponse.title).toBe('string');
+            expect(typeof jsonResponse.text).toBe('string');
+            expect(typeof jsonResponse.url).toBe('string');
+        });
+        it('should include optional metadata field', async () => {
+            const mockTask = createMockTask({ id: TEST_IDS.TASK_1, content: 'Test' });
+            mockTodoistApi.getTask.mockResolvedValue(mockTask);
+            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse).toHaveProperty('metadata');
+            expect(typeof jsonResponse.metadata).toBe('object');
+        });
+    });
+});

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

@@ -55,7 +55,6 @@ describe(`${FIND_COMMENTS} tool`, () => {
                 searchType: 'task',
                 searchId: 'task123',
                 hasMore: false,
-                nextCursor: null,
                 totalCount: 2,
             }));
         });
@@ -128,7 +127,6 @@ describe(`${FIND_COMMENTS} tool`, () => {
                 searchType: 'project',
                 searchId: 'project456',
                 hasMore: false,
-                nextCursor: null,
                 totalCount: 1,
             }));
         });
@@ -155,13 +153,11 @@ describe(`${FIND_COMMENTS} tool`, () => {
                         id: 'comment789',
                         content: 'Single comment content',
                         taskId: 'task123',
-                        fileAttachment: null,
                     }),
                 ]),
                 searchType: 'single',
                 searchId: 'comment789',
                 hasMore: false,
-                nextCursor: null,
                 totalCount: 1,
             }));
         });
@@ -200,7 +196,6 @@ describe(`${FIND_COMMENTS} tool`, () => {
                 searchType: 'single',
                 searchId: 'comment789',
                 hasMore: false,
-                nextCursor: null,
                 totalCount: 1,
             }));
         });
@@ -229,14 +224,13 @@ describe(`${FIND_COMMENTS} tool`, () => {
             expect(extractTextContent(result)).toMatchSnapshot();
             // Verify structured content
             const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                comments: [],
+            expect(structuredContent).toEqual({
                 searchType: 'task',
                 searchId: 'task123',
                 hasMore: false,
-                nextCursor: null,
                 totalCount: 0,
-            }));
+                // comments array is removed when empty
+            });
         });
     });
 });

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

@@ -53,7 +53,6 @@ describe(`${FIND_PROJECTS} tool`, () => {
                 projects: expect.any(Array),
                 totalCount: 3,
                 hasMore: false,
-                nextCursor: null,
                 appliedFilters: {
                     search: undefined,
                     limit: 50,
@@ -112,7 +111,6 @@ describe(`${FIND_PROJECTS} tool`, () => {
             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,

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

@@ -77,12 +77,8 @@ describe(`${FIND_SECTIONS} tool`, () => {
             expect(textContent).toContain(`Use ${ADD_SECTIONS} to create sections`);
             // Verify structured content
             const structuredContent = extractStructuredContent(result);
-            expect(structuredContent.sections).toHaveLength(0);
+            expect(structuredContent.sections).toBeUndefined(); // Empty arrays are removed
             expect(structuredContent.totalCount).toBe(0);
-            expect(structuredContent.appliedFilters).toEqual({
-                projectId: 'empty-project-id',
-                search: undefined,
-            });
         });
     });
     describe('searching sections by name', () => {

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

@@ -117,7 +117,6 @@ describe(`${FIND_TASKS} tool`, () => {
                 tasks: expect.any(Array),
                 totalCount: 1,
                 hasMore: false,
-                nextCursor: null,
                 appliedFilters: expect.objectContaining({
                     searchText: params.searchText,
                     limit: expectedLimit,
@@ -144,15 +143,14 @@ describe(`${FIND_TASKS} tool`, () => {
             expect(extractTextContent(result)).toMatchSnapshot();
             // Verify structured content for empty results
             const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                tasks: [],
+            expect(structuredContent).toEqual({
+                // tasks array is removed when empty
                 totalCount: 0,
                 hasMore: false,
-                nextCursor: null,
                 appliedFilters: expect.objectContaining({
                     searchText: searchText,
                 }),
-            }));
+            });
         });
     });
     describe('validation', () => {

package/dist/tools/__tests__/get-overview.test.js

@@ -59,7 +59,7 @@ describe(`${GET_OVERVIEW} tool`, () => {
                 inbox: expect.objectContaining({
                     id: TEST_IDS.PROJECT_INBOX,
                     name: 'Inbox',
-                    sections: expect.any(Array),
+                    // sections array removed if empty
                 }),
                 projects: expect.any(Array),
                 totalProjects: 2,
@@ -75,14 +75,13 @@ describe(`${GET_OVERVIEW} tool`, () => {
             expect(extractTextContent(result)).toMatchSnapshot();
             // Test structured content sanity checks
             const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
+            expect(structuredContent).toEqual({
                 type: 'account_overview',
-                inbox: null,
-                projects: [],
+                // projects array is removed when empty
                 totalProjects: 0,
                 totalSections: 0,
                 hasNestedProjects: false,
-            }));
+            });
         });
     });
     describe('project overview (with projectId)', () => {
@@ -188,20 +187,19 @@ describe(`${GET_OVERVIEW} tool`, () => {
             expect(extractTextContent(result)).toMatchSnapshot();
             // Test structured content sanity checks
             const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
+            expect(structuredContent).toEqual({
                 type: 'project_overview',
                 project: expect.objectContaining({
                     id: 'empty-project-id',
                     name: 'Empty Project',
                 }),
-                sections: [],
-                tasks: [],
+                // sections and tasks arrays are removed when empty
                 stats: expect.objectContaining({
                     totalTasks: 0,
                     totalSections: 0,
                     tasksWithoutSection: 0,
                 }),
-            }));
+            });
         });
     });
     describe('error handling', () => {

package/dist/tools/__tests__/search.test.d.ts

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

package/dist/tools/__tests__/search.test.d.ts.map

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

package/dist/tools/__tests__/search.test.js

@@ -0,0 +1,208 @@
+import { jest } from '@jest/globals';
+import { getTasksByFilter } from '../../tool-helpers.js';
+import { createMappedTask, createMockApiResponse, createMockProject, TEST_IDS, } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { search } from '../search.js';
+jest.mock('../../tool-helpers', () => {
+    const actual = jest.requireActual('../../tool-helpers');
+    return {
+        getTasksByFilter: jest.fn(),
+        buildTodoistUrl: actual.buildTodoistUrl,
+    };
+});
+const { SEARCH } = ToolNames;
+const mockGetTasksByFilter = getTasksByFilter;
+// Mock the Todoist API
+const mockTodoistApi = {
+    getProjects: jest.fn(),
+};
+describe(`${SEARCH} tool`, () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('searching tasks and projects', () => {
+        it('should search both tasks and projects and return combined results', async () => {
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'Important meeting task',
+                }),
+                createMappedTask({
+                    id: TEST_IDS.TASK_2,
+                    content: 'Another important item',
+                }),
+            ];
+            const mockProjects = [
+                createMockProject({
+                    id: TEST_IDS.PROJECT_WORK,
+                    name: 'Important Work Project',
+                }),
+                createMockProject({
+                    id: TEST_IDS.PROJECT_TEST,
+                    name: 'Test Project',
+                }),
+            ];
+            mockGetTasksByFilter.mockResolvedValue({ tasks: mockTasks, nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await search.execute({ query: 'important' }, mockTodoistApi);
+            // Verify both API calls were made
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: 'search: important',
+                limit: 100, // TASKS_MAX
+                cursor: undefined,
+            });
+            expect(mockTodoistApi.getProjects).toHaveBeenCalledWith({
+                limit: 100, // PROJECTS_MAX
+            });
+            // Verify result structure
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0]?.type).toBe('text');
+            // Parse the JSON response
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse).toHaveProperty('results');
+            expect(jsonResponse.results).toHaveLength(3); // 2 tasks + 1 project matching "important"
+            // Verify task results
+            expect(jsonResponse.results[0]).toEqual({
+                id: `task:${TEST_IDS.TASK_1}`,
+                title: 'Important meeting task',
+                url: `https://app.todoist.com/app/task/${TEST_IDS.TASK_1}`,
+            });
+            expect(jsonResponse.results[1]).toEqual({
+                id: `task:${TEST_IDS.TASK_2}`,
+                title: 'Another important item',
+                url: `https://app.todoist.com/app/task/${TEST_IDS.TASK_2}`,
+            });
+            // Verify project result (only "Important Work Project" matches)
+            expect(jsonResponse.results[2]).toEqual({
+                id: `project:${TEST_IDS.PROJECT_WORK}`,
+                title: 'Important Work Project',
+                url: `https://app.todoist.com/app/project/${TEST_IDS.PROJECT_WORK}`,
+            });
+        });
+        it('should return only matching tasks when no projects match', async () => {
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'Unique task content',
+                }),
+            ];
+            const mockProjects = [
+                createMockProject({
+                    id: TEST_IDS.PROJECT_WORK,
+                    name: 'Work Project',
+                }),
+            ];
+            mockGetTasksByFilter.mockResolvedValue({ tasks: mockTasks, nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await search.execute({ query: 'unique' }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.results).toHaveLength(1);
+            expect(jsonResponse.results[0].id).toBe(`task:${TEST_IDS.TASK_1}`);
+        });
+        it('should return only matching projects when no tasks match', async () => {
+            const mockProjects = [
+                createMockProject({
+                    id: TEST_IDS.PROJECT_WORK,
+                    name: 'Special Project Name',
+                }),
+                createMockProject({
+                    id: TEST_IDS.PROJECT_TEST,
+                    name: 'Another Project',
+                }),
+            ];
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await search.execute({ query: 'special' }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.results).toHaveLength(1);
+            expect(jsonResponse.results[0]).toEqual({
+                id: `project:${TEST_IDS.PROJECT_WORK}`,
+                title: 'Special Project Name',
+                url: `https://app.todoist.com/app/project/${TEST_IDS.PROJECT_WORK}`,
+            });
+        });
+        it('should return empty results when nothing matches', async () => {
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse([]));
+            const result = await search.execute({ query: 'nonexistent' }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.results).toHaveLength(0);
+        });
+        it('should perform case-insensitive project filtering', async () => {
+            const mockProjects = [
+                createMockProject({
+                    id: TEST_IDS.PROJECT_WORK,
+                    name: 'Important Work',
+                }),
+            ];
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await search.execute({ query: 'IMPORTANT' }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.results).toHaveLength(1);
+            expect(jsonResponse.results[0].title).toBe('Important Work');
+        });
+        it('should handle partial matches in project names', async () => {
+            const mockProjects = [
+                createMockProject({ id: 'project-1', name: 'Development Tasks' }),
+                createMockProject({ id: 'project-2', name: 'Developer Resources' }),
+                createMockProject({ id: 'project-3', name: 'Marketing' }),
+            ];
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await search.execute({ query: 'develop' }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.results).toHaveLength(2);
+            expect(jsonResponse.results[0].title).toBe('Development Tasks');
+            expect(jsonResponse.results[1].title).toBe('Developer Resources');
+        });
+    });
+    describe('error handling', () => {
+        it('should return error response for task search failure', async () => {
+            mockGetTasksByFilter.mockRejectedValue(new Error('Task search failed'));
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse([]));
+            const result = await search.execute({ query: 'test' }, mockTodoistApi);
+            expect(result.isError).toBe(true);
+            expect(result.content[0]?.text).toBe('Task search failed');
+        });
+        it('should return error response for project search failure', async () => {
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockRejectedValue(new Error('Project search failed'));
+            const result = await search.execute({ query: 'test' }, mockTodoistApi);
+            expect(result.isError).toBe(true);
+            expect(result.content[0]?.text).toBe('Project search failed');
+        });
+    });
+    describe('OpenAI MCP spec compliance', () => {
+        it('should return exactly one content item with type "text"', async () => {
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse([]));
+            const result = await search.execute({ query: 'test' }, mockTodoistApi);
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0]?.type).toBe('text');
+        });
+        it('should return valid JSON string in text field', async () => {
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse([]));
+            const result = await search.execute({ query: 'test' }, mockTodoistApi);
+            expect(() => JSON.parse(result.content[0]?.text ?? '{}')).not.toThrow();
+        });
+        it('should include required fields (id, title, url) in each result', async () => {
+            const mockTasks = [createMappedTask({ id: TEST_IDS.TASK_1, content: 'Test' })];
+            const mockProjects = [createMockProject({ id: TEST_IDS.PROJECT_WORK, name: 'Test' })];
+            mockGetTasksByFilter.mockResolvedValue({ tasks: mockTasks, nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await search.execute({ query: 'test' }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            for (const item of jsonResponse.results) {
+                expect(item).toHaveProperty('id');
+                expect(item).toHaveProperty('title');
+                expect(item).toHaveProperty('url');
+                expect(typeof item.id).toBe('string');
+                expect(typeof item.title).toBe('string');
+                expect(typeof item.url).toBe('string');
+            }
+        });
+    });
+});