@taazkareem/clickup-mcp-server 0.6.2 → 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.2",
+  "version": "0.6.3",
   "description": "ClickUp MCP Server - Integrate ClickUp tasks with AI through Model Context Protocol",
   "type": "module",
   "main": "build/index.js",

package/build/mcp-tools.js

@@ -1,64 +0,0 @@
-import { Logger } from "./logger.js";
-// Create a logger instance
-const logger = new Logger('MCPTools');
-/**
- * Register a handler for a tool that may receive JSON string parameters
- * This wrapper ensures that array and object parameters are properly parsed
- *
- * @param server MCP Server instance
- * @param name Tool name
- * @param handler Handler function
- */
-export function registerToolHandler(server, name, handler) {
-    // Create a wrapper handler that pre-processes parameters
-    const wrappedHandler = async (params) => {
-        logger.debug(`Processing parameters for tool ${name}`, { params });
-        try {
-            // Process the parameters before passing them to the actual handler
-            const processedParams = {};
-            // Process each parameter - try to parse strings that might be JSON
-            for (const [key, value] of Object.entries(params)) {
-                if (typeof value === 'string') {
-                    try {
-                        // Check if this might be a JSON array or object
-                        if ((value.startsWith('[') && value.endsWith(']')) ||
-                            (value.startsWith('{') && value.endsWith('}'))) {
-                            try {
-                                processedParams[key] = JSON.parse(value);
-                                logger.debug(`Parsed JSON parameter: ${key}`, { original: value, parsed: processedParams[key] });
-                            }
-                            catch (parseError) {
-                                // If parsing fails, use the original string
-                                processedParams[key] = value;
-                                logger.debug(`Failed to parse JSON for parameter: ${key}, using original`, { error: parseError.message });
-                            }
-                        }
-                        else {
-                            processedParams[key] = value;
-                        }
-                    }
-                    catch (error) {
-                        // If there's any error, use the original value
-                        processedParams[key] = value;
-                        logger.debug(`Error processing parameter: ${key}`, { error: error.message });
-                    }
-                }
-                else {
-                    // Non-string values are used as-is
-                    processedParams[key] = value;
-                }
-            }
-            logger.debug(`Processed parameters for tool ${name}`, { processedParams });
-            // Call the original handler with processed parameters
-            return handler(processedParams);
-        }
-        catch (error) {
-            logger.error(`Error in wrapped handler for tool ${name}:`, { error: error.stack || error.message });
-            throw error;
-        }
-    };
-    // Use setRequestHandler to register the wrapped handler
-    logger.info(`Registering wrapped handler for tool: ${name}`);
-    // Override the tool's handler in the CallTool switch statement
-    // The server.ts file will use the switch case to call this handler
-}

package/build/server-state.js

@@ -1,93 +0,0 @@
-/**
- * Server State Management Module
- *
- * This module provides shared state management for the MCP server,
- * particularly for controlling shutdown behavior and tracking busy states.
- */
-// State variables
-let serverBusyState = false; // Tracks if server is doing critical work
-let gracePeriodActive = false; // Tracks if we're in post-initialization grace period
-let gracePeriodTimer = null;
-export const GRACE_PERIOD_MS = 10000; // 10 second grace period after startup
-/**
- * Logging helper that avoids circular dependency
- */
-function safeLog(level, message, data) {
-    // Use console as a fallback to avoid circular dependency with logger
-    const timestamp = new Date().toISOString();
-    if (level === 'error') {
-        console.error(`[${timestamp}] ${level.toUpperCase()}: ${message}`, data || '');
-    }
-    else if (level === 'debug' && process.env.DEBUG) {
-        console.debug(`[${timestamp}] ${level.toUpperCase()}: ${message}`, data || '');
-    }
-    else if (level !== 'debug') {
-        console.log(`[${timestamp}] ${level.toUpperCase()}: ${message}`, data || '');
-    }
-}
-/**
- * Set the server as busy doing critical work that shouldn't be interrupted
- * @param busy Whether the server is currently busy with critical operations
- */
-export function setServerBusy(busy) {
-    serverBusyState = busy;
-    safeLog('debug', `Server busy state set to: ${busy}`);
-}
-/**
- * Start grace period after initialization to prevent immediate shutdown
- */
-export function startGracePeriod() {
-    gracePeriodActive = true;
-    safeLog('debug', `Starting ${GRACE_PERIOD_MS}ms grace period to prevent premature shutdown`);
-    if (gracePeriodTimer) {
-        clearTimeout(gracePeriodTimer);
-    }
-    gracePeriodTimer = setTimeout(() => {
-        gracePeriodActive = false;
-        safeLog('debug', 'Grace period ended, server will now respond to shutdown signals');
-        gracePeriodTimer = null;
-    }, GRACE_PERIOD_MS);
-}
-/**
- * Cancel the grace period if needed
- */
-export function cancelGracePeriod() {
-    if (gracePeriodTimer) {
-        clearTimeout(gracePeriodTimer);
-        gracePeriodTimer = null;
-    }
-    gracePeriodActive = false;
-    safeLog('debug', 'Grace period canceled, server will now respond to shutdown signals');
-}
-/**
- * Check if the server should ignore shutdown signals
- * @returns true if shutdown signals should be ignored
- */
-export function shouldIgnoreShutdown() {
-    // Ignore shutdown if explicitly configured via environment variable
-    if (process.env.FORCE_KEEP_ALIVE === 'true') {
-        return true;
-    }
-    // Ignore shutdown during the grace period after startup
-    if (gracePeriodActive) {
-        return true;
-    }
-    // Ignore shutdown if the server is doing critical work
-    if (serverBusyState) {
-        return true;
-    }
-    // Otherwise, allow normal shutdown
-    return false;
-}
-/**
- * Check if grace period is currently active
- */
-export function isGracePeriodActive() {
-    return gracePeriodActive;
-}
-/**
- * Check if server is currently in busy state
- */
-export function isServerBusy() {
-    return serverBusyState;
-}