@doist/todoist-ai 3.0.0 → 4.0.0

package/dist/tools/update-comments.js

@@ -0,0 +1,82 @@
+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, DELETE_OBJECT } = ToolNames;
+const CommentUpdateSchema = z.object({
+    id: z.string().min(1).describe('The ID of the comment to update.'),
+    content: z.string().min(1).describe('The new content for the comment.'),
+});
+const ArgsSchema = {
+    comments: z.array(CommentUpdateSchema).min(1).describe('The comments to update.'),
+};
+const updateComments = {
+    name: ToolNames.UPDATE_COMMENTS,
+    description: 'Update multiple existing comments with new content.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const { comments } = args;
+        const updateCommentPromises = comments.map(async (comment) => {
+            return await client.updateComment(comment.id, { content: comment.content });
+        });
+        const updatedComments = await Promise.all(updateCommentPromises);
+        const textContent = generateTextContent({
+            comments: updatedComments,
+        });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                comments: updatedComments,
+                totalCount: updatedComments.length,
+                updatedCommentIds: updatedComments.map((comment) => comment.id),
+                appliedOperations: {
+                    updateCount: updatedComments.length,
+                },
+            },
+        });
+    },
+};
+function generateNextSteps(comments) {
+    const nextSteps = [];
+    // Early return for empty comments
+    if (comments.length === 0) {
+        return nextSteps;
+    }
+    // Multiple comments case
+    if (comments.length > 1) {
+        nextSteps.push(`Use ${FIND_COMMENTS} to view comments by task or project`);
+        nextSteps.push(`Use ${DELETE_OBJECT} with type=comment to remove comments`);
+        return nextSteps;
+    }
+    // Single comment case
+    const comment = comments[0];
+    if (!comment)
+        return nextSteps;
+    if (comment.taskId) {
+        nextSteps.push(`Use ${FIND_COMMENTS} with taskId=${comment.taskId} to see all task comments`);
+    }
+    else if (comment.projectId) {
+        nextSteps.push(`Use ${FIND_COMMENTS} with projectId=${comment.projectId} to see all project comments`);
+    }
+    nextSteps.push(`Use ${DELETE_OBJECT} with type=comment id=${comment.id} to remove comment`);
+    return nextSteps;
+}
+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;
+    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 ? `Updated ${parts.join(' and ')}` : 'No comments updated';
+    const nextSteps = generateNextSteps(comments);
+    const next = formatNextSteps(nextSteps);
+    return `${summary}\n${next}`;
+}
+export { updateComments };

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

