@taazkareem/clickup-mcp-server 0.6.4 → 0.6.6

package/build/tools/task/handlers.js

@@ -12,10 +12,40 @@ import { clickUpServices } from '../../services/shared.js';
 import { BulkService } from '../../services/clickup/bulk.js';
 import { parseDueDate } from '../utils.js';
 import { validateTaskIdentification, validateListIdentification, validateTaskUpdateData, validateBulkTasks, parseBulkOptions, resolveListIdWithValidation } from './utilities.js';
+import { workspaceService } from '../../services/shared.js';
+import { isNameMatch } from '../../utils/resolver-utils.js';
+import { Logger } from '../../logger.js';
 // Use shared services instance
 const { task: taskService, list: listService } = clickUpServices;
 // Create a bulk service instance that uses the task service
 const bulkService = new BulkService(taskService);
+// Create a logger instance for task handlers
+const logger = new Logger('TaskHandlers');
+// Cache for task context between sequential operations
+const taskContextCache = new Map();
+const TASK_CONTEXT_TTL = 5 * 60 * 1000; // 5 minutes
+/**
+ * Store task context for sequential operations
+ */
+function storeTaskContext(taskName, taskId) {
+    taskContextCache.set(taskName, {
+        id: taskId,
+        timestamp: Date.now()
+    });
+}
+/**
+ * Get cached task context if valid
+ */
+function getCachedTaskContext(taskName) {
+    const context = taskContextCache.get(taskName);
+    if (!context)
+        return null;
+    if (Date.now() - context.timestamp > TASK_CONTEXT_TTL) {
+        taskContextCache.delete(taskName);
+        return null;
+    }
+    return context.id;
+}
 //=============================================================================
 // SHARED UTILITY FUNCTIONS
 //=============================================================================
