@doist/todoist-ai 4.1.0 → 4.5.1

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

@@ -1,6 +1,6 @@
 import { jest } from '@jest/globals';
 import { getTasksByFilter } from '../../tool-helpers.js';
-import { TEST_ERRORS, TEST_IDS, createMappedTask, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { createMappedTask, extractStructuredContent, extractTextContent, TEST_ERRORS, TEST_IDS, } from '../../utils/test-helpers.js';
 import { ToolNames } from '../../utils/tool-names.js';
 import { findTasksByDate } from '../find-tasks-by-date.js';
 // Mock the tool helpers
@@ -193,7 +193,11 @@ describe(`${FIND_TASKS_BY_DATE} tool`, () => {
             ];
             const mockResponse = { tasks: mockTasks, nextCursor: null };
             mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await findTasksByDate.execute({ startDate: '2025-08-15', limit: 10, daysCount: 1 }, mockTodoistApi);
+            const result = await findTasksByDate.execute({
+                startDate: '2025-08-15',
+                limit: 10,
+                daysCount: 1,
+            }, mockTodoistApi);
             const textContent = extractTextContent(result);
             expect(textContent).toMatchSnapshot();
             expect(textContent).toContain(`Use ${UPDATE_TASKS} to modify priorities or due dates`);
@@ -240,13 +244,128 @@ describe(`${FIND_TASKS_BY_DATE} tool`, () => {
         it('should provide helpful suggestions for empty date range results', async () => {
             const mockResponse = { tasks: [], nextCursor: null };
             mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await findTasksByDate.execute({ startDate: '2025-08-20', limit: 10, daysCount: 1 }, mockTodoistApi);
+            const result = await findTasksByDate.execute({
+                startDate: '2025-08-20',
+                limit: 10,
+                daysCount: 1,
+            }, mockTodoistApi);
             const textContent = extractTextContent(result);
             expect(textContent).toMatchSnapshot();
             expect(textContent).toContain("Expand date range with larger 'daysCount'");
             expect(textContent).toContain("Check 'overdue' for past-due items");
         });
     });
+    describe('label filtering', () => {
+        it.each([
+            {
+                name: 'single label with OR operator',
+                params: {
+                    startDate: 'today',
+                    daysCount: 1,
+                    limit: 50,
+                    labels: ['work'],
+                },
+                expectedQueryPattern: '((@work))', // Will be combined with date query
+            },
+            {
+                name: 'multiple labels with AND operator',
+                params: {
+                    startDate: 'overdue',
+                    daysCount: 1,
+                    limit: 50,
+                    labels: ['work', 'urgent'],
+                    labelsOperator: 'and',
+                },
+                expectedQueryPattern: 'overdue & ((@work  &  @urgent))',
+            },
+            {
+                name: 'multiple labels with OR operator',
+                params: {
+                    startDate: '2025-08-20',
+                    daysCount: 3,
+                    limit: 50,
+                    labels: ['personal', 'shopping'],
+                    labelsOperator: 'or',
+                },
+                expectedQueryPattern: '((@personal  |  @shopping))',
+            },
+        ])('should filter tasks by labels: $name', async ({ params, expectedQueryPattern }) => {
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'Task with work label',
+                    labels: ['work'],
+                    dueDate: '2025-08-20',
+                }),
+            ];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasksByDate.execute(params, mockTodoistApi);
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: expect.stringContaining('(@'),
+                cursor: undefined,
+                limit: 50,
+            });
+            // For overdue specifically, check the exact pattern
+            if (params.startDate === 'overdue') {
+                expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                    client: mockTodoistApi,
+                    query: expectedQueryPattern,
+                    cursor: undefined,
+                    limit: 50,
+                });
+            }
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent.appliedFilters).toEqual(expect.objectContaining({
+                labels: params.labels,
+                ...(params.labelsOperator ? { labelsOperator: params.labelsOperator } : {}),
+            }));
+        });
+        it('should handle empty labels array', async () => {
+            const params = {
+                startDate: 'today',
+                daysCount: 1,
+                limit: 50,
+            };
+            const mockResponse = { tasks: [], nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            await findTasksByDate.execute(params, mockTodoistApi);
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: expect.not.stringContaining('@'),
+                cursor: undefined,
+                limit: 50,
+            });
+        });
+        it('should combine date filters with label filters', async () => {
+            const params = {
+                startDate: '2025-08-15',
+                daysCount: 1,
+                limit: 25,
+                labels: ['important'],
+            };
+            const mockTasks = [
+                createMappedTask({
+                    content: 'Important task for specific date',
+                    labels: ['important'],
+                    dueDate: '2025-08-15',
+                }),
+            ];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasksByDate.execute(params, mockTodoistApi);
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: expect.stringContaining('due after:') &&
+                    expect.stringContaining('(@important)'),
+                cursor: undefined,
+                limit: 25,
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+        });
+    });
     describe('error handling', () => {
         it.each([
             {

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

@@ -1,6 +1,6 @@
 import { jest } from '@jest/globals';
 import { getTasksByFilter } from '../../tool-helpers.js';
-import { TEST_ERRORS, TEST_IDS, TODAY, createMappedTask, createMockApiResponse, createMockTask, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { createMappedTask, createMockApiResponse, createMockTask, extractStructuredContent, extractTextContent, TEST_ERRORS, TEST_IDS, TODAY, } from '../../utils/test-helpers.js';
 import { ToolNames } from '../../utils/tool-names.js';
 import { findTasks } from '../find-tasks.js';
 jest.mock('../../tool-helpers', () => {
@@ -60,7 +60,6 @@ describe(`${FIND_TASKS} tool`, () => {
                 appliedFilters: {
                     searchText: 'important meeting',
                     limit: 10,
-                    cursor: undefined,
                 },
             }));
             expect(structuredContent).toEqual(expect.objectContaining({
@@ -70,14 +69,21 @@ describe(`${FIND_TASKS} tool`, () => {
         it.each([
             {
                 name: 'custom limit',
-                params: { searchText: 'project update', limit: 5 },
+                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' },
+                params: {
+                    searchText: 'follow up',
+                    limit: 20,
+                    cursor: 'cursor-from-first-page',
+                },
                 expectedQuery: 'search: follow up',
                 expectedLimit: 20,
                 expectedCursor: 'cursor-from-first-page',
@@ -141,26 +147,35 @@ describe(`${FIND_TASKS} tool`, () => {
     });
     describe('validation', () => {
         it('should require at least one filter parameter', async () => {
-            await expect(findTasks.execute({ limit: 10 }, mockTodoistApi)).rejects.toThrow('At least one filter must be provided: searchText, projectId, sectionId, or parentId');
+            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 },
+                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 },
+                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 },
+                params: {
+                    parentId: TEST_IDS.TASK_1,
+                    limit: 10,
+                },
                 expectedApiParam: { parentId: TEST_IDS.TASK_1 },
                 tasks: [createMockTask({ content: 'Subtask' })],
             },
@@ -307,21 +322,253 @@ describe(`${FIND_TASKS} tool`, () => {
             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('error handling', () => {
         it.each([
             {
-                error: 'At least one filter must be provided: searchText, projectId, sectionId, or parentId',
+                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 },
+                params: {
+                    searchText: 'any search term',
+                    limit: 10,
+                },
                 expectValidation: false,
             },
             {
                 error: TEST_ERRORS.INVALID_CURSOR,
-                params: { searchText: 'test', cursor: 'invalid-cursor-format', limit: 10 },
+                params: {
+                    searchText: 'test',
+                    cursor: 'invalid-cursor-format',
+                    limit: 10,
+                },
                 expectValidation: false,
             },
         ])('should propagate $error', async ({ error, params, expectValidation }) => {

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

@@ -1,5 +1,5 @@
 import { jest } from '@jest/globals';
-import { TEST_ERRORS, TEST_IDS, createMockProject, createMockSection, createMockTask, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { createMockProject, createMockSection, createMockTask, extractStructuredContent, extractTextContent, TEST_ERRORS, TEST_IDS, } from '../../utils/test-helpers.js';
 import { ToolNames } from '../../utils/tool-names.js';
 import { getOverview } from '../get-overview.js';
 // Mock the Todoist API

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

@@ -25,6 +25,7 @@ describe(`${UPDATE_SECTIONS} tool`, () => {
                 isDeleted: false,
                 isCollapsed: false,
                 name: 'Updated Section Name',
+                url: 'https://todoist.com/sections/existing-section-123',
             };
             mockTodoistApi.updateSection.mockResolvedValue(mockApiResponse);
             const result = await updateSections.execute({ sections: [{ id: 'existing-section-123', name: 'Updated Section Name' }] }, mockTodoistApi);

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

@@ -1,5 +1,5 @@
 import { jest } from '@jest/globals';
-import { TEST_IDS, createMockTask, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { createMockTask, extractStructuredContent, extractTextContent, TEST_IDS, } from '../../utils/test-helpers.js';
 import { ToolNames } from '../../utils/tool-names.js';
 import { updateTasks } from '../update-tasks.js';
 // Mock the Todoist API
@@ -109,13 +109,13 @@ describe(`${UPDATE_TASKS} tool`, () => {
                 tasks: [
                     {
                         id: '8485093749',
-                        priority: 3,
+                        priority: 'p3',
                         dueString: 'Aug 20',
                     },
                 ],
             }, mockTodoistApi);
             expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('8485093749', {
-                priority: 3,
+                priority: 2,
                 dueString: 'Aug 20',
             });
             // Verify result structure
@@ -208,7 +208,7 @@ describe(`${UPDATE_TASKS} tool`, () => {
                         id: '8485093752',
                         content: 'Completely updated task',
                         description: 'New description with details',
-                        priority: 4,
+                        priority: 'p4',
                         dueString: 'every Friday',
                         projectId: 'different-project-id',
                     },
@@ -222,7 +222,7 @@ describe(`${UPDATE_TASKS} tool`, () => {
             expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('8485093752', {
                 content: 'Completely updated task',
                 description: 'New description with details',
-                priority: 4,
+                priority: 1,
                 dueString: 'every Friday',
             });
             // Verify result structure
@@ -391,7 +391,7 @@ describe(`${UPDATE_TASKS} tool`, () => {
             },
             {
                 error: 'API Error: Invalid priority value',
-                params: { id: '8485093748', priority: 5 },
+                params: { id: '8485093748', content: 'Test task' },
             },
         ])('should propagate $error', async ({ error, params }) => {
             mockTodoistApi.updateTask.mockRejectedValue(new Error(error));

package/dist/tools/__tests__/user-info.test.d.ts

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

package/dist/tools/__tests__/user-info.test.d.ts.map

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