@doist/todoist-ai 2.2.2 → 4.0.0

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/add-sections.d.ts

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

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

@@ -0,0 +1,82 @@
+import type { TodoistApi } from '@doist/todoist-api-typescript';
+import { z } from 'zod';
+declare const addTasks: {
+    name: "add-tasks";
+    description: string;
+    parameters: {
+        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({ 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;
+        }[];
+    }, client: TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            tasks: {
+                id: string;
+                content: string;
+                description: string;
+                dueDate: string | undefined;
+                recurring: string | boolean;
+                priority: number;
+                projectId: string;
+                sectionId: string | null;
+                parentId: string | null;
+                labels: string[];
+                duration: string | null;
+            }[];
+            totalCount: number;
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { addTasks };
+//# sourceMappingURL=add-tasks.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
+import { mapTask } from '../tool-helpers.js';
+import { DurationParseError, parseDuration } from '../utils/duration-parser.js';
+import { generateTaskNextSteps, getDateString, summarizeTaskOperation, } from '../utils/response-builders.js';
+import { ToolNames } from '../utils/tool-names.js';
+const TaskSchema = z.object({
+    content: z.string().min(1).describe('The content of the task to create.'),
+    description: z.string().optional().describe('The description of the task.'),
+    priority: z.number().int().min(1).max(4).optional().describe('The priority of the task (1-4).'),
+    dueString: z.string().optional().describe('The due date for the task, in natural language.'),
+    duration: z
+        .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 = {
+    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({ 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: { tasks },
+        });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                tasks: mappedTasks,
+                totalCount: mappedTasks.length,
+            },
+        });
+    },
+};
+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 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');
+    }
+    let projectContext = '';
+    if (contextTypes.size === 1) {
+        const contextType = Array.from(contextTypes)[0];
+        projectContext = contextType === 'inbox' ? '' : `to ${contextType}`;
+    }
+    else if (contextTypes.size > 1) {
+        projectContext = 'to multiple contexts';
+    }
+    return summarizeTaskOperation('Added', tasks, {
+        context: projectContext,
+        nextSteps: generateTaskNextSteps('added', tasks, { hasToday }),
+        showDetails: true,
+    });
+}
+export { addTasks };

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

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+declare const completeTasks: {
+    name: "complete-tasks";
+    description: string;
+    parameters: {
+        ids: z.ZodArray<z.ZodString, "many">;
+    };
+    execute(args: {
+        ids: string[];
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            completed: string[];
+            failures: {
+                item: string;
+                error: string;
+                code?: string;
+            }[];
+            totalRequested: number;
+            successCount: number;
+            failureCount: number;
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { completeTasks };
+//# sourceMappingURL=complete-tasks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"complete-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/complete-tasks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAUvB,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;sBAMmB,MAAM;uBAAS,MAAM;uBAAS,MAAM;;;;;;;;;;;;;;;;;;CAgChC,CAAA;AAsC1C,OAAO,EAAE,aAAa,EAAE,CAAA"}

package/dist/tools/complete-tasks.js

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
+import { summarizeBatch } from '../utils/response-builders.js';
+import { ToolNames } from '../utils/tool-names.js';
+const ArgsSchema = {
+    ids: z.array(z.string().min(1)).min(1).describe('The IDs of the tasks to complete.'),
+};
+const completeTasks = {
+    name: ToolNames.COMPLETE_TASKS,
+    description: 'Complete one or more tasks by their IDs.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const completed = [];
+        const failures = [];
+        for (const id of args.ids) {
+            try {
+                await client.closeTask(id);
+                completed.push(id);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                failures.push({
+                    item: id,
+                    error: errorMessage,
+                });
+            }
+        }
+        const textContent = generateTextContent({
+            completed,
+            failures,
+            args,
+        });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                completed,
+                failures,
+                totalRequested: args.ids.length,
+                successCount: completed.length,
+                failureCount: failures.length,
+            },
+        });
+    },
+};
+function generateNextSteps(completed, failures) {
+    if (completed > 0) {
+        const moveResult = failures === 0
+            ? "Use find-tasks-by-date('overdue') to tackle remaining overdue items."
+            : 'Review failed completions and retry if needed.';
+        return [moveResult];
+    }
+    if (failures > 0) {
+        return ['Check task IDs and permissions, then retry.'];
+    }
+    return ['No tasks were completed.'];
+}
+function generateTextContent({ completed, failures, args, }) {
+    const nextSteps = generateNextSteps(completed.length, failures.length);
+    return summarizeBatch({
+        action: 'Completed tasks',
+        success: completed.length,
+        total: args.ids.length,
+        successItems: completed,
+        failures,
+        nextSteps,
+    });
+}
+export { completeTasks };