@taazkareem/clickup-mcp-server 0.4.67 → 0.4.69

package/build/server.log

@@ -0,0 +1,154 @@
+[2025-03-18T02:45:47.590Z] [PID:17869] INFO: [SharedServices] Creating shared ClickUp services singleton
+[2025-03-18T02:45:47.592Z] [PID:17869] INFO: [ClickUpServices] Starting ClickUp services initialization
+{
+  "teamId": "9014370478",
+  "baseUrl": "https://api.clickup.com/api/v2"
+}
+[2025-03-18T02:45:47.592Z] [PID:17869] INFO: [ClickUpServices] Initializing ClickUp Workspace service
+[2025-03-18T02:45:47.593Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Initialized WorkspaceService
+{
+  "teamId": "9014370478",
+  "baseUrl": "https://api.clickup.com/api/v2"
+}
+[2025-03-18T02:45:47.593Z] [PID:17869] INFO: [ClickUpServices] Initializing ClickUp Task service
+[2025-03-18T02:45:47.594Z] [PID:17869] DEBUG: [ClickUp:TaskService] Initialized TaskService
+{
+  "teamId": "9014370478",
+  "baseUrl": "https://api.clickup.com/api/v2"
+}
+[2025-03-18T02:45:47.594Z] [PID:17869] DEBUG: [ClickUp:ListService] Initialized ListService
+{
+  "teamId": "9014370478",
+  "baseUrl": "https://api.clickup.com/api/v2"
+}
+[2025-03-18T02:45:47.594Z] [PID:17869] INFO: [ClickUpServices] Initializing ClickUp List service
+[2025-03-18T02:45:47.595Z] [PID:17869] DEBUG: [ClickUp:ListService] Initialized ListService
+{
+  "teamId": "9014370478",
+  "baseUrl": "https://api.clickup.com/api/v2"
+}
+[2025-03-18T02:45:47.595Z] [PID:17869] INFO: [ClickUpServices] Initializing ClickUp Folder service
+[2025-03-18T02:45:47.595Z] [PID:17869] DEBUG: [ClickUp:FolderService] Initialized FolderService
+{
+  "teamId": "9014370478",
+  "baseUrl": "https://api.clickup.com/api/v2"
+}
+[2025-03-18T02:45:47.595Z] [PID:17869] INFO: [ClickUpServices] All ClickUp services initialized successfully
+{
+  "services": [
+    "workspace",
+    "task",
+    "list",
+    "folder"
+  ],
+  "baseUrl": "https://api.clickup.com/api/v2"
+}
+[2025-03-18T02:45:47.595Z] [PID:17869] INFO: [SharedServices] Services initialization complete
+{
+  "services": "workspace, task, list, folder",
+  "teamId": "9014370478"
+}
+[2025-03-18T02:45:47.596Z] [PID:17869] INFO: Starting ClickUp MCP Server...
+[2025-03-18T02:45:48.175Z] [PID:17869] INFO: Server environment
+{
+  "pid": 17869,
+  "node": "v23.5.0",
+  "os": "darwin",
+  "arch": "x64"
+}
+[2025-03-18T02:45:48.176Z] [PID:17869] INFO: Initializing workspace tools
+[2025-03-18T02:45:48.176Z] [PID:17869] INFO: [WorkspaceTool] Initializing workspace tool
+[2025-03-18T02:45:48.176Z] [PID:17869] INFO: [WorkspaceTool] Workspace tool initialized successfully
+{
+  "serviceType": "WorkspaceService"
+}
+[2025-03-18T02:45:48.176Z] [PID:17869] INFO: Configuring server request handlers
+[2025-03-18T02:45:48.176Z] [PID:17869] INFO: [Server] Registering server request handlers
+[2025-03-18T02:45:48.176Z] [PID:17869] INFO: [Server] Registering tool handlers
+{
+  "toolCount": 22,
+  "categories": [
+    "workspace",
+    "task",
+    "list",
+    "folder"
+  ]
+}
+[2025-03-18T02:45:48.176Z] [PID:17869] INFO: Connecting to MCP stdio transport
+[2025-03-18T02:45:48.177Z] [PID:17869] INFO: Server startup complete - ready to handle requests
+[2025-03-18T02:45:48.908Z] [PID:17869] DEBUG: [Server] Received ListTools request
+[2025-03-18T02:45:55.731Z] [PID:17869] INFO: [Server] Received CallTool request for tool: update_task_batch
+{
+  "params": {
+    "task1_name": "📌 Now With Added Emoji",
+    "task1_list": "clickup-mcp-server",
+    "task1_status": "in progress",
+    "task2_id": "86b4a5d5h",
+    "task2_status": "in progress"
+  }
+}
+[2025-03-18T02:45:56.405Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Request completed successfully in 673ms
+[2025-03-18T02:45:56.778Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Request completed successfully in 373ms
+[2025-03-18T02:45:57.131Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Request completed successfully in 351ms
+[2025-03-18T02:45:57.697Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Request completed successfully in 566ms
+[2025-03-18T02:45:57.697Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Found 2 folderless lists in space 90141365861
+[2025-03-18T02:45:57.697Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Adding 2 lists directly to space Talib's Space (90141365861)
+[2025-03-18T02:45:57.697Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Adding list directly to space: Personal List (901403617613)
+[2025-03-18T02:45:57.697Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Adding list directly to space: Work List (901403621899)
+[2025-03-18T02:45:58.083Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Request completed successfully in 385ms
+[2025-03-18T02:45:58.517Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Request completed successfully in 433ms
+[2025-03-18T02:45:58.916Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Request completed successfully in 398ms
+[2025-03-18T02:45:58.917Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Found 0 folderless lists in space 90141864154
+[2025-03-18T02:45:58.918Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Adding 0 lists directly to space Education (90141864154)
+[2025-03-18T02:45:59.264Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Request completed successfully in 345ms
+[2025-03-18T02:45:59.672Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Request completed successfully in 408ms
+[2025-03-18T02:45:59.672Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Found 1 folderless lists in space 90141369187
+[2025-03-18T02:45:59.672Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Adding 1 lists directly to space Social Media Content (90141369187)
+[2025-03-18T02:45:59.672Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Adding list directly to space: VibeCase (901403679582)
+[2025-03-18T02:46:00.159Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Request completed successfully in 487ms
+[2025-03-18T02:46:00.564Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Request completed successfully in 405ms
+[2025-03-18T02:46:01.094Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Request completed successfully in 530ms
+[2025-03-18T02:46:01.691Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Request completed successfully in 597ms
+[2025-03-18T02:46:02.048Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Request completed successfully in 357ms
+[2025-03-18T02:46:02.510Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Request completed successfully in 461ms
+[2025-03-18T02:46:02.891Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Request completed successfully in 381ms
+[2025-03-18T02:46:03.412Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Request completed successfully in 521ms
+[2025-03-18T02:46:03.933Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Request completed successfully in 521ms
+[2025-03-18T02:46:04.456Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Request completed successfully in 523ms
+[2025-03-18T02:46:04.456Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Found 8 folderless lists in space 90141392755
+[2025-03-18T02:46:04.456Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Adding 8 lists directly to space Custom Space (90141392755)
+[2025-03-18T02:46:04.456Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Adding list directly to space: Job Applications (901404823810)
+[2025-03-18T02:46:04.456Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Adding list directly to space: Prompts | Snippets | Commands (901407112060)
+[2025-03-18T02:46:04.456Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Adding list directly to space: Style Scraper (901408105509)
+[2025-03-18T02:46:04.456Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Adding list directly to space: goal-tracker (901408127809)
+[2025-03-18T02:46:04.456Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Adding list directly to space: Cursor Rules MCP Server (901408134949)
+[2025-03-18T02:46:04.456Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Adding list directly to space: cursor-rules-mcp-server (901408144363)
+[2025-03-18T02:46:04.456Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Adding list directly to space: Items to Sell Online (901404691843)
+[2025-03-18T02:46:04.456Z] [PID:17869] DEBUG: [ClickUp:WorkspaceService] Adding list directly to space: clickup-mcp-server (901408020907)
+[2025-03-18T02:46:04.457Z] [PID:17869] INFO: [ClickUp:TaskService] Operation: findTaskByName
+{
+  "listId": "901407953112",
+  "taskName": "📌 Now With Added Emoji"
+}
+[2025-03-18T02:46:04.457Z] [PID:17869] INFO: [ClickUp:TaskService] Operation: getTasks
+{
+  "listId": "901407953112",
+  "filters": {}
+}
+[2025-03-18T02:46:05.091Z] [PID:17869] DEBUG: [ClickUp:TaskService] Request completed successfully in 634ms
+[2025-03-18T02:46:05.091Z] [PID:17869] INFO: [ClickUp:TaskService] Operation: updateTask
+{
+  "taskId": "86b48gafv",
+  "status": "in progress"
+}
+[2025-03-18T02:46:05.924Z] [PID:17869] DEBUG: [ClickUp:TaskService] Request completed successfully in 832ms
+[2025-03-18T02:46:05.924Z] [PID:17869] INFO: [ClickUp:TaskService] Operation: updateTask
+{
+  "taskId": "86b4a5d5h",
+  "status": "in progress"
+}
+[2025-03-18T02:46:06.505Z] [PID:17869] DEBUG: [ClickUp:TaskService] Request completed successfully in 581ms
+[2025-03-18T02:48:53.078Z] [PID:17869] INFO: [Server] Received CallTool request for tool: get_workspace_hierarchy
+{
+  "params": {}
+}

package/build/services/clickup/base.js

@@ -8,6 +8,7 @@
  * - Common request methods
  */
 import axios from 'axios';
+import { Logger, LogLevel } from '../../logger.js';
 /**
  * Error types for better error handling
  */
@@ -56,6 +57,9 @@ export class BaseClickUpService {
         this.apiKey = apiKey;
         this.teamId = teamId;
         this.requestSpacing = this.defaultRequestSpacing;
+        // Create a logger with the actual class name for better context
+        const className = this.constructor.name;
+        this.logger = new Logger(`ClickUp:${className}`);
         // Configure the Axios client with default settings
         this.client = axios.create({
             baseURL: baseUrl,
@@ -65,6 +69,7 @@ export class BaseClickUpService {
             },
             timeout: this.timeout
         });
+        this.logger.debug(`Initialized ${className}`, { teamId, baseUrl });
         // Add response interceptor for error handling
         this.client.interceptors.response.use(response => response, error => this.handleAxiosError(error));
     }
@@ -75,88 +80,89 @@ export class BaseClickUpService {
      * @returns Never - always throws an error
      */
     handleAxiosError(error) {
-        let message = 'Unknown error occurred';
-        let code = ErrorCode.UNKNOWN;
-        let details = null;
-        let status = undefined;
-        if (error.response) {
-            // Server responded with an error status code
-            status = error.response.status;
-            details = error.response.data;
-            switch (status) {
-                case 401:
-                    message = 'Unauthorized: Invalid API key';
-                    code = ErrorCode.UNAUTHORIZED;
-                    break;
-                case 403:
-                    message = 'Forbidden: Insufficient permissions';
-                    code = ErrorCode.UNAUTHORIZED;
-                    break;
-                case 404:
-                    message = 'Resource not found';
-                    code = ErrorCode.NOT_FOUND;
-                    break;
-                case 429:
-                    message = 'Rate limit exceeded';
-                    code = ErrorCode.RATE_LIMIT;
-                    break;
-                case 400:
-                    message = 'Invalid request: ' + (error.response.data?.err || 'Validation error');
-                    code = ErrorCode.VALIDATION;
-                    break;
-                case 500:
-                case 502:
-                case 503:
-                case 504:
-                    message = 'ClickUp server error';
-                    code = ErrorCode.SERVER_ERROR;
-                    break;
-                default:
-                    message = `ClickUp API error (${status}): ${error.response.data?.err || 'Unknown error'}`;
-            }
+        // Determine error details
+        const status = error.response?.status;
+        const responseData = error.response?.data;
+        const errorMsg = responseData?.err || responseData?.error || error.message || 'Unknown API error';
+        const path = error.config?.url || 'unknown path';
+        // Context object for providing more detailed log information
+        const errorContext = {
+            path,
+            status,
+            method: error.config?.method?.toUpperCase() || 'UNKNOWN',
+            requestData: error.config?.data ? JSON.parse(error.config.data) : undefined
+        };
+        // Pick the appropriate error code based on status
+        let code;
+        let logMessage;
+        if (error.code === 'ECONNABORTED' || error.message?.includes('timeout')) {
+            code = ErrorCode.NETWORK_ERROR;
+            logMessage = `Request timeout for ${path}`;
         }
-        else if (error.request) {
-            // Request was made but no response received
-            message = 'Network error: No response received from ClickUp';
+        else if (!error.response) {
             code = ErrorCode.NETWORK_ERROR;
-            details = { request: error.request };
+            logMessage = `Network error accessing ${path}: ${error.message}`;
+        }
+        else if (status === 429) {
+            code = ErrorCode.RATE_LIMIT;
+            this.handleRateLimitHeaders(error.response.headers);
+            logMessage = `Rate limit exceeded for ${path}`;
+        }
+        else if (status === 401 || status === 403) {
+            code = ErrorCode.UNAUTHORIZED;
+            logMessage = `Authorization failed for ${path}`;
+        }
+        else if (status === 404) {
+            code = ErrorCode.NOT_FOUND;
+            logMessage = `Resource not found: ${path}`;
+        }
+        else if (status >= 400 && status < 500) {
+            code = ErrorCode.VALIDATION;
+            logMessage = `Validation error for ${path}: ${errorMsg}`;
+        }
+        else if (status >= 500) {
+            code = ErrorCode.SERVER_ERROR;
+            logMessage = `ClickUp server error: ${errorMsg}`;
         }
         else {
-            // Error setting up the request
-            message = `Request setup error: ${error.message}`;
-            details = { message: error.message };
+            code = ErrorCode.UNKNOWN;
+            logMessage = `Unknown API error: ${errorMsg}`;
         }
-        throw new ClickUpServiceError(message, code, details, status);
+        // Log the error with context
+        this.logger.error(logMessage, errorContext);
+        // Throw a well-structured error
+        throw new ClickUpServiceError(errorMsg, code, responseData, status, errorContext);
     }
     /**
      * Process the request queue, respecting rate limits by spacing out requests
      * @private
      */
     async processQueue() {
-        if (this.processingQueue || this.requestQueue.length === 0) {
+        if (this.requestQueue.length === 0) {
+            this.logger.debug('Queue empty, exiting queue processing mode');
+            this.processingQueue = false;
             return;
         }
-        this.processingQueue = true;
+        this.logger.debug(`Processing request queue (${this.requestQueue.length} items)`);
+        const startTime = Date.now();
         try {
-            while (this.requestQueue.length > 0) {
-                const request = this.requestQueue.shift();
-                if (request) {
-                    try {
-                        await request();
-                    }
-                    catch (error) {
-                        console.error('Request failed:', error);
-                        // Continue processing queue even if one request fails
-                    }
-                    // Space out requests to stay within rate limit
-                    if (this.requestQueue.length > 0) {
-                        await new Promise(resolve => setTimeout(resolve, this.requestSpacing));
-                    }
-                }
+            // Take the first request from the queue
+            const request = this.requestQueue.shift();
+            if (request) {
+                // Wait for the request spacing interval
+                await new Promise(resolve => setTimeout(resolve, this.requestSpacing));
+                // Run the request
+                await request();
             }
         }
+        catch (error) {
+            this.logger.error('Error executing queued request', error);
+        }
         finally {
-            this.processingQueue = false;
+            const duration = Date.now() - startTime;
+            this.logger.trace(`Queue item processed in ${duration}ms, ${this.requestQueue.length} items remaining`);
+            // Continue processing the queue after a short delay
+            setTimeout(() => this.processQueue(), this.requestSpacing);
         }
     }
     /**
@@ -165,21 +171,38 @@ export class BaseClickUpService {
      * @param headers Response headers from ClickUp
      */
     handleRateLimitHeaders(headers) {
-        const limit = parseInt(headers['x-ratelimit-limit'], 10);
-        const remaining = parseInt(headers['x-ratelimit-remaining'], 10);
-        const reset = parseInt(headers['x-ratelimit-reset'], 10);
-        if (!isNaN(reset)) {
-            this.lastRateLimitReset = reset;
-        }
-        // If we're running low on remaining requests, increase spacing
-        if (!isNaN(remaining) && remaining < 10) {
-            const timeUntilReset = (this.lastRateLimitReset * 1000) - Date.now();
-            if (timeUntilReset > 0) {
-                this.requestSpacing = Math.max(this.defaultRequestSpacing, Math.floor(timeUntilReset / remaining));
+        try {
+            // Parse the rate limit headers
+            const limit = headers['x-ratelimit-limit'];
+            const remaining = headers['x-ratelimit-remaining'];
+            const reset = headers['x-ratelimit-reset'];
+            // Only log if we're getting close to the limit
+            if (remaining < limit * 0.2) {
+                this.logger.warn('Approaching rate limit', { remaining, limit, reset });
+            }
+            else {
+                this.logger.debug('Rate limit status', { remaining, limit, reset });
+            }
+            if (reset) {
+                this.lastRateLimitReset = reset;
+                // If reset is in the future, calculate a safe request spacing
+                const now = Date.now();
+                const resetTime = reset * 1000; // convert to milliseconds
+                const timeToReset = Math.max(0, resetTime - now);
+                if (timeToReset > 0 && remaining > 0) {
+                    // Calculate time between requests to stay under limit
+                    // Add 10% buffer to be safe
+                    const safeSpacing = Math.ceil((timeToReset / remaining) * 1.1);
+                    // Only adjust if it's greater than our current spacing
+                    if (safeSpacing > this.requestSpacing) {
+                        this.logger.debug(`Adjusting request spacing: ${this.requestSpacing}ms → ${safeSpacing}ms`);
+                        this.requestSpacing = safeSpacing;
+                    }
+                }
             }
         }
-        else {
-            this.requestSpacing = this.defaultRequestSpacing; // Reset to default spacing
+        catch (error) {
+            this.logger.warn('Failed to parse rate limit headers', error);
         }
     }
     /**
@@ -189,41 +212,59 @@ export class BaseClickUpService {
      * @returns Promise that resolves with the result of the API request
      */
     async makeRequest(fn) {
-        return new Promise((resolve, reject) => {
-            this.requestQueue.push(async () => {
-                try {
-                    const result = await fn();
-                    // Handle rate limit headers if present
-                    if (result && typeof result === 'object' && 'headers' in result) {
-                        this.handleRateLimitHeaders(result.headers);
+        // If we're being rate limited, queue the request rather than executing immediately
+        if (this.processingQueue) {
+            this.logger.debug('Queue active, adding request to queue');
+            return new Promise((resolve, reject) => {
+                this.requestQueue.push(async () => {
+                    try {
+                        const result = await fn();
+                        resolve(result);
+                    }
+                    catch (error) {
+                        reject(error);
                     }
-                    resolve(result);
+                });
+            });
+        }
+        const startTime = Date.now();
+        try {
+            // Execute the request function
+            const result = await fn();
+            // Debug log for successful requests with timing information
+            const duration = Date.now() - startTime;
+            this.logger.debug(`Request completed successfully in ${duration}ms`);
+            return result;
+        }
+        catch (error) {
+            // If we hit a rate limit, start processing the queue
+            if (error instanceof ClickUpServiceError && error.code === ErrorCode.RATE_LIMIT) {
+                this.logger.warn('Rate limit reached, switching to queue mode', {
+                    reset: this.lastRateLimitReset,
+                    queueLength: this.requestQueue.length
+                });
+                if (!this.processingQueue) {
+                    this.processingQueue = true;
+                    this.processQueue().catch(err => {
+                        this.logger.error('Error processing request queue', err);
+                    });
                 }
-                catch (error) {
-                    if (axios.isAxiosError(error) && error.response?.status === 429) {
-                        const retryAfter = parseInt(error.response.headers['retry-after'] || '60', 10);
-                        const resetTime = parseInt(error.response.headers['x-ratelimit-reset'] || '0', 10);
-                        // Use the more precise reset time if available
-                        const waitTime = resetTime > 0 ?
-                            (resetTime * 1000) - Date.now() :
-                            retryAfter * 1000;
-                        await new Promise(resolve => setTimeout(resolve, waitTime));
+                // Queue this failed request and return a promise that will resolve when it's retried
+                return new Promise((resolve, reject) => {
+                    this.requestQueue.push(async () => {
                         try {
-                            // Retry the request once after waiting
                             const result = await fn();
                             resolve(result);
                         }
                         catch (retryError) {
                             reject(retryError);
                         }
-                    }
-                    else {
-                        reject(error);
-                    }
-                }
-            });
-            this.processQueue().catch(reject);
-        });
+                    });
+                });
+            }
+            // For other errors, just throw
+            throw error;
+        }
     }
     /**
      * Gets the ClickUp team ID associated with this service instance
@@ -239,6 +280,18 @@ export class BaseClickUpService {
      * @param details - Details about the operation
      */
     logOperation(operation, details) {
-        console.log(`[${new Date().toISOString()}] ${operation}:`, details);
+        this.logger.info(`Operation: ${operation}`, details);
+    }
+    /**
+     * Log detailed information about a request (path and payload)
+     * For trace level logging only
+     */
+    traceRequest(method, url, data) {
+        if (this.logger.isLevelEnabled(LogLevel.TRACE)) {
+            this.logger.trace(`${method} ${url}`, {
+                payload: data,
+                teamId: this.teamId
+            });
+        }
     }
 }

package/build/services/clickup/index.js

@@ -18,6 +18,9 @@ import { WorkspaceService } from './workspace.js';
 import { TaskService } from './task.js';
 import { ListService } from './list.js';
 import { FolderService } from './folder.js';
+import { Logger } from '../../logger.js';
+// Singleton logger for ClickUp services
+const logger = new Logger('ClickUpServices');
 /**
  * Factory function to create instances of all ClickUp services
  * @param config Configuration for the services
@@ -25,12 +28,31 @@ import { FolderService } from './folder.js';
  */
 export function createClickUpServices(config) {
     const { apiKey, teamId, baseUrl } = config;
-    // Create the workspace service
+    // Log start of overall initialization
+    logger.info('Starting ClickUp services initialization', {
+        teamId,
+        baseUrl: baseUrl || 'https://api.clickup.com/api/v2'
+    });
+    // Create workspace service first since others depend on it
+    logger.info('Initializing ClickUp Workspace service');
     const workspaceService = new WorkspaceService(apiKey, teamId, baseUrl);
-    return {
+    // Initialize remaining services with workspace dependency
+    logger.info('Initializing ClickUp Task service');
+    const taskService = new TaskService(apiKey, teamId, baseUrl, workspaceService);
+    logger.info('Initializing ClickUp List service');
+    const listService = new ListService(apiKey, teamId, baseUrl, workspaceService);
+    logger.info('Initializing ClickUp Folder service');
+    const folderService = new FolderService(apiKey, teamId, baseUrl, workspaceService);
+    const services = {
         workspace: workspaceService,
-        task: new TaskService(apiKey, teamId, baseUrl, workspaceService),
-        list: new ListService(apiKey, teamId, baseUrl, workspaceService),
-        folder: new FolderService(apiKey, teamId, baseUrl, workspaceService)
+        task: taskService,
+        list: listService,
+        folder: folderService
     };
+    // Log successful completion
+    logger.info('All ClickUp services initialized successfully', {
+        services: Object.keys(services),
+        baseUrl: baseUrl || 'https://api.clickup.com/api/v2'
+    });
+    return services;
 }

package/build/services/clickup/task.js

@@ -158,7 +158,7 @@ export class TaskService extends BaseClickUpService {
         }
     }
     /**
-     * Find a task by its name in a specific list
+     * Find a task by name within a list
      * @param listId The list ID to search within
      * @param taskName The name of the task to find
      * @returns The task if found, otherwise null
@@ -167,7 +167,26 @@ export class TaskService extends BaseClickUpService {
         this.logOperation('findTaskByName', { listId, taskName });
         try {
             const tasks = await this.getTasks(listId);
-            const matchingTask = tasks.find(task => task.name.toLowerCase() === taskName.toLowerCase());
+            // Normalize the search term
+            const normalizedSearchTerm = taskName.toLowerCase().trim();
+            // First try exact match
+            let matchingTask = tasks.find(task => task.name.toLowerCase().trim() === normalizedSearchTerm);
+            // If no exact match, try substring match
+            if (!matchingTask) {
+                matchingTask = tasks.find(task => task.name.toLowerCase().trim().includes(normalizedSearchTerm) ||
+                    normalizedSearchTerm.includes(task.name.toLowerCase().trim()));
+            }
+            // If still no match and there are emoji characters, try matching without emoji
+            if (!matchingTask && /[\p{Emoji}]/u.test(normalizedSearchTerm)) {
+                // Remove emoji and try again (simple approximation)
+                const withoutEmoji = normalizedSearchTerm.replace(/[\p{Emoji}]/gu, '').trim();
+                matchingTask = tasks.find(task => {
+                    const taskNameWithoutEmoji = task.name.toLowerCase().replace(/[\p{Emoji}]/gu, '').trim();
+                    return taskNameWithoutEmoji === withoutEmoji ||
+                        taskNameWithoutEmoji.includes(withoutEmoji) ||
+                        withoutEmoji.includes(taskNameWithoutEmoji);
+                });
+            }
             return matchingTask || null;
         }
         catch (error) {
@@ -489,4 +508,29 @@ export class TaskService extends BaseClickUpService {
             throw new ClickUpServiceError(`Failed to delete tasks in bulk: ${error.message}`, ErrorCode.UNKNOWN, error);
         }
     }
+    /**
+     * Get comments for a specific task
+     * @param taskId The ID of the task to retrieve comments for
+     * @param start Optional parameter for pagination, timestamp from which to start fetching comments
+     * @param startId Optional parameter for pagination, comment ID from which to start fetching
+     * @returns Array of task comments
+     */
+    async getTaskComments(taskId, start, startId) {
+        this.logOperation('getTaskComments', { taskId, start, startId });
+        try {
+            return await this.makeRequest(async () => {
+                const params = new URLSearchParams();
+                // Add pagination parameters if provided
+                if (start)
+                    params.append('start', String(start));
+                if (startId)
+                    params.append('start_id', startId);
+                const response = await this.client.get(`/task/${taskId}/comment`, { params });
+                return response.data.comments;
+            });
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to retrieve comments for task ${taskId}`);
+        }
+    }
 }