@doist/todoist-ai 4.15.1 → 4.16.1

package/dist/tools/__tests__/get-overview.test.d.ts

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

package/dist/tools/__tests__/get-overview.test.d.ts.map

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

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

@@ -1,225 +0,0 @@
-import { jest } from '@jest/globals';
-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
-const mockTodoistApi = {
-    getProjects: jest.fn(),
-    getProject: jest.fn(),
-    getSections: jest.fn(),
-    getTasks: jest.fn(),
-};
-const { GET_OVERVIEW } = ToolNames;
-describe(`${GET_OVERVIEW} tool`, () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('account overview (no projectId)', () => {
-        it('should generate account overview with projects and sections', 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',
-                    childOrder: 1,
-                }),
-            ];
-            const mockSections = [
-                createMockSection({
-                    id: TEST_IDS.SECTION_1,
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    name: 'test-section',
-                }),
-            ];
-            mockTodoistApi.getProjects.mockResolvedValue({
-                results: mockProjects,
-                nextCursor: null,
-            });
-            mockTodoistApi.getSections.mockImplementation(({ projectId }) => {
-                if (projectId === TEST_IDS.PROJECT_TEST) {
-                    return Promise.resolve({ results: mockSections, nextCursor: null });
-                }
-                return Promise.resolve({ results: [], nextCursor: null });
-            });
-            const result = await getOverview.execute({}, mockTodoistApi);
-            expect(mockTodoistApi.getProjects).toHaveBeenCalledWith({});
-            expect(mockTodoistApi.getSections).toHaveBeenCalledTimes(2); // Once for each project
-            // Test text content with snapshot
-            expect(extractTextContent(result)).toMatchSnapshot();
-            // Test structured content sanity checks
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                type: 'account_overview',
-                inbox: expect.objectContaining({
-                    id: TEST_IDS.PROJECT_INBOX,
-                    name: 'Inbox',
-                    // sections array removed if empty
-                }),
-                projects: expect.any(Array),
-                totalProjects: 2,
-                totalSections: 1,
-                hasNestedProjects: false,
-            }));
-            expect(structuredContent.projects).toHaveLength(1); // Only non-inbox projects
-        });
-        it('should handle empty projects list', async () => {
-            mockTodoistApi.getProjects.mockResolvedValue({ results: [], nextCursor: null });
-            const result = await getOverview.execute({}, mockTodoistApi);
-            // Test text content with snapshot
-            expect(extractTextContent(result)).toMatchSnapshot();
-            // Test structured content sanity checks
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual({
-                type: 'account_overview',
-                // projects array is removed when empty
-                totalProjects: 0,
-                totalSections: 0,
-                hasNestedProjects: false,
-            });
-        });
-    });
-    describe('project overview (with projectId)', () => {
-        it('should generate detailed project overview with tasks', async () => {
-            const mockProject = createMockProject({
-                id: TEST_IDS.PROJECT_TEST,
-                name: 'test-abc123def456-project',
-            });
-            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',
-                }),
-            ];
-            const mockTasks = [
-                createMockTask({
-                    id: TEST_IDS.TASK_1,
-                    content: 'Task without section',
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    deadline: {
-                        date: '2025-08-15',
-                        lang: 'en',
-                    },
-                    responsibleUid: TEST_IDS.USER_ID,
-                    assignedByUid: TEST_IDS.USER_ID,
-                }),
-                createMockTask({
-                    id: TEST_IDS.TASK_2,
-                    content: 'Task in To Do section',
-                    description: 'Important task',
-                    labels: ['work'],
-                    priority: 2,
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    sectionId: TEST_IDS.SECTION_1,
-                }),
-                createMockTask({
-                    id: TEST_IDS.TASK_3,
-                    content: 'Subtask of important task',
-                    childOrder: 2,
-                    projectId: TEST_IDS.PROJECT_TEST,
-                    sectionId: TEST_IDS.SECTION_1,
-                    parentId: TEST_IDS.TASK_2,
-                }),
-            ];
-            mockTodoistApi.getProject.mockResolvedValue(mockProject);
-            mockTodoistApi.getSections.mockResolvedValue({
-                results: mockSections,
-                nextCursor: null,
-            });
-            mockTodoistApi.getTasks.mockResolvedValue({
-                results: mockTasks,
-                nextCursor: null,
-            });
-            const result = await getOverview.execute({ projectId: TEST_IDS.PROJECT_TEST }, mockTodoistApi);
-            expect(mockTodoistApi.getProject).toHaveBeenCalledWith(TEST_IDS.PROJECT_TEST);
-            expect(mockTodoistApi.getSections).toHaveBeenCalledWith({
-                projectId: TEST_IDS.PROJECT_TEST,
-            });
-            expect(mockTodoistApi.getTasks).toHaveBeenCalledWith({
-                projectId: TEST_IDS.PROJECT_TEST,
-                limit: 50,
-                cursor: undefined,
-            });
-            // Test text content with snapshot
-            expect(extractTextContent(result)).toMatchSnapshot();
-            // Test structured content sanity checks
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                type: 'project_overview',
-                project: expect.objectContaining({
-                    id: TEST_IDS.PROJECT_TEST,
-                    name: 'test-abc123def456-project',
-                }),
-                sections: expect.any(Array),
-                tasks: expect.any(Array),
-                stats: expect.objectContaining({
-                    totalTasks: 3,
-                    totalSections: 2,
-                    tasksWithoutSection: 1,
-                }),
-            }));
-            expect(structuredContent.sections).toHaveLength(2);
-            expect(structuredContent.tasks).toHaveLength(3);
-        });
-        it('should handle project with no tasks', async () => {
-            const mockProject = createMockProject({
-                id: 'empty-project-id',
-                name: 'Empty Project',
-                color: 'blue',
-            });
-            mockTodoistApi.getProject.mockResolvedValue(mockProject);
-            mockTodoistApi.getSections.mockResolvedValue({ results: [], nextCursor: null });
-            mockTodoistApi.getTasks.mockResolvedValue({ results: [], nextCursor: null });
-            const result = await getOverview.execute({ projectId: 'empty-project-id' }, mockTodoistApi);
-            // Test text content with snapshot
-            expect(extractTextContent(result)).toMatchSnapshot();
-            // Test structured content sanity checks
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual({
-                type: 'project_overview',
-                project: expect.objectContaining({
-                    id: 'empty-project-id',
-                    name: 'Empty Project',
-                }),
-                // sections and tasks arrays are removed when empty
-                stats: expect.objectContaining({
-                    totalTasks: 0,
-                    totalSections: 0,
-                    tasksWithoutSection: 0,
-                }),
-            });
-        });
-    });
-    describe('error handling', () => {
-        it.each([
-            {
-                scenario: 'project retrieval',
-                error: 'API Error: Project not found',
-                params: { projectId: 'non-existent-project' },
-                mockMethod: 'getProject',
-            },
-            {
-                scenario: 'projects list',
-                error: TEST_ERRORS.API_UNAUTHORIZED,
-                params: {},
-                mockMethod: 'getProjects',
-            },
-        ])('should propagate API errors for $scenario', async ({ error, params, mockMethod }) => {
-            const apiError = new Error(error);
-            mockTodoistApi[mockMethod].mockRejectedValue(apiError);
-            await expect(getOverview.execute(params, mockTodoistApi)).rejects.toThrow(error);
-        });
-    });
-});

