@taazkareem/clickup-mcp-server 0.6.2 → 0.6.4

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

package/build/tools/task/utilities.js

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

package/build/utils/date-utils.js

@@ -30,6 +30,31 @@ export function getRelativeTimestamp(minutes = 0, hours = 0, days = 0, weeks = 0
         now.setMonth(now.getMonth() + months);
     return now.getTime();
 }
+/**
+ * Get the start of today (midnight) in Unix milliseconds
+ * @returns Timestamp in milliseconds for start of current day
+ */
+export function getStartOfDay() {
+    const now = new Date();
+    now.setHours(0, 0, 0, 0);
+    return now.getTime();
+}
+/**
+ * Get the end of today (23:59:59.999) in Unix milliseconds
+ * @returns Timestamp in milliseconds for end of current day
+ */
+export function getEndOfDay() {
+    const now = new Date();
+    now.setHours(23, 59, 59, 999);
+    return now.getTime();
+}
+/**
+ * Get the current time in Unix milliseconds
+ * @returns Current timestamp in milliseconds
+ */
+export function getCurrentTimestamp() {
+    return new Date().getTime();
+}
 /**
  * Parse a due date string into a timestamp
  * Supports ISO 8601 format or natural language like "tomorrow"
@@ -42,15 +67,36 @@ export function parseDueDate(dateString) {
         return undefined;
     try {
         // Handle natural language dates
-        const lowerDate = dateString.toLowerCase();
-        const now = new Date();
+        const lowerDate = dateString.toLowerCase().trim();
+        // Handle "now" specifically
+        if (lowerDate === 'now') {
+            return getCurrentTimestamp();
+        }
+        // Handle "today" with different options
         if (lowerDate === 'today') {
-            const today = new Date();
-            today.setHours(23, 59, 59, 999);
-            return today.getTime();
+            return getEndOfDay();
+        }
+        if (lowerDate === 'today start' || lowerDate === 'start of today') {
+            return getStartOfDay();
+        }
+        if (lowerDate === 'today end' || lowerDate === 'end of today') {
+            return getEndOfDay();
+        }
+        // Handle "yesterday" and "tomorrow"
+        if (lowerDate === 'yesterday') {
+            const yesterday = new Date();
+            yesterday.setDate(yesterday.getDate() - 1);
+            yesterday.setHours(23, 59, 59, 999);
+            return yesterday.getTime();
+        }
+        if (lowerDate === 'tomorrow') {
+            const tomorrow = new Date();
+            tomorrow.setDate(tomorrow.getDate() + 1);
+            tomorrow.setHours(23, 59, 59, 999);
+            return tomorrow.getTime();
         }
         // Handle relative dates with specific times
-        const relativeTimeRegex = /(?:(\d+)\s*(minutes?|days?|weeks?|months?)\s*from\s*now|tomorrow|next\s+(?:week|month))\s*(?:at\s+(\d+)(?::(\d+))?\s*(am|pm)?)?/i;
+        const relativeTimeRegex = /(?:(\d+)\s*(minutes?|hours?|days?|weeks?|months?)\s*from\s*now|tomorrow|next\s+(?:week|month|year))\s*(?:at\s+(\d+)(?::(\d+))?\s*(am|pm)?)?/i;
         const match = lowerDate.match(relativeTimeRegex);
         if (match) {
             const date = new Date();
@@ -61,6 +107,9 @@ export function parseDueDate(dateString) {
                 if (unit.startsWith('minute')) {
                     date.setMinutes(date.getMinutes() + value);
                 }
+                else if (unit.startsWith('hour')) {
+                    date.setHours(date.getHours() + value);
+                }
                 else if (unit.startsWith('day')) {
                     date.setDate(date.getDate() + value);
                 }
@@ -80,6 +129,9 @@ export function parseDueDate(dateString) {
             else if (lowerDate.includes('next month')) {
                 date.setMonth(date.getMonth() + 1);
             }
+            else if (lowerDate.includes('next year')) {
+                date.setFullYear(date.getFullYear() + 1);
+            }
             // Set the time if specified
             if (hours) {
                 let parsedHours = parseInt(hours);
@@ -97,31 +149,44 @@ export function parseDueDate(dateString) {
             }
             return date.getTime();
         }
-        // Handle hours from now
-        const minutesRegex = /(\d+)\s*minutes?\s*from\s*now/i;
-        const hoursRegex = /(\d+)\s*hours?\s*from\s*now/i;
-        const daysRegex = /(\d+)\s*days?\s*from\s*now/i;
-        const weeksRegex = /(\d+)\s*weeks?\s*from\s*now/i;
-        const monthsRegex = /(\d+)\s*months?\s*from\s*now/i;
-        if (minutesRegex.test(lowerDate)) {
-            const minutes = parseInt(lowerDate.match(minutesRegex)[1]);
-            return getRelativeTimestamp(minutes);
-        }
-        if (hoursRegex.test(lowerDate)) {
-            const hours = parseInt(lowerDate.match(hoursRegex)[1]);
-            return getRelativeTimestamp(0, hours);
-        }
-        if (daysRegex.test(lowerDate)) {
-            const days = parseInt(lowerDate.match(daysRegex)[1]);
-            return getRelativeTimestamp(0, 0, days);
-        }
-        if (weeksRegex.test(lowerDate)) {
-            const weeks = parseInt(lowerDate.match(weeksRegex)[1]);
-            return getRelativeTimestamp(0, 0, 0, weeks);
+        // Handle various relative formats
+        const relativeFormats = [
+            { regex: /(\d+)\s*minutes?\s*from\s*now/i, handler: (m) => getRelativeTimestamp(m) },
+            { regex: /(\d+)\s*hours?\s*from\s*now/i, handler: (h) => getRelativeTimestamp(0, h) },
+            { regex: /(\d+)\s*days?\s*from\s*now/i, handler: (d) => getRelativeTimestamp(0, 0, d) },
+            { regex: /(\d+)\s*weeks?\s*from\s*now/i, handler: (w) => getRelativeTimestamp(0, 0, 0, w) },
+            { regex: /(\d+)\s*months?\s*from\s*now/i, handler: (m) => getRelativeTimestamp(0, 0, 0, 0, m) }
+        ];
+        for (const format of relativeFormats) {
+            if (format.regex.test(lowerDate)) {
+                const value = parseInt(lowerDate.match(format.regex)[1]);
+                return format.handler(value);
+            }
         }
-        if (monthsRegex.test(lowerDate)) {
-            const months = parseInt(lowerDate.match(monthsRegex)[1]);
-            return getRelativeTimestamp(0, 0, 0, 0, months);
+        // Handle specific date formats
+        // Format: MM/DD/YYYY
+        const usDateRegex = /^(\d{1,2})\/(\d{1,2})\/(\d{4})(?:\s+(\d{1,2})(?::(\d{1,2}))?(?:\s+(am|pm))?)?$/i;
+        const usDateMatch = lowerDate.match(usDateRegex);
+        if (usDateMatch) {
+            const [_, month, day, year, hours, minutes, meridian] = usDateMatch;
+            const date = new Date(parseInt(year), parseInt(month) - 1, // JS months are 0-indexed
+            parseInt(day));
+            // Add time if specified
+            if (hours) {
+                let parsedHours = parseInt(hours);
+                const parsedMinutes = minutes ? parseInt(minutes) : 0;
+                // Convert to 24-hour format if meridian is specified
+                if (meridian?.toLowerCase() === 'pm' && parsedHours < 12)
+                    parsedHours += 12;
+                if (meridian?.toLowerCase() === 'am' && parsedHours === 12)
+                    parsedHours = 0;
+                date.setHours(parsedHours, parsedMinutes, 0, 0);
+            }
+            else {
+                // Default to end of day if no time specified
+                date.setHours(23, 59, 59, 999);
+            }
+            return date.getTime();
         }
         // Try to parse as a date string
         const date = new Date(dateString);
@@ -164,3 +229,57 @@ export function formatDueDate(timestamp) {
         return undefined;
     }
 }
+/**
+ * Checks if a timestamp is for today
+ *
+ * @param timestamp Unix timestamp in milliseconds
+ * @returns Boolean indicating if the timestamp is for today
+ */
+export function isToday(timestamp) {
+    const date = new Date(timestamp);
+    const today = new Date();
+    return date.getDate() === today.getDate() &&
+        date.getMonth() === today.getMonth() &&
+        date.getFullYear() === today.getFullYear();
+}
+/**
+ * Get timestamp range for today (start to end)
+ *
+ * @returns Object with start and end timestamps for today
+ */
+export function getTodayRange() {
+    return {
+        start: getStartOfDay(),
+        end: getEndOfDay()
+    };
+}
+/**
+ * Format a date for display in errors and messages
+ * @param timestamp The timestamp to format
+ * @returns A human-readable relative time (e.g., "2 hours ago")
+ */
+export function formatRelativeTime(timestamp) {
+    if (!timestamp)
+        return 'Unknown';
+    const timestampNum = typeof timestamp === 'string' ? parseInt(timestamp, 10) : timestamp;
+    const now = Date.now();
+    const diffMs = now - timestampNum;
+    // Convert to appropriate time unit
+    const diffSec = Math.floor(diffMs / 1000);
+    if (diffSec < 60)
+        return `${diffSec} seconds ago`;
+    const diffMin = Math.floor(diffSec / 60);
+    if (diffMin < 60)
+        return `${diffMin} minutes ago`;
+    const diffHour = Math.floor(diffMin / 60);
+    if (diffHour < 24)
+        return `${diffHour} hours ago`;
+    const diffDays = Math.floor(diffHour / 24);
+    if (diffDays < 30)
+        return `${diffDays} days ago`;
+    const diffMonths = Math.floor(diffDays / 30);
+    if (diffMonths < 12)
+        return `${diffMonths} months ago`;
+    const diffYears = Math.floor(diffMonths / 12);
+    return `${diffYears} years ago`;
+}

