@alanse/clickup-multi-mcp-server 1.0.0

package/build/services/clickup/tag.js

@@ -0,0 +1,239 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * ClickUp Tag Service
+ *
+ * Provides access to ClickUp API endpoints for tag management:
+ * - Space tags (get, create, update, delete)
+ * - Task tags (add, remove)
+ */
+import { BaseClickUpService } from './base.js';
+/**
+ * ClickUp Tag Service class for managing tags
+ */
+export class ClickUpTagService extends BaseClickUpService {
+    /**
+     * Get all tags in a space
+     * @param spaceId - ID of the space to get tags from
+     * @returns Promise with tags array
+     */
+    async getSpaceTags(spaceId) {
+        try {
+            this.logger.debug(`Getting tags for space: ${spaceId}`);
+            const response = await this.client.get(`/space/${spaceId}/tag`);
+            return {
+                success: true,
+                data: response.data.tags
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to get tags for space: ${spaceId}`, error);
+            return {
+                success: false,
+                error: {
+                    message: error.message || 'Failed to get space tags',
+                    code: error.code,
+                    details: error.data
+                }
+            };
+        }
+    }
+    /**
+     * Create a new tag in a space
+     * @param spaceId - ID of the space
+     * @param tagData - Tag data (name, background color, foreground color)
+     * @returns Promise with created tag
+     */
+    async createSpaceTag(spaceId, tagData) {
+        try {
+            this.logger.debug(`Creating tag "${tagData.tag_name}" in space: ${spaceId}`);
+            // Send tag data wrapped in a 'tag' object
+            const response = await this.client.post(`/space/${spaceId}/tag`, {
+                tag: {
+                    name: tagData.tag_name,
+                    tag_bg: tagData.tag_bg,
+                    tag_fg: tagData.tag_fg
+                }
+            });
+            return {
+                success: true,
+                data: response.data.tag
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to create tag in space: ${spaceId}`, error);
+            return {
+                success: false,
+                error: {
+                    message: error.message || 'Failed to create space tag',
+                    code: error.code,
+                    details: error.data
+                }
+            };
+        }
+    }
+    /**
+     * Update an existing tag in a space
+     * @param spaceId - ID of the space
+     * @param tagName - Current name of the tag to update
+     * @param updateData - Tag data to update (name, colors)
+     * @returns Promise with updated tag
+     */
+    async updateSpaceTag(spaceId, tagName, updateData) {
+        try {
+            this.logger.debug(`Updating tag "${tagName}" in space: ${spaceId}`);
+            // Encode the tag name in the URL
+            const encodedTagName = encodeURIComponent(tagName);
+            const response = await this.client.put(`/space/${spaceId}/tag/${encodedTagName}`, updateData);
+            return {
+                success: true,
+                data: response.data.tag
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to update tag "${tagName}" in space: ${spaceId}`, error);
+            return {
+                success: false,
+                error: {
+                    message: error.message || 'Failed to update space tag',
+                    code: error.code,
+                    details: error.data
+                }
+            };
+        }
+    }
+    /**
+     * Delete a tag from a space
+     * @param spaceId - ID of the space
+     * @param tagName - Name of the tag to delete
+     * @returns Promise with success status
+     */
+    async deleteSpaceTag(spaceId, tagName) {
+        try {
+            this.logger.debug(`Deleting tag "${tagName}" from space: ${spaceId}`);
+            // Encode the tag name in the URL
+            const encodedTagName = encodeURIComponent(tagName);
+            await this.client.delete(`/space/${spaceId}/tag/${encodedTagName}`);
+            return {
+                success: true
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to delete tag "${tagName}" from space: ${spaceId}`, error);
+            return {
+                success: false,
+                error: {
+                    message: error.message || 'Failed to delete space tag',
+                    code: error.code,
+                    details: error.data
+                }
+            };
+        }
+    }
+    /**
+     * Add a tag to a task
+     * @param taskId - ID of the task
+     * @param tagName - Name of the tag to add
+     * @returns Promise with success status and tag data
+     */
+    async addTagToTask(taskId, tagName) {
+        try {
+            this.logger.debug(`Adding tag "${tagName}" to task: ${taskId}`);
+            // First get the task to get its space ID
+            const taskResponse = await this.client.get(`/task/${taskId}`);
+            if (!taskResponse.data?.space?.id) {
+                return {
+                    success: false,
+                    error: {
+                        message: 'Could not determine space ID from task',
+                        code: 'SPACE_NOT_FOUND'
+                    }
+                };
+            }
+            // Get space tags to verify tag exists
+            const spaceId = taskResponse.data.space.id;
+            const spaceTags = await this.getSpaceTags(spaceId);
+            if (!spaceTags.success || !spaceTags.data) {
+                return {
+                    success: false,
+                    error: {
+                        message: 'Failed to verify tag existence in space',
+                        code: 'TAG_VERIFICATION_FAILED',
+                        details: spaceTags.error
+                    }
+                };
+            }
+            // Check if tag exists
+            const tagExists = spaceTags.data.some(tag => tag.name === tagName);
+            if (!tagExists) {
+                return {
+                    success: false,
+                    error: {
+                        message: `Tag "${tagName}" does not exist in the space`,
+                        code: 'TAG_NOT_FOUND'
+                    }
+                };
+            }
+            // Encode the tag name in the URL
+            const encodedTagName = encodeURIComponent(tagName);
+            // Add the tag
+            await this.client.post(`/task/${taskId}/tag/${encodedTagName}`, {});
+            // Verify the tag was added by getting the task again
+            const verifyResponse = await this.client.get(`/task/${taskId}`);
+            const tagAdded = verifyResponse.data?.tags?.some(tag => tag.name === tagName) ?? false;
+            if (!tagAdded) {
+                return {
+                    success: false,
+                    error: {
+                        message: 'Tag addition failed verification',
+                        code: 'TAG_VERIFICATION_FAILED'
+                    }
+                };
+            }
+            return {
+                success: true,
+                data: { tagAdded: true }
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to add tag "${tagName}" to task: ${taskId}`, error);
+            return {
+                success: false,
+                error: {
+                    message: error.message || 'Failed to add tag to task',
+                    code: error.code,
+                    details: error.data
+                }
+            };
+        }
+    }
+    /**
+     * Remove a tag from a task
+     * @param taskId - ID of the task
+     * @param tagName - Name of the tag to remove
+     * @returns Promise with success status
+     */
+    async removeTagFromTask(taskId, tagName) {
+        try {
+            this.logger.debug(`Removing tag "${tagName}" from task: ${taskId}`);
+            // Encode the tag name in the URL
+            const encodedTagName = encodeURIComponent(tagName);
+            await this.client.delete(`/task/${taskId}/tag/${encodedTagName}`);
+            return {
+                success: true
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to remove tag "${tagName}" from task: ${taskId}`, error);
+            return {
+                success: false,
+                error: {
+                    message: error.message || 'Failed to remove tag from task',
+                    code: error.code,
+                    details: error.data
+                }
+            };
+        }
+    }
+}

