@doist/todoist-ai 2.2.2 → 3.0.0

package/dist/tools/__tests__/{sections-search.test.js → find-sections.test.js}

@@ -1,11 +1,13 @@
 import { jest } from '@jest/globals';
-import { sectionsSearch } from '../sections-search.js';
-import { TEST_ERRORS, TEST_IDS, createMockSection } from '../test-helpers.js';
+import { TEST_ERRORS, TEST_IDS, createMockSection, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { findSections } from '../find-sections.js';
 // Mock the Todoist API
 const mockTodoistApi = {
     getSections: jest.fn(),
 };
-describe('sections-search tool', () => {
+const { FIND_SECTIONS, MANAGE_SECTIONS } = ToolNames;
+describe(`${FIND_SECTIONS} tool`, () => {
     beforeEach(() => {
         jest.clearAllMocks();
     });
@@ -40,29 +42,47 @@ describe('sections-search tool', () => {
                 results: mockSections,
                 nextCursor: null,
             });
-            const result = await sectionsSearch.execute({ projectId: TEST_IDS.PROJECT_TEST }, mockTodoistApi);
-            // Verify API was called correctly
+            const result = await findSections.execute({ projectId: TEST_IDS.PROJECT_TEST }, mockTodoistApi);
             expect(mockTodoistApi.getSections).toHaveBeenCalledWith({
                 projectId: TEST_IDS.PROJECT_TEST,
             });
-            // Verify result is properly mapped (simplified format)
-            expect(result).toEqual([
-                { id: TEST_IDS.SECTION_1, name: 'To Do' },
-                { id: TEST_IDS.SECTION_2, name: 'In Progress' },
-                { id: 'section-789', name: 'Done' },
-                { id: 'section-999', name: 'Backlog Items' },
-            ]);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Sections in project');
+            expect(textContent).toContain('To Do • id=');
+            expect(textContent).toContain('In Progress • id=');
+            expect(textContent).toContain('Done • id=');
+            expect(textContent).toContain('Backlog Items • id=');
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent.sections).toHaveLength(4);
+            expect(structuredContent.totalCount).toBe(4);
+            expect(structuredContent.appliedFilters).toEqual({
+                projectId: TEST_IDS.PROJECT_TEST,
+                search: undefined,
+            });
         });
         it('should handle project with no sections', async () => {
             mockTodoistApi.getSections.mockResolvedValue({
                 results: [],
                 nextCursor: null,
             });
-            const result = await sectionsSearch.execute({ projectId: 'empty-project-id' }, mockTodoistApi);
+            const result = await findSections.execute({ projectId: 'empty-project-id' }, mockTodoistApi);
             expect(mockTodoistApi.getSections).toHaveBeenCalledWith({
                 projectId: 'empty-project-id',
             });
-            expect(result).toEqual([]);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Project has no sections yet');
+            expect(textContent).toContain(`Use ${MANAGE_SECTIONS} to create sections`);
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent.sections).toHaveLength(0);
+            expect(structuredContent.totalCount).toBe(0);
+            expect(structuredContent.appliedFilters).toEqual({
+                projectId: 'empty-project-id',
+                search: undefined,
+            });
         });
     });
     describe('searching sections by name', () => {
@@ -96,18 +116,16 @@ describe('sections-search tool', () => {
                 results: mockSections,
                 nextCursor: null,
             });
-            const result = await sectionsSearch.execute({
-                projectId: TEST_IDS.PROJECT_TEST,
-                search: 'progress',
-            }, mockTodoistApi);
+            const result = await findSections.execute({ projectId: TEST_IDS.PROJECT_TEST, search: 'progress' }, mockTodoistApi);
             expect(mockTodoistApi.getSections).toHaveBeenCalledWith({
                 projectId: TEST_IDS.PROJECT_TEST,
             });
             // Should return both "In Progress" and "Progress Review" (case insensitive partial match)
-            expect(result).toEqual([
-                { id: TEST_IDS.SECTION_2, name: 'In Progress' },
-                { id: 'section-999', name: 'Progress Review' },
-            ]);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('matching "progress"');
+            expect(textContent).toContain('In Progress • id=');
+            expect(textContent).toContain('Progress Review • id=');
         });
         it('should handle search with no matches', async () => {
             const mockSections = [
@@ -127,11 +145,12 @@ describe('sections-search tool', () => {
                 results: mockSections,
                 nextCursor: null,
             });
-            const result = await sectionsSearch.execute({
-                projectId: TEST_IDS.PROJECT_TEST,
-                search: 'nonexistent',
-            }, mockTodoistApi);
-            expect(result).toEqual([]);
+            const result = await findSections.execute({ projectId: TEST_IDS.PROJECT_TEST, search: 'nonexistent' }, mockTodoistApi);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Try broader search terms');
+            expect(textContent).toContain('Check spelling');
+            expect(textContent).toContain('Remove search to see all sections');
         });
         it('should handle case sensitive search correctly', async () => {
             const mockSections = [
@@ -151,13 +170,12 @@ describe('sections-search tool', () => {
                 results: mockSections,
                 nextCursor: null,
             });
-            const result = await sectionsSearch.execute({
-                projectId: TEST_IDS.PROJECT_TEST,
-                search: 'IMPORTANT',
-            }, mockTodoistApi);
+            const result = await findSections.execute({ projectId: TEST_IDS.PROJECT_TEST, search: 'IMPORTANT' }, mockTodoistApi);
             // Should match despite different case
-            expect(result).toHaveLength(1);
-            expect(result[0]).toEqual({ id: TEST_IDS.SECTION_1, name: 'Important Tasks' });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('matching "IMPORTANT"');
+            expect(textContent).toContain('Important Tasks • id=');
         });
         it('should handle partial matches correctly', async () => {
             const mockSections = [
@@ -183,15 +201,13 @@ describe('sections-search tool', () => {
                 results: mockSections,
                 nextCursor: null,
             });
-            const result = await sectionsSearch.execute({
-                projectId: TEST_IDS.PROJECT_TEST,
-                search: 'task',
-            }, mockTodoistApi);
+            const result = await findSections.execute({ projectId: TEST_IDS.PROJECT_TEST, search: 'task' }, mockTodoistApi);
             // Should match both sections with "task" in the name
-            expect(result).toEqual([
-                { id: TEST_IDS.SECTION_1, name: 'Development Tasks' },
-                { id: TEST_IDS.SECTION_2, name: 'Testing Tasks' },
-            ]);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('matching "task"');
+            expect(textContent).toContain('Development Tasks • id=');
+            expect(textContent).toContain('Testing Tasks • id=');
         });
         it('should handle exact matches', async () => {
             const mockSections = [
@@ -211,15 +227,13 @@ describe('sections-search tool', () => {
                 results: mockSections,
                 nextCursor: null,
             });
-            const result = await sectionsSearch.execute({
-                projectId: TEST_IDS.PROJECT_TEST,
-                search: 'done',
-            }, mockTodoistApi);
+            const result = await findSections.execute({ projectId: TEST_IDS.PROJECT_TEST, search: 'done' }, mockTodoistApi);
             // Should match both sections containing "done"
-            expect(result).toEqual([
-                { id: TEST_IDS.SECTION_1, name: 'Done' },
-                { id: TEST_IDS.SECTION_2, name: 'Done Soon' },
-            ]);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('matching "done"');
+            expect(textContent).toContain('Done • id=');
+            expect(textContent).toContain('Done Soon • id=');
         });
     });
     describe('error handling', () => {
@@ -229,7 +243,7 @@ describe('sections-search tool', () => {
             { error: 'API Error: Invalid project ID format', projectId: 'invalid-id-format' },
         ])('should propagate $error', async ({ error, projectId }) => {
             mockTodoistApi.getSections.mockRejectedValue(new Error(error));
-            await expect(sectionsSearch.execute({ projectId }, mockTodoistApi)).rejects.toThrow(error);
+            await expect(findSections.execute({ projectId }, mockTodoistApi)).rejects.toThrow(error);
         });
     });
 });

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

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

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

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

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