@@ -50,31 +80,212 @@ function buildUpdateData(params) {
     return updateData;
 }
 /**
- * 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
+ * Core function to find a task by ID or name
+ * This consolidates all task lookup logic in one place for consistency
+ */
+async function findTask(params) {
+    const { taskId, taskName, listName, customTaskId, requireId = false, includeSubtasks = false } = params;
+    // Validate that we have enough information to identify a task
+    const validationResult = validateTaskIdentification({ taskId, taskName, listName, customTaskId }, { requireTaskId: requireId, useGlobalLookup: true });
+    if (!validationResult.isValid) {
+        throw new Error(validationResult.errorMessage);
+    }
+    try {
+        // Direct path for taskId - most efficient
+        if (taskId) {
+            const task = await taskService.getTask(taskId);
+            // Add subtasks if requested
+            if (includeSubtasks) {
+                const subtasks = await taskService.getSubtasks(task.id);
+                return { task, subtasks };
+            }
+            return { task };
+        }
+        // Direct path for customTaskId - also efficient
+        if (customTaskId) {
+            const task = await taskService.getTaskByCustomId(customTaskId);
+            // Add subtasks if requested
+            if (includeSubtasks) {
+                const subtasks = await taskService.getSubtasks(task.id);
+                return { task, subtasks };
+            }
+            return { task };
+        }
+        // Special optimized path for taskName + listName combination
+        if (taskName && listName) {
+            const listId = await resolveListIdWithValidation(null, listName);
+            // Get all tasks in the list
+            const allTasks = await taskService.getTasks(listId);
+            // Find the task that matches the name
+            const matchingTask = findTaskByName(allTasks, taskName);
+            if (!matchingTask) {
+                throw new Error(`Task "${taskName}" not found in list "${listName}"`);
+            }
+            // Add subtasks if requested
+            if (includeSubtasks) {
+                const subtasks = await taskService.getSubtasks(matchingTask.id);
+                return { task: matchingTask, subtasks };
+            }
+            return { task: matchingTask };
+        }
+        // Fallback to searching all lists for taskName-only case
+        if (taskName) {
+            logger.debug(`Searching all lists for task: "${taskName}"`);
+            // Get workspace hierarchy which contains all lists
+            const hierarchy = await workspaceService.getWorkspaceHierarchy();
+            // Extract all list IDs from the hierarchy
+            const listIds = [];
+            const extractListIds = (node) => {
+                if (node.type === 'list') {
+                    listIds.push(node.id);
+                }
+                if (node.children) {
+                    node.children.forEach(extractListIds);
+                }
+            };
+            // Start from the root's children
+            hierarchy.root.children.forEach(extractListIds);
+            // Search through each list
+            const searchPromises = listIds.map(async (listId) => {
+                try {
+                    const tasks = await taskService.getTasks(listId);
+                    const matchingTask = findTaskByName(tasks, taskName);
+                    if (matchingTask) {
+                        logger.debug(`Found task "${matchingTask.name}" (ID: ${matchingTask.id}) in list with ID "${listId}"`);
+                        return matchingTask;
+                    }
+                    return null;
+                }
+                catch (error) {
+                    logger.warn(`Error searching list ${listId}: ${error.message}`);
+                    return null;
+                }
+            });
+            // Wait for all searches to complete
+            const results = await Promise.all(searchPromises);
+            // Filter out null results and sort by match quality and recency
+            const matchingTasks = results
+                .filter(task => task !== null)
+                .sort((a, b) => {
+                const aMatch = isNameMatch(a.name, taskName);
+                const bMatch = isNameMatch(b.name, taskName);
+                // First sort by match quality
+                if (bMatch.score !== aMatch.score) {
+                    return bMatch.score - aMatch.score;
+                }
+                // Then sort by recency
+                return parseInt(b.date_updated) - parseInt(a.date_updated);
+            });
+            if (matchingTasks.length === 0) {
+                throw new Error(`Task "${taskName}" not found in any list across your workspace. Please check the task name and try again.`);
+            }
+            const bestMatch = matchingTasks[0];
+            // Add subtasks if requested
+            if (includeSubtasks) {
+                const subtasks = await taskService.getSubtasks(bestMatch.id);
+                return { task: bestMatch, subtasks };
+            }
+            return { task: bestMatch };
+        }
+        // We shouldn't reach here if validation is working correctly
+        throw new Error("No valid task identification provided");
+    }
+    catch (error) {
+        // Enhance error message for non-existent tasks
+        if (taskName && error.message.includes('not found')) {
+            throw new Error(`Task "${taskName}" not found. Please check the task name and try again.`);
+        }
+        // Pass along other formatted errors
+        throw error;
+    }
+}
+/**
+ * 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;
+    const normalizedSearchName = name.toLowerCase().trim();
+    // Get match scores for all tasks
+    const taskMatchScores = tasks.map(task => {
+        const matchResult = isNameMatch(task.name, name);
+        return {
+            task,
+            matchResult,
+            // Parse the date_updated field as a number for sorting
+            updatedAt: task.date_updated ? parseInt(task.date_updated, 10) : 0
+        };
+    }).filter(result => result.matchResult.isMatch);
+    if (taskMatchScores.length === 0) {
+        return null;
+    }
+    // First, try to find exact matches
+    const exactMatches = taskMatchScores
+        .filter(result => result.matchResult.exactMatch)
+        .sort((a, b) => {
+        // For exact matches with the same score, sort by most recently updated
+        if (b.matchResult.score === a.matchResult.score) {
+            return b.updatedAt - a.updatedAt;
+        }
+        return b.matchResult.score - a.matchResult.score;
+    });
+    // Get the best matches based on whether we have exact matches or need to fall back to fuzzy matches
+    const bestMatches = exactMatches.length > 0 ? exactMatches : taskMatchScores.sort((a, b) => {
+        // First sort by match score (highest first)
+        if (b.matchResult.score !== a.matchResult.score) {
+            return b.matchResult.score - a.matchResult.score;
+        }
+        // Then sort by most recently updated
+        return b.updatedAt - a.updatedAt;
+    });
+    // Get the best match
+    return bestMatches[0].task;
+}
+/**
+ * Handler for getting a task - uses the consolidated findTask function
+ */
+export async function getTaskHandler(params) {
+    try {
+        const result = await findTask({
+            taskId: params.taskId,
+            taskName: params.taskName,
+            listName: params.listName,
+            customTaskId: params.customTaskId,
+            includeSubtasks: params.subtasks
+        });
+        if (result.subtasks) {
+            return { ...result.task, subtasks: result.subtasks };
+        }
+        return result.task;
+    }
+    catch (error) {
+        throw error;
+    }
+}
+/**
+ * Get task ID from various identifiers - uses the consolidated findTask function
  */
