@taazkareem/clickup-mcp-server 0.6.3 → 0.6.4

package/build/server.js

@@ -19,7 +19,7 @@ const logger = new Logger('Server');
 const { workspace } = clickUpServices;
 export const server = new Server({
     name: "clickup-mcp-server",
-    version: "0.6.3",
+    version: "0.6.4",
 }, {
     capabilities: {
         tools: {},

package/build/services/clickup/bulk.js

@@ -7,15 +7,21 @@
  * Enhanced implementation for bulk operations that leverages the existing single-operation methods.
  * This approach reduces code duplication while offering powerful concurrency management.
  */
-import { ClickUpServiceError, ErrorCode } from './base.js';
-import { processBatch } from '../../utils/concurrency-utils.js';
 import { Logger } from '../../logger.js';
+import { processBatch } from '../../utils/concurrency-utils.js';
+import { ClickUpServiceError, ErrorCode } from './base.js';
+import { clickUpServices } from '../shared.js';
+import { findListIDByName } from '../../tools/list.js';
 // Create logger instance
 const logger = new Logger('BulkService');
 /**
- * Service for handling bulk operations in ClickUp
+ * Service for performing bulk operations in ClickUp
  */
 export class BulkService {
+    /**
+     * Create a new bulk service
+     * @param taskService ClickUp Task Service instance
+     */
     constructor(taskService) {
         this.taskService = taskService;
         logger.info('BulkService initialized');
@@ -54,6 +60,61 @@ export class BulkService {
             throw new ClickUpServiceError(`Failed to create tasks in bulk: ${error instanceof Error ? error.message : String(error)}`, error instanceof ClickUpServiceError ? error.code : ErrorCode.UNKNOWN, { listId, taskCount: tasks.length });
         }
     }
+    /**
+     * Find task by name within a specific list
+     */
+    async findTaskInList(taskName, listName) {
+        try {
+            // First get the list ID using the global lookup utility
+            const listInfo = await findListIDByName(clickUpServices.workspace, listName);
+            if (!listInfo) {
+                throw new ClickUpServiceError(`List "${listName}" not found`, ErrorCode.NOT_FOUND);
+            }
+            logger.info(`List "${listName}" resolved to ID: ${listInfo.id}`);
+            // Get tasks from the list using the resolved ID
+            const taskList = await this.taskService.getTasks(listInfo.id);
+            // Find the task by name - first try exact match
+            let matchingTask = taskList.find(t => t.name === taskName);
+            // If no exact match, try case-insensitive match
+            if (!matchingTask) {
+                matchingTask = taskList.find(t => t.name.toLowerCase() === taskName.toLowerCase());
+                // If still no match, try substring match as a fallback
+                if (!matchingTask) {
+                    matchingTask = taskList.find(t => t.name.toLowerCase().includes(taskName.toLowerCase()) ||
+                        taskName.toLowerCase().includes(t.name.toLowerCase()));
+                }
+            }
+            if (!matchingTask) {
+                throw new ClickUpServiceError(`Task "${taskName}" not found in list "${listName}"`, ErrorCode.NOT_FOUND);
+            }
+            logger.info(`Task "${taskName}" found with ID: ${matchingTask.id}`);
+            return matchingTask.id;
+        }
+        catch (error) {
+            // Enhance the error message
+            if (error instanceof ClickUpServiceError) {
+                throw error;
+            }
+            throw new ClickUpServiceError(`Error finding task "${taskName}" in list "${listName}": ${error instanceof Error ? error.message : String(error)}`, ErrorCode.UNKNOWN);
+        }
+    }
+    /**
+     * Resolve task ID using provided identifiers
+     */
+    async resolveTaskId(task) {
+        const { taskId, taskName, listName, customTaskId } = task;
+        if (taskId) {
+            return taskId;
+        }
+        if (customTaskId) {
+            const resolvedTask = await this.taskService.getTaskByCustomId(customTaskId);
+            return resolvedTask.id;
+        }
+        if (taskName && listName) {
+            return await this.findTaskInList(taskName, listName);
+        }
+        throw new ClickUpServiceError('Invalid task identification. Provide either taskId, customTaskId, or both taskName and listName', ErrorCode.INVALID_PARAMETER);
+    }
     /**
      * Update multiple tasks
      * @param tasks Array of tasks to update with their new data
@@ -63,36 +124,10 @@ export class BulkService {
     async updateTasks(tasks, options) {
         logger.info('Starting bulk update operation', { taskCount: tasks.length });
         try {
-            // Extract all task IDs that need validation
-            const taskIds = tasks
-                .map(task => task.taskId)
-                .filter((id) => !!id);
-            // Validate all tasks exist in parallel
-            if (taskIds.length > 0) {
-                await this.taskService.validateTasksExist(taskIds);
-            }
-            // Process updates in batches
             return await processBatch(tasks, async (task) => {
                 const { taskId, taskName, listName, customTaskId, ...updateData } = task;
-                if (taskId) {
-                    return await this.taskService.updateTask(taskId, updateData);
-                }
-                else if (customTaskId) {
-                    const resolvedTask = await this.taskService.getTaskByCustomId(customTaskId);
-                    return await this.taskService.updateTask(resolvedTask.id, updateData);
-                }
-                else if (taskName && listName) {
-                    // For tasks identified by name, we need to resolve the ID first
-                    const taskList = await this.taskService.getTasks(listName);
-                    const matchingTask = taskList.find(t => t.name === taskName);
-                    if (!matchingTask) {
-                        throw new ClickUpServiceError(`Task "${taskName}" not found in list "${listName}"`, ErrorCode.NOT_FOUND);
-                    }
-                    return await this.taskService.updateTask(matchingTask.id, updateData);
-                }
-                else {
-                    throw new ClickUpServiceError('Invalid task identification. Provide either taskId, customTaskId, or both taskName and listName', ErrorCode.INVALID_PARAMETER);
-                }
+                const resolvedTaskId = await this.resolveTaskId({ taskId, taskName, listName, customTaskId });
+                return await this.taskService.updateTask(resolvedTaskId, updateData);
             }, options);
         }
         catch (error) {
@@ -103,44 +138,31 @@ export class BulkService {
     /**
      * Move multiple tasks to a different list
      * @param tasks Array of tasks to move (each with taskId or taskName + listName)
-     * @param targetListId ID of the destination list
+     * @param targetListId ID of the destination list or list name
      * @param options Optional batch processing settings
      * @returns Array of moved tasks
      */
     async moveTasks(tasks, targetListId, options) {
         logger.info('Starting bulk move operation', { taskCount: tasks.length, targetListId });
         try {
-            // First validate the destination list exists
-            await this.taskService.validateListExists(targetListId);
-            // Extract all task IDs that need validation
-            const taskIds = tasks
-                .map(task => task.taskId)
-                .filter((id) => !!id);
-            // Validate all tasks exist in parallel
-            if (taskIds.length > 0) {
-                await this.taskService.validateTasksExist(taskIds);
+            // Determine if targetListId is actually an ID or a name
+            let resolvedTargetListId = targetListId;
+            // If the targetListId doesn't match the pattern of a list ID (usually just numbers),
+            // assume it's a list name and try to resolve it
+            if (!/^\d+$/.test(targetListId)) {
+                logger.info(`Target list appears to be a name: "${targetListId}", attempting to resolve`);
+                const listInfo = await findListIDByName(clickUpServices.workspace, targetListId);
+                if (!listInfo) {
+                    throw new ClickUpServiceError(`Target list "${targetListId}" not found`, ErrorCode.NOT_FOUND);
+                }
+                resolvedTargetListId = listInfo.id;
+                logger.info(`Resolved target list to ID: ${resolvedTargetListId}`);
             }
-            // Process moves in batches
+            // Validate the destination list exists
+            await this.taskService.validateListExists(resolvedTargetListId);
             return await processBatch(tasks, async (task) => {
-                if (task.taskId) {
-                    return await this.taskService.moveTask(task.taskId, targetListId);
-                }
-                else if (task.customTaskId) {
-                    const resolvedTask = await this.taskService.getTaskByCustomId(task.customTaskId);
-                    return await this.taskService.moveTask(resolvedTask.id, targetListId);
-                }
-                else if (task.taskName && task.listName) {
-                    // For tasks identified by name, we need to resolve the ID first
-                    const taskList = await this.taskService.getTasks(task.listName);
-                    const matchingTask = taskList.find(t => t.name === task.taskName);
-                    if (!matchingTask) {
-                        throw new ClickUpServiceError(`Task "${task.taskName}" not found in list "${task.listName}"`, ErrorCode.NOT_FOUND);
-                    }
-                    return await this.taskService.moveTask(matchingTask.id, targetListId);
-                }
-                else {
-                    throw new ClickUpServiceError('Invalid task identification. Provide either taskId, customTaskId, or both taskName and listName', ErrorCode.INVALID_PARAMETER);
-                }
+                const resolvedTaskId = await this.resolveTaskId(task);
+                return await this.taskService.moveTask(resolvedTaskId, resolvedTargetListId);
             }, options);
         }
         catch (error) {
@@ -149,33 +171,22 @@ export class BulkService {
         }
     }
     /**
-     * Delete multiple tasks efficiently
-     *
-     * @param taskIds Array of task IDs to delete
+     * Delete multiple tasks
+     * @param tasks Array of tasks to delete (each with taskId or taskName + listName)
      * @param options Batch processing options
      * @returns Results containing successful and failed deletions
      */
-    async deleteTasks(taskIds, options) {
-        logger.info(`Deleting ${taskIds.length} tasks`, {
-            batchSize: options?.batchSize,
-            concurrency: options?.concurrency
-        });
+    async deleteTasks(tasks, options) {
+        logger.info('Starting bulk delete operation', { taskCount: tasks.length });
         try {
-            return await processBatch(taskIds, async (taskId, index) => {
-                logger.debug(`Deleting task ${index + 1}/${taskIds.length}`, {
-                    taskId
-                });
-                // Reuse the single-task delete method
-                await this.taskService.deleteTask(taskId);
-                return taskId; // Return the ID for successful deletions
+            return await processBatch(tasks, async (task) => {
+                const resolvedTaskId = await this.resolveTaskId(task);
+                await this.taskService.deleteTask(resolvedTaskId);
             }, options);
         }
         catch (error) {
-            logger.error(`Failed to delete tasks in bulk`, {
-                taskCount: taskIds.length,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            throw new ClickUpServiceError(`Failed to delete tasks in bulk: ${error instanceof Error ? error.message : String(error)}`, error instanceof ClickUpServiceError ? error.code : ErrorCode.UNKNOWN, { taskCount: taskIds.length });
+            logger.error('Bulk delete operation failed', error);
+            throw error;
         }
     }
 }

package/build/services/clickup/task/task-core.js

@@ -276,7 +276,7 @@ export class TaskServiceCore extends BaseClickUpService {
         }
     }
     /**
-     * Move a task to a different list
+     * Move a task to another list
      * @param taskId The ID of the task to move
      * @param destinationListId The ID of the list to move the task to
      * @returns The updated task
@@ -285,70 +285,32 @@ export class TaskServiceCore extends BaseClickUpService {
         const startTime = Date.now();
         this.logOperation('moveTask', { taskId, destinationListId, operation: 'start' });
         try {
-            // First, get both the task and list info in parallel
-            const [task, listResult] = await Promise.all([
+            // First, get task and validate destination list
+            const [sourceTask, _] = await Promise.all([
                 this.validateTaskExists(taskId),
-                this.validateListExists(destinationListId).then(() => this.listService.getList(destinationListId))
+                this.validateListExists(destinationListId)
             ]);
-            const originalTask = task;
-            const destinationList = listResult;
-            // Log parallel request timing
-            const parallelRequestTime = Date.now() - startTime;
-            this.logOperation('moveTask', {
-                taskId,
-                destinationListId,
-                operation: 'parallel_requests_complete',
-                timing: { parallelRequestTime }
-            });
-            const currentStatus = originalTask.status?.status;
-            const availableStatuses = destinationList.statuses?.map(s => s.status) || [];
-            // Enhanced status mapping logic
-            let newStatus = currentStatus;
-            if (currentStatus && availableStatuses.length > 0) {
-                // Only map status if current status isn't available in destination list
-                if (!availableStatuses.includes(currentStatus)) {
-                    // Try to find a similar status
-                    const similarStatus = availableStatuses.find(s => s.toLowerCase().includes(currentStatus.toLowerCase()) ||
-                        currentStatus.toLowerCase().includes(s.toLowerCase()));
-                    // If no similar status found, use the first available status
-                    newStatus = similarStatus || availableStatuses[0];
-                    this.logger.debug('Status mapping', {
-                        original: currentStatus,
-                        mapped: newStatus,
-                        available: availableStatuses
-                    });
-                }
-            }
-            // Make the move request
-            const movedTask = await this.makeRequest(async () => {
-                const response = await this.client.post(`/task/${taskId}`, {
-                    list: destinationListId,
-                    status: newStatus
-                });
-                return response.data;
-            });
-            // Cache the moved task
-            this.validationCache.tasks.set(taskId, {
+            // Extract task data for creating the new task
+            const taskData = this.extractTaskData(sourceTask);
+            // Create the task in the new list
+            const newTask = await this.createTask(destinationListId, taskData);
+            // Delete the original task
+            await this.deleteTask(taskId);
+            // Update the cache
+            this.validationCache.tasks.delete(taskId);
+            this.validationCache.tasks.set(newTask.id, {
                 validatedAt: Date.now(),
-                task: movedTask
+                task: newTask
             });
             const totalTime = Date.now() - startTime;
             this.logOperation('moveTask', {
                 taskId,
                 destinationListId,
                 operation: 'complete',
-                timing: {
-                    totalTime,
-                    parallelRequestTime,
-                    moveOperationTime: totalTime - parallelRequestTime
-                },
-                statusMapping: {
-                    original: currentStatus,
-                    new: newStatus,
-                    wasMapped: currentStatus !== newStatus
-                }
+                timing: { totalTime },
+                newTaskId: newTask.id
             });
-            return movedTask;
+            return newTask;
         }
         catch (error) {
             // Log failure
@@ -356,7 +318,7 @@ export class TaskServiceCore extends BaseClickUpService {
                 taskId,
                 destinationListId,
                 operation: 'failed',
-                error: error.message,
+                error: error instanceof Error ? error.message : String(error),
                 timing: { totalTime: Date.now() - startTime }
             });
             throw this.handleError(error, 'Failed to move task');

package/build/tools/task/attachments.js

@@ -33,22 +33,39 @@ export const attachTaskFileTool = {
     description: `Purpose: Attaches a file to a ClickUp task.
 
 Valid Usage:
+1. Use taskId alone (preferred) - works with both regular and custom IDs
+2. Use taskName alone (will search across all lists)
+3. Use taskName + listName (for faster, targeted search)
+
+File Source Options:
 1. Upload from base64: Provide file_data + file_name
-2. Upload from URL or local file: Provide file_url + optional file_name
-   - For web URLs: Use http:// or https:// URLs
-   - For local files: Use absolute file paths (starting with / or drive letter)
-3. For large files, advanced options are available via chunk_* parameters
+2. Upload from URL: Provide file_url starting with http:// or https://
+3. Upload from local file: Provide file_url as absolute path (starting with / or drive letter)
+4. For large files: Use chunk_* parameters for advanced chunked uploading
 
 Requirements:
-- EITHER taskId OR (taskName + listName) is REQUIRED
-- EITHER file_data OR file_url is REQUIRED
+- EITHER taskId OR taskName: REQUIRED
+- listName: Optional, but recommended when using taskName
+- File Source: ONE of the following is REQUIRED:
+  - file_data + file_name
+  - file_url (web URL or local path)
+  - chunk_session (for continuing chunked upload)
 
 Notes:
-- The system automatically selects the best upload method based on file size and source
-- Base64 method has a 10MB size limit due to encoding overhead (file_data parameter)
-- URL method works for files hosted online (file_url parameter with http/https)
-- Local file method works with absolute paths only (file_url parameter with / or drive letter)
-- For large files, the system may use chunked uploading automatically`,
+- The tool automatically searches for tasks using smart name matching
+- When only taskName is provided, it searches across all lists
+- Adding listName narrows the search to a specific list for better performance
+- The system automatically selects the best upload method based on file size and source:
+  - Base64 method: Limited to 10MB due to encoding overhead
+  - URL method: Works for files hosted online
+  - Local file method: Works with absolute paths only
+  - Large files: Automatically uses chunked uploading
+
+Warning:
+- Using taskName without listName may match multiple tasks
+- If multiple matches are found, the operation will fail with a disambiguation error
+- For local files, relative paths are not supported
+- Base64 uploads over 10MB will automatically switch to chunked upload mode`,
     inputSchema: {
         type: "object",
         properties: {
@@ -58,11 +75,11 @@ Notes:
             },
             taskName: {
                 type: "string",
-                description: "Name of the task to attach the file to. When using this parameter, you MUST also provide listName."
+                description: "Name of the task to attach the file to. The tool will search for tasks with this name across all lists unless listName is specified."
             },
             listName: {
                 type: "string",
-                description: "Name of the list containing the task. REQUIRED when using taskName."
+                description: "Optional: Name of list containing the task. Providing this narrows the search to a specific list, improving performance and reducing ambiguity."
             },
             file_name: {
                 type: "string",
@@ -97,8 +114,7 @@ Notes:
                 type: "boolean",
                 description: "Optional: For advanced usage with large file chunking. Whether this is the final chunk."
             }
-        },
-        required: [] // Will validate based on context in the handler
+        }
     }
 };
 /**

package/build/tools/task/bulk-operations.js

@@ -76,17 +76,17 @@ export const createBulkTasksTool = {
     description: `Purpose: Create multiple tasks in a list efficiently.
 
 Valid Usage:
-1. An array of tasks with required properties + listId (preferred)
-2. An array of tasks with required properties + listName
+1. Provide listId + array of tasks (preferred)
+2. Provide listName + array of tasks
 
 Requirements:
 - tasks: REQUIRED (array of tasks, each with at least a name)
 - EITHER listId OR listName: REQUIRED
+- All tasks will be created in the specified list
 
 Notes:
 - Configure batch size and concurrency via options for performance
 - Each task should have a name with emoji prefix
-- All tasks will be created in the same list
 - Custom fields can be set for each task using the custom_fields property (array of {id, value} objects)`,
     inputSchema: {
         type: "object",
@@ -157,37 +157,7 @@ Notes:
                 type: "string",
                 description: "Name of list for new tasks. Only use if you don't have listId."
             },
-            options: {
-                description: "Processing options (or JSON string representing 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."
-                    }
-                ]
-            }
+            options: bulkOptionsSchema
         },
         required: ["tasks"]
     }
@@ -212,7 +182,10 @@ Notes:
 - Only specified fields will be updated for each task
 - Configure batch size and concurrency via options for performance
 - Each task can have different fields to update
-- Custom fields can be updated using the custom_fields property (array of {id, value} objects)`,
+- Custom fields can be updated using the custom_fields property (array of {id, value} objects)
+
+Warning:
+- Using taskName without listName will fail as tasks may have identical names across lists`,
     inputSchema: {
         type: "object",
         properties: {
@@ -222,7 +195,22 @@ Notes:
                 items: {
                     type: "object",
                     properties: {
-                        ...taskIdentifierSchema,
+                        taskId: {
+                            type: "string",
+                            description: "Task ID (preferred). Works with both regular task IDs (9 characters) and custom IDs with uppercase prefixes (like 'DEV-1234')."
+                        },
+                        taskName: {
+                            type: "string",
+                            description: "Task name. Requires listName when used."
+                        },
+                        listName: {
+                            type: "string",
+                            description: "REQUIRED with taskName: List containing the task."
+                        },
+                        customTaskId: {
+                            type: "string",
+                            description: "Custom task ID (e.g., 'DEV-1234'). Only use if you want to explicitly force custom ID lookup. In most cases, use taskId which auto-detects ID format."
+                        },
                         name: {
                             type: "string",
                             description: "New name with emoji prefix"
@@ -268,37 +256,7 @@ Notes:
                     }
                 }
             },
-            options: {
-                description: "Processing options (or JSON string representing 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."
-                    }
-                ]
-            }
+            options: bulkOptionsSchema
         },
         required: ["tasks"]
     }
@@ -335,7 +293,22 @@ Warning:
                 items: {
                     type: "object",
                     properties: {
-                        ...taskIdentifierSchema
+                        taskId: {
+                            type: "string",
+                            description: "Task ID (preferred). Works with both regular task IDs (9 characters) and custom IDs with uppercase prefixes (like 'DEV-1234')."
+                        },
+                        taskName: {
+                            type: "string",
+                            description: "Task name. Requires listName when used."
+                        },
+                        listName: {
+                            type: "string",
+                            description: "REQUIRED with taskName: List containing the task."
+                        },
+                        customTaskId: {
+                            type: "string",
+                            description: "Custom task ID (e.g., 'DEV-1234'). Only use if you want to explicitly force custom ID lookup. In most cases, use taskId which auto-detects ID format."
+                        }
                     }
                 }
             },
@@ -383,7 +356,22 @@ Warning:
                 items: {
                     type: "object",
                     properties: {
-                        ...taskIdentifierSchema
+                        taskId: {
+                            type: "string",
+                            description: "Task ID (preferred). Works with both regular task IDs (9 characters) and custom IDs with uppercase prefixes (like 'DEV-1234')."
+                        },
+                        taskName: {
+                            type: "string",
+                            description: "Task name. Requires listName when used."
+                        },
+                        listName: {
+                            type: "string",
+                            description: "REQUIRED with taskName: List containing the task."
+                        },
+                        customTaskId: {
+                            type: "string",
+                            description: "Custom task ID (e.g., 'DEV-1234'). Only use if you want to explicitly force custom ID lookup. In most cases, use taskId which auto-detects ID format."
+                        }
                     }
                 }
             },

package/build/tools/task/handlers.js

@@ -392,58 +392,76 @@ export async function getWorkspaceTasksHandler(taskService, params) {
  * Handler for creating multiple tasks
  */
 export async function createBulkTasksHandler(params) {
-    validateBulkTasks(params.tasks);
-    const listId = await getListId(params.listId, params.listName);
-    // Process tasks - prepare data for each task
-    const tasks = params.tasks.map(task => {
-        const processedTask = { ...task };
+    const { tasks, listId, listName, options } = params;
+    // Validate tasks array
+    validateBulkTasks(tasks, 'create');
+    // Validate and resolve list ID
+    const targetListId = await resolveListIdWithValidation(listId, listName);
+    // Format tasks for creation
+    const formattedTasks = tasks.map(task => {
+        const taskData = {
+            name: task.name,
+            description: task.description,
+            markdown_description: task.markdown_description,
+            status: task.status,
+            priority: toTaskPriority(task.priority),
+            tags: task.tags,
+            custom_fields: task.custom_fields
+        };
+        // Add due date if specified
         if (task.dueDate) {
-            processedTask.due_date = parseDueDate(task.dueDate);
-            delete processedTask.dueDate;
+            taskData.due_date = parseDueDate(task.dueDate);
+            taskData.due_date_time = true;
         }
-        // Make sure custom_fields is preserved in the processed task
-        if (task.custom_fields) {
-            processedTask.custom_fields = task.custom_fields;
+        // Add start date if specified
+        if (task.startDate) {
+            taskData.start_date = parseDueDate(task.startDate);
+            taskData.start_date_time = true;
         }
-        return processedTask;
+        return taskData;
     });
-    const result = await bulkService.createTasks(listId, tasks, parseBulkOptions(params.options));
-    return result.successful;
+    // Parse bulk options
+    const bulkOptions = parseBulkOptions(options);
+    // Create tasks - pass arguments in correct order: listId, tasks, options
+    return await bulkService.createTasks(targetListId, formattedTasks, bulkOptions);
 }
 /**
  * Handler for updating multiple tasks
  */
 export async function updateBulkTasksHandler(params) {
-    validateBulkTasks(params.tasks);
-    const updates = await Promise.all(params.tasks.map(async (task) => {
-        validateTaskUpdateData(task);
-        const taskId = await getTaskId(task.taskId, task.taskName, task.listName);
-        return { id: taskId, data: buildUpdateData(task) };
-    }));
-    const result = await bulkService.updateTasks(updates, parseBulkOptions(params.options));
-    return result.successful;
+    const { tasks, options } = params;
+    // Validate tasks array
+    validateBulkTasks(tasks, 'update');
+    // Parse bulk options
+    const bulkOptions = parseBulkOptions(options);
+    // Update tasks
+    return await bulkService.updateTasks(tasks, bulkOptions);
 }
 /**
  * Handler for moving multiple tasks
  */
 export async function moveBulkTasksHandler(params) {
-    validateBulkTasks(params.tasks);
-    if (!params.targetListId && !params.targetListName) {
-        throw new Error("Either targetListId or targetListName must be provided");
-    }
-    const targetListId = await getListId(params.targetListId, params.targetListName);
-    const taskIds = await mapTaskIds(params.tasks);
-    const result = await bulkService.moveTasks(taskIds.map(taskId => ({ taskId })), targetListId, parseBulkOptions(params.options));
-    return result.successful;
+    const { tasks, targetListId, targetListName, options } = params;
+    // Validate tasks array
+    validateBulkTasks(tasks, 'move');
+    // Validate and resolve target list ID
+    const resolvedTargetListId = await resolveListIdWithValidation(targetListId, targetListName);
+    // Parse bulk options
+    const bulkOptions = parseBulkOptions(options);
+    // Move tasks
+    return await bulkService.moveTasks(tasks, resolvedTargetListId, bulkOptions);
 }
 /**
  * Handler for deleting multiple tasks
  */
 export async function deleteBulkTasksHandler(params) {
-    validateBulkTasks(params.tasks);
-    const taskIds = await mapTaskIds(params.tasks);
-    await bulkService.deleteTasks(taskIds, parseBulkOptions(params.options));
-    return taskIds.map(() => true);
+    const { tasks, options } = params;
+    // Validate tasks array
+    validateBulkTasks(tasks, 'delete');
+    // Parse bulk options
+    const bulkOptions = parseBulkOptions(options);
+    // Delete tasks
+    return await bulkService.deleteTasks(tasks, bulkOptions);
 }
 /**
  * Handler for deleting a task

package/build/tools/task/main.js

@@ -100,22 +100,37 @@ export const handleCreateTaskComment = createHandlerWrapper(createTaskCommentHan
 //=============================================================================
 // BULK TASK OPERATIONS - HANDLER IMPLEMENTATIONS
 //=============================================================================
-export const handleCreateBulkTasks = createHandlerWrapper(createBulkTasksHandler, (tasks) => ({
-    tasks,
-    count: tasks.length
+export const handleCreateBulkTasks = createHandlerWrapper(createBulkTasksHandler, (result) => ({
+    successful: result.successful,
+    failed: result.failed,
+    count: result.totals.total,
+    success_count: result.totals.success,
+    failure_count: result.totals.failure,
+    errors: result.failed.map(f => f.error)
 }));
-export const handleUpdateBulkTasks = createHandlerWrapper(updateBulkTasksHandler, (tasks) => ({
-    tasks,
-    count: tasks.length
+export const handleUpdateBulkTasks = createHandlerWrapper(updateBulkTasksHandler, (result) => ({
+    successful: result.successful,
+    failed: result.failed,
+    count: result.totals.total,
+    success_count: result.totals.success,
+    failure_count: result.totals.failure,
+    errors: result.failed.map(f => f.error)
 }));
-export const handleMoveBulkTasks = createHandlerWrapper(moveBulkTasksHandler, (tasks) => ({
-    tasks,
-    count: tasks.length
+export const handleMoveBulkTasks = createHandlerWrapper(moveBulkTasksHandler, (result) => ({
+    successful: result.successful,
+    failed: result.failed,
+    count: result.totals.total,
+    success_count: result.totals.success,
+    failure_count: result.totals.failure,
+    errors: result.failed.map(f => f.error)
 }));
-export const handleDeleteBulkTasks = createHandlerWrapper(deleteBulkTasksHandler, (results) => ({
-    success: true,
-    count: results.length,
-    results
+export const handleDeleteBulkTasks = createHandlerWrapper(deleteBulkTasksHandler, (result) => ({
+    successful: result.successful,
+    failed: result.failed,
+    count: result.totals.total,
+    success_count: result.totals.success,
+    failure_count: result.totals.failure,
+    errors: result.failed.map(f => f.error)
 }));
 //=============================================================================
 // WORKSPACE TASK OPERATIONS - HANDLER IMPLEMENTATIONS
@@ -128,22 +143,101 @@ export const handleGetWorkspaceTasks = createHandlerWrapper(
 // TOOL DEFINITIONS AND HANDLERS EXPORT
 //=============================================================================
 // Tool definitions with their handler mappings
-export const taskTools = [
-    // Single task operations
-    { definition: createTaskTool, handler: handleCreateTask },
-    { definition: getTaskTool, handler: handleGetTask },
-    { definition: getTasksTool, handler: handleGetTasks },
-    { definition: updateTaskTool, handler: handleUpdateTask },
-    { definition: moveTaskTool, handler: handleMoveTask },
-    { definition: duplicateTaskTool, handler: handleDuplicateTask },
-    { definition: deleteTaskTool, handler: handleDeleteTask },
-    { definition: getTaskCommentsTool, handler: handleGetTaskComments },
-    { definition: createTaskCommentTool, handler: handleCreateTaskComment },
-    // Bulk task operations
-    { definition: createBulkTasksTool, handler: handleCreateBulkTasks },
-    { definition: updateBulkTasksTool, handler: handleUpdateBulkTasks },
-    { definition: moveBulkTasksTool, handler: handleMoveBulkTasks },
-    { definition: deleteBulkTasksTool, handler: handleDeleteBulkTasks },
-    // Team task operations
-    { definition: getWorkspaceTasksTool, handler: handleGetWorkspaceTasks }
+export const tools = [
+    {
+        definition: createTaskTool,
+        handler: createTaskHandler
+    },
+    {
+        definition: updateTaskTool,
+        handler: updateTaskHandler
+    },
+    {
+        definition: moveTaskTool,
+        handler: moveTaskHandler
+    },
+    {
+        definition: duplicateTaskTool,
+        handler: duplicateTaskHandler
+    },
+    {
+        definition: getTaskTool,
+        handler: getTaskHandler
+    },
+    {
+        definition: getTasksTool,
+        handler: getTasksHandler
+    },
+    {
+        definition: getTaskCommentsTool,
+        handler: getTaskCommentsHandler
+    },
+    {
+        definition: createTaskCommentTool,
+        handler: createTaskCommentHandler
+    },
+    {
+        definition: deleteTaskTool,
+        handler: deleteTaskHandler
+    },
+    {
+        definition: getWorkspaceTasksTool,
+        handler: getWorkspaceTasksHandler
+    },
+    {
+        definition: createBulkTasksTool,
+        handler: async (params) => {
+            const result = await createBulkTasksHandler(params);
+            return {
+                successful: result.successful,
+                failed: result.failed,
+                count: result.totals.total,
+                success_count: result.totals.success,
+                failure_count: result.totals.failure,
+                errors: result.failed.map(f => f.error)
+            };
+        }
+    },
+    {
+        definition: updateBulkTasksTool,
+        handler: async (params) => {
+            const result = await updateBulkTasksHandler(params);
+            return {
+                successful: result.successful,
+                failed: result.failed,
+                count: result.totals.total,
+                success_count: result.totals.success,
+                failure_count: result.totals.failure,
+                errors: result.failed.map(f => f.error)
+            };
+        }
+    },
+    {
+        definition: moveBulkTasksTool,
+        handler: async (params) => {
+            const result = await moveBulkTasksHandler(params);
+            return {
+                successful: result.successful,
+                failed: result.failed,
+                count: result.totals.total,
+                success_count: result.totals.success,
+                failure_count: result.totals.failure,
+                errors: result.failed.map(f => f.error)
+            };
+        }
+    },
+    {
+        definition: deleteBulkTasksTool,
+        handler: async (params) => {
+            const result = await deleteBulkTasksHandler(params);
+            return {
+                successful: result.successful,
+                failed: result.failed,
+                count: result.totals.total,
+                success_count: result.totals.success,
+                failure_count: result.totals.failure,
+                errors: result.failed.map(f => f.error)
+            };
+        }
+    }
 ];

package/build/tools/task/single-operations.js

@@ -145,31 +145,39 @@ export const updateTaskTool = {
     description: `Purpose: Modify properties of an existing task.
 
 Valid Usage:
-1. Use taskId alone (preferred if available)
-2. Use taskName + listName
+1. Use taskId alone (preferred) - works with both regular and custom IDs
+2. Use taskName alone (will search across all lists)
+3. Use taskName + listName (for faster, targeted search)
 
 Requirements:
 - At least one update field (name, description, status, priority, dueDate) must be provided
-- When using taskName, listName is REQUIRED
+- EITHER taskId OR taskName: REQUIRED
+- listName: Optional, but recommended when using taskName
 
 Notes:
+- The tool automatically searches for tasks using smart name matching
+- When only taskName is provided, it searches across all lists
+- Adding listName narrows the search to a specific list for better performance
 - Only specified fields will be updated
-- Using taskId is more reliable than taskName
-- You can set custom field values using the custom_fields parameter (array of {id, value} objects)`,
+- Custom fields can be set using the custom_fields parameter (array of {id, value} objects)
+
+Warning:
+- Using taskName without listName may match multiple tasks
+- If multiple matches are found, the operation will fail with a disambiguation error`,
     inputSchema: {
         type: "object",
         properties: {
             taskId: {
                 type: "string",
-                description: "ID of the task to update (preferred). Works with both regular task IDs (9 characters) and custom IDs with uppercase prefixes (like 'DEV-1234')."
+                description: "ID of task to update (preferred). Works with both regular task IDs (9 characters) and custom IDs with uppercase prefixes (like 'DEV-1234')."
             },
             taskName: {
                 type: "string",
-                description: "Name of the task to update. Only use this if you don't have taskId. When using this parameter, you MUST also provide listName."
+                description: "Name of task to update. The tool will search for tasks with this name across all lists unless listName is specified."
             },
             listName: {
                 type: "string",
-                description: "Name of the list containing the task. REQUIRED when using taskName."
+                description: "Optional: Name of list containing the task. Providing this narrows the search to a specific list, improving performance and reducing ambiguity."
             },
             name: {
                 type: "string",
@@ -356,8 +364,7 @@ Note:
                 type: "boolean",
                 description: "Whether to include subtasks in the response. Set to true to retrieve full details of all subtasks."
             }
-        },
-        required: []
+        }
     }
 };
 /**
@@ -518,12 +525,23 @@ export const deleteTaskTool = {
 
 Valid Usage:
 1. Use taskId alone (preferred and safest)
-2. Use taskName + optional listName
+2. Use taskName alone (will search across all lists)
+3. Use taskName + listName (for faster, targeted search)
+
+Requirements:
+- EITHER taskId OR taskName: REQUIRED
+- listName: Optional, but recommended when using taskName
+
+Notes:
+- The tool automatically searches for tasks using smart name matching
+- When only taskName is provided, it searches across all lists
+- Adding listName narrows the search to a specific list for better performance
+- Supports both regular task IDs and custom IDs (like 'DEV-1234')
 
 Warning:
 - This action CANNOT be undone
-- Using taskName is risky as names may not be unique
-- Provide listName when using taskName for more precise targeting`,
+- Using taskName without listName may match multiple tasks
+- If multiple matches are found, the operation will fail with a disambiguation error`,
     inputSchema: {
         type: "object",
         properties: {
@@ -533,11 +551,11 @@ Warning:
             },
             taskName: {
                 type: "string",
-                description: "Name of task to delete. Use with extreme caution as names may not be unique."
+                description: "Name of task to delete. The tool will search for tasks with this name across all lists unless listName is specified."
             },
             listName: {
                 type: "string",
-                description: "Name of list containing the task. Helps ensure correct task deletion when using taskName."
+                description: "Optional: Name of list containing the task. Providing this narrows the search to a specific list, improving performance and reducing ambiguity."
             }
         }
     }

package/build/tools/task/utilities.js

@@ -117,12 +117,31 @@ export function validateTaskUpdateData(updateData) {
     }
 }
 /**
- * Validate bulk operation tasks array
+ * Validate bulk task array and task identification
+ * @param tasks Array of tasks to validate
+ * @param operation The bulk operation type ('create', 'update', 'move', 'delete')
  */
-export function validateBulkTasks(tasks) {
-    if (!tasks || !Array.isArray(tasks) || tasks.length === 0) {
-        throw new Error('You must provide a non-empty array of tasks');
+export function validateBulkTasks(tasks, operation = 'update') {
+    if (!Array.isArray(tasks) || tasks.length === 0) {
+        throw new Error("tasks must be a non-empty array");
     }
+    tasks.forEach((task, index) => {
+        if (!task || typeof task !== 'object') {
+            throw new Error(`Task at index ${index} must be an object`);
+        }
+        // Skip task identification validation for create operations
+        if (operation === 'create') {
+            return;
+        }
+        // For bulk operations, require listName when using taskName
+        if (task.taskName && !task.listName) {
+            throw new Error(`Task at index ${index} using taskName must also provide listName`);
+        }
+        // At least one identifier is required for non-create operations
+        if (!task.taskId && !task.taskName && !task.customTaskId) {
+            throw new Error(`Task at index ${index} must provide either taskId, taskName + listName, or customTaskId`);
+        }
+    });
 }
 /**
  * Parse options for bulk operations

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taazkareem/clickup-mcp-server",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "ClickUp MCP Server - Integrate ClickUp tasks with AI through Model Context Protocol",
   "type": "module",
   "main": "build/index.js",