@taazkareem/clickup-mcp-server 0.4.70 → 0.4.72

package/build/tools/task.js

@@ -6,10 +6,12 @@
  * retrieving task details.
  */
 import { clickUpServices } from '../services/shared.js';
-import { findListIDByName } from './list.js';
-import { parseDueDate, formatDueDate } from './utils.js';
+import { parseDueDate, formatDueDate, enhanceResponseWithSponsor, resolveListId, resolveTaskId } from './utils.js';
+import { BulkService } from '../services/clickup/bulk.js';
 // Use shared services instance
 const { task: taskService, workspace: workspaceService } = clickUpServices;
+// Create a bulk service instance that uses the task service
+const bulkService = new BulkService(taskService);
 /**
  * Tool definition for creating a single task
  */
@@ -49,7 +51,7 @@ export const createTaskTool = {
             },
             dueDate: {
                 type: "string",
-                description: "Due date of the task (Unix timestamp in milliseconds). Convert dates to this format before submitting."
+                description: "Due date of the task. Supports both Unix timestamps (in milliseconds) and natural language expressions like '1 hour from now', 'tomorrow', 'next week', or '3 days from now'."
             }
         },
         required: ["name"]
@@ -146,7 +148,7 @@ export const updateTaskTool = {
             },
             dueDate: {
                 type: "string",
-                description: "New due date (Unix timestamp in milliseconds)"
+                description: "New due date. Supports both Unix timestamps (in milliseconds) and natural language expressions like '1 hour from now', 'tomorrow', 'next week', or '3 days from now'."
             }
         },
         required: []
@@ -588,218 +590,6 @@ export const deleteTaskTool = {
         }
     }
 };
-/**
- * Tool definition for deleting multiple tasks
- */
-export const deleteBulkTasksTool = {
-    name: "delete_bulk_tasks",
-    description: "\u26a0\ufe0f PERMANENTLY DELETE multiple tasks. This action cannot be undone. For each task, you MUST provide either:\n1. taskId alone (preferred and safest)\n2. taskName + listName (use with caution)",
-    inputSchema: {
-        type: "object",
-        properties: {
-            tasks: {
-                type: "array",
-                description: "Array of tasks to delete",
-                items: {
-                    type: "object",
-                    properties: {
-                        taskId: {
-                            type: "string",
-                            description: "Task ID (preferred). Use instead of taskName if available."
-                        },
-                        taskName: {
-                            type: "string",
-                            description: "Task name. Requires listName when used."
-                        },
-                        listName: {
-                            type: "string",
-                            description: "REQUIRED with taskName: List containing the task."
-                        }
-                    }
-                }
-            }
-        },
-        required: ["tasks"]
-    }
-};
-/**
- * Tool definition for creating multiple tasks at once
- */
-export const createBulkTasksTool = {
-    name: "create_bulk_tasks",
-    description: "Create multiple tasks in a list efficiently. You MUST provide:\n1. An array of tasks with required properties\n2. Either listId or listName to specify the target list\n\nOptional: Configure batch size and concurrency for performance.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            listId: {
-                type: "string",
-                description: "ID of list for new tasks (preferred). Use this instead of listName if you have it."
-            },
-            listName: {
-                type: "string",
-                description: "Name of list for new tasks. Only use if you don't have listId."
-            },
-            tasks: {
-                type: "array",
-                description: "Array of tasks to create. Each task must have at least a name.",
-                items: {
-                    type: "object",
-                    properties: {
-                        name: {
-                            type: "string",
-                            description: "Task name with emoji prefix"
-                        },
-                        description: {
-                            type: "string",
-                            description: "Plain text description"
-                        },
-                        markdown_description: {
-                            type: "string",
-                            description: "Markdown description (overrides plain text)"
-                        },
-                        status: {
-                            type: "string",
-                            description: "Task status (uses list default if omitted)"
-                        },
-                        priority: {
-                            type: "number",
-                            description: "Priority 1-4 (1=urgent, 4=low)"
-                        },
-                        dueDate: {
-                            type: "string",
-                            description: "Due date (Unix timestamp ms)"
-                        }
-                    },
-                    required: ["name"]
-                }
-            },
-            options: {
-                type: "object",
-                description: "Optional processing settings",
-                properties: {
-                    batchSize: {
-                        type: "number",
-                        description: "Tasks per batch (default: 10)"
-                    },
-                    concurrency: {
-                        type: "number",
-                        description: "Parallel operations (default: 1)"
-                    },
-                    continueOnError: {
-                        type: "boolean",
-                        description: "Continue if some tasks fail"
-                    },
-                    retryCount: {
-                        type: "number",
-                        description: "Retry attempts for failures"
-                    }
-                }
-            }
-        },
-        required: ["tasks"]
-    }
-};
-/**
- * Tool definition for updating multiple tasks
- */
-export const updateBulkTasksTool = {
-    name: "update_bulk_tasks",
-    description: "Update multiple tasks efficiently. For each task, you MUST provide either:\n1. taskId alone (preferred)\n2. taskName + listName\n\nOnly specified fields will be updated for each task.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            tasks: {
-                type: "array",
-                description: "Array of tasks to update",
-                items: {
-                    type: "object",
-                    properties: {
-                        taskId: {
-                            type: "string",
-                            description: "Task ID (preferred). Use instead of taskName if available."
-                        },
-                        taskName: {
-                            type: "string",
-                            description: "Task name. Requires listName when used."
-                        },
-                        listName: {
-                            type: "string",
-                            description: "REQUIRED with taskName: List containing the task."
-                        },
-                        name: {
-                            type: "string",
-                            description: "New name with emoji prefix"
-                        },
-                        description: {
-                            type: "string",
-                            description: "New plain text description"
-                        },
-                        markdown_description: {
-                            type: "string",
-                            description: "New markdown description"
-                        },
-                        status: {
-                            type: "string",
-                            description: "New status"
-                        },
-                        priority: {
-                            type: ["number", "null"],
-                            enum: [1, 2, 3, 4, null],
-                            description: "New priority (1-4 or null)"
-                        },
-                        dueDate: {
-                            type: "string",
-                            description: "New due date (Unix timestamp in milliseconds)"
-                        }
-                    }
-                }
-            }
-        },
-        required: ["tasks"]
-    }
-};
-/**
- * Tool definition for moving multiple tasks
- */
-export const moveBulkTasksTool = {
-    name: "move_bulk_tasks",
-    description: "Move multiple tasks to a different list efficiently. For each task, you MUST provide either:\n1. taskId alone (preferred)\n2. taskName + listName\n\nWARNING: Task statuses may reset if target list has different status options.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            tasks: {
-                type: "array",
-                description: "Array of tasks to move",
-                items: {
-                    type: "object",
-                    properties: {
-                        taskId: {
-                            type: "string",
-                            description: "Task ID (preferred). Use instead of taskName if available."
-                        },
-                        taskName: {
-                            type: "string",
-                            description: "Task name. Requires listName when used."
-                        },
-                        listName: {
-                            type: "string",
-                            description: "REQUIRED with taskName: List containing the task."
-                        }
-                    }
-                }
-            },
-            targetListId: {
-                type: "string",
-                description: "ID of destination list (preferred). Use instead of targetListName if available."
-            },
-            targetListName: {
-                type: "string",
-                description: "Name of destination list. Only use if you don't have targetListId."
-            }
-        },
-        required: ["tasks"]
-    }
-};
 /**
  * Tool definition for getting task comments
  */