@@ -1,13 +1,14 @@
 import { jest } from '@jest/globals';
 import { getTasksByFilter } from '../../tool-helpers.js';
-import { tasksListByDate } from '../tasks-list-by-date.js';
-import { TEST_ERRORS, TEST_IDS, createMappedTask } from '../test-helpers.js';
+import { TEST_ERRORS, TEST_IDS, createMappedTask, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { findTasksByDate } from '../find-tasks-by-date.js';
 // Mock the tool helpers
 jest.mock('../../tool-helpers', () => ({
     getTasksByFilter: jest.fn(),
 }));
 const mockGetTasksByFilter = getTasksByFilter;
-// Mock the Todoist API (not directly used by tasks-list-by-date, but needed for type)
+// Mock the Todoist API (not directly used by find-tasks-by-date, but needed for type)
 const mockTodoistApi = {};
 // Mock date-fns functions to make tests deterministic
 jest.mock('date-fns', () => ({
@@ -25,7 +26,8 @@ jest.mock('date-fns', () => ({
         return '2025-08-16'; // Return predictable end date
     }),
 }));
-describe('tasks-list-by-date tool', () => {
+const { FIND_TASKS_BY_DATE, UPDATE_TASKS } = ToolNames;
+describe(`${FIND_TASKS_BY_DATE} tool`, () => {
     beforeEach(() => {
         jest.clearAllMocks();
         // Mock current date to make tests deterministic
@@ -52,14 +54,26 @@ describe('tasks-list-by-date tool', () => {
                 : [];
             const mockResponse = { tasks: mockTasks, nextCursor: null };
             mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await tasksListByDate.execute({ startDate: 'overdue', limit: 50, daysCount }, mockTodoistApi);
+            const result = await findTasksByDate.execute({ startDate: 'overdue', limit: 50, daysCount }, mockTodoistApi);
             expect(mockGetTasksByFilter).toHaveBeenCalledWith({
                 client: mockTodoistApi,
                 query: 'overdue',
                 cursor: undefined,
                 limit: 50,
             });
-            expect(result).toEqual(mockResponse);
+            // Verify result is a concise summary
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent.tasks).toHaveLength(hasTasks ? 1 : 0);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                totalCount: hasTasks ? 1 : 0,
+                hasMore: false,
+                nextCursor: null,
+                appliedFilters: expect.objectContaining({
+                    startDate: 'overdue',
+                }),
+            }));
         });
     });
     describe('listing tasks by date range', () => {
@@ -67,14 +81,15 @@ describe('tasks-list-by-date tool', () => {
             const mockTasks = [createMappedTask({ content: 'Today task', dueDate: '2025-08-15' })];
             const mockResponse = { tasks: mockTasks, nextCursor: null };
             mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await tasksListByDate.execute({ startDate: 'today', limit: 50, daysCount: 7 }, mockTodoistApi);
+            const result = await findTasksByDate.execute({ startDate: 'today', limit: 50, daysCount: 7 }, mockTodoistApi);
             expect(mockGetTasksByFilter).toHaveBeenCalledWith({
                 client: mockTodoistApi,
                 query: expect.stringContaining('due after:') && expect.stringContaining('due before:'),
                 cursor: undefined,
                 limit: 50,
             });
-            expect(result).toEqual(mockResponse);
+            // Verify result is a concise summary
+            expect(extractTextContent(result)).toMatchSnapshot();
         });
         it.each([
             {
@@ -108,14 +123,15 @@ describe('tasks-list-by-date tool', () => {
         ])('should handle $name', async ({ params, tasks, cursor }) => {
             const mockResponse = { tasks, nextCursor: cursor };
             mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await tasksListByDate.execute(params, mockTodoistApi);
+            const result = await findTasksByDate.execute(params, mockTodoistApi);
             expect(mockGetTasksByFilter).toHaveBeenCalledWith({
                 client: mockTodoistApi,
                 query: expect.stringContaining('2025-08-20'),
                 cursor: params.cursor || undefined,
                 limit: params.limit,
             });
-            expect(result).toEqual(mockResponse);
+            // Verify result is a concise summary
+            expect(extractTextContent(result)).toMatchSnapshot();
         });
     });
     describe('pagination and limits', () => {
@@ -140,7 +156,7 @@ describe('tasks-list-by-date tool', () => {
         ])('should handle $name', async ({ params, expectedCursor, expectedLimit }) => {
             const mockResponse = { tasks: [], nextCursor: null };
             mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            await tasksListByDate.execute(params, mockTodoistApi);
+            await findTasksByDate.execute(params, mockTodoistApi);
             expect(mockGetTasksByFilter).toHaveBeenCalledWith({
                 client: mockTodoistApi,
                 query: expect.any(String),
@@ -158,13 +174,79 @@ describe('tasks-list-by-date tool', () => {
             const mockResponse = { tasks: [], nextCursor: null };
             mockGetTasksByFilter.mockResolvedValue(mockResponse);
             const startDate = daysCount === 7 ? 'today' : '2025-08-15';
-            const result = await tasksListByDate.execute({ startDate, limit: 50, daysCount }, mockTodoistApi);
+            const result = await findTasksByDate.execute({ startDate, limit: 50, daysCount }, mockTodoistApi);
             expect(mockGetTasksByFilter).toHaveBeenCalledTimes(1);
             if (shouldReturnResult) {
-                expect(result).toEqual(mockResponse);
+                // Verify result is a concise summary
+                expect(extractTextContent(result)).toMatchSnapshot();
             }
         });
     });
+    describe('next steps logic', () => {
+        it('should suggest appropriate actions when hasOverdue is true', async () => {
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'Overdue task from list',
+                    dueDate: '2025-08-10', // Past date - creates hasOverdue context
+                }),
+            ];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            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`);
+        });
+        it('should suggest today-focused actions when startDate is today', async () => {
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: "Today's task",
+                    dueDate: '2025-08-15', // Today's date based on our mock
+                }),
+            ];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasksByDate.execute({ startDate: 'today', limit: 10, daysCount: 1 }, mockTodoistApi);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain(`Use ${UPDATE_TASKS} to modify priorities or due dates`);
+        });
+        it('should suggest appropriate actions when startDate is overdue', async () => {
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'Overdue task',
+                    dueDate: '2025-08-10',
+                }),
+            ];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasksByDate.execute({ startDate: 'overdue', limit: 10, daysCount: 1 }, 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 overdue results', async () => {
+            const mockResponse = { tasks: [], nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasksByDate.execute({ startDate: 'overdue', limit: 10, daysCount: 1 }, mockTodoistApi);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Great job! No overdue tasks');
+            expect(textContent).toContain("Check today's tasks with startDate='today'");
+        });
+        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 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('error handling', () => {
         it.each([
             {
@@ -186,7 +268,7 @@ describe('tasks-list-by-date tool', () => {
             },
         ])('should propagate $error', async ({ error, params }) => {
             mockGetTasksByFilter.mockRejectedValue(new Error(error));
-            await expect(tasksListByDate.execute(params, mockTodoistApi)).rejects.toThrow(error);
+            await expect(findTasksByDate.execute(params, mockTodoistApi)).rejects.toThrow(error);
         });
     });
 });

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

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

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

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