@doist/todoist-ai 3.0.0 → 4.0.0

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

@@ -0,0 +1,205 @@
+import { jest } from '@jest/globals';
+import { createMockProject, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { updateProjects } from '../update-projects.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    updateProject: jest.fn(),
+};
+const { FIND_PROJECTS, UPDATE_PROJECTS, GET_OVERVIEW } = ToolNames;
+describe(`${UPDATE_PROJECTS} tool`, () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('updating a single project', () => {
+        it('should update a project when id and name are 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 updateProjects.execute({ projects: [{ id: 'existing-project-123', name: 'Updated Project Name' }] }, mockTodoistApi);
+            expect(mockTodoistApi.updateProject).toHaveBeenCalledWith('existing-project-123', {
+                name: 'Updated Project Name',
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Updated 1 project:');
+            expect(textContent).toContain('Updated Project Name (id=existing-project-123)');
+            expect(textContent).toContain(`Use ${GET_OVERVIEW} with projectId=existing-project-123`);
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                projects: [mockApiResponse],
+                totalCount: 1,
+                updatedProjectIds: ['existing-project-123'],
+                appliedOperations: {
+                    updateCount: 1,
+                    skippedCount: 0,
+                },
+            }));
+        });
+        it('should update project with isFavorite and viewStyle options', async () => {
+            const mockApiResponse = {
+                url: 'https://todoist.com/projects/project-123',
+                id: 'project-123',
+                parentId: null,
+                isDeleted: false,
+                updatedAt: '2025-08-13T22:10:30.000000Z',
+                childOrder: 1,
+                description: '',
+                isCollapsed: false,
+                canAssignTasks: false,
+                color: 'red',
+                isFavorite: true,
+                isFrozen: false,
+                name: 'Updated Favorite Project',
+                viewStyle: 'board',
+                isArchived: false,
+                inboxProject: false,
+                isShared: false,
+                createdAt: '2024-01-01T00:00:00Z',
+                defaultOrder: 0,
+            };
+            mockTodoistApi.updateProject.mockResolvedValue(mockApiResponse);
+            const result = await updateProjects.execute({
+                projects: [
+                    {
+                        id: 'project-123',
+                        name: 'Updated Favorite Project',
+                        isFavorite: true,
+                        viewStyle: 'board',
+                    },
+                ],
+            }, mockTodoistApi);
+            expect(mockTodoistApi.updateProject).toHaveBeenCalledWith('project-123', {
+                name: 'Updated Favorite Project',
+                isFavorite: true,
+                viewStyle: 'board',
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Updated 1 project:');
+            expect(textContent).toContain('Updated Favorite Project (id=project-123)');
+        });
+    });
+    describe('updating multiple projects', () => {
+        it('should update multiple projects and return mapped results', async () => {
+            const mockProjects = [
+                createMockProject({ id: 'project-1', name: 'Updated First Project' }),
+                createMockProject({ id: 'project-2', name: 'Updated Second Project' }),
+                createMockProject({ id: 'project-3', name: 'Updated Third Project' }),
+            ];
+            const [project1, project2, project3] = mockProjects;
+            mockTodoistApi.updateProject
+                .mockResolvedValueOnce(project1)
+                .mockResolvedValueOnce(project2)
+                .mockResolvedValueOnce(project3);
+            const result = await updateProjects.execute({
+                projects: [
+                    { id: 'project-1', name: 'Updated First Project' },
+                    { id: 'project-2', name: 'Updated Second Project' },
+                    { id: 'project-3', name: 'Updated Third Project' },
+                ],
+            }, mockTodoistApi);
+            // Verify API was called correctly for each project
+            expect(mockTodoistApi.updateProject).toHaveBeenCalledTimes(3);
+            expect(mockTodoistApi.updateProject).toHaveBeenNthCalledWith(1, 'project-1', {
+                name: 'Updated First Project',
+            });
+            expect(mockTodoistApi.updateProject).toHaveBeenNthCalledWith(2, 'project-2', {
+                name: 'Updated Second Project',
+            });
+            expect(mockTodoistApi.updateProject).toHaveBeenNthCalledWith(3, 'project-3', {
+                name: 'Updated Third Project',
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Updated 3 projects:');
+            expect(textContent).toContain('Updated First Project (id=project-1)');
+            expect(textContent).toContain('Updated Second Project (id=project-2)');
+            expect(textContent).toContain('Updated Third Project (id=project-3)');
+            expect(textContent).toContain(`Use ${FIND_PROJECTS} to see all projects`);
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                projects: mockProjects,
+                totalCount: 3,
+                updatedProjectIds: ['project-1', 'project-2', 'project-3'],
+                appliedOperations: {
+                    updateCount: 3,
+                    skippedCount: 0,
+                },
+            }));
+        });
+        it('should skip projects with no updates and report correctly', async () => {
+            const mockProject = createMockProject({
+                id: 'project-1',
+                name: 'Updated Project',
+            });
+            mockTodoistApi.updateProject.mockResolvedValue(mockProject);
+            const result = await updateProjects.execute({
+                projects: [
+                    { id: 'project-1', name: 'Updated Project' },
+                    { id: 'project-2' }, // No name provided, should be skipped
+                ],
+            }, mockTodoistApi);
+            // Should only call API once for the project with actual updates
+            expect(mockTodoistApi.updateProject).toHaveBeenCalledTimes(1);
+            expect(mockTodoistApi.updateProject).toHaveBeenCalledWith('project-1', {
+                name: 'Updated Project',
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Updated 1 project (1 skipped - no changes):');
+            expect(textContent).toContain('Updated Project (id=project-1)');
+            // Verify structured content reflects skipped count
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                appliedOperations: {
+                    updateCount: 1,
+                    skippedCount: 1,
+                },
+            }));
+        });
+    });
+    describe('error handling', () => {
+        it('should propagate API errors', async () => {
+            const apiError = new Error('API Error: Project not found');
+            mockTodoistApi.updateProject.mockRejectedValue(apiError);
+            await expect(updateProjects.execute({ projects: [{ id: 'nonexistent', name: 'New Name' }] }, mockTodoistApi)).rejects.toThrow('API Error: Project not found');
+        });
+        it('should handle partial failures in multiple projects', async () => {
+            const mockProject = createMockProject({
+                id: 'project-1',
+                name: 'Updated Project',
+            });
+            mockTodoistApi.updateProject
+                .mockResolvedValueOnce(mockProject)
+                .mockRejectedValueOnce(new Error('API Error: Project not found'));
+            await expect(updateProjects.execute({
+                projects: [
+                    { id: 'project-1', name: 'Updated Project' },
+                    { id: 'nonexistent', name: 'New Name' },
+                ],
+            }, mockTodoistApi)).rejects.toThrow('API Error: Project not found');
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,156 @@
+import { jest } from '@jest/globals';
+import { createMockSection, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { updateSections } from '../update-sections.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    updateSection: jest.fn(),
+};
+const { FIND_TASKS, UPDATE_SECTIONS, GET_OVERVIEW } = ToolNames;
+describe(`${UPDATE_SECTIONS} tool`, () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('updating a single section', () => {
+        it('should update a section when id and name are provided', async () => {
+            const mockApiResponse = {
+                id: 'existing-section-123',
+                projectId: '6cfCcrrCFg2xP94Q',
+                sectionOrder: 1,
+                userId: 'test-user',
+                addedAt: '2024-01-01T00:00:00Z',
+                updatedAt: '2024-01-01T00:00:00Z',
+                archivedAt: null,
+                isArchived: false,
+                isDeleted: false,
+                isCollapsed: false,
+                name: 'Updated Section Name',
+            };
+            mockTodoistApi.updateSection.mockResolvedValue(mockApiResponse);
+            const result = await updateSections.execute({ sections: [{ id: 'existing-section-123', name: 'Updated Section Name' }] }, mockTodoistApi);
+            expect(mockTodoistApi.updateSection).toHaveBeenCalledWith('existing-section-123', {
+                name: 'Updated Section Name',
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Updated 1 section:');
+            expect(textContent).toContain('Updated Section Name (id=existing-section-123, projectId=6cfCcrrCFg2xP94Q)');
+            expect(textContent).toContain(`Use ${FIND_TASKS} with sectionId=existing-section-123`);
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                sections: [mockApiResponse],
+                totalCount: 1,
+                updatedSectionIds: ['existing-section-123'],
+            }));
+        });
+    });
+    describe('updating multiple sections', () => {
+        it('should update multiple sections and return mapped results', async () => {
+            const mockSections = [
+                createMockSection({
+                    id: 'section-1',
+                    projectId: 'project-1',
+                    name: 'Updated First Section',
+                }),
+                createMockSection({
+                    id: 'section-2',
+                    projectId: 'project-1',
+                    name: 'Updated Second Section',
+                }),
+                createMockSection({
+                    id: 'section-3',
+                    projectId: 'project-2',
+                    name: 'Updated Third Section',
+                }),
+            ];
+            const [section1, section2, section3] = mockSections;
+            mockTodoistApi.updateSection
+                .mockResolvedValueOnce(section1)
+                .mockResolvedValueOnce(section2)
+                .mockResolvedValueOnce(section3);
+            const result = await updateSections.execute({
+                sections: [
+                    { id: 'section-1', name: 'Updated First Section' },
+                    { id: 'section-2', name: 'Updated Second Section' },
+                    { id: 'section-3', name: 'Updated Third Section' },
+                ],
+            }, mockTodoistApi);
+            // Verify API was called correctly for each section
+            expect(mockTodoistApi.updateSection).toHaveBeenCalledTimes(3);
+            expect(mockTodoistApi.updateSection).toHaveBeenNthCalledWith(1, 'section-1', {
+                name: 'Updated First Section',
+            });
+            expect(mockTodoistApi.updateSection).toHaveBeenNthCalledWith(2, 'section-2', {
+                name: 'Updated Second Section',
+            });
+            expect(mockTodoistApi.updateSection).toHaveBeenNthCalledWith(3, 'section-3', {
+                name: 'Updated Third Section',
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Updated 3 sections:');
+            expect(textContent).toContain('Updated First Section (id=section-1, projectId=project-1)');
+            expect(textContent).toContain('Updated Second Section (id=section-2, projectId=project-1)');
+            expect(textContent).toContain('Updated Third Section (id=section-3, projectId=project-2)');
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent).toEqual(expect.objectContaining({
+                sections: mockSections,
+                totalCount: 3,
+                updatedSectionIds: ['section-1', 'section-2', 'section-3'],
+            }));
+        });
+        it('should handle sections from the same project', async () => {
+            const mockSections = [
+                createMockSection({
+                    id: 'section-1',
+                    projectId: 'same-project',
+                    name: 'Backlog',
+                }),
+                createMockSection({
+                    id: 'section-2',
+                    projectId: 'same-project',
+                    name: 'Done',
+                }),
+            ];
+            const [section1, section2] = mockSections;
+            mockTodoistApi.updateSection
+                .mockResolvedValueOnce(section1)
+                .mockResolvedValueOnce(section2);
+            const result = await updateSections.execute({
+                sections: [
+                    { id: 'section-1', name: 'Backlog' },
+                    { id: 'section-2', name: 'Done' },
+                ],
+            }, mockTodoistApi);
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+            expect(textContent).toContain('Updated 2 sections:');
+            expect(textContent).toContain(`Use ${GET_OVERVIEW} with projectId=same-project`);
+        });
+    });
+    describe('error handling', () => {
+        it('should propagate API errors', async () => {
+            const apiError = new Error('API Error: Section not found');
+            mockTodoistApi.updateSection.mockRejectedValue(apiError);
+            await expect(updateSections.execute({ sections: [{ id: 'nonexistent', name: 'New Name' }] }, mockTodoistApi)).rejects.toThrow('API Error: Section not found');
+        });
+        it('should handle partial failures in multiple sections', async () => {
+            const mockSection = createMockSection({
+                id: 'section-1',
+                projectId: 'project-1',
+                name: 'Updated Section',
+            });
+            mockTodoistApi.updateSection
+                .mockResolvedValueOnce(mockSection)
+                .mockRejectedValueOnce(new Error('API Error: Section not found'));
+            await expect(updateSections.execute({
+                sections: [
+                    { id: 'section-1', name: 'Updated Section' },
+                    { id: 'nonexistent', name: 'New Name' },
+                ],
+            }, mockTodoistApi)).rejects.toThrow('API Error: Section not found');
+        });
+    });
+});

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

@@ -0,0 +1,51 @@
+import type { Comment } from '@doist/todoist-api-typescript';
+import { z } from 'zod';
+declare const addComments: {
+    name: "add-comments";
+    description: string;
+    parameters: {
+        comments: z.ZodArray<z.ZodObject<{
+            taskId: z.ZodOptional<z.ZodString>;
+            projectId: z.ZodOptional<z.ZodString>;
+            content: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            content: string;
+            projectId?: string | undefined;
+            taskId?: string | undefined;
+        }, {
+            content: string;
+            projectId?: string | undefined;
+            taskId?: string | undefined;
+        }>, "many">;
+    };
+    execute(args: {
+        comments: {
+            content: string;
+            projectId?: string | undefined;
+            taskId?: string | undefined;
+        }[];
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            comments: Comment[];
+            totalCount: number;
+            addedCommentIds: string[];
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { addComments };
+//# sourceMappingURL=add-comments.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"add-comments.d.ts","sourceRoot":"","sources":["../../src/tools/add-comments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,OAAO,EAAE,MAAM,+BAA+B,CAAA;AAC5E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAkBvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CyB,CAAA;AA6C1C,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/tools/add-comments.js

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
+import { formatNextSteps } from '../utils/response-builders.js';
+import { ToolNames } from '../utils/tool-names.js';
+const { FIND_COMMENTS, UPDATE_COMMENTS, DELETE_OBJECT } = ToolNames;
+const CommentSchema = z.object({
+    taskId: z.string().optional().describe('The ID of the task to comment on.'),
+    projectId: z.string().optional().describe('The ID of the project to comment on.'),
+    content: z.string().min(1).describe('The content of the comment.'),
+});
+const ArgsSchema = {
+    comments: z.array(CommentSchema).min(1).describe('The array of comments to add.'),
+};
+const addComments = {
+    name: ToolNames.ADD_COMMENTS,
+    description: 'Add multiple comments to tasks or projects. Each comment must specify either taskId or projectId.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const { comments } = args;
+        // Validate each comment
+        for (const [index, comment] of comments.entries()) {
+            if (!comment.taskId && !comment.projectId) {
+                throw new Error(`Comment ${index + 1}: Either taskId or projectId must be provided.`);
+            }
+            if (comment.taskId && comment.projectId) {
+                throw new Error(`Comment ${index + 1}: Cannot provide both taskId and projectId. Choose one.`);
+            }
+        }
+        const addCommentPromises = comments.map(async ({ content, taskId, projectId }) => await client.addComment({
+            content,
+            ...(taskId ? { taskId } : { projectId }),
+        }));
+        const newComments = await Promise.all(addCommentPromises);
+        const textContent = generateTextContent({ comments: newComments });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                comments: newComments,
+                totalCount: newComments.length,
+                addedCommentIds: newComments.map((comment) => comment.id),
+            },
+        });
+    },
+};
+function generateTextContent({ comments, }) {
+    // Group comments by entity type and count
+    const taskComments = comments.filter((c) => c.taskId).length;
+    const projectComments = comments.filter((c) => c.projectId).length;
+    // Generate summary text
+    const parts = [];
+    if (taskComments > 0) {
+        const commentsLabel = taskComments > 1 ? 'comments' : 'comment';
+        parts.push(`${taskComments} task ${commentsLabel}`);
+    }
+    if (projectComments > 0) {
+        const commentsLabel = projectComments > 1 ? 'comments' : 'comment';
+        parts.push(`${projectComments} project ${commentsLabel}`);
+    }
+    const summary = parts.length > 0 ? `Added ${parts.join(' and ')}` : 'No comments added';
+    // Context-aware next steps
+    const nextSteps = [];
+    if (comments.length > 0) {
+        if (comments.length === 1 && comments[0]) {
+            const comment = comments[0];
+            const targetId = comment.taskId || comment.projectId || '';
+            const targetType = comment.taskId ? 'task' : 'project';
+            nextSteps.push(`Use ${FIND_COMMENTS} with ${targetType}Id=${targetId} to see all comments`);
+            nextSteps.push(`Use ${UPDATE_COMMENTS} with id=${comment.id} to edit content`);
+        }
+        else {
+            nextSteps.push(`Use ${FIND_COMMENTS} to view comments by task or project`);
+            nextSteps.push(`Use ${UPDATE_COMMENTS} to edit any comment content`);
+        }
+        nextSteps.push(`Use ${DELETE_OBJECT} with type=comment to remove comments`);
+    }
+    const next = formatNextSteps(nextSteps);
+    return `${summary}\n${next}`;
+}
+export { addComments };

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

@@ -0,0 +1,50 @@
+import type { PersonalProject, WorkspaceProject } from '@doist/todoist-api-typescript';
+import { z } from 'zod';
+declare const addProjects: {
+    name: "add-projects";
+    description: string;
+    parameters: {
+        projects: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            isFavorite: z.ZodOptional<z.ZodBoolean>;
+            viewStyle: z.ZodOptional<z.ZodEnum<["list", "board", "calendar"]>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            isFavorite?: boolean | undefined;
+            viewStyle?: "list" | "board" | "calendar" | undefined;
+        }, {
+            name: string;
+            isFavorite?: boolean | undefined;
+            viewStyle?: "list" | "board" | "calendar" | undefined;
+        }>, "many">;
+    };
+    execute({ projects }: {
+        projects: {
+            name: string;
+            isFavorite?: boolean | undefined;
+            viewStyle?: "list" | "board" | "calendar" | undefined;
+        }[];
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            projects: (PersonalProject | WorkspaceProject)[];
+            totalCount: number;
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { addProjects };
+//# sourceMappingURL=add-projects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"add-projects.d.ts","sourceRoot":"","sources":["../../src/tools/add-projects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AACtF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAwBvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgByB,CAAA;AAmC1C,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/tools/add-projects.js

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
+import { formatNextSteps } from '../utils/response-builders.js';
+import { ToolNames } from '../utils/tool-names.js';
+const { ADD_SECTIONS, ADD_TASKS, FIND_PROJECTS, GET_OVERVIEW } = ToolNames;
+const ProjectSchema = z.object({
+    name: z.string().min(1).describe('The name of the project.'),
+    isFavorite: z
+        .boolean()
+        .optional()
+        .describe('Whether the project is a favorite. Defaults to false.'),
+    viewStyle: z
+        .enum(['list', 'board', 'calendar'])
+        .optional()
+        .describe('The project view style. Defaults to "list".'),
+});
+const ArgsSchema = {
+    projects: z.array(ProjectSchema).min(1).describe('The array of projects to add.'),
+};
+const addProjects = {
+    name: ToolNames.ADD_PROJECTS,
+    description: 'Add one or more new projects.',
+    parameters: ArgsSchema,
+    async execute({ projects }, client) {
+        const newProjects = await Promise.all(projects.map((project) => client.addProject(project)));
+        const textContent = generateTextContent({ projects: newProjects });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                projects: newProjects,
+                totalCount: newProjects.length,
+            },
+        });
+    },
+};
+function generateTextContent({ projects, }) {
+    const count = projects.length;
+    const projectList = projects.map((project) => `• ${project.name} (id=${project.id})`).join('\n');
+    const summary = `Added ${count} project${count === 1 ? '' : 's'}:\n${projectList}`;
+    // Context-aware next steps for new projects
+    const nextSteps = [];
+    if (count === 1) {
+        const project = projects[0];
+        if (project) {
+            nextSteps.push(`Use ${ADD_SECTIONS} to organize new project with sections`);
+            nextSteps.push(`Use ${ADD_TASKS} to add your first tasks to this project`);
+            nextSteps.push(`Use ${GET_OVERVIEW} with projectId=${project.id} to see project structure`);
+        }
+    }
+    else {
+        nextSteps.push(`Use ${ADD_SECTIONS} to organize these projects with sections`);
+        nextSteps.push(`Use ${ADD_TASKS} to add tasks to these projects`);
+        nextSteps.push(`Use ${FIND_PROJECTS} to see all projects including the new ones`);
+        nextSteps.push(`Use ${GET_OVERVIEW} to see updated project hierarchy`);
+    }
+    const next = formatNextSteps(nextSteps);
+    return `${summary}\n${next}`;
+}
+export { addProjects };

package/dist/tools/{manage-sections.d.ts → add-sections.d.ts}

@@ -1,25 +1,33 @@
 import type { Section } from '@doist/todoist-api-typescript';
 import { z } from 'zod';
-declare const manageSections: {
-    name: "manage-sections";
+declare const addSections: {
+    name: "add-sections";
     description: string;
     parameters: {
-        id: z.ZodOptional<z.ZodString>;
-        name: z.ZodString;
-        projectId: z.ZodOptional<z.ZodString>;
+        sections: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            projectId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            projectId: string;
+        }, {
+            name: string;
+            projectId: string;
+        }>, "many">;
     };
-    execute(args: {
-        name: string;
-        id?: string | undefined;
-        projectId?: string | undefined;
+    execute({ sections }: {
+        sections: {
+            name: string;
+            projectId: string;
+        }[];
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
         content: {
             type: "text";
             text: string;
         }[];
         structuredContent: {
-            section: Section;
-            operation: string;
+            sections: Section[];
+            totalCount: number;
         };
     } | {
         content: ({
@@ -34,5 +42,5 @@ declare const manageSections: {
         structuredContent?: undefined;
     }>;
 };
-export { manageSections };
-//# sourceMappingURL=manage-sections.d.ts.map
+export { addSections };
+//# sourceMappingURL=add-sections.d.ts.map