@@ -907,78 +697,19 @@ export const getTaskCommentsTool = {
         };
     }
 };
-/**
- * Handler for bulk task updates
- */
-export async function handleUpdateBulkTasks({ tasks }) {
-    if (!tasks || !tasks.length) {
-        throw new Error("No tasks provided for bulk update");
-    }
-    const results = {
-        total: tasks.length,
-        successful: 0,
-        failed: 0,
-        failures: []
-    };
-    for (const task of tasks) {
-        try {
-            let taskId = task.taskId;
-            if (!taskId && task.taskName) {
-                if (!task.listName) {
-                    throw new Error(`List name is required when using task name for task "${task.taskName}"`);
-                }
-                const listInfo = await findListIDByName(workspaceService, task.listName);
-                if (!listInfo) {
-                    throw new Error(`List "${task.listName}" not found`);
-                }
-                const taskList = await taskService.getTasks(listInfo.id);
-                const foundTask = taskList.find(t => t.name.toLowerCase() === task.taskName.toLowerCase());
-                if (!foundTask) {
-                    throw new Error(`Task "${task.taskName}" not found in list "${task.listName}"`);
-                }
-                taskId = foundTask.id;
-            }
-            if (!taskId) {
-                throw new Error("Either taskId or taskName must be provided");
-            }
-            await taskService.updateTask(taskId, {
-                name: task.name,
-                description: task.description,
-                markdown_description: task.markdown_description,
-                status: task.status,
-                priority: task.priority,
-                due_date: task.dueDate ? parseDueDate(task.dueDate) : undefined
-            });
-            results.successful++;
-        }
-        catch (error) {
-            results.failed++;
-            results.failures.push({
-                task: task.taskId || task.taskName,
-                error: error.message
-            });
-        }
-    }
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify(results, null, 2)
-            }]
-    };
-}
-/**
- * Handler for bulk task creation
- */
-export async function handleCreateBulkTasks(parameters) {
-    // Validate required parameters
-    const { tasks, listId, listName } = parameters;
-    if (!tasks || !Array.isArray(tasks) || tasks.length === 0) {
-        throw new Error('You must provide a non-empty array of tasks to create');
+// Export handlers to be used by the server
+export async function handleCreateTask(parameters) {
+    const { name, description, markdown_description, listId, listName, status, priority, dueDate } = parameters;
+    // Validate required fields
+    if (!name) {
+        throw new Error("Task name is required");
     }
     let targetListId = listId;
     // If no listId but listName is provided, look up the list ID
     if (!targetListId && listName) {
-        const listInfo = await findListIDByName(workspaceService, listName);
+        // Use workspace service to find the list by name in the hierarchy
+        const hierarchy = await workspaceService.getWorkspaceHierarchy();
+        const listInfo = workspaceService.findIDByNameInHierarchy(hierarchy, listName, 'list');
         if (!listInfo) {
             throw new Error(`List "${listName}" not found`);
         }
@@ -987,94 +718,23 @@ export async function handleCreateBulkTasks(parameters) {
     if (!targetListId) {
         throw new Error("Either listId or listName must be provided");
     }
-    const results = {
-        total: tasks.length,
-        successful: 0,
-        failed: 0,
-        failures: []
+    // Prepare task data
+    const taskData = {
+        name,
+        description,
+        markdown_description,
+        status,
+        priority: priority,
+        due_date: dueDate ? parseDueDate(dueDate) : undefined
     };
-    // Map tasks to ClickUp format
-    const clickupTasks = tasks.map((task) => {
-        const taskData = {
-            name: task.name,
-            description: task.description,
-            markdown_description: task.markdown_description,
-            status: task.status,
-            priority: task.priority,
-            due_date: task.dueDate ? parseDueDate(task.dueDate) : undefined
-        };
-        // Add due_date_time flag if due date is set
-        if (task.dueDate && taskData.due_date) {
-            taskData.due_date_time = true;
-        }
-        return taskData;
-    });
-    // Create tasks in bulk using the task service
-    try {
-        const bulkResult = await taskService.createBulkTasks(targetListId, { tasks: clickupTasks });
-        // Update results based on bulk operation outcome
-        results.successful = bulkResult.successfulItems.length;
-        results.failed = bulkResult.failedItems.length;
-        results.failures = bulkResult.failedItems.map(failure => ({
-            task: failure.item.name,
-            error: failure.error.message
-        }));
-    }
-    catch (error) {
-        // If the bulk operation itself fails, mark all tasks as failed
-        results.failed = tasks.length;
-        results.failures = tasks.map(task => ({
-            task: task.name,
-            error: error.message
-        }));
-    }
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify(results, null, 2)
-            }]
-    };
-}
-/**
- * Handler for the create_task tool
- */
-export async function handleCreateTask(parameters) {
-    const { name, description, markdown_description, listId, listName, status, priority, dueDate } = parameters;
-    // Validate required fields
-    if (!name) {
-        throw new Error("Task name is required");
-    }
-    let targetListId = listId;
-    // If no listId but listName is provided, look up the list ID
-    if (!targetListId && listName) {
-        // Use workspace service to find the list by name in the hierarchy
-        const hierarchy = await workspaceService.getWorkspaceHierarchy();
-        const listInfo = workspaceService.findIDByNameInHierarchy(hierarchy, listName, 'list');
-        if (!listInfo) {
-            throw new Error(`List "${listName}" not found`);
-        }
-        targetListId = listInfo.id;
-    }
-    if (!targetListId) {
-        throw new Error("Either listId or listName must be provided");
-    }
-    // Prepare task data
-    const taskData = {
-        name,
-        description,
-        markdown_description,
-        status,
-        priority: priority,
-        due_date: dueDate ? parseDueDate(dueDate) : undefined
-    };
-    // Add due_date_time flag if due date is set
-    if (dueDate && taskData.due_date) {
-        taskData.due_date_time = true;
+    // Add due_date_time flag if due date is set
+    if (dueDate && taskData.due_date) {
+        taskData.due_date_time = true;
     }
     // Create the task
     const task = await taskService.createTask(targetListId, taskData);
-    // Format response
-    return {
+    // Create response object
+    const response = {
         content: [{
                 type: "text",
                 text: JSON.stringify({
@@ -1089,10 +749,9 @@ export async function handleCreateTask(parameters) {
                 }, null, 2)
             }]
     };
+    // Add sponsor message to response
+    return enhanceResponseWithSponsor(response);
 }
-/**
- * Handler for the update_task tool
- */
 export async function handleUpdateTask(parameters) {
     const { taskId, taskName, listName, name, description, markdown_description, status, priority, dueDate } = parameters;
     let targetTaskId = taskId;
@@ -1156,9 +815,6 @@ export async function handleUpdateTask(parameters) {
             }]
     };
 }
-/**
- * Handler for the move_task tool
- */
 export async function handleMoveTask(parameters) {
     const { taskId, taskName, sourceListName, listId, listName } = parameters;
     let targetTaskId = taskId;
@@ -1220,9 +876,6 @@ export async function handleMoveTask(parameters) {
             }]
     };
 }
-/**
- * Handler for the duplicate_task tool
- */
 export async function handleDuplicateTask(parameters) {
     const { taskId, taskName, sourceListName, listId, listName } = parameters;
     let targetTaskId = taskId;
@@ -1284,9 +937,6 @@ export async function handleDuplicateTask(parameters) {
             }]
     };
 }