@@ -0,0 +1,59 @@
+import type { PersonalProject, WorkspaceProject } from '@doist/todoist-api-typescript';
+import { z } from 'zod';
+declare const updateProjects: {
+    name: "update-projects";
+    description: string;
+    parameters: {
+        projects: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            isFavorite: z.ZodOptional<z.ZodBoolean>;
+            viewStyle: z.ZodOptional<z.ZodEnum<["list", "board", "calendar"]>>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            name?: string | undefined;
+            isFavorite?: boolean | undefined;
+            viewStyle?: "list" | "board" | "calendar" | undefined;
+        }, {
+            id: string;
+            name?: string | undefined;
+            isFavorite?: boolean | undefined;
+            viewStyle?: "list" | "board" | "calendar" | undefined;
+        }>, "many">;
+    };
+    execute(args: {
+        projects: {
+            id: string;
+            name?: string | undefined;
+            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;
+            updatedProjectIds: string[];
+            appliedOperations: {
+                updateCount: number;
+                skippedCount: number;
+            };
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { updateProjects };
+//# sourceMappingURL=update-projects.d.ts.map

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

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

package/dist/tools/update-projects.js

@@ -0,0 +1,84 @@
+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_PROJECTS, FIND_TASKS, GET_OVERVIEW } = ToolNames;
+const ProjectUpdateSchema = z.object({
+    id: z.string().min(1).describe('The ID of the project to update.'),
+    name: z.string().min(1).optional().describe('The new name of the project.'),
+    isFavorite: z.boolean().optional().describe('Whether the project is a favorite.'),
+    viewStyle: z.enum(['list', 'board', 'calendar']).optional().describe('The project view style.'),
+});
+const ArgsSchema = {
+    projects: z.array(ProjectUpdateSchema).min(1).describe('The projects to update.'),
+};
+const updateProjects = {
+    name: ToolNames.UPDATE_PROJECTS,
+    description: 'Update multiple existing projects with new values.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const { projects } = args;
+        const updateProjectsPromises = projects.map(async (project) => {
+            if (!hasUpdatesToMake(project)) {
+                return undefined;
+            }
+            const { id, ...updateArgs } = project;
+            return await client.updateProject(id, updateArgs);
+        });
+        const updatedProjects = (await Promise.all(updateProjectsPromises)).filter((project) => project !== undefined);
+        const textContent = generateTextContent({
+            projects: updatedProjects,
+            args,
+        });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                projects: updatedProjects,
+                totalCount: updatedProjects.length,
+                updatedProjectIds: updatedProjects.map((project) => project.id),
+                appliedOperations: {
+                    updateCount: updatedProjects.length,
+                    skippedCount: projects.length - updatedProjects.length,
+                },
+            },
+        });
+    },
+};
+function generateTextContent({ projects, args, }) {
+    const totalRequested = args.projects.length;
+    const actuallyUpdated = projects.length;
+    const skipped = totalRequested - actuallyUpdated;
+    const count = projects.length;
+    const projectList = projects.map((project) => `• ${project.name} (id=${project.id})`).join('\n');
+    let summary = `Updated ${count} project${count === 1 ? '' : 's'}`;
+    if (skipped > 0) {
+        summary += ` (${skipped} skipped - no changes)`;
+    }
+    if (count > 0) {
+        summary += `:\n${projectList}`;
+    }
+    // Context-aware next steps for updated projects
+    const nextSteps = [];
+    if (projects.length > 0) {
+        if (count === 1) {
+            const project = projects[0];
+            if (project) {
+                nextSteps.push(`Use ${GET_OVERVIEW} with projectId=${project.id} to see project structure`);
+                nextSteps.push(`Use ${FIND_TASKS} with projectId=${project.id} to review existing tasks`);
+            }
+        }
+        else {
+            nextSteps.push(`Use ${FIND_PROJECTS} to see all projects with updated names`);
+            nextSteps.push(`Use ${GET_OVERVIEW} to see updated project hierarchy`);
+        }
+    }
+    else {
+        nextSteps.push(`Use ${FIND_PROJECTS} to see current projects`);
+    }
+    const next = formatNextSteps(nextSteps);
+    return `${summary}\n${next}`;
+}
+function hasUpdatesToMake({ id, ...otherUpdateArgs }) {
+    return Object.keys(otherUpdateArgs).length > 0;
+}
+export { updateProjects };

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

