@doist/todoist-ai 2.2.2 → 3.0.0

package/dist/tools/get-overview.d.ts

@@ -0,0 +1,67 @@
+import type { Section, TodoistApi } from '@doist/todoist-api-typescript';
+import { z } from 'zod';
+import { mapTask } from '../tool-helpers.js';
+type ProjectStructure = {
+    id: string;
+    name: string;
+    parentId: string | null;
+    sections: Section[];
+    children: ProjectStructure[];
+};
+type AccountOverviewStructured = Record<string, unknown> & {
+    type: 'account_overview';
+    inbox: {
+        id: string;
+        name: string;
+        sections: Section[];
+    } | null;
+    projects: ProjectStructure[];
+    totalProjects: number;
+    totalSections: number;
+    hasNestedProjects: boolean;
+};
+interface ProjectOverviewStructured extends Record<string, unknown> {
+    type: 'project_overview';
+    project: {
+        id: string;
+        name: string;
+    };
+    sections: Section[];
+    tasks: Array<ReturnType<typeof mapTask> & {
+        children: never[];
+    }>;
+    stats: {
+        totalTasks: number;
+        totalSections: number;
+        tasksWithoutSection: number;
+    };
+}
+declare const getOverview: {
+    name: "get-overview";
+    description: string;
+    parameters: {
+        projectId: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        projectId?: string | undefined;
+    }, client: TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: AccountOverviewStructured | ProjectOverviewStructured;
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { getOverview, type AccountOverviewStructured, type ProjectOverviewStructured };
+//# sourceMappingURL=get-overview.d.ts.map

package/dist/tools/get-overview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-overview.d.ts","sourceRoot":"","sources":["../../src/tools/get-overview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAA;AACxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,EAAmC,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAgI7E,KAAK,gBAAgB,GAAG;IACpB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,QAAQ,EAAE,gBAAgB,EAAE,CAAA;CAC/B,CAAA;AAED,KAAK,yBAAyB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IACvD,IAAI,EAAE,kBAAkB,CAAA;IACxB,KAAK,EAAE;QACH,EAAE,EAAE,MAAM,CAAA;QACV,IAAI,EAAE,MAAM,CAAA;QACZ,QAAQ,EAAE,OAAO,EAAE,CAAA;KACtB,GAAG,IAAI,CAAA;IACR,QAAQ,EAAE,gBAAgB,EAAE,CAAA;IAC5B,aAAa,EAAE,MAAM,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;IACrB,iBAAiB,EAAE,OAAO,CAAA;CAC7B,CAAA;AAED,UAAU,yBAA0B,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC/D,IAAI,EAAE,kBAAkB,CAAA;IACxB,OAAO,EAAE;QACL,EAAE,EAAE,MAAM,CAAA;QACV,IAAI,EAAE,MAAM,CAAA;KACf,CAAA;IACD,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,OAAO,OAAO,CAAC,GAAG;QAAE,QAAQ,EAAE,KAAK,EAAE,CAAA;KAAE,CAAC,CAAA;IAChE,KAAK,EAAE;QACH,UAAU,EAAE,MAAM,CAAA;QAClB,aAAa,EAAE,MAAM,CAAA;QACrB,mBAAmB,EAAE,MAAM,CAAA;KAC9B,CAAA;CACJ;AA6JD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;CAeyB,CAAA;AAE1C,OAAO,EAAE,WAAW,EAAE,KAAK,yBAAyB,EAAE,KAAK,yBAAyB,EAAE,CAAA"}

package/dist/tools/{overview.js → get-overview.js}

@@ -1,5 +1,8 @@
 import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
 import { isPersonalProject, mapTask } from '../tool-helpers.js';
+import { ApiLimits } from '../utils/constants.js';
+import { ToolNames } from '../utils/tool-names.js';
 const ArgsSchema = {
     projectId: z
         .string()
@@ -101,13 +104,22 @@ function renderTaskTreeMarkdown(tasks, indent = '') {
     }
     return lines;
 }
+function buildProjectStructure(project, sectionsByProject) {
+    return {
+        id: project.id,
+        name: project.name,
+        parentId: isPersonalProject(project) ? (project.parentId ?? null) : null,
+        sections: sectionsByProject[project.id] || [],
+        children: project.children.map((child) => buildProjectStructure(child, sectionsByProject)),
+    };
+}
 async function getAllTasksForProject(client, projectId) {
     let allTasks = [];
     let cursor = undefined;
     do {
         const { results, nextCursor } = await client.getTasks({
             projectId,
-            limit: 50,
+            limit: ApiLimits.TASKS_BATCH_SIZE,
             cursor: cursor ?? undefined,
         });
         allTasks = allTasks.concat(results.map(mapTask));
@@ -119,7 +131,6 @@ async function getProjectSections(client, projectId) {
     const { results } = await client.getSections({ projectId });
     return results;
 }
-// Account overview implementation
 async function generateAccountOverview(client) {
     const { results: projects } = await client.getProjects({});
     const inbox = projects.find((p) => isPersonalProject(p) && p.inboxProject === true);
@@ -127,6 +138,7 @@ async function generateAccountOverview(client) {
     const tree = buildProjectTree(nonInbox);
     const allProjectIds = projects.map((p) => p.id);
     const sectionsByProject = await getSectionsByProject(client, allProjectIds);
+    // Generate markdown text content
     const lines = ['# Personal Projects', ''];
     if (inbox) {
         lines.push(`- Inbox Project: ${inbox.name} (id=${inbox.id})`);
@@ -148,9 +160,24 @@ async function generateAccountOverview(client) {
     if (hasNested) {
         lines.push('_Note: Indentation indicates that a project is a sub-project of the one above it. This allows for organizing projects hierarchically, with parent projects containing related sub-projects._', '');
     }
-    return lines.join('\n');
+    const textContent = lines.join('\n');
+    // Generate structured content
+    const structuredContent = {
+        type: 'account_overview',
+        inbox: inbox
+            ? {
+                id: inbox.id,
+                name: inbox.name,
+                sections: sectionsByProject[inbox.id] || [],
+            }
+            : null,
+        projects: tree.map((project) => buildProjectStructure(project, sectionsByProject)),
+        totalProjects: projects.length,
+        totalSections: allProjectIds.reduce((total, id) => total + (sectionsByProject[id]?.length || 0), 0),
+        hasNestedProjects: hasNested,
+    };
+    return { textContent, structuredContent };
 }
-// Project overview implementation
 async function generateProjectOverview(client, projectId) {
     const project = await client.getProject(projectId);
     const sections = await getProjectSections(client, projectId);
@@ -162,14 +189,12 @@ async function generateProjectOverview(client, projectId) {
     }
     const tasksWithoutSection = [];
     for (const task of allTasks) {
-        if (task.sectionId && tasksBySection[task.sectionId]) {
-            // biome-ignore lint/style/noNonNullAssertion: the "if" above ensures that it is defined
-            tasksBySection[task.sectionId].push(task);
-        }
-        else {
-            tasksWithoutSection.push(task);
-        }
+        const sectionTasks = task.sectionId
+            ? (tasksBySection[task.sectionId] ?? tasksWithoutSection)
+            : tasksWithoutSection;
+        sectionTasks.push(task);
     }
+    // Generate markdown text content
     const lines = [`# ${project.name}`];
     if (tasksWithoutSection.length > 0) {
         lines.push('');
@@ -186,17 +211,39 @@ async function generateProjectOverview(client, projectId) {
         const tree = buildTaskTree(sectionTasks);
         lines.push(...renderTaskTreeMarkdown(tree));
     }
-    return lines.join('\n');
+    const textContent = lines.join('\n');
+    // Generate structured content
+    const structuredContent = {
+        type: 'project_overview',
+        project: {
+            id: project.id,
+            name: project.name,
+        },
+        sections: sections,
+        tasks: allTasks.map((task) => ({
+            ...task,
+            children: [], // Tasks already include hierarchical info via parentId
+        })),
+        stats: {
+            totalTasks: allTasks.length,
+            totalSections: sections.length,
+            tasksWithoutSection: tasksWithoutSection.length,
+        },
+    };
+    return { textContent, structuredContent };
 }
-const overview = {
-    name: 'overview',
+const getOverview = {
+    name: ToolNames.GET_OVERVIEW,
     description: 'Get a Markdown overview. If no projectId is provided, shows all projects with hierarchy and sections (useful for navigation). If projectId is provided, shows detailed overview of that specific project including all tasks grouped by sections.',
     parameters: ArgsSchema,
     async execute(args, client) {
-        if (args.projectId) {
-            return await generateProjectOverview(client, args.projectId);
-        }
-        return await generateAccountOverview(client);
+        const result = args.projectId
+            ? await generateProjectOverview(client, args.projectId)
+            : await generateAccountOverview(client);
+        return getToolOutput({
+            textContent: result.textContent,
+            structuredContent: result.structuredContent,
+        });
     },
 };
-export { overview };
+export { getOverview };

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

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+declare const manageProjects: {
+    name: "manage-projects";
+    description: string;
+    parameters: {
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+    };
+    execute(args: {
+        name: string;
+        id?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            project: import("@doist/todoist-api-typescript").PersonalProject | import("@doist/todoist-api-typescript").WorkspaceProject;
+            operation: string;
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { manageProjects };
+//# sourceMappingURL=manage-projects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"manage-projects.d.ts","sourceRoot":"","sources":["../../src/tools/manage-projects.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAmBvB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCsB,CAAA;AA+B1C,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/dist/tools/manage-projects.js

@@ -0,0 +1,63 @@
+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 { MANAGE_SECTIONS, ADD_TASKS, FIND_PROJECTS, FIND_TASKS, GET_OVERVIEW } = ToolNames;
+const ArgsSchema = {
+    id: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('The ID of the project to update. If provided, updates the project. If omitted, creates a new project.'),
+    name: z.string().min(1).describe('The name of the project.'),
+};
+const manageProjects = {
+    name: ToolNames.MANAGE_PROJECTS,
+    description: 'Add a new project or update an existing project. If id is provided, updates the project. If id is omitted, creates a new project.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        if (args.id) {
+            // Update existing project
+            const project = await client.updateProject(args.id, { name: args.name });
+            const textContent = generateTextContent({ project, operation: 'updated' });
+            return getToolOutput({
+                textContent,
+                structuredContent: {
+                    project,
+                    operation: 'updated',
+                },
+            });
+        }
+        // Create new project
+        const project = await client.addProject({ name: args.name });
+        const textContent = generateTextContent({ project, operation: 'created' });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                project,
+                operation: 'created',
+            },
+        });
+    },
+};
+function generateTextContent({ project, operation, }) {
+    const action = operation === 'created' ? 'Created' : 'Updated';
+    const summary = `${action} project: ${project.name} • id=${project.id}`;
+    // Context-aware next steps based on operation
+    const nextSteps = [];
+    if (operation === 'created') {
+        // For new projects, suggest logical setup workflow
+        nextSteps.push(`Use ${MANAGE_SECTIONS} to organize this project with sections`);
+        nextSteps.push(`Use ${ADD_TASKS} to add your first tasks`);
+        nextSteps.push(`Use ${GET_OVERVIEW} with projectId to see updated project structure.`);
+    }
+    else {
+        // For updated projects, suggest review and management
+        nextSteps.push(`Use ${GET_OVERVIEW} with projectId=${project.id} to see project structure`);
+        nextSteps.push(`Use ${FIND_PROJECTS} to see all projects with updated name`);
+        nextSteps.push(`Use ${FIND_TASKS} with projectId=${project.id} to review existing tasks`);
+    }
+    const next = formatNextSteps(nextSteps);
+    return `${summary}\n${next}`;
+}
+export { manageProjects };

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

@@ -0,0 +1,38 @@
+import type { Section } from '@doist/todoist-api-typescript';
+import { z } from 'zod';
+declare const manageSections: {
+    name: "manage-sections";
+    description: string;
+    parameters: {
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        name: string;
+        id?: string | undefined;
+        projectId?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            section: Section;
+            operation: string;
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { manageSections };
+//# sourceMappingURL=manage-sections.d.ts.map

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

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

package/dist/tools/manage-sections.js

@@ -0,0 +1,78 @@
+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 ArgsSchema = {
+    id: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('The ID of the section to update. If provided, updates the section. If omitted, creates a new section.'),
+    name: z.string().min(1).describe('The name of the section.'),
+    projectId: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('The ID of the project to add the section to. Required when creating a new section (when id is not provided).'),
+};
+const manageSections = {
+    name: ToolNames.MANAGE_SECTIONS,
+    description: 'Add a new section to a project or update an existing section. If id is provided, updates the section. If id is omitted, creates a new section (requires projectId).',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        if (args.id) {
+            // Update existing section
+            const section = await client.updateSection(args.id, { name: args.name });
+            const textContent = generateTextContent({ section, operation: 'updated' });
+            return getToolOutput({
+                textContent,
+                structuredContent: {
+                    section,
+                    operation: 'updated',
+                },
+            });
+        }
+        // Create new section - projectId is required
+        if (!args.projectId) {
+            throw new Error('Error: projectId is required when creating a new section (when id is not provided).');
+        }
+        const section = await client.addSection({
+            name: args.name,
+            projectId: args.projectId,
+        });
+        const textContent = generateTextContent({ section, operation: 'created' });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                section,
+                operation: 'created',
+            },
+        });
+    },
+};
+function generateTextContent({ section, operation, }) {
+    const action = operation === 'created' ? 'Created' : 'Updated';
+    const summary = `${action} section: ${section.name} • id=${section.id}`;
+    // Workflow-aware next steps based on operation and section context
+    const nextSteps = [];
+    if (operation === 'created') {
+        // For new sections, suggest immediate setup workflow
+        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`);
+        // Suggest related organization
+        if (section.projectId) {
+            nextSteps.push(`Use ${GET_OVERVIEW} with projectId=${section.projectId} to see project organization`);
+        }
+    }
+    else {
+        // For updated sections, suggest review and management
+        nextSteps.push(`Use ${FIND_TASKS} with sectionId=${section.id} to see existing tasks`);
+        nextSteps.push(`Use ${FIND_SECTIONS} to see all sections in this project`);
+        // Suggest task updates if section was renamed
+        nextSteps.push('Consider updating task descriptions if section purpose changed');
+    }
+    const next = formatNextSteps(nextSteps);
+    return `${summary}\n${next}`;
+}
+export { manageSections };

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

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+declare const updateTasks: {
+    name: "update-tasks";
+    description: string;
+    parameters: {
+        tasks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            content: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            projectId: z.ZodOptional<z.ZodString>;
+            sectionId: z.ZodOptional<z.ZodString>;
+            parentId: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodNumber>;
+            priority: z.ZodOptional<z.ZodNumber>;
+            dueString: z.ZodOptional<z.ZodString>;
+            duration: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            content?: string | undefined;
+            description?: string | undefined;
+            parentId?: string | undefined;
+            projectId?: string | undefined;
+            sectionId?: string | undefined;
+            priority?: number | undefined;
+            dueString?: string | undefined;
+            duration?: string | undefined;
+            order?: number | undefined;
+        }, {
+            id: string;
+            content?: string | undefined;
+            description?: string | undefined;
+            parentId?: string | undefined;
+            projectId?: string | undefined;
+            sectionId?: string | undefined;
+            priority?: number | undefined;
+            dueString?: string | undefined;
+            duration?: string | undefined;
+            order?: number | undefined;
+        }>, "many">;
+    };
+    execute(args: {
+        tasks: {
+            id: string;
+            content?: string | undefined;
+            description?: string | undefined;
+            parentId?: string | undefined;
+            projectId?: string | undefined;
+            sectionId?: string | undefined;
+            priority?: number | undefined;
+            dueString?: string | undefined;
+            duration?: string | undefined;
+            order?: number | undefined;
+        }[];
+    }, client: import("@doist/todoist-api-typescript").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;
+            updatedTaskIds: string[];
+            appliedOperations: {
+                updateCount: number;
+                skippedCount: number;
+            };
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { updateTasks };
+//# sourceMappingURL=update-tasks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"update-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/update-tasks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA2CvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6EyB,CAAA;AAqC1C,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/tools/update-tasks.js

@@ -0,0 +1,120 @@
+import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
+import { createMoveTaskArgs, mapTask } from '../tool-helpers.js';
+import { DurationParseError, parseDuration } from '../utils/duration-parser.js';
+import { summarizeTaskOperation } from '../utils/response-builders.js';
+import { ToolNames } from '../utils/tool-names.js';
+const { FIND_TASKS_BY_DATE, GET_OVERVIEW } = ToolNames;
+const TasksUpdateSchema = z.object({
+    id: z.string().min(1).describe('The ID of the task to update.'),
+    content: z.string().optional().describe('The new content of the task.'),
+    description: z.string().optional().describe('The new description of the task.'),
+    projectId: z.string().optional().describe('The new project ID for the task.'),
+    sectionId: z.string().optional().describe('The new section ID for the task.'),
+    parentId: z.string().optional().describe('The new parent task ID (for subtasks).'),
+    order: z.number().optional().describe('The new order of the task within its parent/section.'),
+    priority: z
+        .number()
+        .int()
+        .min(1)
+        .max(4)
+        .optional()
+        .describe('The new priority of the task (1-4).'),
+    dueString: z
+        .string()
+        .optional()
+        .describe("The new due date for the task, in natural language (e.g., 'tomorrow at 5pm')."),
+    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.'),
+});
+const ArgsSchema = {
+    tasks: z.array(TasksUpdateSchema).min(1).describe('The tasks to update.'),
+};
+const updateTasks = {
+    name: ToolNames.UPDATE_TASKS,
+    description: 'Update multiple existing tasks with new values.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const { tasks } = args;
+        const updateTasksPromises = tasks.map(async (task) => {
+            if (!hasUpdatesToMake(task)) {
+                return undefined;
+            }
+            const { id, projectId, sectionId, parentId, duration: durationStr, ...otherUpdateArgs } = task;
+            let updateArgs = { ...otherUpdateArgs };
+            // Parse duration if provided
+            if (durationStr) {
+                try {
+                    const { minutes } = parseDuration(durationStr);
+                    updateArgs = {
+                        ...updateArgs,
+                        duration: minutes,
+                        durationUnit: 'minute',
+                    };
+                }
+                catch (error) {
+                    if (error instanceof DurationParseError) {
+                        throw new Error(`Task ${id}: ${error.message}`);
+                    }
+                    throw error;
+                }
+            }
+            // If no move parameters are provided, use updateTask without moveTasks
+            if (!projectId && !sectionId && !parentId) {
+                return await client.updateTask(id, updateArgs);
+            }
+            const moveArgs = createMoveTaskArgs(id, projectId, sectionId, parentId);
+            const movedTasks = await client.moveTasks([id], moveArgs);
+            if (Object.keys(updateArgs).length > 0) {
+                return await client.updateTask(id, updateArgs);
+            }
+            return movedTasks[0];
+        });
+        const updatedTasks = (await Promise.all(updateTasksPromises)).filter((task) => task !== undefined);
+        const mappedTasks = updatedTasks.map(mapTask);
+        const textContent = generateTextContent({
+            tasks: mappedTasks,
+            args,
+        });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                tasks: mappedTasks,
+                totalCount: mappedTasks.length,
+                updatedTaskIds: updatedTasks.map((task) => task.id),
+                appliedOperations: {
+                    updateCount: mappedTasks.length,
+                    skippedCount: tasks.length - mappedTasks.length,
+                },
+            },
+        });
+    },
+};
+function generateTextContent({ tasks, args, }) {
+    const totalRequested = args.tasks.length;
+    const actuallyUpdated = tasks.length;
+    const skipped = totalRequested - actuallyUpdated;
+    let context = '';
+    if (skipped > 0) {
+        context = ` (${skipped} skipped - no changes)`;
+    }
+    const nextSteps = [];
+    if (tasks.length > 0) {
+        nextSteps.push(`Use ${FIND_TASKS_BY_DATE} to see your updated schedule`);
+        nextSteps.push(`Use ${GET_OVERVIEW} to see updated project organization`);
+    }
+    else {
+        nextSteps.push(`Use ${FIND_TASKS_BY_DATE} to see current tasks`);
+    }
+    return summarizeTaskOperation('Updated', tasks, {
+        context,
+        nextSteps,
+        showDetails: tasks.length <= 5,
+    });
+}
+function hasUpdatesToMake({ id, ...otherUpdateArgs }) {
+    return Object.keys(otherUpdateArgs).length > 0;
+}
+export { updateTasks };