package/build/services/clickup/task/index.js

@@ -0,0 +1,32 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * ClickUp Task Service - Module Exports
+ *
+ * Exports all task-related functionality:
+ * - Core task operations (CRUD)
+ * - Task searching and filtering
+ * - Task comments
+ * - File attachments
+ * - Task tags
+ * - Custom fields
+ */
+// Export the main TaskService class
+export { TaskService } from './task-service.js';
+// Export all component services
+export { TaskServiceCore } from './task-core.js';
+export { TaskServiceSearch } from './task-search.js';
+export { TaskServiceAttachments } from './task-attachments.js';
+export { TaskServiceComments } from './task-comments.js';
+export { TaskServiceTags } from './task-tags.js';
+export { TaskServiceCustomFields } from './task-custom-fields.js';
+// Export types and interfaces from all modules
+export * from './task-core.js';
+export * from './task-search.js';
+export * from './task-attachments.js';
+export * from './task-comments.js';
+export * from './task-tags.js';
+export * from './task-custom-fields.js';
+// Re-export TaskService as the default export
+export { TaskService as default } from './task-service.js';

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

@@ -0,0 +1,105 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * ClickUp Task Service - Attachments Module
+ *
+ * Handles file attachment operations for ClickUp tasks, supporting three methods:
+ * - Uploading file attachments from base64/buffer data
+ * - Uploading file attachments from a URL (web URLs like http/https)
+ * - Uploading file attachments from local file paths (absolute paths)
+ *
+ * REFACTORED: Now uses composition instead of inheritance.
+ * Only depends on TaskServiceCore for base functionality.
+ */
+/**
+ * Attachment functionality for the TaskService
+ *
+ * This service handles all file attachment operations for ClickUp tasks.
+ * It uses composition to access core functionality instead of inheritance.
+ */
+export class TaskServiceAttachments {
+    constructor(core) {
+        this.core = core;
+    }
+    /**
+     * Upload a file attachment to a ClickUp task
+     * @param taskId The ID of the task to attach the file to
+     * @param fileData The file data as a Buffer
+     * @param fileName The name of the file
+     * @returns Promise resolving to the attachment response from ClickUp
+     */
+    async uploadTaskAttachment(taskId, fileData, fileName) {
+        this.core.logOperation('uploadTaskAttachment', { taskId, fileName, fileSize: fileData.length });
+        try {
+            return await this.core.makeRequest(async () => {
+                // Create FormData for multipart/form-data upload
+                const FormData = (await import('form-data')).default;
+                const formData = new FormData();
+                // Add the file to the form data
+                formData.append('attachment', fileData, {
+                    filename: fileName,
+                    contentType: 'application/octet-stream' // Let ClickUp determine the content type
+                });
+                // Use the raw axios client for this request since we need to handle FormData
+                const response = await this.core.client.post(`/task/${taskId}/attachment`, formData, {
+                    headers: {
+                        ...formData.getHeaders(),
+                        'Authorization': this.core.apiKey
+                    }
+                });
+                return response.data;
+            });
+        }
+        catch (error) {
+            throw this.core.handleError(error, `Failed to upload attachment to task ${taskId}`);
+        }
+    }
+    /**
+     * Upload a file attachment to a ClickUp task from a URL
+     * @param taskId The ID of the task to attach the file to
+     * @param fileUrl The URL of the file to download and attach
+     * @param fileName Optional file name (if not provided, it will be extracted from the URL)
+     * @param authHeader Optional authorization header for the URL
+     * @returns Promise resolving to the attachment response from ClickUp
+     */
+    async uploadTaskAttachmentFromUrl(taskId, fileUrl, fileName, authHeader) {
+        this.core.logOperation('uploadTaskAttachmentFromUrl', { taskId, fileUrl, fileName });
+        try {
+            return await this.core.makeRequest(async () => {
+                // Import required modules
+                const axios = (await import('axios')).default;
+                const FormData = (await import('form-data')).default;
+                // Download the file from the URL
+                const headers = {};
+                if (authHeader) {
+                    headers['Authorization'] = authHeader;
+                }
+                const response = await axios.get(fileUrl, {
+                    responseType: 'arraybuffer',
+                    headers
+                });
+                // Extract filename from URL if not provided
+                const actualFileName = fileName || fileUrl.split('/').pop() || 'downloaded-file';
+                // Create FormData for multipart/form-data upload
+                const formData = new FormData();
+                // Add the file to the form data
+                formData.append('attachment', Buffer.from(response.data), {
+                    filename: actualFileName,
+                    contentType: 'application/octet-stream'
+                });
+                // Upload the file to ClickUp
+                const uploadResponse = await this.core.client.post(`/task/${taskId}/attachment`, formData, {
+                    headers: {
+                        ...formData.getHeaders(),
+                        'Authorization': this.core.apiKey
+                    }
+                });
+                return uploadResponse.data;
+            });
+        }
+        catch (error) {
+            throw this.core.handleError(error, `Failed to upload attachment from URL to task ${taskId}`);
+        }
+    }
+}

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