@@ -0,0 +1,47 @@
+import type { Section } from '@doist/todoist-api-typescript';
+import { z } from 'zod';
+declare const updateSections: {
+    name: "update-sections";
+    description: string;
+    parameters: {
+        sections: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            id: string;
+        }, {
+            name: string;
+            id: string;
+        }>, "many">;
+    };
+    execute({ sections }: {
+        sections: {
+            name: string;
+            id: string;
+        }[];
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            sections: Section[];
+            totalCount: number;
+            updatedSectionIds: string[];
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { updateSections };
+//# sourceMappingURL=update-sections.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"update-sections.d.ts","sourceRoot":"","sources":["../../src/tools/update-sections.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAA;AAC5D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAiBvB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBsB,CAAA;AAsD1C,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/dist/tools/update-sections.js

@@ -0,0 +1,70 @@
+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_TASKS, GET_OVERVIEW, FIND_SECTIONS } = ToolNames;
+const SectionUpdateSchema = z.object({
+    id: z.string().min(1).describe('The ID of the section to update.'),
+    name: z.string().min(1).describe('The new name of the section.'),
+});
+const ArgsSchema = {
+    sections: z.array(SectionUpdateSchema).min(1).describe('The sections to update.'),
+};
+const updateSections = {
+    name: ToolNames.UPDATE_SECTIONS,
+    description: 'Update multiple existing sections with new values.',
+    parameters: ArgsSchema,
+    async execute({ sections }, client) {
+        const updatedSections = await Promise.all(sections.map((section) => client.updateSection(section.id, { name: section.name })));
+        const textContent = generateTextContent({
+            sections: updatedSections,
+        });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                sections: updatedSections,
+                totalCount: updatedSections.length,
+                updatedSectionIds: updatedSections.map((section) => section.id),
+            },
+        });
+    },
+};
+function generateNextSteps(sections) {
+    // Handle empty sections first (early return)
+    if (sections.length === 0) {
+        return [`Use ${FIND_SECTIONS} to see current sections`];
+    }
+    // Handle single section case
+    if (sections.length === 1) {
+        const section = sections[0];
+        if (!section)
+            return [];
+        return [
+            `Use ${FIND_TASKS} with sectionId=${section.id} to see existing tasks`,
+            `Use ${GET_OVERVIEW} with projectId=${section.projectId} to see project structure`,
+            'Consider updating task descriptions if section purpose changed',
+        ];
+    }
+    // Handle multiple sections case
+    const projectIds = [...new Set(sections.map((s) => s.projectId))];
+    const steps = [`Use ${FIND_SECTIONS} to see all sections with updated names`];
+    if (projectIds.length === 1) {
+        steps.push(`Use ${GET_OVERVIEW} with projectId=${projectIds[0]} to see updated project structure`);
+    }
+    else {
+        steps.push(`Use ${GET_OVERVIEW} to see updated project structures`);
+    }
+    steps.push('Consider updating task descriptions if section purposes changed');
+    return steps;
+}
+function generateTextContent({ sections, }) {
+    const count = sections.length;
+    const sectionList = sections
+        .map((section) => `• ${section.name} (id=${section.id}, projectId=${section.projectId})`)
+        .join('\n');
+    const summary = `Updated ${count} section${count === 1 ? '' : 's'}:\n${sectionList}`;
+    const nextSteps = generateNextSteps(sections);
+    const next = formatNextSteps(nextSteps);
+    return `${summary}\n${next}`;
+}
+export { updateSections };

package/dist/utils/constants.d.ts

@@ -19,6 +19,10 @@ export declare const ApiLimits: {
     readonly PROJECTS_MAX: 100;
     /** Batch size for fetching all tasks in a project */
     readonly TASKS_BATCH_SIZE: 50;
+    /** Default limit for comment listings */
+    readonly COMMENTS_DEFAULT: 10;
+    /** Maximum limit for comment search and list operations */
+    readonly COMMENTS_MAX: 10;
 };
 export declare const DisplayLimits: {
     /** Maximum number of failures to show in detailed error messages */

package/dist/utils/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/utils/constants.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,eAAO,MAAM,SAAS;IAClB,sCAAsC;;IAEtC,wDAAwD;;IAExD,wCAAwC;;IAExC,wCAAwC;;IAExC,yCAAyC;;IAEzC,yCAAyC;;IAEzC,qDAAqD;;CAE/C,CAAA;AAGV,eAAO,MAAM,aAAa;IACtB,oEAAoE;;IAEpE,gDAAgD;;CAE1C,CAAA;AAGV,eAAO,MAAM,cAAc;IACvB,oDAAoD;;IAEpD,mCAAmC;;CAE7B,CAAA"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/utils/constants.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,eAAO,MAAM,SAAS;IAClB,sCAAsC;;IAEtC,wDAAwD;;IAExD,wCAAwC;;IAExC,wCAAwC;;IAExC,yCAAyC;;IAEzC,yCAAyC;;IAEzC,qDAAqD;;IAErD,yCAAyC;;IAEzC,2DAA2D;;CAErD,CAAA;AAGV,eAAO,MAAM,aAAa;IACtB,oEAAoE;;IAEpE,gDAAgD;;CAE1C,CAAA;AAGV,eAAO,MAAM,cAAc;IACvB,oDAAoD;;IAEpD,mCAAmC;;CAE7B,CAAA"}

package/dist/utils/constants.js

