@doist/todoist-ai 4.16.0 → 4.17.0

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

@@ -1,154 +0,0 @@
-import { jest } from '@jest/globals';
-import { createMockApiResponse, createMockProject, extractStructuredContent, extractTextContent, TEST_ERRORS, TEST_IDS, } 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(),
-};
-const { FIND_PROJECTS } = ToolNames;
-describe(`${FIND_PROJECTS} tool`, () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('listing all projects', () => {
-        it('should list all projects when no search parameter is provided', async () => {
-            const mockProjects = [
-                createMockProject({
-                    id: TEST_IDS.PROJECT_INBOX,
-                    name: 'Inbox',
-                    color: 'grey',
-                    inboxProject: true,
-                    childOrder: 0,
-                }),
-                createMockProject({
-                    id: TEST_IDS.PROJECT_TEST,
-                    name: 'test-abc123def456-project',
-                    color: 'charcoal',
-                    childOrder: 1,
-                }),
-                createMockProject({
-                    id: TEST_IDS.PROJECT_WORK,
-                    name: 'Work Project',
-                    color: 'blue',
-                    isFavorite: true,
-                    isShared: true,
-                    viewStyle: 'board',
-                    childOrder: 2,
-                    description: 'Important work tasks',
-                    canAssignTasks: true,
-                }),
-            ];
-            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
-            const result = await findProjects.execute({ limit: 50 }, mockTodoistApi);
-            // Verify API was called correctly
-            expect(mockTodoistApi.getProjects).toHaveBeenCalledWith({
-                limit: 50,
-                cursor: null,
-            });
-            expect(extractTextContent(result)).toMatchSnapshot();
-            // Verify structured content
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                projects: expect.any(Array),
-                totalCount: 3,
-                hasMore: false,
-                appliedFilters: {
-                    search: undefined,
-                    limit: 50,
-                    cursor: undefined,
-                },
-            }));
-            expect(structuredContent.projects).toHaveLength(3);
-        });
-        it('should handle pagination with limit and cursor', async () => {
-            const mockProject = createMockProject({
-                id: 'project-1',
-                name: 'First Project',
-                color: 'red',
-            });
-            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse([mockProject], 'next-page-cursor'));
-            const result = await findProjects.execute({ limit: 10, cursor: 'current-page-cursor' }, mockTodoistApi);
-            expect(mockTodoistApi.getProjects).toHaveBeenCalledWith({
-                limit: 10,
-                cursor: 'current-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', () => {
-        it('should filter projects by search term (case insensitive)', async () => {
-            const mockProjects = [
-                createMockProject({
-                    id: TEST_IDS.PROJECT_WORK,
-                    name: 'Work Project',
-                    color: 'blue',
-                }),
-                createMockProject({
-                    id: 'personal-project-id',
-                    name: 'Personal Tasks',
-                    color: 'green',
-                }),
-                createMockProject({ id: 'hobby-project-id', name: 'Hobby Work', color: 'orange' }),
-            ];
-            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
-            const result = await findProjects.execute({ search: 'work', limit: 50 }, mockTodoistApi);
-            expect(mockTodoistApi.getProjects).toHaveBeenCalledWith({ limit: 50, cursor: null });
-            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.appliedFilters).toEqual({
-                search: 'work',
-                limit: 50,
-                cursor: undefined,
-            });
-        });
-        it.each([
-            {
-                search: 'nonexistent',
-                projects: ['Project One'],
-                expectedCount: 0,
-                description: 'no matches',
-            },
-            {
-                search: 'IMPORTANT',
-                projects: ['Important Project'],
-                expectedCount: 1,
-                description: 'case insensitive matching',
-            },
-        ])('should handle search with $description', async ({ search, projects }) => {
-            const mockProjects = projects.map((name) => createMockProject({ name }));
-            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
-            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', () => {
-        it.each([
-            { error: TEST_ERRORS.API_UNAUTHORIZED, params: { limit: 50 } },
-            { 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(findProjects.execute(params, mockTodoistApi)).rejects.toThrow(error);
-        });
-    });
-});

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

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

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

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

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

@@ -1,313 +0,0 @@
-import { jest } from '@jest/globals';
-import { createMockSection, createMockUser, extractStructuredContent, extractTextContent, TEST_ERRORS, TEST_IDS, } 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(),
-    getUser: jest.fn(),
-};
-const { FIND_SECTIONS, ADD_SECTIONS } = ToolNames;
-describe(`${FIND_SECTIONS} tool`, () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('listing all sections in a project', () => {
-        it('should list all sections when no search parameter is provided', async () => {
-            const mockSections = [
-                createMockSection({
-                    id: TEST_IDS.SECTION_1,
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    name: 'To Do',
-                }),
-                createMockSection({
-                    id: TEST_IDS.SECTION_2,
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    sectionOrder: 2,
-                    name: 'In Progress',
-                }),
-                createMockSection({
-                    id: 'section-789',
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    sectionOrder: 3,
-                    name: 'Done',
-                }),
-                createMockSection({
-                    id: 'section-999',
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    sectionOrder: 4,
-                    name: 'Backlog Items',
-                }),
-            ];
-            mockTodoistApi.getSections.mockResolvedValue({
-                results: mockSections,
-                nextCursor: null,
-            });
-            const result = await findSections.execute({ projectId: TEST_IDS.PROJECT_TEST }, mockTodoistApi);
-            expect(mockTodoistApi.getSections).toHaveBeenCalledWith({
-                projectId: TEST_IDS.PROJECT_TEST,
-            });
-            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 findSections.execute({ projectId: 'empty-project-id' }, mockTodoistApi);
-            expect(mockTodoistApi.getSections).toHaveBeenCalledWith({
-                projectId: 'empty-project-id',
-            });
-            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).toBeUndefined(); // Empty arrays are removed
-            expect(structuredContent.totalCount).toBe(0);
-        });
-    });
-    describe('searching sections by name', () => {
-        it('should filter sections by search term (case insensitive)', async () => {
-            const mockSections = [
-                createMockSection({
-                    id: TEST_IDS.SECTION_1,
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    name: 'To Do',
-                }),
-                createMockSection({
-                    id: TEST_IDS.SECTION_2,
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    sectionOrder: 2,
-                    name: 'In Progress',
-                }),
-                createMockSection({
-                    id: 'section-789',
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    sectionOrder: 3,
-                    name: 'Done',
-                }),
-                createMockSection({
-                    id: 'section-999',
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    sectionOrder: 4,
-                    name: 'Progress Review',
-                }),
-            ];
-            mockTodoistApi.getSections.mockResolvedValue({
-                results: mockSections,
-                nextCursor: null,
-            });
-            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)
-            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 = [
-                createMockSection({
-                    id: TEST_IDS.SECTION_1,
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    name: 'To Do',
-                }),
-                createMockSection({
-                    id: TEST_IDS.SECTION_2,
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    sectionOrder: 2,
-                    name: 'In Progress',
-                }),
-            ];
-            mockTodoistApi.getSections.mockResolvedValue({
-                results: mockSections,
-                nextCursor: null,
-            });
-            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 = [
-                createMockSection({
-                    id: TEST_IDS.SECTION_1,
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    name: 'Important Tasks',
-                }),
-                createMockSection({
-                    id: TEST_IDS.SECTION_2,
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    sectionOrder: 2,
-                    name: 'Regular Work',
-                }),
-            ];
-            mockTodoistApi.getSections.mockResolvedValue({
-                results: mockSections,
-                nextCursor: null,
-            });
-            const result = await findSections.execute({ projectId: TEST_IDS.PROJECT_TEST, search: 'IMPORTANT' }, mockTodoistApi);
-            // Should match despite different case
-            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 = [
-                createMockSection({
-                    id: TEST_IDS.SECTION_1,
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    name: 'Development Tasks',
-                }),
-                createMockSection({
-                    id: TEST_IDS.SECTION_2,
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    sectionOrder: 2,
-                    name: 'Testing Tasks',
-                }),
-                createMockSection({
-                    id: 'section-789',
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    sectionOrder: 3,
-                    name: 'Deployment',
-                }),
-            ];
-            mockTodoistApi.getSections.mockResolvedValue({
-                results: mockSections,
-                nextCursor: null,
-            });
-            const result = await findSections.execute({ projectId: TEST_IDS.PROJECT_TEST, search: 'task' }, mockTodoistApi);
-            // Should match both sections with "task" in the name
-            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 = [
-                createMockSection({
-                    id: TEST_IDS.SECTION_1,
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    name: 'Done',
-                }),
-                createMockSection({
-                    id: TEST_IDS.SECTION_2,
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    sectionOrder: 2,
-                    name: 'Done Soon',
-                }),
-            ];
-            mockTodoistApi.getSections.mockResolvedValue({
-                results: mockSections,
-                nextCursor: null,
-            });
-            const result = await findSections.execute({ projectId: TEST_IDS.PROJECT_TEST, search: 'done' }, mockTodoistApi);
-            // Should match both sections containing "done"
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-            expect(textContent).toContain('matching "done"');
-            expect(textContent).toContain('Done • id=');
-            expect(textContent).toContain('Done Soon • id=');
-        });
-    });
-    describe('inbox project ID resolution', () => {
-        it('should resolve "inbox" to actual inbox project ID', async () => {
-            const mockUser = createMockUser({
-                inboxProjectId: TEST_IDS.PROJECT_INBOX,
-            });
-            const mockSections = [
-                createMockSection({
-                    id: TEST_IDS.SECTION_1,
-                    projectId: TEST_IDS.PROJECT_INBOX,
-                    name: 'Inbox Section 1',
-                }),
-                createMockSection({
-                    id: TEST_IDS.SECTION_2,
-                    projectId: TEST_IDS.PROJECT_INBOX,
-                    name: 'Inbox Section 2',
-                    sectionOrder: 2,
-                }),
-            ];
-            // Mock getUser to return our mock user with inbox ID
-            mockTodoistApi.getUser.mockResolvedValue(mockUser);
-            // Mock the API response
-            mockTodoistApi.getSections.mockResolvedValue({
-                results: mockSections,
-                nextCursor: null,
-            });
-            const result = await findSections.execute({ projectId: 'inbox' }, mockTodoistApi);
-            // Verify getUser was called to resolve inbox
-            expect(mockTodoistApi.getUser).toHaveBeenCalledTimes(1);
-            // Verify getSections was called with resolved inbox project ID
-            expect(mockTodoistApi.getSections).toHaveBeenCalledWith({
-                projectId: TEST_IDS.PROJECT_INBOX,
-            });
-            // Verify result contains the sections
-            const textContent = extractTextContent(result);
-            expect(textContent).toContain('Sections in project');
-            expect(textContent).toContain('Inbox Section 1');
-            expect(textContent).toContain('Inbox Section 2');
-            // Verify structured content
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent.totalCount).toBe(2);
-            expect(structuredContent.sections).toEqual([
-                { id: TEST_IDS.SECTION_1, name: 'Inbox Section 1' },
-                { id: TEST_IDS.SECTION_2, name: 'Inbox Section 2' },
-            ]);
-        });
-        it('should not call getUser when projectId is not "inbox"', async () => {
-            const mockSections = [
-                createMockSection({
-                    id: TEST_IDS.SECTION_1,
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    name: 'Regular Section',
-                }),
-            ];
-            // Mock the API response
-            mockTodoistApi.getSections.mockResolvedValue({
-                results: mockSections,
-                nextCursor: null,
-            });
-            await findSections.execute({ projectId: TEST_IDS.PROJECT_TEST }, mockTodoistApi);
-            // Verify getUser was NOT called for regular project ID
-            expect(mockTodoistApi.getUser).not.toHaveBeenCalled();
-            // Verify getSections was called with original project ID
-            expect(mockTodoistApi.getSections).toHaveBeenCalledWith({
-                projectId: TEST_IDS.PROJECT_TEST,
-            });
-        });
-    });
-    describe('error handling', () => {
-        it.each([
-            { error: 'API Error: Project not found', projectId: 'non-existent-project' },
-            { error: TEST_ERRORS.API_UNAUTHORIZED, projectId: 'restricted-project' },
-            { 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(findSections.execute({ projectId }, mockTodoistApi)).rejects.toThrow(error);
-        });
-    });
-});

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

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

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

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