@doist/todoist-ai 3.0.0 → 4.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"add-sections.d.ts","sourceRoot":"","sources":["../../src/tools/add-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,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgByB,CAAA;AAiD1C,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/tools/add-sections.js

@@ -0,0 +1,61 @@
+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_TASKS, FIND_TASKS, GET_OVERVIEW, FIND_SECTIONS } = ToolNames;
+const SectionSchema = z.object({
+    name: z.string().min(1).describe('The name of the section.'),
+    projectId: z.string().min(1).describe('The ID of the project to add the section to.'),
+});
+const ArgsSchema = {
+    sections: z.array(SectionSchema).min(1).describe('The array of sections to add.'),
+};
+const addSections = {
+    name: ToolNames.ADD_SECTIONS,
+    description: 'Add one or more new sections to projects.',
+    parameters: ArgsSchema,
+    async execute({ sections }, client) {
+        const newSections = await Promise.all(sections.map((section) => client.addSection(section)));
+        const textContent = generateTextContent({ sections: newSections });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                sections: newSections,
+                totalCount: newSections.length,
+            },
+        });
+    },
+};
+function generateTextContent({ sections, }) {
+    const count = sections.length;
+    const sectionList = sections
+        .map((section) => `• ${section.name} (id=${section.id}, projectId=${section.projectId})`)
+        .join('\n');
+    const summary = `Added ${count} section${count === 1 ? '' : 's'}:\n${sectionList}`;
+    // Context-aware next steps for new sections
+    const nextSteps = [];
+    if (count === 1) {
+        const section = sections[0];
+        if (section) {
+            nextSteps.push(`Use ${ADD_TASKS} with sectionId=${section.id} to add your first tasks`);
+            nextSteps.push(`Use ${FIND_TASKS} with sectionId=${section.id} to verify setup`);
+            nextSteps.push(`Use ${GET_OVERVIEW} with projectId=${section.projectId} to see project organization`);
+        }
+    }
+    else {
+        // Group sections by project for better guidance
+        const projectIds = [...new Set(sections.map((s) => s.projectId))];
+        nextSteps.push(`Use ${ADD_TASKS} to add tasks to these new sections`);
+        if (projectIds.length === 1) {
+            nextSteps.push(`Use ${GET_OVERVIEW} with projectId=${projectIds[0]} to see updated project structure`);
+            nextSteps.push(`Use ${FIND_SECTIONS} with projectId=${projectIds[0]} to see all sections`);
+        }
+        else {
+            nextSteps.push(`Use ${GET_OVERVIEW} to see updated project structures`);
+            nextSteps.push(`Use ${FIND_SECTIONS} to see sections in specific projects`);
+        }
+    }
+    const next = formatNextSteps(nextSteps);
+    return `${summary}\n${next}`;
+}
+export { addSections };

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

