@doist/todoist-ai 2.2.2 → 4.0.0

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

@@ -1,12 +1,14 @@
 import { jest } from '@jest/globals';
-import { tasksListCompleted } from '../tasks-list-completed.js';
-import { createMockTask } from '../test-helpers.js';
+import { createMockTask, extractTextContent } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { findCompletedTasks } from '../find-completed-tasks.js';
 // Mock the Todoist API
 const mockTodoistApi = {
     getCompletedTasksByCompletionDate: jest.fn(),
     getCompletedTasksByDueDate: jest.fn(),
 };
-describe('tasks-list-completed tool', () => {
+const { FIND_COMPLETED_TASKS } = ToolNames;
+describe(`${FIND_COMPLETED_TASKS} tool`, () => {
     beforeEach(() => {
         jest.clearAllMocks();
     });
@@ -35,32 +37,20 @@ describe('tasks-list-completed tool', () => {
                 items: mockCompletedTasks,
                 nextCursor: null,
             });
-            const result = await tasksListCompleted.execute({ getBy: 'completion', limit: 50, since: '2025-08-10', until: '2025-08-15' }, mockTodoistApi);
+            const result = await findCompletedTasks.execute({ getBy: 'completion', limit: 50, since: '2025-08-10', until: '2025-08-15' }, mockTodoistApi);
             expect(mockTodoistApi.getCompletedTasksByCompletionDate).toHaveBeenCalledWith({
                 since: '2025-08-10',
                 until: '2025-08-15',
                 limit: 50,
             });
-            expect(result).toEqual({
-                tasks: [
-                    expect.objectContaining({
-                        id: '8485093748',
-                        content: 'Completed task 1',
-                        description: 'Task completed yesterday',
-                        dueDate: '2025-08-14',
-                        priority: 2,
-                        labels: ['work'],
-                    }),
-                ],
-                nextCursor: null,
-            });
+            expect(extractTextContent(result)).toMatchSnapshot();
         });
         it('should handle explicit completion date query', async () => {
             mockTodoistApi.getCompletedTasksByCompletionDate.mockResolvedValue({
                 items: [],
                 nextCursor: 'next-cursor',
             });
-            const result = await tasksListCompleted.execute({
+            const result = await findCompletedTasks.execute({
                 getBy: 'completion',
                 limit: 100,
                 since: '2025-08-01',
@@ -75,7 +65,7 @@ describe('tasks-list-completed tool', () => {
                 limit: 100,
                 cursor: 'current-cursor',
             });
-            expect(result).toEqual({ tasks: [], nextCursor: 'next-cursor' });
+            expect(extractTextContent(result)).toMatchSnapshot();
         });
     });
     describe('getting completed tasks by due date', () => {
@@ -103,7 +93,7 @@ describe('tasks-list-completed tool', () => {
                 items: mockCompletedTasks,
                 nextCursor: null,
             });
-            const result = await tasksListCompleted.execute({
+            const result = await findCompletedTasks.execute({
                 getBy: 'due',
                 limit: 50,
                 since: '2025-08-10',
@@ -115,34 +105,21 @@ describe('tasks-list-completed tool', () => {
                 limit: 50,
             });
             expect(mockTodoistApi.getCompletedTasksByCompletionDate).not.toHaveBeenCalled();
-            expect(result).toEqual({
-                tasks: [
-                    expect.objectContaining({
-                        id: '8485093750',
-                        content: 'Task completed by due date',
-                        description: 'This task was due and completed',
-                        dueDate: '2025-08-15',
-                        recurring: 'every Monday',
-                        priority: 3,
-                        labels: ['urgent'],
-                    }),
-                ],
-                nextCursor: null,
-            });
+            expect(extractTextContent(result)).toMatchSnapshot();
         });
     });
     describe('error handling', () => {
         it('should propagate completion date API errors', async () => {
             const apiError = new Error('API Error: Invalid date range');
             mockTodoistApi.getCompletedTasksByCompletionDate.mockRejectedValue(apiError);
-            await expect(tasksListCompleted.execute(
+            await expect(findCompletedTasks.execute(
             // invalid date range
             { getBy: 'completion', limit: 50, since: '2025-08-31', until: '2025-08-01' }, mockTodoistApi)).rejects.toThrow('API Error: Invalid date range');
         });
         it('should propagate due date API errors', async () => {
             const apiError = new Error('API Error: Project not found');
             mockTodoistApi.getCompletedTasksByDueDate.mockRejectedValue(apiError);
-            await expect(tasksListCompleted.execute({
+            await expect(findCompletedTasks.execute({
                 getBy: 'due',
                 limit: 50,
                 since: '2025-08-01',

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

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

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

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

package/dist/tools/__tests__/{projects-list.test.js → find-projects.test.js}

@@ -1,11 +1,13 @@
 import { jest } from '@jest/globals';
-import { projectsList } from '../projects-list.js';
-import { TEST_ERRORS, TEST_IDS, createMockApiResponse, createMockProject } from '../test-helpers.js';
+import { TEST_ERRORS, TEST_IDS, createMockApiResponse, createMockProject, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { findProjects } from '../find-projects.js';
 // Mock the Todoist API
 const mockTodoistApi = {
     getProjects: jest.fn(),
 };
-describe('projects-list tool', () => {
+const { FIND_PROJECTS } = ToolNames;
+describe(`${FIND_PROJECTS} tool`, () => {
     beforeEach(() => {
         jest.clearAllMocks();
     });
@@ -38,37 +40,27 @@ describe('projects-list tool', () => {
                 }),
             ];
             mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
-            const result = await projectsList.execute({ limit: 50 }, mockTodoistApi);
+            const result = await findProjects.execute({ limit: 50 }, mockTodoistApi);
             // Verify API was called correctly
             expect(mockTodoistApi.getProjects).toHaveBeenCalledWith({
                 limit: 50,
                 cursor: null,
             });
-            // Verify result is properly mapped
-            expect(result).toEqual({
-                projects: [
-                    expect.objectContaining({
-                        id: TEST_IDS.PROJECT_INBOX,
-                        name: 'Inbox',
-                        color: 'grey',
-                        inboxProject: true,
-                    }),
-                    expect.objectContaining({
-                        id: TEST_IDS.PROJECT_TEST,
-                        name: 'test-abc123def456-project',
-                        color: 'charcoal',
-                    }),
-                    expect.objectContaining({
-                        id: TEST_IDS.PROJECT_WORK,
-                        name: 'Work Project',
-                        color: 'blue',
-                        isFavorite: true,
-                        isShared: true,
-                        viewStyle: 'board',
-                    }),
-                ],
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                projects: expect.any(Array),
+                totalCount: 3,
+                hasMore: false,
                 nextCursor: null,
-            });
+                appliedFilters: {
+                    search: undefined,
+                    limit: 50,
+                    cursor: undefined,
+                },
+            }));
+            expect(structuredContent.projects).toHaveLength(3);
         });
         it('should handle pagination with limit and cursor', async () => {
             const mockProject = createMockProject({
@@ -77,14 +69,23 @@ describe('projects-list tool', () => {
                 color: 'red',
             });
             mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse([mockProject], 'next-page-cursor'));
-            const result = await projectsList.execute({ limit: 10, cursor: 'current-page-cursor' }, mockTodoistApi);
+            const result = await findProjects.execute({ limit: 10, cursor: 'current-page-cursor' }, mockTodoistApi);
             expect(mockTodoistApi.getProjects).toHaveBeenCalledWith({
                 limit: 10,
                 cursor: 'current-page-cursor',
             });
-            expect(result.projects).toHaveLength(1);
-            expect(result.projects[0]?.name).toBe('First Project');
-            expect(result.nextCursor).toBe('next-page-cursor');
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent.projects).toHaveLength(1);
+            expect(structuredContent.totalCount).toBe(1);
+            expect(structuredContent.hasMore).toBe(true);
+            expect(structuredContent.nextCursor).toBe('next-page-cursor');
+            expect(structuredContent.appliedFilters).toEqual({
+                search: undefined,
+                limit: 10,
+                cursor: 'current-page-cursor',
+            });
         });
     });
     describe('searching projects', () => {
@@ -103,10 +104,20 @@ describe('projects-list tool', () => {
                 createMockProject({ id: 'hobby-project-id', name: 'Hobby Work', color: 'orange' }),
             ];
             mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
-            const result = await projectsList.execute({ search: 'work', limit: 50 }, mockTodoistApi);
+            const result = await findProjects.execute({ search: 'work', limit: 50 }, mockTodoistApi);
             expect(mockTodoistApi.getProjects).toHaveBeenCalledWith({ limit: 50, cursor: null });
-            expect(result.projects).toHaveLength(2);
-            expect(result.projects.map((p) => p.name)).toEqual(['Work Project', 'Hobby Work']);
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content with search filter
+            const structuredContent = extractStructuredContent(result);
+            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,
+                cursor: undefined,
+            });
         });
         it.each([
             {
@@ -121,11 +132,16 @@ describe('projects-list tool', () => {
                 expectedCount: 1,
                 description: 'case insensitive matching',
             },
-        ])('should handle search with $description', async ({ search, projects, expectedCount }) => {
+        ])('should handle search with $description', async ({ search, projects }) => {
             const mockProjects = projects.map((name) => createMockProject({ name }));
             mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
-            const result = await projectsList.execute({ search, limit: 50 }, mockTodoistApi);
-            expect(result.projects).toHaveLength(expectedCount);
+            const result = await findProjects.execute({ search, limit: 50 }, mockTodoistApi);
+            expect(extractTextContent(result)).toMatchSnapshot();
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                appliedFilters: expect.objectContaining({ search }),
+            }));
         });
     });
     describe('error handling', () => {
@@ -134,7 +150,7 @@ describe('projects-list tool', () => {
             { error: TEST_ERRORS.INVALID_CURSOR, params: { cursor: 'invalid-cursor', limit: 50 } },
         ])('should propagate $error', async ({ error, params }) => {
             mockTodoistApi.getProjects.mockRejectedValue(new Error(error));
-            await expect(projectsList.execute(params, mockTodoistApi)).rejects.toThrow(error);
+            await expect(findProjects.execute(params, mockTodoistApi)).rejects.toThrow(error);
         });
     });
 });

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

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

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

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

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, ADD_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 ${ADD_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":""}