package/dist/tools/__tests__/search.test.d.ts

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

package/dist/tools/__tests__/search.test.d.ts.map

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

package/dist/tools/__tests__/search.test.js

@@ -1,206 +0,0 @@
-import { jest } from '@jest/globals';
-import { getTasksByFilter } from '../../tool-helpers.js';
-import { createMappedTask, createMockApiResponse, createMockProject, TEST_IDS, } from '../../utils/test-helpers.js';
-import { ToolNames } from '../../utils/tool-names.js';
-import { search } from '../search.js';
-jest.mock('../../tool-helpers', () => {
-    return {
-        getTasksByFilter: jest.fn(),
-    };
-});
-const { SEARCH } = ToolNames;
-const mockGetTasksByFilter = getTasksByFilter;
-// Mock the Todoist API
-const mockTodoistApi = {
-    getProjects: jest.fn(),
-};
-describe(`${SEARCH} tool`, () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('searching tasks and projects', () => {
-        it('should search both tasks and projects and return combined results', async () => {
-            const mockTasks = [
-                createMappedTask({
-                    id: TEST_IDS.TASK_1,
-                    content: 'Important meeting task',
-                }),
-                createMappedTask({
-                    id: TEST_IDS.TASK_2,
-                    content: 'Another important item',
-                }),
-            ];
-            const mockProjects = [
-                createMockProject({
-                    id: TEST_IDS.PROJECT_WORK,
-                    name: 'Important Work Project',
-                }),
-                createMockProject({
-                    id: TEST_IDS.PROJECT_TEST,
-                    name: 'Test Project',
-                }),
-            ];
-            mockGetTasksByFilter.mockResolvedValue({ tasks: mockTasks, nextCursor: null });
-            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
-            const result = await search.execute({ query: 'important' }, mockTodoistApi);
-            // Verify both API calls were made
-            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
-                client: mockTodoistApi,
-                query: 'search: important',
-                limit: 100, // TASKS_MAX
-                cursor: undefined,
-            });
-            expect(mockTodoistApi.getProjects).toHaveBeenCalledWith({
-                limit: 100, // PROJECTS_MAX
-            });
-            // Verify result structure
-            expect(result.content).toHaveLength(1);
-            expect(result.content[0]?.type).toBe('text');
-            // Parse the JSON response
-            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
-            expect(jsonResponse).toHaveProperty('results');
-            expect(jsonResponse.results).toHaveLength(3); // 2 tasks + 1 project matching "important"
-            // Verify task results
-            expect(jsonResponse.results[0]).toEqual({
-                id: `task:${TEST_IDS.TASK_1}`,
-                title: 'Important meeting task',
-                url: `https://app.todoist.com/app/task/${TEST_IDS.TASK_1}`,
-            });
-            expect(jsonResponse.results[1]).toEqual({
-                id: `task:${TEST_IDS.TASK_2}`,
-                title: 'Another important item',
-                url: `https://app.todoist.com/app/task/${TEST_IDS.TASK_2}`,
-            });
-            // Verify project result (only "Important Work Project" matches)
-            expect(jsonResponse.results[2]).toEqual({
-                id: `project:${TEST_IDS.PROJECT_WORK}`,
-                title: 'Important Work Project',
-                url: `https://app.todoist.com/app/project/${TEST_IDS.PROJECT_WORK}`,
-            });
-        });
-        it('should return only matching tasks when no projects match', async () => {
-            const mockTasks = [
-                createMappedTask({
-                    id: TEST_IDS.TASK_1,
-                    content: 'Unique task content',
-                }),
-            ];
-            const mockProjects = [
-                createMockProject({
-                    id: TEST_IDS.PROJECT_WORK,
-                    name: 'Work Project',
-                }),
-            ];
-            mockGetTasksByFilter.mockResolvedValue({ tasks: mockTasks, nextCursor: null });
-            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
-            const result = await search.execute({ query: 'unique' }, mockTodoistApi);
-            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
-            expect(jsonResponse.results).toHaveLength(1);
-            expect(jsonResponse.results[0].id).toBe(`task:${TEST_IDS.TASK_1}`);
-        });
-        it('should return only matching projects when no tasks match', async () => {
-            const mockProjects = [
-                createMockProject({
-                    id: TEST_IDS.PROJECT_WORK,
-                    name: 'Special Project Name',
-                }),
-                createMockProject({
-                    id: TEST_IDS.PROJECT_TEST,
-                    name: 'Another Project',
-                }),
-            ];
-            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
-            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
-            const result = await search.execute({ query: 'special' }, mockTodoistApi);
-            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
-            expect(jsonResponse.results).toHaveLength(1);
-            expect(jsonResponse.results[0]).toEqual({
-                id: `project:${TEST_IDS.PROJECT_WORK}`,
-                title: 'Special Project Name',
-                url: `https://app.todoist.com/app/project/${TEST_IDS.PROJECT_WORK}`,
-            });
-        });
-        it('should return empty results when nothing matches', async () => {
-            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
-            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse([]));
-            const result = await search.execute({ query: 'nonexistent' }, mockTodoistApi);
-            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
-            expect(jsonResponse.results).toHaveLength(0);
-        });
-        it('should perform case-insensitive project filtering', async () => {
-            const mockProjects = [
-                createMockProject({
-                    id: TEST_IDS.PROJECT_WORK,
-                    name: 'Important Work',
-                }),
-            ];
-            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
-            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
-            const result = await search.execute({ query: 'IMPORTANT' }, mockTodoistApi);
-            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
-            expect(jsonResponse.results).toHaveLength(1);
-            expect(jsonResponse.results[0].title).toBe('Important Work');
-        });
-        it('should handle partial matches in project names', async () => {
-            const mockProjects = [
-                createMockProject({ id: 'project-1', name: 'Development Tasks' }),
-                createMockProject({ id: 'project-2', name: 'Developer Resources' }),
-                createMockProject({ id: 'project-3', name: 'Marketing' }),
-            ];
-            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
-            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
-            const result = await search.execute({ query: 'develop' }, mockTodoistApi);
-            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
-            expect(jsonResponse.results).toHaveLength(2);
-            expect(jsonResponse.results[0].title).toBe('Development Tasks');
-            expect(jsonResponse.results[1].title).toBe('Developer Resources');
-        });
-    });
-    describe('error handling', () => {
-        it('should return error response for task search failure', async () => {
-            mockGetTasksByFilter.mockRejectedValue(new Error('Task search failed'));
-            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse([]));
-            const result = await search.execute({ query: 'test' }, mockTodoistApi);
-            expect(result.isError).toBe(true);
-            expect(result.content[0]?.text).toBe('Task search failed');
-        });
-        it('should return error response for project search failure', async () => {
-            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
-            mockTodoistApi.getProjects.mockRejectedValue(new Error('Project search failed'));
-            const result = await search.execute({ query: 'test' }, mockTodoistApi);
-            expect(result.isError).toBe(true);
-            expect(result.content[0]?.text).toBe('Project search failed');
-        });
-    });
-    describe('OpenAI MCP spec compliance', () => {
-        it('should return exactly one content item with type "text"', async () => {
-            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
-            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse([]));
-            const result = await search.execute({ query: 'test' }, mockTodoistApi);
-            expect(result.content).toHaveLength(1);
-            expect(result.content[0]?.type).toBe('text');
-        });
-        it('should return valid JSON string in text field', async () => {
-            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
-            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse([]));
-            const result = await search.execute({ query: 'test' }, mockTodoistApi);
-            expect(() => JSON.parse(result.content[0]?.text ?? '{}')).not.toThrow();
-        });
-        it('should include required fields (id, title, url) in each result', async () => {
-            const mockTasks = [createMappedTask({ id: TEST_IDS.TASK_1, content: 'Test' })];
-            const mockProjects = [createMockProject({ id: TEST_IDS.PROJECT_WORK, name: 'Test' })];
-            mockGetTasksByFilter.mockResolvedValue({ tasks: mockTasks, nextCursor: null });
-            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
-            const result = await search.execute({ query: 'test' }, mockTodoistApi);
-            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
-            for (const item of jsonResponse.results) {
-                expect(item).toHaveProperty('id');
-                expect(item).toHaveProperty('title');
-                expect(item).toHaveProperty('url');
-                expect(typeof item.id).toBe('string');
-                expect(typeof item.title).toBe('string');
-                expect(typeof item.url).toBe('string');
-            }
-        });
-    });
-});

package/dist/tools/__tests__/update-comments.test.d.ts

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

package/dist/tools/__tests__/update-comments.test.d.ts.map

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