@taazkareem/clickup-mcp-server 0.8.4 → 0.9.0

package/build/services/clickup/task/task-comments.js

@@ -7,12 +7,20 @@
  * Handles comment operations for ClickUp tasks, including:
  * - Retrieving comments for a task
  * - Creating comments on a task
+ *
+ * REFACTORED: Now uses composition instead of inheritance.
+ * Only depends on TaskServiceCore for base functionality.
  */
-import { TaskServiceAttachments } from './task-attachments.js';
 /**
  * Comments functionality for the TaskService
+ *
+ * This service handles all comment-related operations for ClickUp tasks.
+ * It uses composition to access core functionality instead of inheritance.
  */
-export class TaskServiceComments extends TaskServiceAttachments {
+export class TaskServiceComments {
+    constructor(core) {
+        this.core = core;
+    }
     /**
      * Get all comments for a task
      *
@@ -22,7 +30,7 @@ export class TaskServiceComments extends TaskServiceAttachments {
      * @returns Array of task comments
      */
     async getTaskComments(taskId, start, startId) {
-        this.logOperation('getTaskComments', { taskId, start, startId });
+        this.core.logOperation('getTaskComments', { taskId, start, startId });
         try {
             // Build query parameters for pagination
             const queryParams = new URLSearchParams();
@@ -33,11 +41,13 @@ export class TaskServiceComments extends TaskServiceAttachments {
                 queryParams.append('start_id', startId);
             }
             const queryString = queryParams.toString() ? `?${queryParams.toString()}` : '';
-            const response = await this.client.get(`/task/${taskId}/comment${queryString}`);
-            return response.data.comments || [];
+            return await this.core.makeRequest(async () => {
+                const response = await this.core.client.get(`/task/${taskId}/comment${queryString}`);
+                return response.data.comments || [];
+            });
         }
         catch (error) {
-            throw this.handleError(error, 'Failed to get task comments');
+            throw this.core.handleError(error, 'Failed to get task comments');
         }
     }
     /**
@@ -50,7 +60,7 @@ export class TaskServiceComments extends TaskServiceAttachments {
      * @returns The created comment
      */
     async createTaskComment(taskId, commentText, notifyAll = false, assignee) {
-        this.logOperation('createTaskComment', { taskId, commentText, notifyAll, assignee });
+        this.core.logOperation('createTaskComment', { taskId, commentText, notifyAll, assignee });
         try {
             const payload = {
                 comment_text: commentText,
@@ -60,7 +70,7 @@ export class TaskServiceComments extends TaskServiceAttachments {
                 payload.assignee = assignee;
             }
             // Make the request directly without using makeRequest for better error handling
-            const response = await this.client.post(`/task/${taskId}/comment`, payload);
+            const response = await this.core.client.post(`/task/${taskId}/comment`, payload);
             // Handle different response formats from ClickUp API
             if (response.data) {
                 if (response.data.comment) {
@@ -98,7 +108,7 @@ export class TaskServiceComments extends TaskServiceAttachments {
                     resolved: false
                 };
             }
-            throw this.handleError(error, 'Failed to create task comment');
+            throw this.core.handleError(error, 'Failed to create task comment');
         }
     }
 }

package/build/services/clickup/task/task-core.js

@@ -179,11 +179,29 @@ export class TaskServiceCore extends BaseClickUpService {
     }
     /**
      * Get a task by its ID
-     * @param taskId The ID of the task to retrieve
+     * Automatically detects custom task IDs and routes them appropriately
+     * @param taskId The ID of the task to retrieve (regular or custom)
      * @returns The task
      */
     async getTask(taskId) {
         this.logOperation('getTask', { taskId });
+        // Import the detection function here to avoid circular dependencies
+        const { isCustomTaskId } = await import('../../../tools/task/utilities.js');
+        // Test the detection function
+        const isCustom = isCustomTaskId(taskId);
+        this.logger.debug('Custom task ID detection result', {
+            taskId,
+            isCustom,
+            taskIdLength: taskId.length,
+            containsHyphen: taskId.includes('-'),
+            containsUnderscore: taskId.includes('_')
+        });
+        // Automatically detect custom task IDs and route to appropriate method
+        if (isCustom) {
+            this.logger.debug('Detected custom task ID, routing to getTaskByCustomId', { taskId });
+            return this.getTaskByCustomId(taskId);
+        }
+        this.logger.debug('Detected regular task ID, using standard getTask flow', { taskId });
         try {
             return await this.makeRequest(async () => {
                 const response = await this.client.get(`/task/${taskId}`);
@@ -196,6 +214,14 @@ export class TaskServiceCore extends BaseClickUpService {
             });
         }
         catch (error) {
+            // If this was detected as a regular task ID but failed, provide helpful error message
+            // suggesting it might be a custom ID that wasn't properly detected
+            if (error instanceof ClickUpServiceError && error.code === ErrorCode.NOT_FOUND) {
+                const { isCustomTaskId } = await import('../../../tools/task/utilities.js');
+                if (!isCustomTaskId(taskId) && (taskId.includes('-') || taskId.includes('_'))) {
+                    throw new ClickUpServiceError(`Task ${taskId} not found. If this is a custom task ID, ensure your workspace has custom task IDs enabled and you have access to the task.`, ErrorCode.NOT_FOUND, error.data);
+                }
+            }
             throw this.handleError(error, `Failed to get task ${taskId}`);
         }
     }
@@ -259,6 +285,14 @@ export class TaskServiceCore extends BaseClickUpService {
                     custom_task_ids: 'true',
                     team_id: this.teamId // team_id is required when custom_task_ids is true
                 });
+                // Debug logging for troubleshooting
+                this.logger.debug('Making custom task ID API request', {
+                    customTaskId,
+                    url,
+                    teamId: this.teamId,
+                    params: params.toString(),
+                    fullUrl: `${url}?${params.toString()}`
+                });
                 // Note: The ClickUp API documentation for GET /task/{task_id} doesn't explicitly mention
                 // filtering by list_id when custom_task_ids=true. This parameter might be ignored.
                 if (listId) {
@@ -276,6 +310,13 @@ export class TaskServiceCore extends BaseClickUpService {
             });
         }
         catch (error) {
+            // Enhanced error logging for debugging
+            this.logger.error('Custom task ID request failed', {
+                customTaskId,
+                teamId: this.teamId,
+                error: error instanceof Error ? error.message : String(error),
+                errorDetails: error
+            });
             // Provide more specific error context if possible
             if (error instanceof ClickUpServiceError && error.code === ErrorCode.NOT_FOUND) {
                 throw new ClickUpServiceError(`Task with custom ID ${customTaskId} not found or not accessible for team ${this.teamId}.`, ErrorCode.NOT_FOUND, error.data);
@@ -292,11 +333,34 @@ export class TaskServiceCore extends BaseClickUpService {
     async updateTask(taskId, updateData) {
         this.logOperation('updateTask', { taskId, ...updateData });
         try {
-            // Extract custom fields from updateData
-            const { custom_fields, ...standardFields } = updateData;
+            // Extract custom fields and assignees from updateData
+            const { custom_fields, assignees, ...standardFields } = updateData;
+            // Prepare the fields to send to API
+            let fieldsToSend = { ...standardFields };
+            // Handle assignees separately if provided
+            if (assignees !== undefined) {
+                // Get current task to compare assignees
+                const currentTask = await this.getTask(taskId);
+                const currentAssigneeIds = currentTask.assignees.map(a => a.id);
+                let assigneesToProcess;
+                if (Array.isArray(assignees)) {
+                    // If assignees is an array, calculate add/rem based on current vs new
+                    const newAssigneeIds = assignees;
+                    assigneesToProcess = {
+                        add: newAssigneeIds.filter(id => !currentAssigneeIds.includes(id)),
+                        rem: currentAssigneeIds.filter(id => !newAssigneeIds.includes(id))
+                    };
+                }
+                else {
+                    // If assignees is already in add/rem format, use it directly
+                    assigneesToProcess = assignees;
+                }
+                // Add assignees to the fields in the correct format
+                fieldsToSend.assignees = assigneesToProcess;
+            }
             // First update the standard fields
             const updatedTask = await this.makeRequest(async () => {
-                const response = await this.client.put(`/task/${taskId}`, standardFields);
+                const response = await this.client.put(`/task/${taskId}`, fieldsToSend);
                 // Handle both JSON and text responses
                 const data = response.data;
                 if (typeof data === 'string') {

package/build/services/clickup/task/task-custom-fields.js

@@ -7,12 +7,20 @@
  * Handles custom fields operations for ClickUp tasks, including:
  * - Setting custom field values
  * - Retrieving custom field values
+ *
+ * REFACTORED: Now uses composition instead of inheritance.
+ * Only depends on TaskServiceCore for getTask() and base functionality.
  */
-import { TaskServiceTags } from './task-tags.js';
 /**
  * Custom fields functionality for the TaskService
+ *
+ * This service handles all custom field operations for ClickUp tasks.
+ * It uses composition to access core functionality instead of inheritance.
  */
-export class TaskServiceCustomFields extends TaskServiceTags {
+export class TaskServiceCustomFields {
+    constructor(core) {
+        this.core = core;
+    }
     /**
      * Set a single custom field value on a task
      *
@@ -22,16 +30,18 @@ export class TaskServiceCustomFields extends TaskServiceTags {
      * @returns Success response
      */
     async setCustomFieldValue(taskId, fieldId, value) {
-        this.logOperation('setCustomFieldValue', { taskId, fieldId, value });
+        this.core.logOperation('setCustomFieldValue', { taskId, fieldId, value });
         try {
             const payload = {
                 value
             };
-            await this.client.post(`/task/${taskId}/field/${fieldId}`, payload);
+            await this.core.makeRequest(async () => {
+                return await this.core.client.post(`/task/${taskId}/field/${fieldId}`, payload);
+            });
             return true;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to set custom field "${fieldId}" value`);
+            throw this.core.handleError(error, `Failed to set custom field "${fieldId}" value`);
         }
     }
     /**
@@ -42,7 +52,7 @@ export class TaskServiceCustomFields extends TaskServiceTags {
      * @returns Success response
      */
     async setCustomFieldValues(taskId, customFields) {
-        this.logOperation('setCustomFieldValues', { taskId, customFields });
+        this.core.logOperation('setCustomFieldValues', { taskId, customFields });
         try {
             // Execute each update sequentially
             for (const field of customFields) {
@@ -51,7 +61,7 @@ export class TaskServiceCustomFields extends TaskServiceTags {
             return true;
         }
         catch (error) {
-            throw this.handleError(error, 'Failed to set custom field values');
+            throw this.core.handleError(error, 'Failed to set custom field values');
         }
     }
     /**
@@ -61,14 +71,14 @@ export class TaskServiceCustomFields extends TaskServiceTags {
      * @returns Record mapping field IDs to their values
      */
     async getCustomFieldValues(taskId) {
-        this.logOperation('getCustomFieldValues', { taskId });
+        this.core.logOperation('getCustomFieldValues', { taskId });
         try {
             // We need to fetch the full task to get its custom fields
-            const task = await this.getTask(taskId);
+            const task = await this.core.getTask(taskId);
             return task.custom_fields || {};
         }
         catch (error) {
-            throw this.handleError(error, 'Failed to get custom field values');
+            throw this.core.handleError(error, 'Failed to get custom field values');
         }
     }
     /**
@@ -80,18 +90,18 @@ export class TaskServiceCustomFields extends TaskServiceTags {
      * @throws ClickUpServiceError if the field doesn't exist
      */
     async getCustomFieldValue(taskId, fieldId) {
-        this.logOperation('getCustomFieldValue', { taskId, fieldId });
+        this.core.logOperation('getCustomFieldValue', { taskId, fieldId });
         try {
             const customFields = await this.getCustomFieldValues(taskId);
             if (fieldId in customFields) {
                 return customFields[fieldId];
             }
             else {
-                throw this.handleError(new Error(`Custom field "${fieldId}" not found on task`), `Custom field "${fieldId}" not found on task`);
+                throw this.core.handleError(new Error(`Custom field "${fieldId}" not found on task`), `Custom field "${fieldId}" not found on task`);
             }
         }
         catch (error) {
-            throw this.handleError(error, `Failed to get custom field "${fieldId}" value`);
+            throw this.core.handleError(error, `Failed to get custom field "${fieldId}" value`);
         }
     }
 }