@taazkareem/clickup-mcp-server 0.6.1 → 0.6.3

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,
@@ -260,6 +401,10 @@ export async function createBulkTasksHandler(params) {
             processedTask.due_date = parseDueDate(task.dueDate);
             delete processedTask.dueDate;
         }
+        // Make sure custom_fields is preserved in the processed task
+        if (task.custom_fields) {
+            processedTask.custom_fields = task.custom_fields;
+        }
         return processedTask;
     });
     const result = await bulkService.createTasks(listId, tasks, parseBulkOptions(params.options));
@@ -288,7 +433,7 @@ export async function moveBulkTasksHandler(params) {
     }
     const targetListId = await getListId(params.targetListId, params.targetListName);
     const taskIds = await mapTaskIds(params.tasks);
-    const result = await bulkService.moveTasks(taskIds, targetListId, parseBulkOptions(params.options));
+    const result = await bulkService.moveTasks(taskIds.map(taskId => ({ taskId })), targetListId, parseBulkOptions(params.options));
     return result.successful;
 }
 /**

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, () => ({

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

@@ -61,7 +61,8 @@ Requirements:
 Notes:
 - For multiple tasks, use create_bulk_tasks instead
 - Reuse list IDs from previous responses when possible to avoid redundant lookups
-- To create a subtask, set the parent parameter to the ID of the parent task`,
+- To create a subtask, set the parent parameter to the ID of the parent task
+- Custom fields can be set using the custom_fields parameter (array of {id, value} objects)`,
     inputSchema: {
         type: "object",
         properties: {
@@ -97,6 +98,10 @@ Notes:
                 type: "string",
                 description: "Optional due date. Supports Unix timestamps (ms) or natural language like '1 hour from now', 'tomorrow', 'next week', etc."
             },
+            startDate: {
+                type: "string",
+                description: "Optional start date. Supports Unix timestamps (ms) or natural language like 'now', 'start of today', etc."
+            },
             parent: {
                 type: "string",
                 description: "Optional ID of the parent task. When specified, this task will be created as a subtask of the specified parent task."
@@ -107,6 +112,27 @@ Notes:
                     type: "string"
                 },
                 description: "Optional array of tag names to assign to the task. The tags must already exist in the space."
+            },
+            custom_fields: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        id: {
+                            type: "string",
+                            description: "ID of the custom field"
+                        },
+                        value: {
+                            description: "Value for the custom field. Type depends on the field type."
+                        }
+                    },
+                    required: ["id", "value"]
+                },
+                description: "Optional array of custom field values to set on the task. Each object must have an 'id' and 'value' property."
+            },
+            check_required_custom_fields: {
+                type: "boolean",
+                description: "Optional flag to check if all required custom fields are set before saving the task."
             }
         }
     }
@@ -128,7 +154,8 @@ Requirements:
 
 Notes:
 - Only specified fields will be updated
-- Using taskId is more reliable than taskName`,
+- Using taskId is more reliable than taskName
+- You can set custom field values using the custom_fields parameter (array of {id, value} objects)`,
     inputSchema: {
         type: "object",
         properties: {
@@ -168,9 +195,29 @@ Notes:
             dueDate: {
                 type: "string",
                 description: "New due date. Supports both Unix timestamps (in milliseconds) and natural language expressions like '1 hour from now', 'tomorrow', 'next week', or '3 days from now'."
+            },
+            startDate: {
+                type: "string",
+                description: "New start date. Supports both Unix timestamps (in milliseconds) and natural language expressions."
+            },
+            custom_fields: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        id: {
+                            type: "string",
+                            description: "ID of the custom field"
+                        },
+                        value: {
+                            description: "Value for the custom field. Type depends on the field type."
+                        }
+                    },
+                    required: ["id", "value"]
+                },
+                description: "Optional array of custom field values to set on the task. Each object must have an 'id' and 'value' property."
             }
-        },
-        required: []
+        }
     }
 };
 /**

package/build/tools/task/utilities.js

@@ -9,6 +9,7 @@
  */
 import { formatDueDate } from '../utils.js';
 import { clickUpServices } from '../../services/shared.js';
+import { findListIDByName } from '../../tools/list.js';
 // Use shared services instance for ID resolution
 const { workspace: workspaceService } = clickUpServices;
 //=============================================================================
