@alanse/clickup-multi-mcp-server 1.0.0

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

@@ -0,0 +1,104 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * ClickUp Task Service
+ *
+ * Complete task service combining all task-related functionality
+ *
+ * REFACTORED: Now uses composition instead of linear inheritance.
+ * Extends TaskServiceCore and composes other services as properties.
+ */
+import { TaskServiceCore } from './task-core.js';
+import { TaskServiceSearch } from './task-search.js';
+import { TaskServiceAttachments } from './task-attachments.js';
+import { TaskServiceComments } from './task-comments.js';
+import { TaskServiceTags } from './task-tags.js';
+import { TaskServiceCustomFields } from './task-custom-fields.js';
+/**
+ * Complete TaskService combining all task-related functionality
+ *
+ * This service uses composition to provide access to all task operations
+ * while maintaining clean separation of concerns and eliminating artificial
+ * dependencies between service modules.
+ */
+export class TaskService extends TaskServiceCore {
+    constructor(apiKey, teamId, baseUrl, workspaceService) {
+        super(apiKey, teamId, baseUrl, workspaceService);
+        this.logOperation('constructor', { initialized: true });
+        // Initialize composed services with core as dependency
+        this.search = new TaskServiceSearch(this);
+        this.attachments = new TaskServiceAttachments(this);
+        this.comments = new TaskServiceComments(this);
+        this.tags = new TaskServiceTags(this);
+        this.customFields = new TaskServiceCustomFields(this);
+    }
+    // ===== DELEGATED SEARCH METHODS =====
+    async findTaskByName(listId, taskName) {
+        return this.search.findTaskByName(listId, taskName);
+    }
+    async getWorkspaceTasks(filters = {}) {
+        return this.search.getWorkspaceTasks(filters);
+    }
+    async getTaskSummaries(filters = {}) {
+        return this.search.getTaskSummaries(filters);
+    }
+    async getListViews(listId) {
+        return this.search.getListViews(listId);
+    }
+    async getTasksFromView(viewId, filters = {}) {
+        return this.search.getTasksFromView(viewId, filters);
+    }
+    async getTaskDetails(filters = {}) {
+        return this.search.getTaskDetails(filters);
+    }
+    async updateTaskByName(listId, taskName, updateData) {
+        return this.search.updateTaskByName(listId, taskName, updateData);
+    }
+    async findTaskByNameGlobally(taskName) {
+        return this.search.findTaskByNameGlobally(taskName);
+    }
+    async findTasks(params) {
+        return this.search.findTasks(params);
+    }
+    // ===== DELEGATED ATTACHMENT METHODS =====
+    async uploadTaskAttachment(taskId, fileData, fileName) {
+        return this.attachments.uploadTaskAttachment(taskId, fileData, fileName);
+    }
+    async uploadTaskAttachmentFromUrl(taskId, fileUrl, fileName, authHeader) {
+        return this.attachments.uploadTaskAttachmentFromUrl(taskId, fileUrl, fileName, authHeader);
+    }
+    // ===== DELEGATED COMMENT METHODS =====
+    async getTaskComments(taskId, start, startId) {
+        return this.comments.getTaskComments(taskId, start, startId);
+    }
+    async createTaskComment(taskId, commentText, notifyAll, assignee) {
+        return this.comments.createTaskComment(taskId, commentText, notifyAll, assignee);
+    }
+    // ===== DELEGATED TAG METHODS =====
+    async addTagToTask(taskId, tagName) {
+        return this.tags.addTagToTask(taskId, tagName);
+    }
+    async removeTagFromTask(taskId, tagName) {
+        return this.tags.removeTagFromTask(taskId, tagName);
+    }
+    async getTaskTags(taskId) {
+        return this.tags.getTaskTags(taskId);
+    }
+    async updateTaskTags(taskId, tagNames) {
+        return this.tags.updateTaskTags(taskId, tagNames);
+    }
+    // ===== DELEGATED CUSTOM FIELD METHODS =====
+    async setCustomFieldValue(taskId, fieldId, value) {
+        return this.customFields.setCustomFieldValue(taskId, fieldId, value);
+    }
+    async setCustomFieldValues(taskId, customFields) {
+        return this.customFields.setCustomFieldValues(taskId, customFields);
+    }
+    async getCustomFieldValues(taskId) {
+        return this.customFields.getCustomFieldValues(taskId);
+    }
+    async getCustomFieldValue(taskId, fieldId) {
+        return this.customFields.getCustomFieldValue(taskId, fieldId);
+    }
+}

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

