@doist/todoist-ai 4.15.1 → 4.16.1

package/dist/tool-helpers.test.js

@@ -1,223 +0,0 @@
-import { createMoveTaskArgs, isPersonalProject, isWorkspaceProject, mapProject, mapTask, } from './tool-helpers.js';
-describe('shared utilities', () => {
-    describe('mapTask', () => {
-        it('should map a basic task correctly', () => {
-            const mockTask = {
-                id: '123',
-                content: 'Test task',
-                description: 'Test description',
-                projectId: 'proj-1',
-                sectionId: null,
-                parentId: null,
-                labels: ['work'],
-                priority: 1,
-                due: {
-                    date: '2024-01-15',
-                    isRecurring: false,
-                    datetime: '2024-01-15T10:00:00Z',
-                    string: 'Jan 15',
-                    timezone: 'UTC',
-                },
-            };
-            expect(mapTask(mockTask)).toEqual({
-                id: '123',
-                content: 'Test task',
-                description: 'Test description',
-                dueDate: '2024-01-15',
-                recurring: false,
-                priority: 1,
-                projectId: 'proj-1',
-                sectionId: null,
-                parentId: null,
-                labels: ['work'],
-                duration: null,
-            });
-        });
-        it('should handle recurring tasks', () => {
-            const mockTask = {
-                id: '456',
-                content: 'Recurring task',
-                description: '',
-                projectId: 'proj-1',
-                sectionId: null,
-                parentId: null,
-                labels: [],
-                priority: 1,
-                due: {
-                    date: '2024-01-15',
-                    isRecurring: true,
-                    datetime: '2024-01-15T10:00:00Z',
-                    string: 'every day',
-                    timezone: 'UTC',
-                },
-            };
-            const result = mapTask(mockTask);
-            expect(result.recurring).toBe('every day');
-            expect(result.duration).toBe(null);
-        });
-        it('should handle task with duration', () => {
-            const mockTask = {
-                id: '789',
-                content: 'Task with duration',
-                description: '',
-                projectId: 'proj-1',
-                sectionId: null,
-                parentId: null,
-                labels: [],
-                priority: 1,
-                duration: {
-                    amount: 150,
-                    unit: 'minute',
-                },
-            };
-            const result = mapTask(mockTask);
-            expect(result.duration).toBe('2h30m');
-        });
-        it('should preserve markdown links and formatting in content and description', () => {
-            const mockTask = {
-                id: '123',
-                content: 'Task with **bold** and [link](https://example.com)',
-                description: `Rich markdown description:
-
-### Links
-[Wikipedia](https://en.wikipedia.org/wiki/Test)
-[GitHub](https://github.com/example/repo)
-
-### Formatting
-**Bold text**
-*Italic text*
-\`code block\`
-
-End of description.`,
-                projectId: 'proj-1',
-                sectionId: null,
-                parentId: null,
-                labels: [],
-                priority: 1,
-            };
-            const result = mapTask(mockTask);
-            // Verify exact preservation of markdown content
-            expect(result.content).toBe('Task with **bold** and [link](https://example.com)');
-            expect(result.description).toBe(`Rich markdown description:
-
-### Links
-[Wikipedia](https://en.wikipedia.org/wiki/Test)
-[GitHub](https://github.com/example/repo)
-
-### Formatting
-**Bold text**
-*Italic text*
-\`code block\`
-
-End of description.`);
-            // Verify specific URLs are preserved
-            expect(result.content).toContain('[link](https://example.com)');
-            expect(result.description).toContain('[Wikipedia](https://en.wikipedia.org/wiki/Test)');
-            expect(result.description).toContain('[GitHub](https://github.com/example/repo)');
-            // Verify other markdown formatting is preserved
-            expect(result.content).toContain('**bold**');
-            expect(result.description).toContain('**Bold text**');
-            expect(result.description).toContain('*Italic text*');
-            expect(result.description).toContain('`code block`');
-        });
-    });
-    describe('mapProject', () => {
-        it('should map a personal project correctly', () => {
-            const mockPersonalProject = {
-                id: 'proj-1',
-                name: 'Personal Project',
-                color: 'blue',
-                isFavorite: false,
-                isShared: false,
-                parentId: null,
-                inboxProject: false,
-                viewStyle: 'list',
-            };
-            expect(mapProject(mockPersonalProject)).toEqual({
-                id: 'proj-1',
-                name: 'Personal Project',
-                color: 'blue',
-                isFavorite: false,
-                isShared: false,
-                parentId: null,
-                inboxProject: false,
-                viewStyle: 'list',
-            });
-        });
-        it('should map a workspace project correctly', () => {
-            const mockWorkspaceProject = {
-                id: 'proj-2',
-                name: 'Workspace Project',
-                color: 'red',
-                isFavorite: true,
-                isShared: true,
-                viewStyle: 'board',
-            };
-            expect(mapProject(mockWorkspaceProject)).toEqual({
-                id: 'proj-2',
-                name: 'Workspace Project',
-                color: 'red',
-                isFavorite: true,
-                isShared: true,
-                parentId: null,
-                inboxProject: false,
-                viewStyle: 'board',
-            });
-        });
-    });
-    describe('type guards', () => {
-        it('should correctly identify personal projects', () => {
-            const personalProject = {
-                id: 'proj-1',
-                name: 'Personal',
-                color: 'blue',
-                isFavorite: false,
-                isShared: false,
-                parentId: null,
-                inboxProject: true,
-                viewStyle: 'list',
-            };
-            expect(isPersonalProject(personalProject)).toBe(true);
-            expect(isWorkspaceProject(personalProject)).toBe(false);
-        });
-        it('should correctly identify workspace projects', () => {
-            const workspaceProject = {
-                id: 'proj-2',
-                name: 'Workspace',
-                color: 'red',
-                isFavorite: false,
-                isShared: true,
-                viewStyle: 'board',
-                accessLevel: 'admin',
-            };
-            expect(isWorkspaceProject(workspaceProject)).toBe(true);
-            expect(isPersonalProject(workspaceProject)).toBe(false);
-        });
-    });
-    describe('createMoveTaskArgs', () => {
-        it('should create MoveTaskArgs for projectId', () => {
-            const result = createMoveTaskArgs('task-1', 'project-123');
-            expect(result).toEqual({ projectId: 'project-123' });
-        });
-        it('should create MoveTaskArgs for sectionId', () => {
-            const result = createMoveTaskArgs('task-1', undefined, 'section-456');
-            expect(result).toEqual({ sectionId: 'section-456' });
-        });
-        it('should create MoveTaskArgs for parentId', () => {
-            const result = createMoveTaskArgs('task-1', undefined, undefined, 'parent-789');
-            expect(result).toEqual({ parentId: 'parent-789' });
-        });
-        it('should throw error when multiple move parameters are provided', () => {
-            expect(() => createMoveTaskArgs('task-1', 'project-123', 'section-456')).toThrow('Task task-1: Only one of projectId, sectionId, or parentId can be specified at a time');
-        });
-        it('should throw error when all three move parameters are provided', () => {
-            expect(() => createMoveTaskArgs('task-1', 'project-123', 'section-456', 'parent-789')).toThrow('Task task-1: Only one of projectId, sectionId, or parentId can be specified at a time');
-        });
-        it('should throw error when no move parameters are provided', () => {
-            expect(() => createMoveTaskArgs('task-1')).toThrow('Task task-1: At least one of projectId, sectionId, or parentId must be provided');
-        });
-        it('should throw error when empty strings are provided', () => {
-            expect(() => createMoveTaskArgs('task-1', '', '', '')).toThrow('Task task-1: At least one of projectId, sectionId, or parentId must be provided');
-        });
-    });
-});

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

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

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

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