@@ -1,43 +1,50 @@
+import type { TodoistApi } from '@doist/todoist-api-typescript';
 import { z } from 'zod';
 declare const addTasks: {
     name: "add-tasks";
     description: string;
     parameters: {
-        projectId: z.ZodOptional<z.ZodString>;
-        sectionId: z.ZodOptional<z.ZodString>;
-        parentId: z.ZodOptional<z.ZodString>;
         tasks: z.ZodArray<z.ZodObject<{
             content: z.ZodString;
             description: z.ZodOptional<z.ZodString>;
             priority: z.ZodOptional<z.ZodNumber>;
             dueString: z.ZodOptional<z.ZodString>;
             duration: z.ZodOptional<z.ZodString>;
+            projectId: z.ZodOptional<z.ZodString>;
+            sectionId: z.ZodOptional<z.ZodString>;
+            parentId: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             content: string;
             description?: string | undefined;
+            parentId?: string | undefined;
+            projectId?: string | undefined;
+            sectionId?: string | undefined;
             priority?: number | undefined;
             dueString?: string | undefined;
             duration?: string | undefined;
         }, {
             content: string;
             description?: string | undefined;
+            parentId?: string | undefined;
+            projectId?: string | undefined;
+            sectionId?: string | undefined;
             priority?: number | undefined;
             dueString?: string | undefined;
             duration?: string | undefined;
         }>, "many">;
     };
-    execute(args: {
+    execute({ tasks }: {
         tasks: {
             content: string;
             description?: string | undefined;
+            parentId?: string | undefined;
+            projectId?: string | undefined;
+            sectionId?: string | undefined;
             priority?: number | undefined;
             dueString?: string | undefined;
             duration?: string | undefined;
         }[];
-        parentId?: string | undefined;
-        projectId?: string | undefined;
-        sectionId?: string | undefined;
-    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+    }, client: TodoistApi): Promise<{
         content: {
             type: "text";
             text: string;

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

@@ -1 +1 @@
-{"version":3,"file":"add-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/add-tasks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAgCvB,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgD4B,CAAA;AA8B1C,OAAO,EAAE,QAAQ,EAAE,CAAA"}
+{"version":3,"file":"add-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/add-tasks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAqB,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAClF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAgCvB,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsB4B,CAAA;AA8D1C,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/dist/tools/add-tasks.js

@@ -13,46 +13,24 @@ const TaskSchema = z.object({
         .string()
         .optional()
         .describe('The duration of the task. Use format: "2h" (hours), "90m" (minutes), "2h30m" (combined), or "1.5h" (decimal hours). Max 24h.'),
+    projectId: z.string().optional().describe('The project ID to add this task to.'),
+    sectionId: z.string().optional().describe('The section ID to add this task to.'),
+    parentId: z.string().optional().describe('The parent task ID (for subtasks).'),
 });
 const ArgsSchema = {
-    projectId: z.string().optional().describe('The project ID to add the tasks to.'),
-    sectionId: z.string().optional().describe('The section ID to add the tasks to.'),
-    parentId: z.string().optional().describe('The parent task ID (for subtasks).'),
     tasks: z.array(TaskSchema).min(1).describe('The array of tasks to add.'),
 };
 const addTasks = {
     name: ToolNames.ADD_TASKS,
     description: 'Add one or more tasks to a project, section, or parent.',
     parameters: ArgsSchema,
-    async execute(args, client) {
-        const { projectId, sectionId, parentId, tasks } = args;
-        const newTasks = [];
-        for (const task of tasks) {
-            const { duration: durationStr, ...otherTaskArgs } = task;
-            let taskArgs = { ...otherTaskArgs, projectId, sectionId, parentId };
-            // Parse duration if provided
-            if (durationStr) {
-                try {
-                    const { minutes } = parseDuration(durationStr);
-                    taskArgs = {
-                        ...taskArgs,
-                        duration: minutes,
-                        durationUnit: 'minute',
-                    };
-                }
-                catch (error) {
-                    if (error instanceof DurationParseError) {
-                        throw new Error(`Task "${task.content}": ${error.message}`);
-                    }
-                    throw error;
-                }
-            }
-            newTasks.push(await client.addTask(taskArgs));
-        }
+    async execute({ tasks }, client) {
+        const addTaskPromises = tasks.map((task) => processTask(task, client));
+        const newTasks = await Promise.all(addTaskPromises);
         const mappedTasks = newTasks.map(mapTask);
         const textContent = generateTextContent({
             tasks: mappedTasks,
-            args,
+            args: { tasks },
         });
         return getToolOutput({
             textContent,
@@ -63,20 +41,51 @@ const addTasks = {
         });
     },
 };
+async function processTask(task, client) {
+    const { duration: durationStr, projectId, sectionId, parentId, ...otherTaskArgs } = task;
+    let taskArgs = { ...otherTaskArgs, projectId, sectionId, parentId };
+    // Parse duration if provided
+    if (durationStr) {
+        try {
+            const { minutes } = parseDuration(durationStr);
+            taskArgs = {
+                ...taskArgs,
+                duration: minutes,
+                durationUnit: 'minute',
+            };
+        }
+        catch (error) {
+            if (error instanceof DurationParseError) {
+                throw new Error(`Task "${task.content}": ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    return await client.addTask(taskArgs);
+}
 function generateTextContent({ tasks, args, }) {
     // Get context for smart next steps
     const todayStr = getDateString();
     const hasToday = tasks.some((task) => task.dueDate === todayStr);
-    // Generate context description without API calls
-    let projectContext = '';
-    if (args.projectId) {
-        projectContext = 'to specified project';
+    // Generate context description for mixed contexts
+    const contextTypes = new Set();
+    for (const task of args.tasks) {
+        if (task.projectId)
+            contextTypes.add('projects');
+        else if (task.sectionId)
+            contextTypes.add('sections');
+        else if (task.parentId)
+            contextTypes.add('subtasks');
+        else
+            contextTypes.add('inbox');
     }
-    else if (args.sectionId) {
-        projectContext = 'to specified section';
+    let projectContext = '';
+    if (contextTypes.size === 1) {
+        const contextType = Array.from(contextTypes)[0];
+        projectContext = contextType === 'inbox' ? '' : `to ${contextType}`;
     }
-    else if (args.parentId) {
-        projectContext = 'as subtasks';
+    else if (contextTypes.size > 1) {
+        projectContext = 'to multiple contexts';
     }
     return summarizeTaskOperation('Added', tasks, {
         context: projectContext,

package/dist/tools/delete-object.d.ts

@@ -3,11 +3,11 @@ declare const deleteObject: {
     name: "delete-object";
     description: string;
     parameters: {
-        type: z.ZodEnum<["project", "section", "task"]>;
+        type: z.ZodEnum<["project", "section", "task", "comment"]>;
         id: z.ZodString;
     };
     execute(args: {
-        type: "task" | "project" | "section";
+        type: "task" | "comment" | "project" | "section";
         id: string;
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
         content: {
@@ -16,7 +16,7 @@ declare const deleteObject: {
         }[];
         structuredContent: {
             deletedEntity: {
-                type: "task" | "project" | "section";
+                type: "task" | "comment" | "project" | "section";
                 id: string;
             };
             success: boolean;

package/dist/tools/delete-object.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delete-object.d.ts","sourceRoot":"","sources":["../../src/tools/delete-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAavB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCwB,CAAA;AAyC1C,OAAO,EAAE,YAAY,EAAE,CAAA"}
+{"version":3,"file":"delete-object.d.ts","sourceRoot":"","sources":["../../src/tools/delete-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAsBvB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCwB,CAAA;AA+C1C,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/tools/delete-object.js

@@ -2,14 +2,16 @@ 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, GET_OVERVIEW, FIND_SECTIONS, FIND_TASKS, FIND_TASKS_BY_DATE } = ToolNames;
+const { FIND_PROJECTS, GET_OVERVIEW, FIND_SECTIONS, FIND_TASKS, FIND_TASKS_BY_DATE, FIND_COMMENTS, } = ToolNames;
 const ArgsSchema = {
-    type: z.enum(['project', 'section', 'task']).describe('The type of entity to delete.'),
+    type: z
+        .enum(['project', 'section', 'task', 'comment'])
+        .describe('The type of entity to delete.'),
     id: z.string().min(1).describe('The ID of the entity to delete.'),
 };
 const deleteObject = {
     name: ToolNames.DELETE_OBJECT,
-    description: 'Delete a project, section, or task by its ID.',
+    description: 'Delete a project, section, task, or comment by its ID.',
     parameters: ArgsSchema,
     async execute(args, client) {
         switch (args.type) {
@@ -22,6 +24,9 @@ const deleteObject = {
             case 'task':
                 await client.deleteTask(args.id);
                 break;
+            case 'comment':
+                await client.deleteComment(args.id);
+                break;
         }
         const textContent = generateTextContent({
             type: args.type,
@@ -62,6 +67,11 @@ function generateTextContent({ type, id, }) {
             nextSteps.push(`Use ${GET_OVERVIEW} to check if this affects any dependent tasks`);
             nextSteps.push('Note: Any subtasks of this task were also deleted');
             break;
+        case 'comment':
+            // Help user understand comment deletion impact
+            nextSteps.push(`Use ${FIND_COMMENTS} to see remaining comments on the task/project`);
+            nextSteps.push('Note: Comment attachments were also deleted');
+            break;
     }
     const next = formatNextSteps(nextSteps);
     return `${summary}\n${next}`;

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

@@ -0,0 +1,46 @@
+import type { Comment } from '@doist/todoist-api-typescript';
+import { z } from 'zod';
+declare const findComments: {
+    name: "find-comments";
+    description: string;
+    parameters: {
+        taskId: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        commentId: z.ZodOptional<z.ZodString>;
+        cursor: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    };
+    execute(args: {
+        projectId?: string | undefined;
+        limit?: number | undefined;
+        cursor?: string | undefined;
+        taskId?: string | undefined;
+        commentId?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            comments: Comment[];
+            searchType: string;
+            searchId: string;
+            hasMore: boolean;
+            nextCursor: string | null;
+            totalCount: number;
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { findComments };
+//# sourceMappingURL=find-comments.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"find-comments.d.ts","sourceRoot":"","sources":["../../src/tools/find-comments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAA;AAC5D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAuBvB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsEwB,CAAA;AAoF1C,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/tools/find-comments.js

@@ -0,0 +1,143 @@
+import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
+import { ApiLimits } from '../utils/constants.js';
+import { formatNextSteps } from '../utils/response-builders.js';
+import { ToolNames } from '../utils/tool-names.js';
+const { ADD_COMMENTS, UPDATE_COMMENTS, DELETE_OBJECT } = ToolNames;
+const ArgsSchema = {
+    taskId: z.string().optional().describe('Find comments for a specific task.'),
+    projectId: z.string().optional().describe('Find comments for a specific project.'),
+    commentId: z.string().optional().describe('Get a specific comment by ID.'),
+    cursor: z.string().optional().describe('Pagination cursor for retrieving more results.'),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(ApiLimits.COMMENTS_MAX)
+        .optional()
+        .describe('Maximum number of comments to return'),
+};
+const findComments = {
+    name: ToolNames.FIND_COMMENTS,
+    description: 'Find comments by task, project, or get a specific comment by ID. Exactly one of taskId, projectId, or commentId must be provided.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        // Validate that exactly one search parameter is provided
+        const searchParams = [args.taskId, args.projectId, args.commentId].filter(Boolean);
+        if (searchParams.length === 0) {
+            throw new Error('Must provide exactly one of: taskId, projectId, or commentId.');
+        }
+        if (searchParams.length > 1) {
+            throw new Error('Cannot provide multiple search parameters. Choose one of: taskId, projectId, or commentId.');
+        }
+        let comments;
+        let hasMore = false;
+        let nextCursor = null;
+        if (args.commentId) {
+            // Get single comment
+            const comment = await client.getComment(args.commentId);
+            comments = [comment];
+        }
+        else if (args.taskId) {
+            // Get comments by task
+            const response = await client.getComments({
+                taskId: args.taskId,
+                cursor: args.cursor || null,
+                limit: args.limit || ApiLimits.COMMENTS_DEFAULT,
+            });
+            comments = response.results;
+            hasMore = response.nextCursor !== null;
+            nextCursor = response.nextCursor;
+        }
+        else if (args.projectId) {
+            // Get comments by project
+            const response = await client.getComments({
+                projectId: args.projectId,
+                cursor: args.cursor || null,
+                limit: args.limit || ApiLimits.COMMENTS_DEFAULT,
+            });
+            comments = response.results;
+            hasMore = response.nextCursor !== null;
+            nextCursor = response.nextCursor;
+        }
+        else {
+            // This should never happen due to validation, but TypeScript needs it
+            throw new Error('Invalid state: no search parameter provided');
+        }
+        const textContent = generateTextContent({
+            comments,
+            searchType: args.commentId ? 'single' : args.taskId ? 'task' : 'project',
+            searchId: args.commentId || args.taskId || args.projectId || '',
+            hasMore,
+            nextCursor,
+        });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                comments,
+                searchType: args.commentId ? 'single' : args.taskId ? 'task' : 'project',
+                searchId: args.commentId || args.taskId || args.projectId || '',
+                hasMore,
+                nextCursor,
+                totalCount: comments.length,
+            },
+        });
+    },
+};
+function generateTextContent({ comments, searchType, searchId, hasMore, nextCursor, }) {
+    if (comments.length === 0) {
+        return `No comments found for ${searchType}${searchType !== 'single' ? ` ${searchId}` : ''}`;
+    }
+    // Build summary
+    let summary;
+    if (searchType === 'single') {
+        const comment = comments[0];
+        if (!comment) {
+            return 'Comment not found';
+        }
+        const hasAttachment = comment.fileAttachment !== null;
+        const attachmentInfo = hasAttachment
+            ? ` • Has attachment: ${comment.fileAttachment?.fileName || 'file'}`
+            : '';
+        summary = `Found comment${attachmentInfo} • id=${comment.id}`;
+    }
+    else {
+        const attachmentCount = comments.filter((c) => c.fileAttachment !== null).length;
+        const attachmentInfo = attachmentCount > 0 ? ` (${attachmentCount} with attachments)` : '';
+        const commentsLabel = comments.length === 1 ? 'comment' : 'comments';
+        summary = `Found ${comments.length} ${commentsLabel} for ${searchType} ${searchId}${attachmentInfo}`;
+        if (hasMore) {
+            summary += ' • More available';
+        }
+    }
+    // Context-aware next steps
+    const nextSteps = [];
+    if (searchType === 'single') {
+        const comment = comments[0];
+        if (comment) {
+            nextSteps.push(`Use ${UPDATE_COMMENTS} with id=${comment.id} to edit content`);
+            nextSteps.push(`Use ${DELETE_OBJECT} with type=comment id=${comment.id} to remove`);
+            // Suggest viewing related comments
+            if (comment.taskId) {
+                nextSteps.push(`Use ${ToolNames.FIND_COMMENTS} with taskId=${comment.taskId} to see all task comments`);
+            }
+            else if (comment.projectId) {
+                nextSteps.push(`Use ${ToolNames.FIND_COMMENTS} with projectId=${comment.projectId} to see all project comments`);
+            }
+        }
+    }
+    else {
+        // Multiple comments
+        nextSteps.push(`Use ${ADD_COMMENTS} with ${searchType}Id=${searchId} to add new comment`);
+        if (comments.length > 0) {
+            nextSteps.push(`Use ${ToolNames.FIND_COMMENTS} with commentId to view specific comment details`);
+        }
+        // Pagination
+        if (hasMore && nextCursor) {
+            nextSteps.push(`Use ${ToolNames.FIND_COMMENTS} with cursor="${nextCursor}" to get more results`);
+        }
+    }
+    const next = formatNextSteps(nextSteps);
+    return `${summary}\n${next}`;
+}
+export { findComments };

package/dist/tools/find-projects.js

@@ -4,7 +4,7 @@ import { mapProject } from '../tool-helpers.js';
 import { ApiLimits } from '../utils/constants.js';
 import { formatProjectPreview, summarizeList } from '../utils/response-builders.js';
 import { ToolNames } from '../utils/tool-names.js';
-const { MANAGE_PROJECTS, FIND_TASKS } = ToolNames;
+const { ADD_PROJECTS, FIND_TASKS } = ToolNames;
 const ArgsSchema = {
     search: z
         .string()
@@ -76,7 +76,7 @@ function generateTextContent({ projects, args, nextCursor, }) {
         }
         else {
             zeroReasonHints.push('No projects created yet');
-            zeroReasonHints.push(`Use ${MANAGE_PROJECTS} to create a project`);
+            zeroReasonHints.push(`Use ${ADD_PROJECTS} to create a project`);
         }
     }
     // Generate contextual next steps

package/dist/tools/find-sections.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { getToolOutput } from '../mcp-helpers.js';
 import { summarizeList } from '../utils/response-builders.js';
 import { ToolNames } from '../utils/tool-names.js';
-const { MANAGE_SECTIONS, FIND_TASKS, UPDATE_TASKS, DELETE_OBJECT } = ToolNames;
+const { ADD_SECTIONS, UPDATE_SECTIONS, FIND_TASKS, UPDATE_TASKS, DELETE_OBJECT } = ToolNames;
 const ArgsSchema = {
     projectId: z.string().min(1).describe('The ID of the project to search sections in.'),
     search: z
@@ -50,7 +50,7 @@ function generateTextContent({ sections, projectId, search, }) {
     }
     else {
         zeroReasonHints.push('Project has no sections yet');
-        zeroReasonHints.push(`Use ${MANAGE_SECTIONS} to create sections`);
+        zeroReasonHints.push(`Use ${ADD_SECTIONS} to create sections`);
     }
     // Data-driven next steps based on results
     const nextSteps = [];
@@ -59,7 +59,7 @@ function generateTextContent({ sections, projectId, search, }) {
         if (sections.length === 1) {
             const sectionId = sections[0]?.id;
             nextSteps.push(`Use ${FIND_TASKS} with sectionId=${sectionId} to see tasks`);
-            nextSteps.push(`Use ${MANAGE_SECTIONS} to create additional sections for organization`);
+            nextSteps.push(`Use ${ADD_SECTIONS} to create additional sections for organization`);
         }
         else if (sections.length > 8) {
             nextSteps.push('Consider consolidating sections - many small sections can reduce productivity');
@@ -68,7 +68,7 @@ function generateTextContent({ sections, projectId, search, }) {
         }
         else {
             nextSteps.push(`Use ${FIND_TASKS} with sectionId to see tasks in specific sections`);
-            nextSteps.push(`Use ${MANAGE_SECTIONS} to modify section names or order`);
+            nextSteps.push(`Use ${UPDATE_SECTIONS} to modify section names`);
         }
         // Search-specific suggestions
         if (search) {

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"update-comments.d.ts","sourceRoot":"","sources":["../../src/tools/update-comments.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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BsB,CAAA;AA2D1C,OAAO,EAAE,cAAc,EAAE,CAAA"}