-/**
- * Handler for the get_tasks tool
- */
 export async function handleGetTasks(parameters) {
     const { listId, listName, archived, page, order_by, reverse, subtasks, statuses, include_closed, assignees, due_date_gt, due_date_lt, date_created_gt, date_created_lt, date_updated_gt, date_updated_lt, custom_fields } = parameters;
     let targetListId = listId;
@@ -1334,9 +984,6 @@ export async function handleGetTasks(parameters) {
             }]
     };
 }
-/**
- * Handler for the delete_task tool
- */
 export async function handleDeleteTask(parameters) {
     const { taskId, taskName, listName } = parameters;
     let targetTaskId = taskId;
@@ -1388,204 +1035,634 @@ export async function handleDeleteTask(parameters) {
             }]
     };
 }
+export async function handleGetTaskComments(parameters) {
+    const { taskId, taskName, listName, start, startId } = parameters;
+    try {
+        // Call the handler with validation
+        const result = await getTaskCommentsTool.handler({
+            taskId,
+            taskName,
+            listName,
+            start: start ? Number(start) : undefined,
+            startId
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify(result, null, 2)
+                }]
+        };
+    }
+    catch (error) {
+        // Handle and format error response with proper content array
+        console.error('Error getting task comments:', error);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        error: error.message || 'Failed to get task comments',
+                        taskId: taskId || null,
+                        taskName: taskName || null,
+                        listName: listName || null
+                    }, null, 2)
+                }]
+        };
+    }
+}
+// Helper function for path extraction
+export function extractPath(node) {
+    if (!node)
+        return '';
+    if (!node.parent)
+        return node.name;
+    return `${extractPath(node.parent)} > ${node.name}`;
+}
+// Helper function for path traversal
+export function extractTreePath(root, targetId) {
+    if (!root)
+        return [];
+    // If this node is the target, return it in an array
+    if (root.id === targetId) {
+        return [root];
+    }
+    // Check children if they exist
+    if (root.children) {
+        for (const child of root.children) {
+            const path = extractTreePath(child, targetId);
+            if (path.length > 0) {
+                return [root, ...path];
+            }
+        }
+    }
+    // Not found in this branch
+    return [];
+}
+// After the existing tools, add the bulk tools:
 /**
- * Handler for the delete_bulk_tasks tool
+ * Tool definition for creating multiple tasks at once
  */