package/dist/tools/__tests__/add-comments.test.js

@@ -1,241 +0,0 @@
-import { jest } from '@jest/globals';
-import { extractStructuredContent, extractTextContent } from '../../utils/test-helpers.js';
-import { ToolNames } from '../../utils/tool-names.js';
-import { addComments } from '../add-comments.js';
-// Mock the Todoist API
-const mockTodoistApi = {
-    addComment: jest.fn(),
-};
-const { ADD_COMMENTS } = ToolNames;
-const createMockComment = (overrides = {}) => ({
-    id: '12345',
-    content: 'Test comment content',
-    postedAt: '2024-01-01T12:00:00Z',
-    postedUid: 'user123',
-    taskId: 'task123',
-    projectId: undefined,
-    fileAttachment: null,
-    uidsToNotify: null,
-    reactions: null,
-    isDeleted: false,
-    ...overrides,
-});
-describe(`${ADD_COMMENTS} tool`, () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('adding comments to tasks', () => {
-        it('should add comment to task', async () => {
-            const mockComment = createMockComment({
-                id: '98765',
-                content: 'This is a task comment',
-                taskId: 'task456',
-            });
-            mockTodoistApi.addComment.mockResolvedValue(mockComment);
-            const result = await addComments.execute({ comments: [{ taskId: 'task456', content: 'This is a task comment' }] }, mockTodoistApi);
-            expect(mockTodoistApi.addComment).toHaveBeenCalledWith({
-                content: 'This is a task comment',
-                taskId: 'task456',
-            });
-            // Verify result is a concise summary
-            expect(extractTextContent(result)).toMatchSnapshot();
-            // Verify structured content
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                comments: [
-                    expect.objectContaining({
-                        id: '98765',
-                        content: 'This is a task comment',
-                        taskId: 'task456',
-                    }),
-                ],
-                totalCount: 1,
-                addedCommentIds: ['98765'],
-            }));
-        });
-    });
-    describe('adding comments to projects', () => {
-        it('should add comment to project', async () => {
-            const mockComment = createMockComment({
-                id: '98767',
-                content: 'This is a project comment',
-                taskId: undefined,
-                projectId: 'project789',
-            });
-            mockTodoistApi.addComment.mockResolvedValue(mockComment);
-            const result = await addComments.execute({ comments: [{ projectId: 'project789', content: 'This is a project comment' }] }, mockTodoistApi);
-            expect(mockTodoistApi.addComment).toHaveBeenCalledWith({
-                content: 'This is a project comment',
-                projectId: 'project789',
-            });
-            // Verify result is a concise summary
-            expect(extractTextContent(result)).toMatchSnapshot();
-            // Verify structured content
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                comments: [
-                    expect.objectContaining({
-                        id: '98767',
-                        content: 'This is a project comment',
-                        taskId: undefined,
-                        projectId: 'project789',
-                    }),
-                ],
-                totalCount: 1,
-                addedCommentIds: ['98767'],
-            }));
-        });
-    });
-    describe('bulk operations', () => {
-        it('should add multiple comments to different entities (task + project)', async () => {
-            const mockTaskComment = createMockComment({
-                id: '11111',
-                content: 'Task comment',
-                taskId: 'task123',
-                projectId: undefined,
-            });
-            const mockProjectComment = createMockComment({
-                id: '22222',
-                content: 'Project comment',
-                taskId: undefined,
-                projectId: 'project456',
-            });
-            mockTodoistApi.addComment
-                .mockResolvedValueOnce(mockTaskComment)
-                .mockResolvedValueOnce(mockProjectComment);
-            const result = await addComments.execute({
-                comments: [
-                    { taskId: 'task123', content: 'Task comment' },
-                    { projectId: 'project456', content: 'Project comment' },
-                ],
-            }, mockTodoistApi);
-            expect(mockTodoistApi.addComment).toHaveBeenCalledTimes(2);
-            expect(mockTodoistApi.addComment).toHaveBeenCalledWith({
-                content: 'Task comment',
-                taskId: 'task123',
-            });
-            expect(mockTodoistApi.addComment).toHaveBeenCalledWith({
-                content: 'Project comment',
-                projectId: 'project456',
-            });
-            // Verify result is a concise summary
-            expect(extractTextContent(result)).toMatchSnapshot();
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                comments: [
-                    expect.objectContaining({
-                        id: '11111',
-                        content: 'Task comment',
-                        taskId: 'task123',
-                    }),
-                    expect.objectContaining({
-                        id: '22222',
-                        content: 'Project comment',
-                        projectId: 'project456',
-                    }),
-                ],
-                totalCount: 2,
-                addedCommentIds: ['11111', '22222'],
-            }));
-        });
-        it('should add multiple comments to different tasks', async () => {
-            const mockComment1 = createMockComment({
-                id: '33333',
-                content: 'First task comment',
-                taskId: 'task111',
-            });
-            const mockComment2 = createMockComment({
-                id: '44444',
-                content: 'Second task comment',
-                taskId: 'task222',
-            });
-            mockTodoistApi.addComment
-                .mockResolvedValueOnce(mockComment1)
-                .mockResolvedValueOnce(mockComment2);
-            const result = await addComments.execute({
-                comments: [
-                    { taskId: 'task111', content: 'First task comment' },
-                    { taskId: 'task222', content: 'Second task comment' },
-                ],
-            }, mockTodoistApi);
-            expect(mockTodoistApi.addComment).toHaveBeenCalledTimes(2);
-            // Verify result is a concise summary
-            expect(extractTextContent(result)).toMatchSnapshot();
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                comments: expect.arrayContaining([
-                    expect.objectContaining({
-                        id: '33333',
-                        content: 'First task comment',
-                        taskId: 'task111',
-                    }),
-                    expect.objectContaining({
-                        id: '44444',
-                        content: 'Second task comment',
-                        taskId: 'task222',
-                    }),
-                ]),
-                totalCount: 2,
-                addedCommentIds: ['33333', '44444'],
-            }));
-        });
-        it('should add multiple comments to the same task', async () => {
-            const mockComment1 = createMockComment({
-                id: '55555',
-                content: 'First comment on same task',
-                taskId: 'task999',
-            });
-            const mockComment2 = createMockComment({
-                id: '66666',
-                content: 'Second comment on same task',
-                taskId: 'task999',
-            });
-            mockTodoistApi.addComment
-                .mockResolvedValueOnce(mockComment1)
-                .mockResolvedValueOnce(mockComment2);
-            const result = await addComments.execute({
-                comments: [
-                    { taskId: 'task999', content: 'First comment on same task' },
-                    { taskId: 'task999', content: 'Second comment on same task' },
-                ],
-            }, mockTodoistApi);
-            expect(mockTodoistApi.addComment).toHaveBeenCalledTimes(2);
-            expect(mockTodoistApi.addComment).toHaveBeenCalledWith({
-                content: 'First comment on same task',
-                taskId: 'task999',
-            });
-            expect(mockTodoistApi.addComment).toHaveBeenCalledWith({
-                content: 'Second comment on same task',
-                taskId: 'task999',
-            });
-            // Verify result is a concise summary
-            expect(extractTextContent(result)).toMatchSnapshot();
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                comments: expect.arrayContaining([
-                    expect.objectContaining({
-                        id: '55555',
-                        content: 'First comment on same task',
-                        taskId: 'task999',
-                    }),
-                    expect.objectContaining({
-                        id: '66666',
-                        content: 'Second comment on same task',
-                        taskId: 'task999',
-                    }),
-                ]),
-                totalCount: 2,
-                addedCommentIds: ['55555', '66666'],
-            }));
-        });
-    });
-    describe('validation', () => {
-        it('should throw error when neither taskId nor projectId provided', async () => {
-            await expect(addComments.execute({ comments: [{ content: 'Test comment' }] }, mockTodoistApi)).rejects.toThrow('Comment 1: Either taskId or projectId must be provided.');
-        });
-        it('should throw error when both taskId and projectId provided', async () => {
-            const comment = { taskId: 'task123', projectId: 'project456', content: 'Test comment' };
-            await expect(addComments.execute({ comments: [comment] }, mockTodoistApi)).rejects.toThrow('Comment 1: Cannot provide both taskId and projectId. Choose one.');
-        });
-    });
-});

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

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

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

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

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