@@ -0,0 +1,113 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * ClickUp Task Service - Tags Module
+ *
+ * Handles tag operations for ClickUp tasks, including:
+ * - Adding tags to a task
+ * - Removing tags from a task
+ *
+ * REFACTORED: Now uses composition instead of inheritance.
+ * Only depends on TaskServiceCore for getTask() and base functionality.
+ */
+/**
+ * Tags functionality for the TaskService
+ *
+ * This service handles all tag-related operations for ClickUp tasks.
+ * It uses composition to access core functionality instead of inheritance.
+ */
+export class TaskServiceTags {
+    constructor(core) {
+        this.core = core;
+    }
+    /**
+     * Add a tag to a task
+     *
+     * @param taskId ID of the task
+     * @param tagName Name of the tag to add
+     * @returns Success response
+     */
+    async addTagToTask(taskId, tagName) {
+        this.core.logOperation('addTagToTask', { taskId, tagName });
+        try {
+            const payload = {
+                tag_name: tagName,
+            };
+            await this.core.makeRequest(async () => {
+                return await this.core.client.post(`/task/${taskId}/tag/${encodeURIComponent(tagName)}`, payload);
+            });
+            return true;
+        }
+        catch (error) {
+            throw this.core.handleError(error, `Failed to add tag "${tagName}" to task`);
+        }
+    }
+    /**
+     * Remove a tag from a task
+     *
+     * @param taskId ID of the task
+     * @param tagName Name of the tag to remove
+     * @returns Success response
+     */
+    async removeTagFromTask(taskId, tagName) {
+        this.core.logOperation('removeTagFromTask', { taskId, tagName });
+        try {
+            await this.core.makeRequest(async () => {
+                return await this.core.client.delete(`/task/${taskId}/tag/${encodeURIComponent(tagName)}`);
+            });
+            return true;
+        }
+        catch (error) {
+            throw this.core.handleError(error, `Failed to remove tag "${tagName}" from task`);
+        }
+    }
+    /**
+     * Get all tags for a task
+     *
+     * @param taskId ID of the task
+     * @returns Array of task tags
+     */
+    async getTaskTags(taskId) {
+        this.core.logOperation('getTaskTags', { taskId });
+        try {
+            // We need to fetch the full task to get its tags
+            const task = await this.core.getTask(taskId);
+            return task.tags || [];
+        }
+        catch (error) {
+            throw this.core.handleError(error, 'Failed to get task tags');
+        }
+    }
+    /**
+     * Update all tags for a task (replaces existing tags)
+     *
+     * @param taskId ID of the task
+     * @param tagNames Array of tag names to set
+     * @returns Success response
+     */
+    async updateTaskTags(taskId, tagNames) {
+        this.core.logOperation('updateTaskTags', { taskId, tagNames });
+        try {
+            // First get existing tags
+            const existingTags = await this.getTaskTags(taskId);
+            const existingTagNames = existingTags.map(tag => tag.name);
+            // Remove tags that shouldn't be there
+            for (const tagName of existingTagNames) {
+                if (!tagNames.includes(tagName)) {
+                    await this.removeTagFromTask(taskId, tagName);
+                }
+            }
+            // Add new tags
+            for (const tagName of tagNames) {
+                if (!existingTagNames.includes(tagName)) {
+                    await this.addTagToTask(taskId, tagName);
+                }
+            }
+            return true;
+        }
+        catch (error) {
+            throw this.core.handleError(error, 'Failed to update task tags');
+        }
+    }
+}