-export async function handleDeleteBulkTasks({ tasks }) {
-    if (!tasks || !Array.isArray(tasks) || tasks.length === 0) {
-        throw new Error('You must provide a non-empty array of tasks to delete');
-    }
-    const results = {
-        total: tasks.length,
-        successful: 0,
-        failed: 0,
-        failures: [],
-        deleted: []
-    };
-    // Collect all task IDs for deletion
-    const taskIdsToDelete = [];
-    const taskMap = new Map();
-    // First, resolve all task IDs
-    for (const task of tasks) {
-        try {
-            let taskId = task.taskId;
-            if (!taskId && task.taskName) {
-                if (!task.listName) {
-                    throw new Error(`List name is required when using task name for task "${task.taskName}"`);
-                }
-                const listInfo = await findListIDByName(workspaceService, task.listName);
-                if (!listInfo) {
-                    throw new Error(`List "${task.listName}" not found`);
+export const createBulkTasksTool = {
+    name: "create_bulk_tasks",
+    description: "Create multiple tasks in a list efficiently. You MUST provide:\n1. An array of tasks with required properties\n2. Either listId or listName to specify the target list\n\nOptional: Configure batch size and concurrency for performance.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            listId: {
+                type: "string",
+                description: "ID of list for new tasks (preferred). Use this instead of listName if you have it."
+            },
+            listName: {
+                type: "string",
+                description: "Name of list for new tasks. Only use if you don't have listId."
+            },
+            tasks: {
+                type: "array",
+                description: "Array of tasks to create. Each task must have at least a name.",
+                items: {
+                    type: "object",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description: "Task name with emoji prefix"
+                        },
+                        description: {
+                            type: "string",
+                            description: "Plain text description"
+                        },
+                        markdown_description: {
+                            type: "string",
+                            description: "Markdown description (overrides plain text)"
+                        },
+                        status: {
+                            type: "string",
+                            description: "Task status (uses list default if omitted)"
+                        },
+                        priority: {
+                            type: "number",
+                            description: "Priority 1-4 (1=urgent, 4=low)"
+                        },
+                        dueDate: {
+                            type: "string",
+                            description: "Due date. Supports Unix timestamps (in milliseconds) and natural language expressions like '1 hour from now', 'tomorrow', 'next week', etc."
+                        }
+                    },
+                    required: ["name"]
                 }
-                // Use the improved findTaskByName method
-                const foundTask = await taskService.findTaskByName(listInfo.id, task.taskName);
-                if (!foundTask) {
-                    throw new Error(`Task "${task.taskName}" not found in list "${task.listName}"`);
+            },
+            options: {
+                oneOf: [
+                    {
+                        type: "object",
+                        description: "Optional processing settings",
+                        properties: {
+                            batchSize: {
+                                type: "number",
+                                description: "Tasks per batch (default: 10)"
+                            },
+                            concurrency: {
+                                type: "number",
+                                description: "Parallel operations (default: 3)"
+                            },
+                            continueOnError: {
+                                type: "boolean",
+                                description: "Continue if some tasks fail"
+                            },
+                            retryCount: {
+                                type: "number",
+                                description: "Retry attempts for failures"
+                            }
+                        }
+                    },
+                    {
+                        type: "string",
+                        description: "JSON string representing options. Will be parsed automatically."
+                    }
+                ],
+                description: "Processing options (or JSON string representing options)"
+            }
+        },
+        required: ["tasks"]
+    }
+};
+/**
+ * Tool definition for updating multiple tasks
+ */
+export const updateBulkTasksTool = {
+    name: "update_bulk_tasks",
+    description: "Update multiple tasks efficiently. For each task, you MUST provide either:\n1. taskId alone (preferred)\n2. taskName + listName\n\nOnly specified fields will be updated for each task.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            tasks: {
+                type: "array",
+                description: "Array of tasks to update",
+                items: {
+                    type: "object",
+                    properties: {
+                        taskId: {
+                            type: "string",
+                            description: "Task ID (preferred). Use instead of taskName if available."
+                        },
+                        taskName: {
+                            type: "string",
+                            description: "Task name. Requires listName when used."
+                        },
+                        listName: {
+                            type: "string",
+                            description: "REQUIRED with taskName: List containing the task."
+                        },
+                        name: {
+                            type: "string",
+                            description: "New name with emoji prefix"
+                        },
+                        description: {
+                            type: "string",
+                            description: "New plain text description"
+                        },
+                        markdown_description: {
+                            type: "string",
+                            description: "New markdown description"
+                        },
+                        status: {
+                            type: "string",
+                            description: "New status"
+                        },
+                        priority: {
+                            type: ["number", "null"],
+                            enum: [1, 2, 3, 4, null],
+                            description: "New priority (1-4 or null)"
+                        },
+                        dueDate: {
+                            type: "string",
+                            description: "New due date. Supports Unix timestamps (in milliseconds) and natural language expressions like '1 hour from now', 'tomorrow', etc."
+                        }
+                    }
                 }
-                taskId = foundTask.id;
-                // Store original task info for the response
-                taskMap.set(taskId, { id: taskId, name: foundTask.name, originalTask: task });
+            },
+            options: {
+                oneOf: [
+                    {
+                        type: "object",
+                        description: "Optional processing settings",
+                        properties: {
+                            batchSize: {
+                                type: "number",
+                                description: "Tasks per batch (default: 10)"
+                            },
+                            concurrency: {
+                                type: "number",
+                                description: "Parallel operations (default: 3)"
+                            },
+                            continueOnError: {
+                                type: "boolean",
+                                description: "Continue if some tasks fail"
+                            },
+                            retryCount: {
+                                type: "number",
+                                description: "Retry attempts for failures"
+                            }
+                        }
+                    },
+                    {
+                        type: "string",
+                        description: "JSON string representing options. Will be parsed automatically."
+                    }
+                ],
+                description: "Processing options (or JSON string representing options)"
             }
-            else if (taskId) {
-                // Store task ID with basic info for the response
-                taskMap.set(taskId, { id: taskId, name: task.taskName || "Unknown", originalTask: task });
+        },
+        required: ["tasks"]
+    }
+};
+/**
+ * Tool definition for moving multiple tasks
+ */
+export const moveBulkTasksTool = {
+    name: "move_bulk_tasks",
+    description: "Move multiple tasks to a different list efficiently. For each task, you MUST provide either:\n1. taskId alone (preferred)\n2. taskName + listName\n\nWARNING: Task statuses may reset if target list has different status options.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            tasks: {
+                type: "array",
+                description: "Array of tasks to move",
+                items: {
+                    type: "object",
+                    properties: {
+                        taskId: {
+                            type: "string",
+                            description: "Task ID (preferred). Use instead of taskName if available."
+                        },
+                        taskName: {
+                            type: "string",
+                            description: "Task name. Requires listName when used."
+                        },
+                        listName: {
+                            type: "string",
+                            description: "REQUIRED with taskName: List containing the task."
+                        }
+                    }
+                }
+            },
+            targetListId: {
+                type: "string",
+                description: "ID of destination list (preferred). Use instead of targetListName if available."
+            },
+            targetListName: {
+                type: "string",
+                description: "Name of destination list. Only use if you don't have targetListId."
+            },
+            options: {
+                oneOf: [
+                    {
+                        type: "object",
+                        description: "Optional processing settings",
+                        properties: {
+                            batchSize: {
+                                type: "number",
+                                description: "Tasks per batch (default: 10)"
+                            },
+                            concurrency: {
+                                type: "number",
+                                description: "Parallel operations (default: 3)"
+                            },
+                            continueOnError: {
+                                type: "boolean",
+                                description: "Continue if some tasks fail"
+                            },
+                            retryCount: {
+                                type: "number",
+                                description: "Retry attempts for failures"
+                            }
+                        }
+                    },
+                    {
+                        type: "string",
+                        description: "JSON string representing options. Will be parsed automatically."
+                    }
+                ],
+                description: "Processing options (or JSON string representing options)"
             }
