@taazkareem/clickup-mcp-server 0.6.1 → 0.6.3

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");
-}

package/build/utils/sponsor-service.js

@@ -59,7 +59,7 @@ export class SponsorService {
         if (this.isEnabled && includeSponsorMessage) {
             content.push({
                 type: "text",
-                text: `⎯ Support this project by sponsoring the developer at ${this.sponsorUrl}`
+                text: `♥ Support this project by sponsoring the developer at ${this.sponsorUrl}`
             });
         }
         return { content };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taazkareem/clickup-mcp-server",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "ClickUp MCP Server - Integrate ClickUp tasks with AI through Model Context Protocol",
   "type": "module",
   "main": "build/index.js",