@taazkareem/clickup-mcp-server 0.6.2 → 0.6.4

package/build/tools/task/handlers.js

@@ -11,7 +11,7 @@ import { toTaskPriority } from '../../services/clickup/types.js';
 import { clickUpServices } from '../../services/shared.js';
 import { BulkService } from '../../services/clickup/bulk.js';
 import { parseDueDate } from '../utils.js';
-import { validateTaskIdentification, validateListIdentification, validateTaskUpdateData, validateBulkTasks, parseBulkOptions, resolveTaskIdWithValidation, resolveListIdWithValidation } from './utilities.js';
+import { validateTaskIdentification, validateListIdentification, validateTaskUpdateData, validateBulkTasks, parseBulkOptions, resolveListIdWithValidation } from './utilities.js';
 // Use shared services instance
 const { task: taskService, list: listService } = clickUpServices;
 // Create a bulk service instance that uses the task service
@@ -32,18 +32,49 @@ function buildUpdateData(params) {
         updateData.markdown_description = params.markdown_description;
     if (params.status !== undefined)
         updateData.status = params.status;
+    // Skip toTaskPriority conversion since we're handling priority in the main handler
     if (params.priority !== undefined)
-        updateData.priority = toTaskPriority(params.priority);
-    if (params.dueDate !== undefined)
+        updateData.priority = params.priority;
+    if (params.dueDate !== undefined) {
         updateData.due_date = parseDueDate(params.dueDate);
+        updateData.due_date_time = true;
+    }
+    if (params.startDate !== undefined) {
+        updateData.start_date = parseDueDate(params.startDate);
+        updateData.start_date_time = true;
+    }
+    // Handle custom fields if provided
+    if (params.custom_fields !== undefined) {
+        updateData.custom_fields = params.custom_fields;
+    }
     return updateData;
 }
 /**
- * Process a task identification validation, returning the task ID
+ * Resolves a task ID from various input formats
+ * Smart disambiguation is used for task name lookups
+ *
+ * @param taskId Direct task ID
+ * @param taskName Task name to search for
+ * @param listName List name for context
+ * @param customTaskId Custom task ID (prefixed format)
+ * @returns Resolved task ID
  */
