@doist/todoist-ai 2.0.0 → 2.1.0

package/dist/tool-helpers.test.js

@@ -1,6 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tool_helpers_1 = require("./tool-helpers");
+import { createMoveTaskArgs, isPersonalProject, isWorkspaceProject, mapProject, mapTask, } from './tool-helpers.js';
 describe('shared utilities', () => {
     describe('mapTask', () => {
         it('should map a basic task correctly', () => {
@@ -21,8 +19,7 @@ describe('shared utilities', () => {
                     timezone: 'UTC',
                 },
             };
-            const result = (0, tool_helpers_1.mapTask)(mockTask);
-            expect(result).toEqual({
+            expect(mapTask(mockTask)).toEqual({
                 id: '123',
                 content: 'Test task',
                 description: 'Test description',
@@ -33,6 +30,7 @@ describe('shared utilities', () => {
                 sectionId: null,
                 parentId: null,
                 labels: ['work'],
+                duration: null,
             });
         });
         it('should handle recurring tasks', () => {
@@ -53,8 +51,27 @@ describe('shared utilities', () => {
                     timezone: 'UTC',
                 },
             };
-            const result = (0, tool_helpers_1.mapTask)(mockTask);
+            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');
         });
     });
     describe('mapProject', () => {
@@ -69,8 +86,7 @@ describe('shared utilities', () => {
                 inboxProject: false,
                 viewStyle: 'list',
             };
-            const result = (0, tool_helpers_1.mapProject)(mockPersonalProject);
-            expect(result).toEqual({
+            expect(mapProject(mockPersonalProject)).toEqual({
                 id: 'proj-1',
                 name: 'Personal Project',
                 color: 'blue',
@@ -90,8 +106,7 @@ describe('shared utilities', () => {
                 isShared: true,
                 viewStyle: 'board',
             };
-            const result = (0, tool_helpers_1.mapProject)(mockWorkspaceProject);
-            expect(result).toEqual({
+            expect(mapProject(mockWorkspaceProject)).toEqual({
                 id: 'proj-2',
                 name: 'Workspace Project',
                 color: 'red',
@@ -115,8 +130,8 @@ describe('shared utilities', () => {
                 inboxProject: true,
                 viewStyle: 'list',
             };
-            expect((0, tool_helpers_1.isPersonalProject)(personalProject)).toBe(true);
-            expect((0, tool_helpers_1.isWorkspaceProject)(personalProject)).toBe(false);
+            expect(isPersonalProject(personalProject)).toBe(true);
+            expect(isWorkspaceProject(personalProject)).toBe(false);
         });
         it('should correctly identify workspace projects', () => {
             const workspaceProject = {
@@ -128,8 +143,34 @@ describe('shared utilities', () => {
                 viewStyle: 'board',
                 accessLevel: 'admin',
             };
-            expect((0, tool_helpers_1.isWorkspaceProject)(workspaceProject)).toBe(true);
-            expect((0, tool_helpers_1.isPersonalProject)(workspaceProject)).toBe(false);
+            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__/delete-one.test.d.ts

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

package/dist/tools/__tests__/delete-one.test.d.ts.map

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

package/dist/tools/__tests__/delete-one.test.js

@@ -0,0 +1,90 @@
+import { jest } from '@jest/globals';
+import { deleteOne } from '../delete-one.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    deleteProject: jest.fn(),
+    deleteSection: jest.fn(),
+    deleteTask: jest.fn(),
+};
+describe('delete-one tool', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('deleting projects', () => {
+        it('should delete a project by ID', async () => {
+            mockTodoistApi.deleteProject.mockResolvedValue(true);
+            const result = await deleteOne.execute({ type: 'project', id: '6cfCcrrCFg2xP94Q' }, mockTodoistApi);
+            // Verify API was called correctly
+            expect(mockTodoistApi.deleteProject).toHaveBeenCalledWith('6cfCcrrCFg2xP94Q');
+            expect(mockTodoistApi.deleteSection).not.toHaveBeenCalled();
+            expect(mockTodoistApi.deleteTask).not.toHaveBeenCalled();
+            // Verify success response
+            expect(result).toEqual({ success: true });
+        });
+        it('should propagate project deletion errors', async () => {
+            const apiError = new Error('API Error: Cannot delete project with tasks');
+            mockTodoistApi.deleteProject.mockRejectedValue(apiError);
+            await expect(deleteOne.execute({ type: 'project', id: 'project-with-tasks' }, mockTodoistApi)).rejects.toThrow('API Error: Cannot delete project with tasks');
+        });
+    });
+    describe('deleting sections', () => {
+        it('should delete a section by ID', async () => {
+            mockTodoistApi.deleteSection.mockResolvedValue(true);
+            const result = await deleteOne.execute({ type: 'section', id: 'section-123' }, mockTodoistApi);
+            // Verify API was called correctly
+            expect(mockTodoistApi.deleteSection).toHaveBeenCalledWith('section-123');
+            expect(mockTodoistApi.deleteProject).not.toHaveBeenCalled();
+            expect(mockTodoistApi.deleteTask).not.toHaveBeenCalled();
+            // Verify success response
+            expect(result).toEqual({ success: true });
+        });
+        it('should propagate section deletion errors', async () => {
+            const apiError = new Error('API Error: Section not found');
+            mockTodoistApi.deleteSection.mockRejectedValue(apiError);
+            await expect(deleteOne.execute({ type: 'section', id: 'non-existent-section' }, mockTodoistApi)).rejects.toThrow('API Error: Section not found');
+        });
+    });
+    describe('deleting tasks', () => {
+        it('should delete a task by ID', async () => {
+            mockTodoistApi.deleteTask.mockResolvedValue(true);
+            const result = await deleteOne.execute({ type: 'task', id: '8485093748' }, mockTodoistApi);
+            // Verify API was called correctly
+            expect(mockTodoistApi.deleteTask).toHaveBeenCalledWith('8485093748');
+            expect(mockTodoistApi.deleteProject).not.toHaveBeenCalled();
+            expect(mockTodoistApi.deleteSection).not.toHaveBeenCalled();
+            // Verify success response
+            expect(result).toEqual({ success: true });
+        });
+        it('should propagate task deletion errors', async () => {
+            const apiError = new Error('API Error: Task not found');
+            mockTodoistApi.deleteTask.mockRejectedValue(apiError);
+            await expect(deleteOne.execute({ type: 'task', id: 'non-existent-task' }, mockTodoistApi)).rejects.toThrow('API Error: Task not found');
+        });
+        it('should handle permission errors', async () => {
+            const apiError = new Error('API Error: Insufficient permissions to delete task');
+            mockTodoistApi.deleteTask.mockRejectedValue(apiError);
+            await expect(deleteOne.execute({ type: 'task', id: 'restricted-task' }, mockTodoistApi)).rejects.toThrow('API Error: Insufficient permissions to delete task');
+        });
+    });
+    describe('type validation', () => {
+        it('should handle all supported entity types', async () => {
+            // Test all three supported types work correctly
+            mockTodoistApi.deleteProject.mockResolvedValue(true);
+            mockTodoistApi.deleteSection.mockResolvedValue(true);
+            mockTodoistApi.deleteTask.mockResolvedValue(true);
+            // Delete project
+            await deleteOne.execute({ type: 'project', id: 'proj-1' }, mockTodoistApi);
+            expect(mockTodoistApi.deleteProject).toHaveBeenCalledWith('proj-1');
+            // Delete section
+            await deleteOne.execute({ type: 'section', id: 'sect-1' }, mockTodoistApi);
+            expect(mockTodoistApi.deleteSection).toHaveBeenCalledWith('sect-1');
+            // Delete task
+            await deleteOne.execute({ type: 'task', id: 'task-1' }, mockTodoistApi);
+            expect(mockTodoistApi.deleteTask).toHaveBeenCalledWith('task-1');
+            // Verify each API method was called exactly once
+            expect(mockTodoistApi.deleteProject).toHaveBeenCalledTimes(1);
+            expect(mockTodoistApi.deleteSection).toHaveBeenCalledTimes(1);
+            expect(mockTodoistApi.deleteTask).toHaveBeenCalledTimes(1);
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,163 @@
+import { jest } from '@jest/globals';
+import { overview } from '../overview.js';
+import { TEST_ERRORS, TEST_IDS, createMockProject, createMockSection, createMockTask, } from '../test-helpers.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    getProjects: jest.fn(),
+    getProject: jest.fn(),
+    getSections: jest.fn(),
+    getTasks: jest.fn(),
+};
+describe('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 overview.execute({}, mockTodoistApi);
+            expect(mockTodoistApi.getProjects).toHaveBeenCalledWith({});
+            expect(mockTodoistApi.getSections).toHaveBeenCalledTimes(2); // Once for each project
+            // Use snapshot testing for complex markdown output
+            expect(result).toMatchSnapshot();
+        });
+        it('should handle empty projects list', async () => {
+            mockTodoistApi.getProjects.mockResolvedValue({ results: [], nextCursor: null });
+            expect(await overview.execute({}, mockTodoistApi)).toMatchSnapshot();
+        });
+    });
+    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 overview.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,
+            });
+            // Use snapshot testing for complex markdown output
+            expect(result).toMatchSnapshot();
+        });
+        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 overview.execute({ projectId: 'empty-project-id' }, mockTodoistApi);
+            expect(result).toMatchSnapshot();
+        });
+    });
+    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(overview.execute(params, mockTodoistApi)).rejects.toThrow(error);
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,140 @@
+import { jest } from '@jest/globals';
+import { projectsList } from '../projects-list.js';
+import { TEST_ERRORS, TEST_IDS, createMockApiResponse, createMockProject } from '../test-helpers.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    getProjects: jest.fn(),
+};
+describe('projects-list 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 projectsList.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',
+                    }),
+                ],
+                nextCursor: null,
+            });
+        });
+        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 projectsList.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');
+        });
+    });
+    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 projectsList.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']);
+        });
+        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, expectedCount }) => {
+            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);
+        });
+    });
+    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(projectsList.execute(params, mockTodoistApi)).rejects.toThrow(error);
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,106 @@
+import { jest } from '@jest/globals';
+import { projectsManage } from '../projects-manage.js';
+import { TEST_IDS, createMockProject } from '../test-helpers.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    addProject: jest.fn(),
+    updateProject: jest.fn(),
+};
+describe('projects-manage tool', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('creating a new 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 projectsManage.execute({ name: 'test-abc123def456-project' }, mockTodoistApi);
+            // Verify API was called correctly
+            expect(mockTodoistApi.addProject).toHaveBeenCalledWith({
+                name: 'test-abc123def456-project',
+            });
+            // Verify result is properly mapped
+            expect(result).toEqual({
+                id: TEST_IDS.PROJECT_TEST,
+                name: 'test-abc123def456-project',
+                color: 'charcoal',
+                isFavorite: false,
+                isShared: false,
+                parentId: null,
+                inboxProject: false,
+                viewStyle: 'list',
+            });
+        });
+        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 projectsManage.execute({ name: 'My Blue Project' }, mockTodoistApi);
+            expect(mockTodoistApi.addProject).toHaveBeenCalledWith({ name: 'My Blue Project' });
+            expect(result).toEqual({
+                id: 'project-456',
+                name: 'My Blue Project',
+                color: 'blue',
+                isFavorite: true,
+                isShared: true,
+                parentId: 'parent-123',
+                inboxProject: false,
+                viewStyle: 'board',
+            });
+        });
+    });
+    describe('updating an existing project', () => {
+        it('should update a project when id is provided', async () => {
+            const mockApiResponse = {
+                url: 'https://todoist.com/projects/existing-project-123',
+                id: 'existing-project-123',
+                parentId: null,
+                isDeleted: false,
+                updatedAt: '2025-08-13T22:10:30.000000Z',
+                childOrder: 1,
+                description: '',
+                isCollapsed: false,
+                canAssignTasks: false,
+                color: 'red',
+                isFavorite: false,
+                isFrozen: false,
+                name: 'Updated Project Name',
+                viewStyle: 'list',
+                isArchived: false,
+                inboxProject: false,
+                isShared: false,
+                createdAt: '2024-01-01T00:00:00Z',
+                defaultOrder: 0,
+            };
+            mockTodoistApi.updateProject.mockResolvedValue(mockApiResponse);
+            const result = await projectsManage.execute({ id: 'existing-project-123', name: 'Updated Project Name' }, mockTodoistApi);
+            expect(mockTodoistApi.updateProject).toHaveBeenCalledWith('existing-project-123', {
+                name: 'Updated Project Name',
+            });
+            // Update returns raw project (not mapped) - this is the actual behavior
+            expect(result).toEqual(mockApiResponse);
+        });
+    });
+    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(projectsManage.execute({ name: '' }, mockTodoistApi)).rejects.toThrow('API Error: Project name is required');
+        });
+    });
+});

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

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

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

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