-            else {
-                throw new Error("Either taskId or taskName must be provided for each task");
+        },
+        required: ["tasks"]
+    }
+};
+/**
+ * Tool definition for deleting multiple tasks
+ */
+export const deleteBulkTasksTool = {
+    name: "delete_bulk_tasks",
+    description: "⚠️ PERMANENTLY DELETE multiple tasks. This action cannot be undone. For each task, you MUST provide either:\n1. taskId alone (preferred and safest)\n2. taskName + listName (use with caution)",
+    inputSchema: {
+        type: "object",
+        properties: {
+            tasks: {
+                type: "array",
+                description: "Array of tasks to delete",
+                items: {
+                    type: "object",
+                    properties: {
+                        taskId: {
+                            type: "string",
+                            description: "Task ID (preferred). Use instead of taskName if available."
+                        },
+                        taskName: {
+                            type: "string",
+                            description: "Task name. Requires listName when used."
+                        },
+                        listName: {
+                            type: "string",
+                            description: "REQUIRED with taskName: List containing the task."
+                        }
+                    }
+                }
+            },
+            options: {
+                oneOf: [
+                    {
+                        type: "object",
+                        description: "Optional processing settings",
+                        properties: {
+                            batchSize: {
+                                type: "number",
+                                description: "Tasks per batch (default: 10)"
+                            },
+                            concurrency: {
+                                type: "number",
+                                description: "Parallel operations (default: 3)"
+                            },
+                            continueOnError: {
+                                type: "boolean",
+                                description: "Continue if some tasks fail"
+                            },
+                            retryCount: {
+                                type: "number",
+                                description: "Retry attempts for failures"
+                            }
+                        }
+                    },
+                    {
+                        type: "string",
+                        description: "JSON string representing options. Will be parsed automatically."
+                    }
+                ],
+                description: "Processing options (or JSON string representing options)"
             }
-            taskIdsToDelete.push(taskId);
+        },
+        required: ["tasks"]
+    }
+};
+/**
+ * Handler for bulk task creation
+ */
+export async function handleCreateBulkTasks(parameters) {
+    const { listId, listName, tasks, options: rawOptions } = parameters;
+    // Handle options parameter - may be a string that needs to be parsed
+    let options = rawOptions;
+    if (typeof rawOptions === 'string') {
+        try {
+            options = JSON.parse(rawOptions);
         }
         catch (error) {
-            results.failed++;
-            results.failures.push({
-                task: task.taskId || task.taskName,
-                error: error.message
-            });
+            // Just use default options on parse error
+            options = undefined;
+        }
+    }
+    try {
+        // Validate tasks parameter
+        if (!tasks || !Array.isArray(tasks) || tasks.length === 0) {
+            throw new Error('You must provide a non-empty array of tasks to create');
         }
+        // Resolve list ID
+        const targetListId = await resolveListId(listId, listName);
+        // Format tasks with proper data types
+        const formattedTasks = tasks.map((task) => ({
+            name: task.name,
+            description: task.description,
+            markdown_description: task.markdown_description,
+            status: task.status,
+            priority: task.priority,
+            due_date: task.dueDate ? parseDueDate(task.dueDate) : undefined,
+            due_date_time: task.dueDate ? true : undefined
+        }));
+        // Use bulk service to create tasks
+        const result = await bulkService.createTasks(targetListId, formattedTasks, options);
+        // Format response
+        const response = {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        total: result.totals.total,
+                        successful: result.totals.success,
+                        failed: result.totals.failure,
+                        failures: result.failed.map(failure => ({
+                            task: failure.item.name,
+                            error: failure.error.message
+                        }))
+                    }, null, 2)
+                }]
+        };
+        return enhanceResponseWithSponsor(response);
     }