@@ -20,6 +20,10 @@ export const ApiLimits = {
     PROJECTS_MAX: 100,
     /** Batch size for fetching all tasks in a project */
     TASKS_BATCH_SIZE: 50,
+    /** Default limit for comment listings */
+    COMMENTS_DEFAULT: 10,
+    /** Maximum limit for comment search and list operations */
+    COMMENTS_MAX: 10,
 };
 // UI Display Limits
 export const DisplayLimits = {

package/dist/utils/tool-names.d.ts

@@ -12,10 +12,15 @@ export declare const ToolNames: {
     readonly FIND_TASKS: "find-tasks";
     readonly FIND_TASKS_BY_DATE: "find-tasks-by-date";
     readonly FIND_COMPLETED_TASKS: "find-completed-tasks";
+    readonly ADD_PROJECTS: "add-projects";
+    readonly UPDATE_PROJECTS: "update-projects";
     readonly FIND_PROJECTS: "find-projects";
-    readonly MANAGE_PROJECTS: "manage-projects";
+    readonly ADD_SECTIONS: "add-sections";
+    readonly UPDATE_SECTIONS: "update-sections";
     readonly FIND_SECTIONS: "find-sections";
-    readonly MANAGE_SECTIONS: "manage-sections";
+    readonly ADD_COMMENTS: "add-comments";
+    readonly UPDATE_COMMENTS: "update-comments";
+    readonly FIND_COMMENTS: "find-comments";
     readonly GET_OVERVIEW: "get-overview";
     readonly DELETE_OBJECT: "delete-object";
 };

package/dist/utils/tool-names.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-names.d.ts","sourceRoot":"","sources":["../../src/utils/tool-names.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;CAoBZ,CAAA;AAGV,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAA"}
+{"version":3,"file":"tool-names.d.ts","sourceRoot":"","sources":["../../src/utils/tool-names.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;CA2BZ,CAAA;AAGV,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAA"}

package/dist/utils/tool-names.js

@@ -14,11 +14,17 @@ export const ToolNames = {
     FIND_TASKS_BY_DATE: 'find-tasks-by-date',
     FIND_COMPLETED_TASKS: 'find-completed-tasks',
     // Project management tools
+    ADD_PROJECTS: 'add-projects',
+    UPDATE_PROJECTS: 'update-projects',
     FIND_PROJECTS: 'find-projects',
-    MANAGE_PROJECTS: 'manage-projects',
     // Section management tools
+    ADD_SECTIONS: 'add-sections',
+    UPDATE_SECTIONS: 'update-sections',
     FIND_SECTIONS: 'find-sections',
-    MANAGE_SECTIONS: 'manage-sections',
+    // Comment management tools
+    ADD_COMMENTS: 'add-comments',
+    UPDATE_COMMENTS: 'update-comments',
+    FIND_COMMENTS: 'find-comments',
     // General tools
     GET_OVERVIEW: 'get-overview',
     DELETE_OBJECT: 'delete-object',

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@doist/todoist-ai",
-    "version": "3.0.0",
+    "version": "4.0.0",
     "type": "module",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",

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

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

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

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

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

@@ -1,109 +0,0 @@
-import { jest } from '@jest/globals';
-import { TEST_IDS, createMockProject, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
-import { ToolNames } from '../../utils/tool-names.js';
-import { manageProjects } from '../manage-projects.js';
-// Mock the Todoist API
-const mockTodoistApi = {
-    addProject: jest.fn(),
-    updateProject: jest.fn(),
-};
-const { ADD_TASKS, FIND_PROJECTS, MANAGE_PROJECTS, MANAGE_SECTIONS } = ToolNames;
-describe(`${MANAGE_PROJECTS} 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 manageProjects.execute({ 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('Created project: 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({
-                project: expect.objectContaining({
-                    id: TEST_IDS.PROJECT_TEST,
-                    name: 'test-abc123def456-project',
-                }),
-                operation: 'created',
-            }));
-        });
-        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 manageProjects.execute({ name: 'My Blue Project' }, mockTodoistApi);
-            expect(mockTodoistApi.addProject).toHaveBeenCalledWith({ name: 'My Blue Project' });
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-            expect(textContent).toContain('Created project: My Blue Project');
-            expect(textContent).toContain('id=project-456');
-            expect(textContent).toContain(`Use ${MANAGE_SECTIONS} to organize this project`);
-        });
-    });
-    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 manageProjects.execute({ 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 project: Updated Project Name');
-            expect(textContent).toContain('id=existing-project-123');
-            expect(textContent).toContain(`Use ${FIND_PROJECTS} to see all projects`);
-        });
-    });
-    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(manageProjects.execute({ name: '' }, mockTodoistApi)).rejects.toThrow('API Error: Project name is required');
-        });
-    });
-});

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

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

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

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