-export async function getTaskId(taskId, taskName, listName, customTaskId) {
-    validateTaskIdentification(taskId, taskName, listName, customTaskId, true);
-    const result = await taskService.findTasks({
+export async function getTaskId(taskId, taskName, listName, customTaskId, requireId, includeSubtasks) {
+    // Check task context cache first if we have a task name
+    if (taskName && !taskId && !customTaskId) {
+        const cachedId = getCachedTaskContext(taskName);
+        if (cachedId) {
+            return cachedId;
+        }
+    }
+    const result = await findTask({
         taskId,
-        customTaskId,
         taskName,
         listName,
-        allowMultipleMatches: false,
-        useSmartDisambiguation: true,
-        includeFullDetails: false,
-        includeListContext: false
+        customTaskId,
+        requireId,
+        includeSubtasks
     });
-    if (result && !Array.isArray(result)) {
-        return result.id;
+    // Store task context for future operations
+    if (taskName && result.task.id) {
+        storeTaskContext(taskName, result.task.id);
     }
-    throw new Error("Task not found");
+    return result.task.id;
 }
 /**
  * Process a list identification validation, returning the list ID
@@ -107,7 +318,10 @@ function buildTaskFilters(params) {
  */
 async function mapTaskIds(tasks) {
     return Promise.all(tasks.map(async (task) => {
-        validateTaskIdentification(task.taskId, task.taskName, task.listName, task.customTaskId);
+        const validationResult = validateTaskIdentification({ taskId: task.taskId, taskName: task.taskName, listName: task.listName, customTaskId: task.customTaskId }, { useGlobalLookup: true });
+        if (!validationResult.isValid) {
+            throw new Error(validationResult.errorMessage);
+        }
         return await getTaskId(task.taskId, task.taskName, task.listName, task.customTaskId);
     }));
 }
@@ -150,20 +364,29 @@ export async function createTaskHandler(params) {
 /**
  * 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);
-    const updateData = buildUpdateData(params);
-    console.log('Update Task Handler - Update data:', JSON.stringify(updateData));
-    return await taskService.updateTask(taskId, updateData);
+export async function updateTaskHandler(taskService, params) {
+    const { taskId, taskName, listName, customTaskId, ...updateData } = params;
+    // Validate task identification with global lookup enabled
+    const validationResult = validateTaskIdentification(params, { useGlobalLookup: true });
+    if (!validationResult.isValid) {
+        throw new Error(validationResult.errorMessage);
+    }
+    // Validate update data
+    validateTaskUpdateData(updateData);
+    try {
+        // Get the task ID using global lookup
+        const id = await getTaskId(taskId, taskName, listName, customTaskId);
+        return await taskService.updateTask(id, updateData);
+    }
+    catch (error) {
+        throw new Error(`Failed to update task: ${error instanceof Error ? error.message : String(error)}`);
+    }
 }
 /**
  * Handler for moving a task
  */
 export async function moveTaskHandler(params) {
-    const taskId = await getTaskId(params.taskId, params.taskName, params.listName);
+    const taskId = await getTaskId(params.taskId, params.taskName, undefined, params.customTaskId, false);
     const listId = await getListId(params.listId, params.listName);
     return await taskService.moveTask(taskId, listId);
 }
@@ -171,119 +394,13 @@ export async function moveTaskHandler(params) {
  * Handler for duplicating a task
  */
 export async function duplicateTaskHandler(params) {
-    const taskId = await getTaskId(params.taskId, params.taskName, params.listName);
+    const taskId = await getTaskId(params.taskId, params.taskName, undefined, params.customTaskId, false);
     let listId;
     if (params.listId || params.listName) {
         listId = await getListId(params.listId, params.listName);
     }
     return await taskService.duplicateTask(taskId, listId);
 }
-/**
- * Handler for getting a task
- */
-export async function getTaskHandler(params) {
-    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;
-    }
-}
-/**
- * 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
  */

package/build/tools/task/main.js

@@ -13,7 +13,7 @@ import { createTaskTool, getTaskTool, getTasksTool, updateTaskTool, moveTaskTool
 import { createBulkTasksTool, updateBulkTasksTool, moveBulkTasksTool, deleteBulkTasksTool } from './bulk-operations.js';
 import { getWorkspaceTasksTool } from './workspace-operations.js';
 // Import handlers
-import { createTaskHandler, getTaskHandler, getTasksHandler, updateTaskHandler, moveTaskHandler, duplicateTaskHandler, deleteTaskHandler, getTaskCommentsHandler, createTaskCommentHandler, createBulkTasksHandler, updateBulkTasksHandler, moveBulkTasksHandler, deleteBulkTasksHandler, getWorkspaceTasksHandler } from './handlers.js';
+import { createTaskHandler, getTaskHandler, getTasksHandler, updateTaskHandler, moveTaskHandler, duplicateTaskHandler, deleteTaskHandler, getTaskCommentsHandler, createTaskCommentHandler, createBulkTasksHandler, updateBulkTasksHandler, moveBulkTasksHandler, deleteBulkTasksHandler, getWorkspaceTasksHandler, formatTaskData } from './index.js';
 // Import shared services
 import { clickUpServices } from '../../services/shared.js';
 const { task: taskService } = clickUpServices;
@@ -43,42 +43,18 @@ export const handleGetTasks = createHandlerWrapper(getTasksHandler, (tasks) => (
     tasks,
     count: tasks.length
 }));
-export const handleUpdateTask = async (parameters) => {
+/**
+ * Handle task update operation
+ */
+export async function handleUpdateTask(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);
+        const result = await updateTaskHandler(taskService, parameters);
+        return sponsorService.createResponse(formatTaskData(result), true);
     }
     catch (error) {
-        return sponsorService.createErrorResponse(error, parameters);
+        return sponsorService.createErrorResponse(error instanceof Error ? error.message : String(error));
     }
-};
+}
 export const handleMoveTask = createHandlerWrapper(moveTaskHandler);
 export const handleDuplicateTask = createHandlerWrapper(duplicateTaskHandler);
 export const handleDeleteTask = createHandlerWrapper(deleteTaskHandler, () => ({

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

@@ -329,15 +329,17 @@ export const getTaskTool = {
 
 Valid Usage:
 1. Use taskId alone (preferred) - works with both regular and custom IDs (like "DEV-1234")
-2. Use taskName + listName
-3. Use customTaskId for explicit custom ID lookup
+2. Use taskName alone (will search across all lists in the workspace)
+3. Use taskName + listName (for faster, targeted search)
+4. Use customTaskId for explicit custom ID lookup
 
 Requirements:
-- When using taskName, listName is REQUIRED
-- When using customTaskId, listName is recommended for faster lookup
+- EITHER taskId OR taskName OR customTaskId: REQUIRED
+- listName: Optional, but recommended when using taskName for faster and more precise lookup
 
 Note:
-- Task names are only unique within a list, so the system needs to know which list to search in
+- When using just taskName, the system performs a global search across all lists
+- Task names are most unique within a specific list, so providing listName increases reliability
 - Regular task IDs are always 9 characters long (e.g., "86b394eqa")
 - Custom IDs have an uppercase prefix followed by a hyphen and number (e.g., "DEV-1234")
 - Set subtasks=true to include all subtasks in the response`,
@@ -350,11 +352,11 @@ Note:
             },
             taskName: {
                 type: "string",
-                description: "Name of task to retrieve. When using this parameter, you MUST also provide listName."
+                description: "Name of task to retrieve. Can be used alone for a global search, or with listName for faster lookup."
             },
             listName: {
                 type: "string",
-                description: "Name of list containing the task. REQUIRED when using taskName."
+                description: "Name of list containing the task. Optional but recommended when using taskName."
             },
             customTaskId: {
                 type: "string",

package/build/tools/task/utilities.js

@@ -11,7 +11,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;
+const { workspace: workspaceService, task: taskService } = clickUpServices;
 //=============================================================================
 // DATA FORMATTING UTILITIES
 //=============================================================================
@@ -65,22 +65,38 @@ export function formatTaskData(task, additional = {}) {
         ...additional
     };
 }
-//=============================================================================
-// VALIDATION UTILITIES
-//=============================================================================
 /**
  * Validates task identification parameters
- * Ensures either taskId, customTaskId, or both taskName and listName are provided
- * When useGlobalLookup is true, allows taskName without listName
+ *
+ * @param params - Task identification parameters
+ * @param options - Validation options
+ * @returns Validation result with error message if any
  */
-export function validateTaskIdentification(taskId, taskName, listName, customTaskId, useGlobalLookup = true) {
+export function validateTaskIdentification(params, options = {}) {
+    const { taskId, taskName, customTaskId, listName } = params;
+    const { requireTaskId = false, useGlobalLookup = true } = options;
+    // If taskId is required, it must be provided
+    if (requireTaskId && !taskId) {
+        return {
+            isValid: false,
+            errorMessage: 'Task ID is required for this operation'
+        };
+    }
+    // At least one identification method must be provided
     if (!taskId && !taskName && !customTaskId) {
-        throw new Error("Either taskId, customTaskId, or taskName must be provided");
+        return {
+            isValid: false,
+            errorMessage: 'Either taskId, taskName, or customTaskId must be provided to identify the task'
+        };
     }
-    // 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");
+    // When using taskName without global lookup, listName is required
+    if (taskName && !taskId && !customTaskId && !useGlobalLookup && !listName) {
+        return {
+            isValid: false,
+            errorMessage: 'When identifying a task by name, you must also provide the listName parameter'
+        };
     }
+    return { isValid: true };
 }
 /**
  * Validates list identification parameters
@@ -99,7 +115,7 @@ export function validateTaskUpdateData(updateData) {
     // 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);
+            'dueDate', 'startDate', 'custom_fields'].includes(key);
     });
     if (!hasUpdates) {
         throw new Error("At least one field to update must be provided");
@@ -231,3 +247,34 @@ export function extractTreePath(root, targetId) {
     // Not found in this branch
     return [];
 }
+/**
+ * Get task ID from various identification methods
+ */
+export async function getTaskId(taskId, taskName, listName, customTaskId, requireId = false) {
+    // Validate task identification
+    const validationResult = validateTaskIdentification({ taskId, taskName, listName, customTaskId }, { requireTaskId: requireId, useGlobalLookup: true });
+    if (!validationResult.isValid) {
+        throw new Error(validationResult.errorMessage);
+    }
+    try {
+        const result = await taskService.findTasks({
+            taskId,
+            customTaskId,
+            taskName,
+            listName,
+            allowMultipleMatches: false,
+            useSmartDisambiguation: true,
+            includeFullDetails: false
+        });
+        if (!result || Array.isArray(result)) {
+            throw new Error(`Task not found with the provided identification`);
+        }
+        return result.id;
+    }
+    catch (error) {
+        if (error.message.includes('Multiple tasks found')) {
+            throw new Error(`Multiple tasks found with name "${taskName}". Please provide list name to disambiguate.`);
+        }
+        throw error;
+    }
+}