-    // Perform the bulk delete operation if we have tasks to delete
-    if (taskIdsToDelete.length > 0) {
+    catch (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        error: error.message || 'Failed to create tasks in bulk',
+                        listId,
+                        listName
+                    }, null, 2)
+                }]
+        };
+    }
+}
+/**
+ * Handler for bulk task updates
+ */
+export async function handleUpdateBulkTasks(parameters) {
+    const { tasks, options: rawOptions } = parameters;
+    // Handle options parameter - may be a string that needs to be parsed
+    let options = rawOptions;
+    if (typeof rawOptions === 'string') {
         try {
-            const bulkResult = await taskService.deleteBulkTasks(taskIdsToDelete);
-            // Process successful deletions
-            for (const deletedId of bulkResult.successfulItems) {
-                results.successful++;
-                const taskInfo = taskMap.get(deletedId);
-                results.deleted.push({
-                    id: deletedId,
-                    name: taskInfo?.name || "Unknown",
-                    deleted: true
-                });
-            }
-            // Process failed deletions
-            for (const failure of bulkResult.failedItems) {
-                results.failed++;
-                const taskInfo = taskMap.get(failure.item);
-                results.failures.push({
-                    task: taskInfo?.name || failure.item,
-                    error: failure.error.message
-                });
-            }
+            options = JSON.parse(rawOptions);
         }
         catch (error) {
-            // If the bulk delete fails entirely, mark all remaining tasks as failed
-            for (const taskId of taskIdsToDelete) {
-                const taskInfo = taskMap.get(taskId);
-                if (taskInfo && !results.deleted.some(t => t.id === taskId) &&
-                    !results.failures.some(f => f.task === taskId || f.task === taskInfo.name)) {
-                    results.failed++;
-                    results.failures.push({
-                        task: taskInfo.name || taskId,
-                        error: error.message
-                    });
+            // Just use default options on parse error
+            options = undefined;
+        }
+    }
+    try {
+        // Validate tasks parameter
+        if (!tasks || !Array.isArray(tasks) || tasks.length === 0) {
+            throw new Error('You must provide a non-empty array of tasks to update');
+        }
+        // Process the tasks using TaskResolver
+        const tasksToUpdate = await Promise.all(tasks.map(async (task) => {
+            const taskId = await resolveTaskId(task.taskId, task.taskName, undefined, task.listName);
+            // Create update data object
+            const updateData = {};
+            if (task.name !== undefined)
+                updateData.name = task.name;
+            if (task.description !== undefined)
+                updateData.description = task.description;
+            if (task.markdown_description !== undefined)
+                updateData.markdown_description = task.markdown_description;
+            if (task.status !== undefined)
+                updateData.status = task.status;
+            if (task.priority !== undefined) {
+                updateData.priority = task.priority === null ? null : task.priority;
+            }
+            if (task.dueDate !== undefined) {
+                updateData.due_date = task.dueDate ? parseDueDate(task.dueDate) : null;
+                if (task.dueDate && updateData.due_date) {
+                    updateData.due_date_time = true;
                 }
             }
-        }
+            return { id: taskId, data: updateData };
+        }));
+        // Use bulk service to update tasks
+        const result = await bulkService.updateTasks(tasksToUpdate, options);
+        // Format response
+        const response = {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        total: result.totals.total,
+                        successful: result.totals.success,
+                        failed: result.totals.failure,
+                        failures: result.failed.map(failure => ({
+                            taskId: failure.item.id,
+                            error: failure.error.message
+                        }))
+                    }, null, 2)
+                }]
+        };
+        return enhanceResponseWithSponsor(response);
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        error: error.message || 'Failed to update tasks in bulk',
+                        taskCount: tasks?.length || 0
+                    }, null, 2)
+                }]
+        };
     }
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify(results, null, 2)
-            }]
-    };
 }
 /**
  * Handler for bulk task moves
  */
 export async function handleMoveBulkTasks(parameters) {
-    const { tasks, targetListId, targetListName } = parameters;
-    if (!tasks || !Array.isArray(tasks) || tasks.length === 0) {
-        throw new Error('You must provide a non-empty array of tasks to move');
+    const { tasks, targetListId, targetListName, options: rawOptions } = parameters;
+    // Handle options parameter - may be a string that needs to be parsed
+    let options = rawOptions;
+    if (typeof rawOptions === 'string') {
+        try {
+            options = JSON.parse(rawOptions);
+        }
+        catch (error) {
+            // Just use default options on parse error
+            options = undefined;
+        }
     }
-    let finalTargetListId = targetListId;
-    // If no targetListId but targetListName is provided, look up the list ID
-    if (!finalTargetListId && targetListName) {
-        const listInfo = await findListIDByName(workspaceService, targetListName);
-        if (!listInfo) {
-            throw new Error(`Target list "${targetListName}" not found`);
+    try {
+        // Validate tasks parameter
+        if (!tasks || !Array.isArray(tasks) || tasks.length === 0) {
+            throw new Error('You must provide a non-empty array of tasks to move');
+        }
+        // Resolve target list ID
+        const resolvedTargetListId = await resolveListId(targetListId, targetListName);
+        if (!resolvedTargetListId) {
+            throw new Error('Either targetListId or targetListName must be provided');
         }
-        finalTargetListId = listInfo.id;
+        // Resolve task IDs
+        const taskIds = await Promise.all(tasks.map((task) => resolveTaskId(task.taskId, task.taskName, undefined, task.listName)));
+        // Use bulk service to move tasks
+        const result = await bulkService.moveTasks(taskIds, resolvedTargetListId, options);
+        // Format response
+        const response = {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        total: result.totals.total,
+                        successful: result.totals.success,
+                        failed: result.totals.failure,
+                        targetList: targetListName || resolvedTargetListId,
+                        failures: result.failed.map(failure => ({
+                            taskId: failure.item,
+                            error: failure.error.message
+                        }))
+                    }, null, 2)
+                }]
+        };
+        return enhanceResponseWithSponsor(response);
     }
