@doist/todoist-ai 4.16.0 → 4.17.0

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

@@ -1,771 +0,0 @@
-import { jest } from '@jest/globals';
-import { getTasksByFilter } from '../../tool-helpers.js';
-import { createMappedTask, createMockApiResponse, createMockTask, createMockUser, extractStructuredContent, extractTextContent, TEST_ERRORS, TEST_IDS, TODAY, } from '../../utils/test-helpers.js';
-import { ToolNames } from '../../utils/tool-names.js';
-import { resolveUserNameToId } from '../../utils/user-resolver.js';
-import { findTasks } from '../find-tasks.js';
-jest.mock('../../tool-helpers', () => {
-    const actual = jest.requireActual('../../tool-helpers');
-    return {
-        getTasksByFilter: jest.fn(),
-        mapTask: actual.mapTask,
-        filterTasksByResponsibleUser: actual.filterTasksByResponsibleUser,
-    };
-});
-jest.mock('../../utils/user-resolver', () => ({
-    resolveUserNameToId: jest.fn(),
-}));
-const { FIND_TASKS, UPDATE_TASKS, FIND_COMPLETED_TASKS } = ToolNames;
-const mockGetTasksByFilter = getTasksByFilter;
-const mockResolveUserNameToId = resolveUserNameToId;
-// Mock the Todoist API
-const mockTodoistApi = {
-    getTasks: jest.fn(),
-    getUser: jest.fn(),
-};
-// Mock the Todoist User
-const mockTodoistUser = createMockUser();
-describe(`${FIND_TASKS} tool`, () => {
-    beforeEach(() => {
-        mockTodoistApi.getUser.mockResolvedValue(mockTodoistUser);
-        jest.clearAllMocks();
-    });
-    describe('searching tasks', () => {
-        it('should search tasks and return results', async () => {
-            const mockTasks = [
-                createMappedTask({
-                    id: TEST_IDS.TASK_1,
-                    content: 'Task containing search term',
-                    description: 'Description with more details',
-                    labels: ['work'],
-                }),
-                createMappedTask({
-                    id: TEST_IDS.TASK_2,
-                    content: 'Another matching task',
-                    priority: 2,
-                    sectionId: TEST_IDS.SECTION_1,
-                }),
-            ];
-            const mockResponse = { tasks: mockTasks, nextCursor: 'cursor-for-next-page' };
-            mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await findTasks.execute({
-                searchText: 'important meeting',
-                limit: 10,
-            }, mockTodoistApi);
-            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
-                client: mockTodoistApi,
-                query: 'search: important meeting',
-                cursor: undefined,
-                limit: 10,
-            });
-            // Verify result is a concise summary
-            expect(extractTextContent(result)).toMatchSnapshot();
-            // Verify structured content
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                tasks: expect.any(Array),
-                totalCount: 2,
-                hasMore: true,
-                nextCursor: 'cursor-for-next-page',
-                appliedFilters: {
-                    searchText: 'important meeting',
-                    limit: 10,
-                },
-            }));
-            expect(structuredContent).toEqual(expect.objectContaining({
-                tasks: expect.any(Array),
-            }));
-        });
-        it.each([
-            {
-                name: 'custom limit',
-                params: {
-                    searchText: 'project update',
-                    limit: 5,
-                },
-                expectedQuery: 'search: project update',
-                expectedLimit: 5,
-                expectedCursor: undefined,
-            },
-            {
-                name: 'pagination cursor',
-                params: {
-                    searchText: 'follow up',
-                    limit: 20,
-                    cursor: 'cursor-from-first-page',
-                },
-                expectedQuery: 'search: follow up',
-                expectedLimit: 20,
-                expectedCursor: 'cursor-from-first-page',
-            },
-        ])('should handle $name', async ({ params, expectedQuery, expectedLimit, expectedCursor }) => {
-            const mockTask = createMappedTask({ content: 'Test result' });
-            const mockResponse = { tasks: [mockTask], nextCursor: null };
-            mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await findTasks.execute(params, mockTodoistApi);
-            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
-                client: mockTodoistApi,
-                query: expectedQuery,
-                cursor: expectedCursor,
-                limit: expectedLimit,
-            });
-            // Verify result is a concise summary
-            expect(extractTextContent(result)).toMatchSnapshot();
-            // Verify structured content
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                tasks: expect.any(Array),
-                totalCount: 1,
-                hasMore: false,
-                appliedFilters: expect.objectContaining({
-                    searchText: params.searchText,
-                    limit: expectedLimit,
-                }),
-            }));
-            expect(structuredContent).toEqual(expect.objectContaining({
-                tasks: expect.any(Array),
-            }));
-        });
-        it.each([
-            { searchText: '@work #urgent "exact phrase"', description: 'special characters' },
-            { searchText: 'nonexistent keyword', description: 'empty results' },
-        ])('should handle search with $description', async ({ searchText }) => {
-            const mockResponse = { tasks: [], nextCursor: null };
-            mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await findTasks.execute({ searchText, limit: 10 }, mockTodoistApi);
-            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
-                client: mockTodoistApi,
-                query: `search: ${searchText}`,
-                cursor: undefined,
-                limit: 10,
-            });
-            // Verify result is a concise summary
-            expect(extractTextContent(result)).toMatchSnapshot();
-            // Verify structured content for empty results
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual({
-                // tasks array is removed when empty
-                totalCount: 0,
-                hasMore: false,
-                appliedFilters: expect.objectContaining({
-                    searchText: searchText,
-                }),
-            });
-        });
-    });
-    describe('validation', () => {
-        it('should require at least one filter parameter', async () => {
-            await expect(findTasks.execute({ limit: 10 }, mockTodoistApi)).rejects.toThrow('At least one filter must be provided: searchText, projectId, sectionId, parentId, responsibleUser, or labels');
-        });
-    });
-    describe('container filtering', () => {
-        it.each([
-            {
-                name: 'project',
-                params: {
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    limit: 10,
-                },
-                expectedApiParam: { projectId: TEST_IDS.PROJECT_TEST },
-                tasks: [createMockTask({ content: 'Project task' })],
-            },
-            {
-                name: 'section',
-                params: {
-                    sectionId: TEST_IDS.SECTION_1,
-                    limit: 10,
-                },
-                expectedApiParam: { sectionId: TEST_IDS.SECTION_1 },
-                tasks: [createMockTask({ content: 'Section task' })],
-            },
-            {
-                name: 'parent task',
-                params: {
-                    parentId: TEST_IDS.TASK_1,
-                    limit: 10,
-                },
-                expectedApiParam: { parentId: TEST_IDS.TASK_1 },
-                tasks: [createMockTask({ content: 'Subtask' })],
-            },
-        ])('should find tasks in $name', async ({ params, expectedApiParam, tasks }) => {
-            mockTodoistApi.getTasks.mockResolvedValue(createMockApiResponse(tasks));
-            const result = await findTasks.execute(params, mockTodoistApi);
-            expect(mockTodoistApi.getTasks).toHaveBeenCalledWith({
-                limit: 10,
-                cursor: null,
-                ...expectedApiParam,
-            });
-            expect(extractTextContent(result)).toMatchSnapshot();
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                tasks: expect.any(Array),
-                totalCount: tasks.length,
-                hasMore: false,
-                appliedFilters: params,
-            }));
-        });
-        it('should handle combined search text and container filtering', async () => {
-            const tasks = [
-                createMockTask({
-                    id: '8485093749',
-                    content: 'relevant task',
-                    description: 'contains search term',
-                }),
-                createMockTask({
-                    id: '8485093750',
-                    content: 'other task',
-                    description: 'different content',
-                }),
-            ];
-            mockTodoistApi.getTasks.mockResolvedValue(createMockApiResponse(tasks));
-            const result = await findTasks.execute({
-                projectId: TEST_IDS.PROJECT_TEST,
-                searchText: 'relevant',
-                limit: 10,
-            }, mockTodoistApi);
-            expect(mockTodoistApi.getTasks).toHaveBeenCalledWith({
-                limit: 10,
-                cursor: null,
-                projectId: TEST_IDS.PROJECT_TEST,
-            });
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent.tasks).toHaveLength(1);
-            expect(structuredContent.tasks).toEqual([
-                expect.objectContaining({ content: 'relevant task' }),
-            ]);
-        });
-        it('should handle empty containers', async () => {
-            mockTodoistApi.getTasks.mockResolvedValue(createMockApiResponse([]));
-            const result = await findTasks.execute({
-                sectionId: 'empty-section',
-                limit: 10,
-            }, mockTodoistApi);
-            const textContent = extractTextContent(result);
-            expect(textContent).toContain('Section is empty');
-            expect(textContent).toContain('Tasks may be in other sections of the project');
-        });
-        it('should handle pagination with containers', async () => {
-            mockTodoistApi.getTasks.mockResolvedValue({
-                results: [],
-                nextCursor: 'next-cursor',
-            });
-            const result = await findTasks.execute({
-                projectId: TEST_IDS.PROJECT_TEST,
-                limit: 25,
-                cursor: 'current-cursor',
-            }, mockTodoistApi);
-            expect(mockTodoistApi.getTasks).toHaveBeenCalledWith({
-                limit: 25,
-                cursor: 'current-cursor',
-                projectId: TEST_IDS.PROJECT_TEST,
-            });
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent.hasMore).toBe(true);
-            expect(structuredContent.nextCursor).toBe('next-cursor');
-        });
-    });
-    describe('container error handling', () => {
-        it('should propagate API errors for container queries', async () => {
-            const apiError = new Error('API Error: Project not found');
-            mockTodoistApi.getTasks.mockRejectedValue(apiError);
-            await expect(findTasks.execute({ projectId: 'non-existent', limit: 10 }, mockTodoistApi)).rejects.toThrow('API Error: Project not found');
-        });
-    });
-    describe('next steps logic', () => {
-        it('should suggest different actions when hasOverdue is true', async () => {
-            const mockTasks = [
-                createMappedTask({
-                    id: TEST_IDS.TASK_1,
-                    content: 'Overdue search result',
-                    dueDate: '2025-08-10', // Past date
-                }),
-            ];
-            const mockResponse = { tasks: mockTasks, nextCursor: null };
-            mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await findTasks.execute({ searchText: 'overdue tasks', limit: 10 }, mockTodoistApi);
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-            // Should prioritize overdue tasks in next steps
-            expect(textContent).toContain(`Use ${UPDATE_TASKS} to modify priorities or due dates`);
-        });
-        it('should suggest today tasks when hasToday is true', async () => {
-            const mockTasks = [
-                createMappedTask({
-                    id: TEST_IDS.TASK_1,
-                    content: 'Task due today',
-                    dueDate: TODAY,
-                }),
-            ];
-            const mockResponse = { tasks: mockTasks, nextCursor: null };
-            mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await findTasks.execute({ searchText: 'today tasks', limit: 10 }, mockTodoistApi);
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-            // Should suggest today-focused actions
-            expect(textContent).toContain(`Use ${UPDATE_TASKS} to modify priorities or due dates`);
-        });
-        it('should provide different next steps for regular tasks', async () => {
-            const mockTasks = [
-                createMappedTask({
-                    id: TEST_IDS.TASK_1,
-                    content: 'Regular future task',
-                    dueDate: '2025-08-25', // Future date
-                }),
-            ];
-            const mockResponse = { tasks: mockTasks, nextCursor: null };
-            mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await findTasks.execute({ searchText: 'future tasks', limit: 10 }, mockTodoistApi);
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-            expect(textContent).toContain(`Use ${UPDATE_TASKS} to modify priorities or due dates`);
-        });
-        it('should provide helpful suggestions for empty search results', async () => {
-            const mockResponse = { tasks: [], nextCursor: null };
-            mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await findTasks.execute({ searchText: 'nonexistent', limit: 10 }, mockTodoistApi);
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-            expect(textContent).toContain('Try broader search terms');
-            expect(textContent).toContain(`Check completed tasks with ${FIND_COMPLETED_TASKS}`);
-            expect(textContent).toContain('Verify spelling and try partial words');
-        });
-    });
-    describe('label filtering', () => {
-        it.each([
-            {
-                name: 'text search with single label OR operator',
-                params: {
-                    searchText: 'important meeting',
-                    limit: 10,
-                    labels: ['work'],
-                },
-                expectedQuery: 'search: important meeting & (@work)',
-            },
-            {
-                name: 'text search with multiple labels AND operator',
-                params: {
-                    searchText: 'project update',
-                    limit: 15,
-                    labels: ['work', 'urgent'],
-                    labelsOperator: 'and',
-                },
-                expectedQuery: 'search: project update & (@work  &  @urgent)',
-            },
-            {
-                name: 'text search with multiple labels OR operator',
-                params: {
-                    searchText: 'follow up',
-                    limit: 20,
-                    labels: ['personal', 'shopping'],
-                },
-                expectedQuery: 'search: follow up & (@personal  |  @shopping)',
-            },
-        ])('should filter tasks by labels in text search: $name', async ({ params, expectedQuery }) => {
-            const mockTasks = [
-                createMappedTask({
-                    id: TEST_IDS.TASK_1,
-                    content: 'Task with work label',
-                    labels: ['work'],
-                }),
-            ];
-            const mockResponse = { tasks: mockTasks, nextCursor: null };
-            mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await findTasks.execute(params, mockTodoistApi);
-            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
-                client: mockTodoistApi,
-                query: expectedQuery,
-                cursor: undefined,
-                limit: params.limit,
-            });
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent.appliedFilters).toEqual(expect.objectContaining({
-                searchText: params.searchText,
-                labels: params.labels,
-                ...(params.labelsOperator ? { labelsOperator: params.labelsOperator } : {}),
-            }));
-        });
-        it.each([
-            {
-                name: 'project filter with labels',
-                params: {
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    limit: 10,
-                    labels: ['important'],
-                },
-                expectedApiParam: { projectId: TEST_IDS.PROJECT_TEST },
-            },
-            {
-                name: 'section filter with multiple labels',
-                params: {
-                    sectionId: TEST_IDS.SECTION_1,
-                    limit: 10,
-                    labels: ['work', 'urgent'],
-                    labelsOperator: 'and',
-                },
-                expectedApiParam: { sectionId: TEST_IDS.SECTION_1 },
-            },
-            {
-                name: 'parent task filter with labels',
-                params: {
-                    parentId: TEST_IDS.TASK_1,
-                    limit: 10,
-                    labels: ['personal'],
-                },
-                expectedApiParam: { parentId: TEST_IDS.TASK_1 },
-            },
-        ])('should apply label filtering to container searches: $name', async ({ params, expectedApiParam }) => {
-            const allTasks = [
-                createMockTask({
-                    id: '1',
-                    content: 'Task with matching label',
-                    labels: params.labels,
-                }),
-                createMockTask({
-                    id: '2',
-                    content: 'Task without matching label',
-                    labels: ['other'],
-                }),
-            ];
-            mockTodoistApi.getTasks.mockResolvedValue(createMockApiResponse(allTasks));
-            const result = await findTasks.execute(params, mockTodoistApi);
-            expect(mockTodoistApi.getTasks).toHaveBeenCalledWith({
-                limit: 10,
-                cursor: null,
-                ...expectedApiParam,
-            });
-            // Should filter results client-side based on labels
-            const structuredContent = extractStructuredContent(result);
-            if (params.labelsOperator === 'and') {
-                // AND operation: task must have all specified labels
-                expect(structuredContent.tasks).toEqual(expect.arrayContaining([
-                    expect.objectContaining({
-                        labels: expect.arrayContaining(params.labels),
-                    }),
-                ]));
-            }
-            else {
-                // OR operation: task must have at least one of the specified labels
-                expect(structuredContent.tasks.length).toBeGreaterThanOrEqual(0);
-            }
-        });
-        it('should handle empty labels array', async () => {
-            const params = {
-                searchText: 'test',
-                limit: 10,
-            };
-            const mockResponse = { tasks: [], nextCursor: null };
-            mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            await findTasks.execute(params, mockTodoistApi);
-            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
-                client: mockTodoistApi,
-                query: 'search: test',
-                cursor: undefined,
-                limit: 10,
-            });
-        });
-        it('should combine search text, container, and label filters', async () => {
-            const params = {
-                projectId: TEST_IDS.PROJECT_TEST,
-                searchText: 'important',
-                limit: 10,
-                labels: ['urgent'],
-            };
-            const allTasks = [
-                createMockTask({
-                    id: '1',
-                    content: 'important task',
-                    description: 'urgent work',
-                    labels: ['urgent'],
-                }),
-                createMockTask({
-                    id: '2',
-                    content: 'other task',
-                    description: 'not important',
-                    labels: ['work'],
-                }),
-            ];
-            mockTodoistApi.getTasks.mockResolvedValue(createMockApiResponse(allTasks));
-            const result = await findTasks.execute(params, mockTodoistApi);
-            // Should call API with container filter
-            expect(mockTodoistApi.getTasks).toHaveBeenCalledWith({
-                limit: 10,
-                cursor: null,
-                projectId: TEST_IDS.PROJECT_TEST,
-            });
-            // Should filter results by search text AND labels
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent.tasks).toEqual([
-                expect.objectContaining({
-                    content: 'important task',
-                    labels: expect.arrayContaining(['urgent']),
-                }),
-            ]);
-        });
-        it('should handle labels-only filtering', async () => {
-            const params = {
-                limit: 10,
-                labels: ['work'],
-            };
-            const mockTasks = [
-                createMappedTask({
-                    id: TEST_IDS.TASK_1,
-                    content: 'Task with work label',
-                    labels: ['work'],
-                }),
-            ];
-            const mockResponse = { tasks: mockTasks, nextCursor: null };
-            mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await findTasks.execute(params, mockTodoistApi);
-            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
-                client: mockTodoistApi,
-                query: '(@work)',
-                cursor: undefined,
-                limit: 10,
-            });
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent.appliedFilters).toEqual(expect.objectContaining({
-                labels: ['work'],
-            }));
-        });
-        it('should handle labels with @ symbol', async () => {
-            const params = {
-                limit: 10,
-                labels: ['@work', 'personal'], // Mix of with and without @
-            };
-            const mockTasks = [
-                createMappedTask({
-                    id: TEST_IDS.TASK_1,
-                    content: 'Task with work label',
-                    labels: ['work', 'personal'],
-                }),
-            ];
-            const mockResponse = { tasks: mockTasks, nextCursor: null };
-            mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await findTasks.execute(params, mockTodoistApi);
-            // Should handle both @work (already has @) and personal (needs @ added)
-            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
-                client: mockTodoistApi,
-                query: '(@work  |  @personal)',
-                cursor: undefined,
-                limit: 10,
-            });
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent.appliedFilters).toEqual(expect.objectContaining({
-                labels: ['@work', 'personal'],
-            }));
-        });
-    });
-    describe('markdown content preservation', () => {
-        it('should preserve markdown links and formatting in task content and description', async () => {
-            const richMarkdownContent = 'Test **bold** task with [link](https://example.com)';
-            const richMarkdownDescription = `This is a **comprehensive test** of markdown syntax in Todoist task descriptions:
-
-### Links
-[Wikipedia - Test Link](https://en.wikipedia.org/wiki/Test)
-[GitHub Repository](https://github.com/Doist/todoist-ai)
-[Google Search](https://www.google.com)
-
-### Text Formatting
-**Bold text here**
-*Italic text here*
-***Bold and italic***
-\`inline code\`
-
-### Lists
-- Bullet point 1
-- Bullet point 2
-  - Nested item
-
-1. Numbered item 1
-2. Numbered item 2
-
-End of test content.`;
-            const mockTasks = [
-                createMappedTask({
-                    id: TEST_IDS.TASK_1,
-                    content: richMarkdownContent,
-                    description: richMarkdownDescription,
-                }),
-            ];
-            const mockResponse = { tasks: mockTasks, nextCursor: null };
-            mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await findTasks.execute({ searchText: 'markdown test', limit: 10 }, mockTodoistApi);
-            const structuredContent = extractStructuredContent(result);
-            // Verify that markdown links and formatting are preserved exactly as provided
-            expect(structuredContent.tasks).toHaveLength(1);
-            expect(structuredContent.tasks).toEqual(expect.arrayContaining([
-                expect.objectContaining({
-                    content: richMarkdownContent,
-                    description: richMarkdownDescription,
-                }),
-            ]));
-        });
-        it('should preserve markdown links in container-based searches', async () => {
-            const taskWithLinks = createMockTask({
-                id: TEST_IDS.TASK_1,
-                content: 'Task with [external link](https://todoist.com)',
-                description: 'See this [documentation](https://docs.example.com) for details.',
-            });
-            mockTodoistApi.getTasks.mockResolvedValue(createMockApiResponse([taskWithLinks]));
-            const result = await findTasks.execute({ projectId: TEST_IDS.PROJECT_TEST, limit: 10 }, mockTodoistApi);
-            const structuredContent = extractStructuredContent(result);
-            // Verify URLs are preserved in container-based searches too
-            expect(structuredContent.tasks).toHaveLength(1);
-            expect(structuredContent.tasks).toEqual(expect.arrayContaining([
-                expect.objectContaining({
-                    content: 'Task with [external link](https://todoist.com)',
-                    description: 'See this [documentation](https://docs.example.com) for details.',
-                }),
-            ]));
-        });
-    });
-    describe('responsible user filtering', () => {
-        describe('when no responsibleUser is provided', () => {
-            it('should filter text search results to show only unassigned tasks or tasks assigned to current user', async () => {
-                const mockTasks = [
-                    createMappedTask({
-                        id: TEST_IDS.TASK_1,
-                        content: 'My task',
-                        responsibleUid: TEST_IDS.USER_ID, // Assigned to current user
-                    }),
-                    createMappedTask({
-                        id: TEST_IDS.TASK_2,
-                        content: 'Unassigned task',
-                        responsibleUid: null, // Unassigned
-                    }),
-                    createMappedTask({
-                        id: TEST_IDS.TASK_3,
-                        content: 'Someone else task',
-                        responsibleUid: 'other-user-id', // Assigned to someone else
-                    }),
-                ];
-                const mockResponse = { tasks: mockTasks, nextCursor: null };
-                mockGetTasksByFilter.mockResolvedValue(mockResponse);
-                const result = await findTasks.execute({ searchText: 'task', limit: 10 }, mockTodoistApi);
-                const structuredContent = extractStructuredContent(result);
-                // Should only return tasks 1 and 2, not task 3
-                expect(structuredContent.tasks).toHaveLength(2);
-                expect(structuredContent.tasks.map((t) => t.id)).toEqual([TEST_IDS.TASK_1, TEST_IDS.TASK_2]);
-            });
-            it('should filter container-based results to show only unassigned tasks or tasks assigned to current user', async () => {
-                const mockTasks = [
-                    createMockTask({
-                        id: TEST_IDS.TASK_1,
-                        content: 'My project task',
-                        responsibleUid: TEST_IDS.USER_ID, // Assigned to current user
-                    }),
-                    createMockTask({
-                        id: TEST_IDS.TASK_2,
-                        content: 'Unassigned project task',
-                        responsibleUid: null, // Unassigned
-                    }),
-                    createMockTask({
-                        id: TEST_IDS.TASK_3,
-                        content: 'Someone else project task',
-                        responsibleUid: 'other-user-id', // Assigned to someone else
-                    }),
-                ];
-                mockTodoistApi.getTasks.mockResolvedValue(createMockApiResponse(mockTasks));
-                const result = await findTasks.execute({ projectId: TEST_IDS.PROJECT_WORK, limit: 10 }, mockTodoistApi);
-                const structuredContent = extractStructuredContent(result);
-                // Should only return tasks 1 and 2, not task 3
-                expect(structuredContent.tasks).toHaveLength(2);
-                expect(structuredContent.tasks.map((t) => t.id)).toEqual([TEST_IDS.TASK_1, TEST_IDS.TASK_2]);
-            });
-        });
-        describe('when responsibleUser is provided', () => {
-            it('should filter text search results to show only tasks assigned to specified user', async () => {
-                const mockTasks = [
-                    createMappedTask({
-                        id: TEST_IDS.TASK_1,
-                        content: 'Task for John',
-                        responsibleUid: 'specific-user-id', // Assigned to specified user
-                    }),
-                    createMappedTask({
-                        id: TEST_IDS.TASK_2,
-                        content: 'My task',
-                        responsibleUid: TEST_IDS.USER_ID, // Assigned to current user
-                    }),
-                    createMappedTask({
-                        id: TEST_IDS.TASK_3,
-                        content: 'Unassigned task',
-                        responsibleUid: null, // Unassigned
-                    }),
-                ];
-                const mockResponse = { tasks: mockTasks, nextCursor: null };
-                mockGetTasksByFilter.mockResolvedValue(mockResponse);
-                mockResolveUserNameToId.mockResolvedValue({
-                    userId: 'specific-user-id',
-                    displayName: 'John Doe',
-                    email: 'john@example.com',
-                });
-                const result = await findTasks.execute({ searchText: 'task', responsibleUser: 'John Doe', limit: 10 }, mockTodoistApi);
-                const structuredContent = extractStructuredContent(result);
-                // Should only return task 1 (assigned to John)
-                expect(structuredContent.tasks).toHaveLength(1);
-                expect(structuredContent.tasks[0]?.id).toBe(TEST_IDS.TASK_1);
-            });
-            it('should filter container-based results to show only tasks assigned to specified user', async () => {
-                const mockTasks = [
-                    createMockTask({
-                        id: TEST_IDS.TASK_1,
-                        content: 'Task for John',
-                        responsibleUid: 'specific-user-id', // Assigned to specified user
-                    }),
-                    createMockTask({
-                        id: TEST_IDS.TASK_2,
-                        content: 'My task',
-                        responsibleUid: TEST_IDS.USER_ID, // Assigned to current user
-                    }),
-                    createMockTask({
-                        id: TEST_IDS.TASK_3,
-                        content: 'Unassigned task',
-                        responsibleUid: null, // Unassigned
-                    }),
-                ];
-                mockTodoistApi.getTasks.mockResolvedValue(createMockApiResponse(mockTasks));
-                mockResolveUserNameToId.mockResolvedValue({
-                    userId: 'specific-user-id',
-                    displayName: 'John Doe',
-                    email: 'john@example.com',
-                });
-                const result = await findTasks.execute({ projectId: TEST_IDS.PROJECT_WORK, responsibleUser: 'John Doe', limit: 10 }, mockTodoistApi);
-                const structuredContent = extractStructuredContent(result);
-                // Should only return task 1 (assigned to John)
-                expect(structuredContent.tasks).toHaveLength(1);
-                expect(structuredContent.tasks[0]?.id).toBe(TEST_IDS.TASK_1);
-            });
-        });
-    });
-    describe('error handling', () => {
-        it.each([
-            {
-                error: 'At least one filter must be provided: searchText, projectId, sectionId, parentId, responsibleUser, or labels',
-                params: { limit: 10 },
-                expectValidation: true,
-            },
-            {
-                error: TEST_ERRORS.API_RATE_LIMIT,
-                params: {
-                    searchText: 'any search term',
-                    limit: 10,
-                },
-                expectValidation: false,
-            },
-            {
-                error: TEST_ERRORS.INVALID_CURSOR,
-                params: {
-                    searchText: 'test',
-                    cursor: 'invalid-cursor-format',
-                    limit: 10,
-                },
-                expectValidation: false,
-            },
-        ])('should propagate $error', async ({ error, params, expectValidation }) => {
-            if (!expectValidation) {
-                mockGetTasksByFilter.mockRejectedValue(new Error(error));
-            }
-            await expect(findTasks.execute(params, mockTodoistApi)).rejects.toThrow(error);
-        });
-    });
-});