-async function getTaskId(taskId, taskName, listName, customTaskId) {
-    validateTaskIdentification(taskId, taskName, listName, customTaskId);
-    return await resolveTaskIdWithValidation(taskId, taskName, listName, customTaskId);
+export async function getTaskId(taskId, taskName, listName, customTaskId) {
+    validateTaskIdentification(taskId, taskName, listName, customTaskId, true);
+    const result = await taskService.findTasks({
+        taskId,
+        customTaskId,
+        taskName,
+        listName,
+        allowMultipleMatches: false,
+        useSmartDisambiguation: true,
+        includeFullDetails: false,
+        includeListContext: false
+    });
+    if (result && !Array.isArray(result)) {
+        return result.id;
+    }
+    throw new Error("Task not found");
 }
 /**
  * Process a list identification validation, returning the list ID
@@ -72,11 +103,12 @@ function buildTaskFilters(params) {
 }
 /**
  * Map tasks for bulk operations, resolving task IDs
+ * Uses smart disambiguation for tasks without list context
  */
 async function mapTaskIds(tasks) {
     return Promise.all(tasks.map(async (task) => {
         validateTaskIdentification(task.taskId, task.taskName, task.listName, task.customTaskId);
-        return await resolveTaskIdWithValidation(task.taskId, task.taskName, task.listName, task.customTaskId);
+        return await getTaskId(task.taskId, task.taskName, task.listName, task.customTaskId);
     }));
 }
 //=============================================================================
@@ -86,30 +118,46 @@ async function mapTaskIds(tasks) {
  * Handler for creating a task
  */
 export async function createTaskHandler(params) {
-    const { name, description, markdown_description, status, dueDate, parent, tags } = params;
+    const { name, description, markdown_description, status, dueDate, startDate, parent, tags, custom_fields, check_required_custom_fields } = params;
     if (!name)
         throw new Error("Task name is required");
     // Use our helper function to validate and convert priority
     const priority = toTaskPriority(params.priority);
     const listId = await getListId(params.listId, params.listName);
-    return await taskService.createTask(listId, {
+    const taskData = {
         name,
         description,
         markdown_description,
         status,
         priority,
-        due_date: dueDate ? parseDueDate(dueDate) : undefined,
         parent,
-        tags
-    });
+        tags,
+        custom_fields,
+        check_required_custom_fields
+    };
+    // Add due date if specified
+    if (dueDate) {
+        taskData.due_date = parseDueDate(dueDate);
+        taskData.due_date_time = true;
+    }
+    // Add start date if specified
+    if (startDate) {
+        taskData.start_date = parseDueDate(startDate);
+        taskData.start_date_time = true;
+    }
+    return await taskService.createTask(listId, taskData);
 }
 /**
  * Handler for updating a task
  */
 export async function updateTaskHandler(params) {
+    console.log('Update Task Handler - Raw params:', JSON.stringify(params));
+    console.log('Update Task Handler - Priority type:', typeof params.priority, 'Value:', params.priority);
     validateTaskUpdateData(params);
     const taskId = await getTaskId(params.taskId, params.taskName, params.listName);
-    return await taskService.updateTask(taskId, buildUpdateData(params));
+    const updateData = buildUpdateData(params);
+    console.log('Update Task Handler - Update data:', JSON.stringify(updateData));
+    return await taskService.updateTask(taskId, updateData);
 }
 /**
  * Handler for moving a task
@@ -134,15 +182,107 @@ export async function duplicateTaskHandler(params) {
  * Handler for getting a task
  */
 export async function getTaskHandler(params) {
-    // resolveTaskIdWithValidation now auto-detects whether taskId is a regular ID or custom ID
-    const taskId = await getTaskId(params.taskId, params.taskName, params.listName, params.customTaskId);
-    // If subtasks parameter is provided and true, use the getTaskWithSubtasks method
-    if (params.subtasks) {
-        const task = await taskService.getTask(taskId);
-        const subtasks = await taskService.getSubtasks(taskId);
-        return { ...task, subtasks };
+    try {
+        // Direct path for taskId - most efficient
+        if (params.taskId) {
+            const task = await taskService.getTask(params.taskId);
+            // Add subtasks if requested
+            if (params.subtasks) {
+                const subtasks = await taskService.getSubtasks(task.id);
+                return { ...task, subtasks };
+            }
+            return task;
+        }
+        // Direct path for customTaskId - also efficient
+        if (params.customTaskId) {
+            const task = await taskService.getTaskByCustomId(params.customTaskId);
+            // Add subtasks if requested
+            if (params.subtasks) {
+                const subtasks = await taskService.getSubtasks(task.id);
+                return { ...task, subtasks };
+            }
+            return task;
+        }
+        // Special optimized path for taskName + listName combination
+        if (params.taskName && params.listName) {
+            // First, get the list ID
+            const listId = await getListId(null, params.listName);
+            if (!listId) {
+                throw new Error(`List "${params.listName}" not found`);
+            }
+            // Use the ClickUp API to get filtered tasks
+            // Need to get all tasks and filter on client side
+            // This is more efficient than the original approach because it's a dedicated path 
+            // that skips the global lookup framework entirely
+            const allTasks = await taskService.getTasks(listId);
+            // Find the matching task
+            // Extract this to avoid dependency on internal isNameMatch implementation
+            const matchingTask = findTaskByName(allTasks, params.taskName);
+            if (!matchingTask) {
+                throw new Error(`Task "${params.taskName}" not found in list "${params.listName}"`);
+            }
+            // Add subtasks if requested
+            if (params.subtasks) {
+                const subtasks = await taskService.getSubtasks(matchingTask.id);
+                return { ...matchingTask, subtasks };
+            }
+            return matchingTask;
+        }
+        // Fallback to the original global lookup for all other cases
+        const result = await taskService.findTasks({
+            taskName: params.taskName,
+            allowMultipleMatches: true,
+            useSmartDisambiguation: false,
+            includeFullDetails: true,
+            includeListContext: true
+        });
+        // Handle the response based on the result type
+        if (Array.isArray(result)) {
+            // If multiple tasks matched, format them with task count
+            return {
+                matches: result,
+                count: result.length
+            };
+        }
+        else if (result) {
+            // Single task found, check if we need to include subtasks
+            if (params.subtasks) {
+                const subtasks = await taskService.getSubtasks(result.id);
+                return { ...result, subtasks };
+            }
+            // Return the single task
+            return result;
+        }
+        else {
+            throw new Error("Task not found");
+        }
+    }
+    catch (error) {
+        // Enhance error message for non-existent tasks
+        if (params.taskName && error.message.includes('not found')) {
+            throw new Error(`Task "${params.taskName}" not found. Please check the task name and try again.`);
+        }
+        // Pass along other formatted errors
+        throw error;
     }
-    return await taskService.getTask(taskId);
+}
+/**
+ * Helper function to find a task by name in an array of tasks
+ */
+function findTaskByName(tasks, name) {
+    if (!tasks || !Array.isArray(tasks) || !name)
+        return null;
+    // Try exact match first
+    let match = tasks.find(task => task.name === name);
+    if (match)
+        return match;
+    // Try case-insensitive match
+    match = tasks.find(task => task.name.toLowerCase() === name.toLowerCase());
+    if (match)
+        return match;
+    // Try fuzzy match - looking for name as substring
+    match = tasks.find(task => task.name.toLowerCase().includes(name.toLowerCase()));
+    return match || null;
 }
 /**
  * Handler for getting tasks
@@ -212,7 +352,8 @@ export async function getWorkspaceTasksHandler(taskService, params) {
         if (!hasFilter) {
             throw new Error('At least one filter parameter is required (tags, list_ids, folder_ids, space_ids, statuses, assignees, or date filters)');
         }
-        // Create filter object from parameters
+        // For workspace tasks, we'll continue to use the direct getWorkspaceTasks method
+        // since it supports specific workspace-wide filters that aren't part of the unified findTasks
         const filters = {
             tags: params.tags,
             list_ids: params.list_ids,
@@ -251,54 +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;
+        }
+        // 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, 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/index.js

@@ -25,4 +25,4 @@ createBulkTasksHandler, updateBulkTasksHandler, moveBulkTasksHandler, deleteBulk
 // Team task operation handlers
 getWorkspaceTasksHandler } from './handlers.js';
 // Re-export utilities
-export { formatTaskData, validateTaskIdentification, validateListIdentification, validateTaskUpdateData, validateBulkTasks, parseBulkOptions, resolveTaskIdWithValidation, resolveListIdWithValidation } from './utilities.js';
+export { formatTaskData, validateTaskIdentification, validateListIdentification, validateTaskUpdateData, validateBulkTasks, parseBulkOptions, resolveListIdWithValidation } from './utilities.js';

package/build/tools/task/main.js

@@ -43,7 +43,42 @@ export const handleGetTasks = createHandlerWrapper(getTasksHandler, (tasks) => (
     tasks,
     count: tasks.length
 }));
-export const handleUpdateTask = createHandlerWrapper(updateTaskHandler);
+export const handleUpdateTask = async (parameters) => {
+    try {
+        // Special handling for priority parameter
+        if (parameters.priority !== undefined) {
+            // Ensure priority is converted to a number if it's a valid value
+            if (parameters.priority === null) {
+                // null is valid for clearing priority
+            }
+            else if (typeof parameters.priority === 'number' && [1, 2, 3, 4].includes(parameters.priority)) {
+                // Valid priority number, keep as is
+            }
+            else if (typeof parameters.priority === 'string') {
+                // Try to convert string to number
+                const numPriority = parseInt(parameters.priority, 10);
+                if (!isNaN(numPriority) && [1, 2, 3, 4].includes(numPriority)) {
+                    parameters.priority = numPriority;
+                }
+                else if (parameters.priority === 'null') {
+                    parameters.priority = null;
+                }
+                else {
+                    throw new Error(`Invalid priority value: ${parameters.priority}. Must be 1, 2, 3, 4, or null.`);
+                }
+            }
+            else {
+                throw new Error(`Invalid priority value: ${parameters.priority}. Must be 1, 2, 3, 4, or null.`);
+            }
+        }
+        // Proceed with normal handling
+        const result = await updateTaskHandler(parameters);
+        return sponsorService.createResponse(result, true);
+    }
+    catch (error) {
+        return sponsorService.createErrorResponse(error, parameters);
+    }
+};
 export const handleMoveTask = createHandlerWrapper(moveTaskHandler);
 export const handleDuplicateTask = createHandlerWrapper(duplicateTaskHandler);
 export const handleDeleteTask = createHandlerWrapper(deleteTaskHandler, () => ({
@@ -65,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
@@ -93,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)
+            };
+        }
+    }
 ];