package/build/services/clickup/time.js

@@ -0,0 +1,244 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * Time tracking service for ClickUp tasks
+ *
+ * This service provides methods to manage time tracking for ClickUp tasks:
+ * - Get time entries for a task
+ * - Start time tracking on a task
+ * - Stop time tracking on a task
+ * - Add a manual time entry
+ * - Delete a time entry
+ */
+import { BaseClickUpService, ErrorCode, ClickUpServiceError } from './base.js';
+/**
+ * Time tracking service for ClickUp
+ */
+export class TimeTrackingService extends BaseClickUpService {
+    /**
+     * Get all time entries for a task
+     * @param taskId ID of the task
+     * @param startDate Optional start date filter (Unix timestamp in milliseconds)
+     * @param endDate Optional end date filter (Unix timestamp in milliseconds)
+     * @returns List of time entries
+     */
+    async getTimeEntries(taskId, startDate, endDate) {
+        try {
+            this.logOperation('getTimeEntries', { taskId, startDate, endDate });
+            // Build query parameters
+            let query = {};
+            if (startDate)
+                query.start_date = startDate;
+            if (endDate)
+                query.end_date = endDate;
+            const path = `/task/${taskId}/time`;
+            this.traceRequest('GET', path, query);
+            const response = await this.makeRequest(() => this.client.get(path, {
+                params: query
+            }));
+            return {
+                success: true,
+                data: response.data.data
+            };
+        }
+        catch (error) {
+            if (error instanceof ClickUpServiceError) {
+                return {
+                    success: false,
+                    error: {
+                        message: error.message,
+                        code: error.code,
+                        details: error.data
+                    }
+                };
+            }
+            return {
+                success: false,
+                error: {
+                    message: `Failed to get time entries: ${error.message}`,
+                    code: ErrorCode.UNKNOWN
+                }
+            };
+        }
+    }
+    /**
+     * Start time tracking on a task
+     * @param data Task ID and optional parameters
+     * @returns The created time entry
+     */
+    async startTimeTracking(data) {
+        try {
+            this.logOperation('startTimeTracking', { taskId: data.tid });
+            const path = `/team/${this.teamId}/time_entries/start`;
+            this.traceRequest('POST', path, data);
+            const response = await this.makeRequest(() => this.client.post(path, data));
+            return {
+                success: true,
+                data: response.data.data
+            };
+        }
+        catch (error) {
+            if (error instanceof ClickUpServiceError) {
+                return {
+                    success: false,
+                    error: {
+                        message: error.message,
+                        code: error.code,
+                        details: error.data
+                    }
+                };
+            }
+            return {
+                success: false,
+                error: {
+                    message: `Failed to start time tracking: ${error.message}`,
+                    code: ErrorCode.UNKNOWN
+                }
+            };
+        }
+    }
+    /**
+     * Stop the currently running time tracker
+     * @param data Optional parameters for the stopped time entry
+     * @returns The completed time entry
+     */
+    async stopTimeTracking(data) {
+        try {
+            this.logOperation('stopTimeTracking', {});
+            const path = `/team/${this.teamId}/time_entries/stop`;
+            this.traceRequest('POST', path, data || {});
+            const response = await this.makeRequest(() => this.client.post(path, data || {}));
+            return {
+                success: true,
+                data: response.data.data
+            };
+        }
+        catch (error) {
+            if (error instanceof ClickUpServiceError) {
+                return {
+                    success: false,
+                    error: {
+                        message: error.message,
+                        code: error.code,
+                        details: error.data
+                    }
+                };
+            }
+            return {
+                success: false,
+                error: {
+                    message: `Failed to stop time tracking: ${error.message}`,
+                    code: ErrorCode.UNKNOWN
+                }
+            };
+        }
+    }
+    /**
+     * Add a manual time entry to a task
+     * @param data Time entry data including task ID, start time, and duration
+     * @returns The created time entry
+     */
+    async addTimeEntry(data) {
+        try {
+            this.logOperation('addTimeEntry', { taskId: data.tid, duration: data.duration });
+            const path = `/team/${this.teamId}/time_entries`;
+            this.traceRequest('POST', path, data);
+            const response = await this.makeRequest(() => this.client.post(path, data));
+            return {
+                success: true,
+                data: response.data.data
+            };
+        }
+        catch (error) {
+            if (error instanceof ClickUpServiceError) {
+                return {
+                    success: false,
+                    error: {
+                        message: error.message,
+                        code: error.code,
+                        details: error.data
+                    }
+                };
+            }
+            return {
+                success: false,
+                error: {
+                    message: `Failed to add time entry: ${error.message}`,
+                    code: ErrorCode.UNKNOWN
+                }
+            };
+        }
+    }
+    /**
+     * Delete a time entry
+     * @param timeEntryId ID of the time entry to delete
+     * @returns Success response
+     */
+    async deleteTimeEntry(timeEntryId) {
+        try {
+            this.logOperation('deleteTimeEntry', { timeEntryId });
+            const path = `/team/${this.teamId}/time_entries/${timeEntryId}`;
+            this.traceRequest('DELETE', path);
+            await this.makeRequest(() => this.client.delete(path));
+            return {
+                success: true,
+                data: true
+            };
+        }
+        catch (error) {
+            if (error instanceof ClickUpServiceError) {
+                return {
+                    success: false,
+                    error: {
+                        message: error.message,
+                        code: error.code,
+                        details: error.data
+                    }
+                };
+            }
+            return {
+                success: false,
+                error: {
+                    message: `Failed to delete time entry: ${error.message}`,
+                    code: ErrorCode.UNKNOWN
+                }
+            };
+        }
+    }
+    /**
+     * Get currently running time entry for the user
+     * @returns The currently running time entry or null if no timer is running
+     */
+    async getCurrentTimeEntry() {
+        try {
+            this.logOperation('getCurrentTimeEntry', {});
+            const path = `/team/${this.teamId}/time_entries/current`;
+            this.traceRequest('GET', path);
+            const response = await this.makeRequest(() => this.client.get(path));
+            return {
+                success: true,
+                data: response.data.data
+            };
+        }
+        catch (error) {
+            if (error instanceof ClickUpServiceError) {
+                return {
+                    success: false,
+                    error: {
+                        message: error.message,
+                        code: error.code,
+                        details: error.data
+                    }
+                };
+            }
+            return {
+                success: false,
+                error: {
+                    message: `Failed to get current time entry: ${error.message}`,
+                    code: ErrorCode.UNKNOWN
+                }
+            };
+        }
+    }
+}

package/build/services/clickup/types.js

@@ -0,0 +1,33 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * Common type definitions for ClickUp API entities
+ */
+// Helper function to validate and convert priority values
+export function toTaskPriority(value) {
+    if (value === null)
+        return null;
+    if (value === undefined)
+        return undefined;
+    if (value === "null")
+        return null;
+    // Convert string to number if needed
+    const numValue = typeof value === 'string' ? parseInt(value, 10) : value;
+    // Validate it's a valid priority number
+    if (typeof numValue === 'number' && !isNaN(numValue) && [1, 2, 3, 4].includes(numValue)) {
+        return numValue;
+    }
+    return undefined;
+}
+/**
+ * ClickUp parent container types
+ */
+export var ClickUpParentType;
+(function (ClickUpParentType) {
+    ClickUpParentType[ClickUpParentType["Space"] = 4] = "Space";
+    ClickUpParentType[ClickUpParentType["Folder"] = 5] = "Folder";
+    ClickUpParentType[ClickUpParentType["List"] = 6] = "List";
+    ClickUpParentType[ClickUpParentType["All"] = 7] = "All";
+    ClickUpParentType[ClickUpParentType["Workspace"] = 12] = "Workspace";
+})(ClickUpParentType || (ClickUpParentType = {}));