@taazkareem/clickup-mcp-server 0.4.70 → 0.4.71

package/build/services/clickup/bulk.js

@@ -1,116 +1,147 @@
-export class BulkProcessor {
-    async processBulk(items, processor, options) {
-        const opts = {
-            batchSize: options?.batchSize ?? 10,
-            concurrency: options?.concurrency ?? 3,
-            continueOnError: options?.continueOnError ?? false,
-            retryCount: options?.retryCount ?? 3,
-            retryDelay: options?.retryDelay ?? 1000,
-            exponentialBackoff: options?.exponentialBackoff ?? true,
-            onProgress: options?.onProgress ?? (() => { })
-        };
-        const result = {
-            success: true,
-            successfulItems: [],
-            failedItems: [],
-            totalItems: items.length,
-            successCount: 0,
-            failureCount: 0
-        };
-        if (items.length === 0)
-            return result;
+/**
+ * ClickUp Bulk Service
+ *
+ * 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';
+// Create logger instance
+const logger = new Logger('BulkService');
+/**
+ * Service for handling bulk operations in ClickUp
+ */
+export class BulkService {
+    constructor(taskService) {
+        this.taskService = taskService;
+        logger.info('BulkService initialized');
+    }
+    /**
+     * Create multiple tasks in a list efficiently
+     *
+     * @param listId ID of the list to create tasks in
+     * @param tasks Array of task data
+     * @param options Batch processing options
+     * @returns Results containing successful and failed tasks
+     */
+    async createTasks(listId, tasks, options) {
+        logger.info(`Creating ${tasks.length} tasks in list ${listId}`, {
+            batchSize: options?.batchSize,
+            concurrency: options?.concurrency
+        });
         try {
-            const totalBatches = Math.ceil(items.length / opts.batchSize);
-            let processedItems = 0;
-            for (let batchIndex = 0; batchIndex < totalBatches; batchIndex++) {
-                const startIdx = batchIndex * opts.batchSize;
-                const endIdx = Math.min(startIdx + opts.batchSize, items.length);
-                const batch = items.slice(startIdx, endIdx);
-                const batchResults = await this.processBatch(batch, processor, startIdx, opts);
-                result.successfulItems.push(...batchResults.successfulItems);
-                result.failedItems.push(...batchResults.failedItems);
-                result.successCount += batchResults.successCount;
-                result.failureCount += batchResults.failureCount;
-                if (batchResults.failureCount > 0 && !opts.continueOnError) {
-                    result.success = false;
-                    return result;
-                }
-                processedItems += batch.length;
-                opts.onProgress(processedItems, items.length, result.successCount, result.failureCount);
-            }
-            result.success = result.failedItems.length === 0;
-            return result;
+            // First validate that the list exists - do this once for all tasks
+            await this.taskService.validateListExists(listId);
+            // Process the tasks in batches
+            return await processBatch(tasks, (task, index) => {
+                logger.debug(`Creating task ${index + 1}/${tasks.length}`, {
+                    taskName: task.name
+                });
+                // Reuse the single-task creation method
+                return this.taskService.createTask(listId, task);
+            }, options);
         }
         catch (error) {
-            const err = error;
-            console.error('Failed to process bulk operation:', err.message || String(error));
-            result.success = false;
-            return result;
+            logger.error(`Failed to create tasks in bulk`, {
+                listId,
+                taskCount: tasks.length,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            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 });
         }
     }
-    async processBatch(batch, processor, startIndex, opts) {
-        const result = {
-            success: true,
-            successfulItems: [],
-            failedItems: [],
-            totalItems: batch.length,
-            successCount: 0,
-            failureCount: 0
-        };
+    /**
+     * Update multiple tasks efficiently
+     *
+     * @param tasks Array of task IDs and update data
+     * @param options Batch processing options
+     * @returns Results containing successful and failed task updates
+     */
+    async updateTasks(tasks, options) {
+        logger.info(`Updating ${tasks.length} tasks`, {
+            batchSize: options?.batchSize,
+            concurrency: options?.concurrency
+        });
         try {
-            for (let i = 0; i < batch.length; i += opts.concurrency) {
-                const concurrentBatch = batch.slice(i, Math.min(i + opts.concurrency, batch.length));
-                const promises = concurrentBatch.map((item, idx) => {
-                    const index = startIndex + i + idx;
-                    return this.processWithRetry(() => processor(item, index), index, item, opts);
+            return await processBatch(tasks, ({ id, data }, index) => {
+                logger.debug(`Updating task ${index + 1}/${tasks.length}`, {
+                    taskId: id
                 });
-                const results = await Promise.allSettled(promises);
-                results.forEach((promiseResult, idx) => {
-                    const index = startIndex + i + idx;
-                    if (promiseResult.status === 'fulfilled') {
-                        result.successfulItems.push(promiseResult.value);
-                        result.successCount++;
-                    }
-                    else {
-                        const error = promiseResult.reason;
-                        result.failedItems.push({ item: batch[i + idx], index, error });
-                        result.failureCount++;
-                        if (!opts.continueOnError) {
-                            result.success = false;
-                            throw new Error(`Bulk operation failed at index ${index}: ${error.message || String(error)}`);
-                        }
-                    }
+                // Reuse the single-task update method
+                return this.taskService.updateTask(id, data);
+            }, options);
+        }
+        catch (error) {
+            logger.error(`Failed to update tasks in bulk`, {
+                taskCount: tasks.length,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw new ClickUpServiceError(`Failed to update tasks in bulk: ${error instanceof Error ? error.message : String(error)}`, error instanceof ClickUpServiceError ? error.code : ErrorCode.UNKNOWN, { taskCount: tasks.length });
+        }
+    }
+    /**
+     * Move multiple tasks to a different list efficiently
+     *
+     * @param taskIds Array of task IDs to move
+     * @param targetListId ID of the list to move tasks to
+     * @param options Batch processing options
+     * @returns Results containing successful and failed moves
+     */
+    async moveTasks(taskIds, targetListId, options) {
+        logger.info(`Moving ${taskIds.length} tasks to list ${targetListId}`, {
+            batchSize: options?.batchSize,
+            concurrency: options?.concurrency
+        });
+        try {
+            // First validate that the target list exists - do this once for all tasks
+            await this.taskService.validateListExists(targetListId);
+            return await processBatch(taskIds, (taskId, index) => {
+                logger.debug(`Moving task ${index + 1}/${taskIds.length}`, {
+                    taskId,
+                    targetListId
                 });
-            }
-            return result;
+                // Reuse the single-task move method
+                return this.taskService.moveTask(taskId, targetListId);
+            }, options);
         }
         catch (error) {
-            const err = error;
-            console.error(`Bulk operation failed: ${err.message || String(error)}`, error);
-            result.success = false;
-            return result;
+            logger.error(`Failed to move tasks in bulk`, {
+                targetListId,
+                taskCount: taskIds.length,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw new ClickUpServiceError(`Failed to move tasks in bulk: ${error instanceof Error ? error.message : String(error)}`, error instanceof ClickUpServiceError ? error.code : ErrorCode.UNKNOWN, { targetListId, taskCount: taskIds.length });
         }
     }
-    async processWithRetry(operation, index, item, options) {
-        let attempts = 1;
-        let lastError = new Error('Unknown error');
-        while (attempts <= options.retryCount) {
-            try {
-                return await operation();
-            }
-            catch (error) {
-                const err = error;
-                console.warn(`Operation failed for item at index ${index}, attempt ${attempts}/${options.retryCount}: ${err.message || String(error)}`);
-                lastError = err;
-                if (attempts >= options.retryCount)
-                    break;
-                const delay = options.exponentialBackoff
-                    ? options.retryDelay * Math.pow(2, attempts) + Math.random() * 1000
-                    : options.retryDelay * Math.pow(1.5, attempts - 1);
-                await new Promise(resolve => setTimeout(resolve, delay));
-                attempts++;
-            }
+    /**
+     * Delete multiple tasks efficiently
+     *
+     * @param taskIds Array of task IDs to delete
+     * @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
+        });
+        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
+            }, 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 });
         }
-        throw new Error(`Operation failed after ${attempts} attempts for item at index ${index}: ${lastError?.message || 'Unknown error'}`);
     }
 }

package/build/services/clickup/task.js

@@ -9,15 +9,19 @@
  * - Finding tasks by name
  */
 import { BaseClickUpService, ErrorCode, ClickUpServiceError } from './base.js';
-import { BulkProcessor } from './bulk.js';
 import { ListService } from './list.js';
 export class TaskService extends BaseClickUpService {
     constructor(apiKey, teamId, baseUrl, workspaceService) {
         super(apiKey, teamId, baseUrl);
         this.workspaceService = null;
-        this.bulkProcessor = new BulkProcessor();
-        this.listService = new ListService(apiKey, teamId);
-        this.workspaceService = workspaceService || null;
+        // Cache workspace service if provided
+        if (workspaceService) {
+            this.workspaceService = workspaceService;
+            this.logOperation('constructor', { usingSharedWorkspaceService: true });
+        }
+        // Initialize list service for list lookups
+        this.listService = new ListService(apiKey, teamId, baseUrl, this.workspaceService);
+        this.logOperation('constructor', { initialized: true });
     }
     /**
      * Helper method to handle errors consistently
@@ -263,26 +267,14 @@ export class TaskService extends BaseClickUpService {
     async duplicateTask(taskId, listId) {
         this.logOperation('duplicateTask', { taskId, listId });
         try {
-            // First, get the original task
+            // Get the original task to duplicate
             const originalTask = await this.getTask(taskId);
-            // Priority mapping: convert string priority to numeric value if needed
-            let priorityValue = null;
-            if (originalTask.priority) {
-                // If priority.id exists and is numeric, use that
-                if (originalTask.priority.id) {
-                    priorityValue = parseInt(originalTask.priority.id);
-                    // Ensure it's in the valid range 1-4
-                    if (isNaN(priorityValue) || priorityValue < 1 || priorityValue > 4) {
-                        priorityValue = null;
-                    }
-                }
-            }
-            // Prepare data for the new task
+            // Create a copy of the task data
             const newTaskData = {
-                name: `${originalTask.name} (Copy)`,
-                description: originalTask.description,
+                name: `${originalTask.name} (copy)`,
+                description: originalTask.description || '',
                 status: originalTask.status?.status,
-                priority: priorityValue,
+                priority: originalTask.priority?.id ? parseInt(originalTask.priority.id) : null,
                 due_date: originalTask.due_date ? new Date(originalTask.due_date).getTime() : undefined,
                 assignees: originalTask.assignees?.map(a => a.id) || []
             };
@@ -295,242 +287,51 @@ export class TaskService extends BaseClickUpService {
         }
     }
     /**
-     * Create multiple tasks in a list with advanced batching options
-     *
-     * @param listId The ID of the list to create tasks in
-     * @param data Object containing array of tasks to create
-     * @param options Configuration options for the bulk operation
-     * @param progressCallback Optional callback for tracking progress
-     * @returns Result containing both successful and failed operations
-     */
-    async createBulkTasks(listId, data, options, progressCallback) {
-        this.logOperation('createBulkTasks', {
-            listId,
-            taskCount: data.tasks.length,
-            batchSize: options?.batchSize,
-            concurrency: options?.concurrency
-        });
-        try {
-            // Validate list exists before proceeding
-            const list = await this.listService.getList(listId).catch(() => null);
-            if (!list) {
-                throw new ClickUpServiceError(`List not found with ID: ${listId}`, ErrorCode.NOT_FOUND);
-            }
-            // Set default options for better performance
-            const bulkOptions = {
-                batchSize: options?.batchSize ?? 5, // Smaller batch size for better rate limit handling
-                concurrency: options?.concurrency ?? 2, // Lower concurrency to avoid rate limits
-                continueOnError: options?.continueOnError ?? true, // Continue on individual task failures
-                retryCount: options?.retryCount ?? 3, // Retry failed operations
-                ...options
-            };
-            // Add list validation to progress tracking
-            const wrappedCallback = progressCallback ?
-                (progress) => {
-                    progress.context = { listId, listName: list.name };
-                    progressCallback(progress);
-                } : undefined;
-            return await this.bulkProcessor.processBulk(data.tasks, async (taskData) => {
-                try {
-                    // Ensure task data is properly formatted
-                    const sanitizedData = {
-                        ...taskData,
-                        // Remove any accidentally included list IDs in task data
-                        list: undefined,
-                        // Ensure name has emoji if missing
-                        name: taskData.name.match(/^\p{Emoji}/u) ?
-                            taskData.name :
-                            '📋 ' + taskData.name
-                    };
-                    return await this.createTask(listId, sanitizedData);
-                }
-                catch (error) {
-                    // Enhance error context for better debugging
-                    if (error instanceof ClickUpServiceError) {
-                        error.context = {
-                            ...error.context,
-                            taskName: taskData.name,
-                            listId,
-                            listName: list.name
-                        };
-                    }
-                    throw error;
-                }
-            }, bulkOptions);
-        }
-        catch (error) {
-            const errorMessage = error instanceof ClickUpServiceError ?
-                error.message :
-                `Failed to create tasks in bulk: ${error.message}`;
-            throw new ClickUpServiceError(errorMessage, error instanceof ClickUpServiceError ? error.code : ErrorCode.UNKNOWN, {
-                listId,
-                taskCount: data.tasks.length,
-                error: error instanceof Error ? error.message : String(error)
-            });
-        }
-    }
-    /**
-     * Update multiple tasks in bulk with advanced batching options
+     * Get all comments for a task
      *
-     * @param tasks Array of task IDs and update data
-     * @param options Configuration options for the bulk operation
-     * @param progressCallback Optional callback for tracking progress
-     * @returns Result containing both successful and failed operations
+     * @param taskId ID of the task to get comments for
+     * @param start Optional pagination start
+     * @param startId Optional comment ID to start from
+     * @returns Array of task comments
      */
-    async updateBulkTasks(tasks, options, progressCallback) {
-        this.logOperation('updateBulkTasks', {
-            taskCount: tasks.length,
-            batchSize: options?.batchSize,
-            concurrency: options?.concurrency
-        });
+    async getTaskComments(taskId, start, startId) {
+        this.logOperation('getTaskComments', { taskId, start, startId });
         try {
-            return await this.bulkProcessor.processBulk(tasks, ({ id, data }) => this.updateTask(id, data), options);
-        }
-        catch (error) {
-            if (error instanceof ClickUpServiceError) {
-                throw error;
+            // Build query parameters for pagination
+            const queryParams = new URLSearchParams();
+            if (start !== undefined) {
+                queryParams.append('start', start.toString());
             }
-            throw new ClickUpServiceError(`Failed to update tasks in bulk: ${error.message}`, ErrorCode.UNKNOWN, error);
-        }
-    }
-    /**
-     * Move multiple tasks to a different list in bulk
-     *
-     * @param tasks Array of task IDs to move
-     * @param targetListId ID of the list to move tasks to
-     * @param options Configuration options for the bulk operation
-     * @param progressCallback Optional callback for tracking progress
-     * @returns Result containing both successful and failed operations
-     */
-    async moveBulkTasks(tasks, targetListId, options, progressCallback) {
-        this.logOperation('moveBulkTasks', {
-            taskCount: tasks.length,
-            targetListId,
-            batchSize: options?.batchSize,
-            concurrency: options?.concurrency
-        });
-        try {
-            // First verify destination list exists
-            const destinationList = await this.listService.getList(targetListId);
-            if (!destinationList) {
-                throw new ClickUpServiceError(`Destination list not found with ID: ${targetListId}`, ErrorCode.NOT_FOUND);
+            if (startId) {
+                queryParams.append('start_id', startId);
             }
-            // Set default options for better performance
-            const bulkOptions = {
-                batchSize: options?.batchSize ?? 5, // Smaller batch size for better rate limit handling
-                concurrency: options?.concurrency ?? 2, // Lower concurrency to avoid rate limits
-                continueOnError: options?.continueOnError ?? true, // Continue on individual task failures
-                retryCount: options?.retryCount ?? 3, // Retry failed operations
-                ...options
-            };
-            return await this.bulkProcessor.processBulk(tasks, async (taskId) => {
-                try {
-                    // Get the original task
-                    const originalTask = await this.getTask(taskId);
-                    const currentStatus = originalTask.status?.status;
-                    const availableStatuses = destinationList.statuses?.map(s => s.status) || [];
-                    // Determine the appropriate status for the destination list
-                    let newStatus = availableStatuses.includes(currentStatus || '')
-                        ? currentStatus // Keep the same status if available in destination list
-                        : destinationList.statuses?.[0]?.status; // Otherwise use the default (first) status
-                    // Prepare the task data for the new list
-                    const taskData = {
-                        name: originalTask.name,
-                        description: originalTask.description,
-                        status: newStatus,
-                        priority: originalTask.priority?.priority,
-                        due_date: originalTask.due_date ? Number(originalTask.due_date) : undefined,
-                        assignees: originalTask.assignees?.map(a => a.id) || []
-                    };
-                    // Create new task and delete old one in a single makeRequest call
-                    return await this.makeRequest(async () => {
-                        // First create the new task
-                        const response = await this.client.post(`/list/${targetListId}/task`, taskData);
-                        // Then delete the original task
-                        await this.client.delete(`/task/${taskId}`);
-                        // Add a property to indicate the task was moved
-                        const newTask = {
-                            ...response.data,
-                            moved: true,
-                            originalId: taskId
-                        };
-                        return newTask;
-                    });
-                }
-                catch (error) {
-                    // Enhance error context for better debugging
-                    if (error instanceof ClickUpServiceError) {
-                        error.context = {
-                            ...error.context,
-                            taskId,
-                            targetListId,
-                            targetListName: destinationList.name
-                        };
-                    }
-                    throw error;
-                }
-            }, bulkOptions);
+            const queryString = queryParams.toString() ? `?${queryParams.toString()}` : '';
+            const response = await this.client.get(`/task/${taskId}/comment${queryString}`);
+            return response.data.comments || [];
         }
         catch (error) {
-            const errorMessage = error instanceof ClickUpServiceError ?
-                error.message :
-                `Failed to move tasks in bulk: ${error.message}`;
-            throw new ClickUpServiceError(errorMessage, error instanceof ClickUpServiceError ? error.code : ErrorCode.UNKNOWN, {
-                targetListId,
-                taskCount: tasks.length,
-                error: error instanceof Error ? error.message : String(error)
-            });
+            throw this.handleError(error, 'Failed to get task comments');
         }
     }
     /**
-     * Delete multiple tasks in bulk with advanced batching options
+     * Validate that a list exists
      *
-     * @param taskIds Array of task IDs to delete
-     * @param options Configuration options for the bulk operation
-     * @returns Result containing both successful and failed operations
+     * @param listId ID of the list to validate
+     * @throws ClickUpServiceError if the list doesn't exist
      */
-    async deleteBulkTasks(taskIds, options) {
-        this.logOperation('deleteBulkTasks', {
-            taskCount: taskIds.length,
-            batchSize: options?.batchSize,
-            concurrency: options?.concurrency
-        });
+    async validateListExists(listId) {
+        this.logOperation('validateListExists', { listId });
         try {
-            return await this.bulkProcessor.processBulk(taskIds, async (taskId) => {
-                await this.deleteTask(taskId);
-                return taskId;
-            }, options);
+            const list = await this.listService.getList(listId);
+            if (!list) {
+                throw new ClickUpServiceError(`List not found: ${listId}`, ErrorCode.NOT_FOUND, { listId });
+            }
         }
         catch (error) {
             if (error instanceof ClickUpServiceError) {
                 throw error;
             }
-            throw new ClickUpServiceError(`Failed to delete tasks in bulk: ${error.message}`, ErrorCode.UNKNOWN, error);
-        }
-    }
-    /**
-     * Get comments for a specific task
-     * @param taskId The ID of the task to retrieve comments for
-     * @param start Optional parameter for pagination, timestamp from which to start fetching comments
-     * @param startId Optional parameter for pagination, comment ID from which to start fetching
-     * @returns Array of task comments
-     */
-    async getTaskComments(taskId, start, startId) {
-        this.logOperation('getTaskComments', { taskId, start, startId });
-        try {
-            return await this.makeRequest(async () => {
-                const params = new URLSearchParams();
-                // Add pagination parameters if provided
-                if (start)
-                    params.append('start', String(start));
-                if (startId)
-                    params.append('start_id', startId);
-                const response = await this.client.get(`/task/${taskId}/comment`, { params });
-                return response.data.comments;
-            });
-        }
-        catch (error) {
-            throw this.handleError(error, `Failed to retrieve comments for task ${taskId}`);
+            throw new ClickUpServiceError(`Failed to validate list existence: ${error instanceof Error ? error.message : String(error)}`, ErrorCode.UNKNOWN, { listId });
         }
     }
 }

package/build/tools/bulk-tasks.js

@@ -0,0 +1,36 @@
+/**
+ * Alternative implementation for bulk tasks creation
+ */
+import { handleCreateBulkTasks } from './task.js';
+/**
+ * Alternative tool definition for bulk task creation to work around MCP validation issues
+ */
+export const createTasksBulkTool = {
+    name: "create_tasks_bulk",
+    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",
+    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: {
+                // Define minimally to avoid validation issues
+                description: "Array of tasks to create. Each task must have at least a name."
+            }
+        },
+        required: ["tasks"]
+    }
+};
+/**
+ * Handler for create_tasks_bulk tool
+ */
+export async function handleCreateTasksBulk(parameters) {
+    // Use the same implementation as handleCreateBulkTasks
+    return handleCreateBulkTasks(parameters);
+}