@@ -0,0 +1,114 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * ClickUp Task Service - Comments Module
+ *
+ * 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.
+ */
+/**
+ * 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 {
+    constructor(core) {
+        this.core = core;
+    }
+    /**
+     * Get all comments for a task
+     *
+     * @param taskId ID of the task to get comments for
+     * @param start Optional pagination start
+     * @param startId Optional comment ID to start from
+     * @returns Array of task comments
+     */
+    async getTaskComments(taskId, start, startId) {
+        this.core.logOperation('getTaskComments', { taskId, start, startId });
+        try {
+            // Build query parameters for pagination
+            const queryParams = new URLSearchParams();
+            if (start !== undefined) {
+                queryParams.append('start', start.toString());
+            }
+            if (startId) {
+                queryParams.append('start_id', startId);
+            }
+            const queryString = queryParams.toString() ? `?${queryParams.toString()}` : '';
+            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.core.handleError(error, 'Failed to get task comments');
+        }
+    }
+    /**
+     * Create a comment on a task
+     *
+     * @param taskId ID of the task to comment on
+     * @param commentText Text content of the comment
+     * @param notifyAll Whether to notify all assignees
+     * @param assignee Optional user ID to assign the comment to
+     * @returns The created comment
+     */
+    async createTaskComment(taskId, commentText, notifyAll = false, assignee) {
+        this.core.logOperation('createTaskComment', { taskId, commentText, notifyAll, assignee });
+        try {
+            const payload = {
+                comment_text: commentText,
+                notify_all: notifyAll
+            };
+            if (assignee) {
+                payload.assignee = assignee;
+            }
+            // Make the request directly without using makeRequest for better error handling
+            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) {
+                    // Standard format: { comment: ClickUpComment }
+                    return response.data.comment;
+                }
+                else if (response.data.id && (response.data.comment_text || response.data.comment)) {
+                    // Direct format: the comment object itself
+                    return response.data;
+                }
+                else {
+                    // Fallback: construct a minimal valid comment object
+                    return {
+                        id: response.data.id || `custom-${Date.now()}`,
+                        comment: response.data.comment || commentText,
+                        comment_text: response.data.comment_text || commentText,
+                        user: response.data.user || { id: 0, username: 'Unknown', email: '', color: '' },
+                        date: response.data.date || new Date().toISOString(),
+                        resolved: false
+                    };
+                }
+            }
+            throw new Error('Invalid response from ClickUp API');
+        }
+        catch (error) {
+            // Check if comment might have been created despite error
+            if (error.response?.status === 200 || error.response?.status === 201) {
+                // Try to construct a comment object from what we know
+                return {
+                    id: `fallback-${Date.now()}`,
+                    comment: commentText,
+                    comment_text: commentText,
+                    user: { id: 0, username: 'Unknown', email: '', color: '' },
+                    date: new Date().toISOString(),
+                    resolved: false
+                };
+            }
+            throw this.core.handleError(error, 'Failed to create task comment');
+        }
+    }
+}