package/build/utils/resolver-utils.js

@@ -9,13 +9,40 @@
 import { clickUpServices } from '../services/shared.js';
 import { findListIDByName } from '../tools/list.js';
 /**
- * Resolve a list ID from either a direct ID or list name
+ * Check if a task name matches search criteria
  *
- * @param listId Optional direct list ID
- * @param listName Optional list name to resolve
- * @param workspaceService Workspace service to use for lookup
- * @returns Resolved list ID
- * @throws Error if neither listId nor listName is provided, or if list name can't be resolved
+ * Performs flexible case-insensitive and emoji-aware text matching
+ * Used by multiple components for consistent name matching behavior
+ */
+export function isNameMatch(taskName, searchTerm) {
+    const normalizedTask = taskName.toLowerCase().trim();
+    const normalizedSearch = searchTerm.toLowerCase().trim();
+    // Handle empty strings - don't match empty task names
+    if (normalizedTask === '')
+        return false;
+    if (normalizedSearch === '')
+        return false;
+    // Exact match check
+    if (normalizedTask === normalizedSearch)
+        return true;
+    // Substring match check
+    if (normalizedTask.includes(normalizedSearch) || normalizedSearch.includes(normalizedTask))
+        return true;
+    // Handle emoji characters in names
+    if (/[\p{Emoji}]/u.test(normalizedSearch) || /[\p{Emoji}]/u.test(normalizedTask)) {
+        const taskWithoutEmoji = normalizedTask.replace(/[\p{Emoji}]/gu, '').trim();
+        const searchWithoutEmoji = normalizedSearch.replace(/[\p{Emoji}]/gu, '').trim();
+        // Don't match if either becomes empty after emoji removal
+        if (taskWithoutEmoji === '' || searchWithoutEmoji === '')
+            return false;
+        return taskWithoutEmoji === searchWithoutEmoji ||
+            taskWithoutEmoji.includes(searchWithoutEmoji) ||
+            searchWithoutEmoji.includes(taskWithoutEmoji);
+    }
+    return false;
+}
+/**
+ * Resolve a list ID from either a direct ID or list name
  */
 export async function resolveListId(listId, listName, workspaceService = clickUpServices.workspace) {
     // If list ID is directly provided, use it
@@ -33,37 +60,3 @@ export async function resolveListId(listId, listName, workspaceService = clickUp
     // If neither is provided, throw an error
     throw new Error("Either listId or listName must be provided");
 }
-/**
- * Resolve a task ID from either a direct ID or task name + list info
- *
- * @param taskId Optional direct task ID
- * @param taskName Optional task name to resolve
- * @param listId Optional list ID for task lookup
- * @param listName Optional list name for task lookup
- * @param taskService Task service to use for lookup
- * @returns Resolved task ID
- * @throws Error if parameters are insufficient or task can't be found
- */
-export async function resolveTaskId(taskId, taskName, listId, listName, taskService = clickUpServices.task) {
-    // If task ID is directly provided, use it
-    if (taskId) {
-        return taskId;
-    }
-    // If task name is provided, we need list info to find it
-    if (taskName) {
-        // We need either listId or listName to find a task by name
-        if (!listId && !listName) {
-            throw new Error(`List name or ID is required when using task name for task "${taskName}"`);
-        }
-        // Get list ID
-        const targetListId = await resolveListId(listId, listName);
-        // Find the task in the list
-        const foundTask = await taskService.findTaskByName(targetListId, taskName);
-        if (!foundTask) {
-            throw new Error(`Task "${taskName}" not found in list`);
-        }
-        return foundTask.id;
-    }
-    // If neither is provided, throw an error
-    throw new Error("Either taskId or taskName must be provided");
-}