@@ -39,7 +40,7 @@ export function formatTaskData(task, additional = {}) {
         parent: task.parent,
         priority: task.priority,
         due_date: task.due_date ? formatDueDate(Number(task.due_date)) : undefined,
-        start_date: task.start_date,
+        start_date: task.start_date ? formatDueDate(Number(task.start_date)) : undefined,
         time_estimate: task.time_estimate,
         time_spent: task.time_spent,
         custom_fields: task.custom_fields,
@@ -70,13 +71,15 @@ export function formatTaskData(task, additional = {}) {
 /**
  * Validates task identification parameters
  * Ensures either taskId, customTaskId, or both taskName and listName are provided
+ * When useGlobalLookup is true, allows taskName without listName
  */
-export function validateTaskIdentification(taskId, taskName, listName, customTaskId) {
+export function validateTaskIdentification(taskId, taskName, listName, customTaskId, useGlobalLookup = true) {
     if (!taskId && !taskName && !customTaskId) {
         throw new Error("Either taskId, customTaskId, or taskName must be provided");
     }
-    if (!taskId && !customTaskId && taskName && !listName) {
-        throw new Error("listName is required when using taskName");
+    // When global lookup is not enabled, we need list context for task name lookup
+    if (!useGlobalLookup && !taskId && !customTaskId && taskName && !listName) {
+        throw new Error("listName is required when using taskName and global lookup is disabled");
     }
 }
 /**
@@ -93,10 +96,25 @@ export function validateListIdentification(listId, listName) {
  * Ensures at least one update field is provided
  */
 export function validateTaskUpdateData(updateData) {
-    const hasUpdates = Object.keys(updateData).length > 0;
+    // Check if there are any valid update fields present
+    const hasUpdates = Object.keys(updateData).some(key => {
+        return ['name', 'description', 'markdown_description', 'status', 'priority',
+            'dueDate', 'startDate', 'taskId', 'taskName', 'custom_fields'].includes(key);
+    });
     if (!hasUpdates) {
         throw new Error("At least one field to update must be provided");
     }
+    // Validate custom_fields if provided
+    if (updateData.custom_fields) {
+        if (!Array.isArray(updateData.custom_fields)) {
+            throw new Error("custom_fields must be an array");
+        }
+        for (const field of updateData.custom_fields) {
+            if (!field.id || field.value === undefined) {
+                throw new Error("Each custom field must have both id and value properties");
+            }
+        }
+    }
 }
 /**
  * Validate bulk operation tasks array
@@ -142,69 +160,6 @@ export function isCustomTaskId(id) {
     const customIdPattern = /^[A-Z]+-\d+$/;
     return customIdPattern.test(id);
 }
-//=============================================================================
-// ID RESOLUTION UTILITIES
-//=============================================================================
-/**
- * Resolves a task ID from direct ID, custom ID, or name
- * Handles validation and throws appropriate errors
- */
-export async function resolveTaskIdWithValidation(taskId, taskName, listName, customTaskId) {
-    // Validate parameters
-    validateTaskIdentification(taskId, taskName, listName, customTaskId);
-    // If customTaskId is explicitly provided, use it
-    if (customTaskId) {
-        const { task: taskService } = clickUpServices;
-        try {
-            // First try to get the task by custom ID
-            // If listName is provided, we can also look up in a specific list for better performance
-            let listId;
-            if (listName) {
-                listId = await resolveListIdWithValidation(undefined, listName);
-            }
-            // Look up by custom ID
-            const foundTask = await taskService.getTaskByCustomId(customTaskId, listId);
-            return foundTask.id;
-        }
-        catch (error) {
-            throw new Error(`Task with custom ID "${customTaskId}" not found`);
-        }
-    }
-    // If taskId is provided, check if it looks like a custom ID
-    if (taskId) {
-        if (isCustomTaskId(taskId)) {
-            console.log(`Detected task ID "${taskId}" as a custom ID, using custom ID lookup`);
-            // If it looks like a custom ID, try to get it as a custom ID first
-            const { task: taskService } = clickUpServices;
-            try {
-                // Look up by custom ID
-                let listId;
-                if (listName) {
-                    listId = await resolveListIdWithValidation(undefined, listName);
-                }
-                const foundTask = await taskService.getTaskByCustomId(taskId, listId);
-                return foundTask.id;
-            }
-            catch (error) {
-                // If it fails as a custom ID, try as a regular ID
-                console.log(`Failed to find task with custom ID "${taskId}", falling back to regular ID`);
-                return taskId;
-            }
-        }
-        // Regular task ID
-        return taskId;
-    }
-    // At this point we know we have taskName and listName (validation ensures this)
-    // Find the list ID from its name
-    const listId = await resolveListIdWithValidation(undefined, listName);
-    // Find the task in the list
-    const { task: taskService } = clickUpServices;
-    const foundTask = await taskService.findTaskByName(listId, taskName);
-    if (!foundTask) {
-        throw new Error(`Task "${taskName}" not found in list "${listName}"`);
-    }
-    return foundTask.id;
-}
 /**
  * Resolves a list ID from either direct ID or name
  * Handles validation and throws appropriate errors
@@ -216,9 +171,7 @@ export async function resolveListIdWithValidation(listId, listName) {
     if (listId)
         return listId;
     // At this point we know we have listName (validation ensures this)
-    // Find the list ID from its name
-    const hierarchy = await workspaceService.getWorkspaceHierarchy();
-    const listInfo = workspaceService.findIDByNameInHierarchy(hierarchy, listName, 'list');
+    const listInfo = await findListIDByName(workspaceService, listName);
     if (!listInfo) {
         throw new Error(`List "${listName}" not found`);
     }

package/build/tools/utils.js

@@ -7,6 +7,6 @@
  * Re-exports specialized utilities from dedicated modules.
  */
 // Re-export date utilities
-export { getRelativeTimestamp, parseDueDate, formatDueDate } from '../utils/date-utils.js';
+export { getRelativeTimestamp, parseDueDate, formatDueDate, formatRelativeTime } from '../utils/date-utils.js';
 // Re-export resolver utilities
-export { resolveListId, resolveTaskId } from '../utils/resolver-utils.js';
+export { resolveListId } from '../utils/resolver-utils.js';