-    if (!finalTargetListId) {
-        throw new Error("Either targetListId or targetListName must be provided");
+    catch (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        error: error.message || 'Failed to move tasks in bulk',
+                        targetListId: targetListId || targetListName,
+                        taskCount: tasks?.length || 0
+                    }, null, 2)
+                }]
+        };
     }
-    const results = {
-        total: tasks.length,
-        successful: 0,
-        failed: 0,
-        failures: []
-    };
-    for (const task of tasks) {
+}
+/**
+ * Handler for bulk task deletion
+ */
+export async function handleDeleteBulkTasks(parameters) {
+    const { tasks, options: rawOptions } = parameters;
+    // Handle options parameter - may be a string that needs to be parsed
+    let options = rawOptions;
+    if (typeof rawOptions === 'string') {
         try {
-            let taskId = task.taskId;
-            if (!taskId && task.taskName) {
-                if (!task.listName) {
-                    throw new Error(`List name is required when using task name for task "${task.taskName}"`);
-                }
-                const listInfo = await findListIDByName(workspaceService, task.listName);
-                if (!listInfo) {
-                    throw new Error(`List "${task.listName}" not found`);
-                }
-                const taskList = await taskService.getTasks(listInfo.id);
-                const foundTask = taskList.find(t => t.name.toLowerCase() === task.taskName.toLowerCase());
-                if (!foundTask) {
-                    throw new Error(`Task "${task.taskName}" not found in list "${task.listName}"`);
-                }
-                taskId = foundTask.id;
-            }
-            if (!taskId) {
-                throw new Error("Either taskId or taskName must be provided");
-            }
-            await taskService.moveTask(taskId, finalTargetListId);
-            results.successful++;
+            options = JSON.parse(rawOptions);
         }
         catch (error) {
-            results.failed++;
-            results.failures.push({
-                task: task.taskId || task.taskName,
-                error: error.message
-            });
+            // Just use default options on parse error
+            options = undefined;
         }
     }
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify(results, null, 2)
-            }]
-    };
-}
-/**
- * Handler for getting task comments
- */
-export async function handleGetTaskComments(parameters) {
-    const { taskId, taskName, listName, start, startId } = parameters;
     try {
-        // Call the handler with validation
-        const result = await getTaskCommentsTool.handler({
-            taskId,
-            taskName,
-            listName,
-            start: start ? Number(start) : undefined,
-            startId
-        });
-        return {
+        // Validate tasks parameter
+        if (!tasks || !Array.isArray(tasks) || tasks.length === 0) {
+            throw new Error('You must provide a non-empty array of tasks to delete');
+        }
+        // Resolve task IDs
+        const taskIds = await Promise.all(tasks.map((task) => resolveTaskId(task.taskId, task.taskName, undefined, task.listName)));
+        // Use bulk service to delete tasks
+        const result = await bulkService.deleteTasks(taskIds, options);
+        // Format response
+        const response = {
             content: [{
                     type: "text",
-                    text: JSON.stringify(result, null, 2)
+                    text: JSON.stringify({
+                        total: result.totals.total,
+                        successful: result.totals.success,
+                        failed: result.totals.failure,
+                        failures: result.failed.map(failure => ({
+                            taskId: failure.item,
+                            error: failure.error.message
+                        }))
+                    }, null, 2)
                 }]
         };
+        return enhanceResponseWithSponsor(response);
     }
     catch (error) {
-        // Handle and format error response with proper content array
-        console.error('Error getting task comments:', error);
         return {
             content: [{
                     type: "text",
                     text: JSON.stringify({
-                        error: error.message || 'Failed to get task comments',
-                        taskId: taskId || null,
-                        taskName: taskName || null,
-                        listName: listName || null
+                        error: error.message || 'Failed to delete tasks in bulk',
+                        taskCount: tasks?.length || 0
                     }, null, 2)
                 }]
         };