@@ -1,174 +0,0 @@
-import { jest } from '@jest/globals';
-import { createMockProject, extractStructuredContent, extractTextContent, TEST_IDS, } from '../../utils/test-helpers.js';
-import { ToolNames } from '../../utils/tool-names.js';
-import { addProjects } from '../add-projects.js';
-// Mock the Todoist API
-const mockTodoistApi = {
-    addProject: jest.fn(),
-};
-const { ADD_TASKS, ADD_PROJECTS, ADD_SECTIONS } = ToolNames;
-describe(`${ADD_PROJECTS} tool`, () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('creating a single project', () => {
-        it('should create a project and return mapped result', async () => {
-            const mockApiResponse = createMockProject({
-                id: TEST_IDS.PROJECT_TEST,
-                name: 'test-abc123def456-project',
-                childOrder: 1,
-                createdAt: '2024-01-01T00:00:00Z',
-            });
-            mockTodoistApi.addProject.mockResolvedValue(mockApiResponse);
-            const result = await addProjects.execute({ projects: [{ name: 'test-abc123def456-project' }] }, mockTodoistApi);
-            // Verify API was called correctly
-            expect(mockTodoistApi.addProject).toHaveBeenCalledWith({
-                name: 'test-abc123def456-project',
-            });
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-            expect(textContent).toContain('Added 1 project:');
-            expect(textContent).toContain('test-abc123def456-project');
-            expect(textContent).toContain(`id=${TEST_IDS.PROJECT_TEST}`);
-            expect(textContent).toContain(`Use ${ADD_TASKS} to add your first tasks`);
-            // Verify structured content
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                projects: [
-                    expect.objectContaining({
-                        id: TEST_IDS.PROJECT_TEST,
-                        name: 'test-abc123def456-project',
-                    }),
-                ],
-                totalCount: 1,
-            }));
-        });
-        it('should handle different project properties from API', async () => {
-            const mockApiResponse = createMockProject({
-                id: 'project-456',
-                name: 'My Blue Project',
-                color: 'blue',
-                isFavorite: true,
-                isShared: true,
-                parentId: 'parent-123',
-                viewStyle: 'board',
-                childOrder: 2,
-                description: 'A test project',
-                createdAt: '2024-01-01T00:00:00Z',
-            });
-            mockTodoistApi.addProject.mockResolvedValue(mockApiResponse);
-            const result = await addProjects.execute({ projects: [{ name: 'My Blue Project' }] }, mockTodoistApi);
-            expect(mockTodoistApi.addProject).toHaveBeenCalledWith({
-                name: 'My Blue Project',
-                isFavorite: undefined,
-                viewStyle: undefined,
-            });
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-            expect(textContent).toContain('Added 1 project:');
-            expect(textContent).toContain('My Blue Project');
-            expect(textContent).toContain('id=project-456');
-            expect(textContent).toContain(`Use ${ADD_SECTIONS} to organize new project`);
-        });
-        it('should create project with isFavorite and viewStyle options', async () => {
-            const mockApiResponse = createMockProject({
-                id: 'project-789',
-                name: 'Board Project',
-                isFavorite: true,
-                viewStyle: 'board',
-            });
-            mockTodoistApi.addProject.mockResolvedValue(mockApiResponse);
-            const result = await addProjects.execute({ projects: [{ name: 'Board Project', isFavorite: true, viewStyle: 'board' }] }, mockTodoistApi);
-            expect(mockTodoistApi.addProject).toHaveBeenCalledWith({
-                name: 'Board Project',
-                isFavorite: true,
-                viewStyle: 'board',
-            });
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-            expect(textContent).toContain('Added 1 project:');
-            expect(textContent).toContain('Board Project');
-            expect(textContent).toContain('id=project-789');
-        });
-        it('should create project with parentId to create a sub-project', async () => {
-            const mockApiResponse = createMockProject({
-                id: 'project-child',
-                name: 'Child Project',
-                parentId: 'project-parent',
-            });
-            mockTodoistApi.addProject.mockResolvedValue(mockApiResponse);
-            const result = await addProjects.execute({ projects: [{ name: 'Child Project', parentId: 'project-parent' }] }, mockTodoistApi);
-            expect(mockTodoistApi.addProject).toHaveBeenCalledWith({
-                name: 'Child Project',
-                parentId: 'project-parent',
-            });
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-            expect(textContent).toContain('Added 1 project:');
-            expect(textContent).toContain('Child Project');
-            expect(textContent).toContain('id=project-child');
-        });
-    });
-    describe('creating multiple projects', () => {
-        it('should create multiple projects and return mapped results', async () => {
-            const mockProjects = [
-                createMockProject({ id: 'project-1', name: 'First Project' }),
-                createMockProject({ id: 'project-2', name: 'Second Project' }),
-                createMockProject({ id: 'project-3', name: 'Third Project' }),
-            ];
-            const [project1, project2, project3] = mockProjects;
-            mockTodoistApi.addProject
-                .mockResolvedValueOnce(project1)
-                .mockResolvedValueOnce(project2)
-                .mockResolvedValueOnce(project3);
-            const result = await addProjects.execute({
-                projects: [
-                    { name: 'First Project' },
-                    { name: 'Second Project' },
-                    { name: 'Third Project' },
-                ],
-            }, mockTodoistApi);
-            // Verify API was called correctly for each project
-            expect(mockTodoistApi.addProject).toHaveBeenCalledTimes(3);
-            expect(mockTodoistApi.addProject).toHaveBeenNthCalledWith(1, { name: 'First Project' });
-            expect(mockTodoistApi.addProject).toHaveBeenNthCalledWith(2, { name: 'Second Project' });
-            expect(mockTodoistApi.addProject).toHaveBeenNthCalledWith(3, { name: 'Third Project' });
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-            expect(textContent).toContain('Added 3 projects:');
-            expect(textContent).toContain('First Project (id=project-1)');
-            expect(textContent).toContain('Second Project (id=project-2)');
-            expect(textContent).toContain('Third Project (id=project-3)');
-            expect(textContent).toContain(`Use ${ADD_SECTIONS} to organize these projects`);
-            // Verify structured content
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                projects: expect.arrayContaining([
-                    expect.objectContaining({ id: 'project-1', name: 'First Project' }),
-                    expect.objectContaining({ id: 'project-2', name: 'Second Project' }),
-                    expect.objectContaining({ id: 'project-3', name: 'Third Project' }),
-                ]),
-                totalCount: 3,
-            }));
-        });
-    });
-    describe('error handling', () => {
-        it('should propagate API errors', async () => {
-            const apiError = new Error('API Error: Project name is required');
-            mockTodoistApi.addProject.mockRejectedValue(apiError);
-            await expect(addProjects.execute({ projects: [{ name: '' }] }, mockTodoistApi)).rejects.toThrow('API Error: Project name is required');
-        });
-        it('should handle partial failures in multiple projects', async () => {
-            const mockProject = createMockProject({
-                id: 'project-1',
-                name: 'First Project',
-            });
-            mockTodoistApi.addProject
-                .mockResolvedValueOnce(mockProject)
-                .mockRejectedValueOnce(new Error('API Error: Invalid project name'));
-            await expect(addProjects.execute({
-                projects: [{ name: 'First Project' }, { name: 'Invalid' }],
-            }, mockTodoistApi)).rejects.toThrow('API Error: Invalid project name');
-        });
-    });
-});

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

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

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

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