@taazkareem/clickup-mcp-server 0.6.1 → 0.6.3

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

@@ -0,0 +1,477 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * ClickUp Task Service - Core Module
+ *
+ * Handles core operations related to tasks in ClickUp, including:
+ * - Base service initialization
+ * - Core utility methods
+ * - Basic CRUD operations
+ */
+import { BaseClickUpService, ErrorCode, ClickUpServiceError } from '../base.js';
+import { ListService } from '../list.js';
+/**
+ * Core TaskService class providing basic task operations
+ */
+export class TaskServiceCore extends BaseClickUpService {
+    constructor(apiKey, teamId, baseUrl, workspaceService) {
+        super(apiKey, teamId, baseUrl);
+        this.workspaceService = null;
+        // Cache for validated tasks and lists
+        this.validationCache = {
+            tasks: new Map(),
+            lists: new Map()
+        };
+        // Cache TTL in milliseconds (5 minutes)
+        this.CACHE_TTL = 5 * 60 * 1000;
+        if (workspaceService) {
+            this.workspaceService = workspaceService;
+            this.logOperation('constructor', { usingSharedWorkspaceService: true });
+        }
+        // Initialize list service for list lookups
+        this.listService = new ListService(apiKey, teamId, baseUrl, this.workspaceService);
+        this.logOperation('constructor', { initialized: true });
+    }
+    /**
+     * Helper method to handle errors consistently
+     * @param error The error that occurred
+     * @param message Optional custom error message
+     * @returns A ClickUpServiceError
+     */
+    handleError(error, message) {
+        if (error instanceof ClickUpServiceError) {
+            return error;
+        }
+        return new ClickUpServiceError(message || `Task service error: ${error.message}`, ErrorCode.UNKNOWN, error);
+    }
+    /**
+     * Build URL parameters from task filters
+     * @param filters Task filters to convert to URL parameters
+     * @returns URLSearchParams object
+     */
+    buildTaskFilterParams(filters) {
+        const params = new URLSearchParams();
+        // Add all filters to the query parameters
+        if (filters.include_closed)
+            params.append('include_closed', String(filters.include_closed));
+        if (filters.subtasks)
+            params.append('subtasks', String(filters.subtasks));
+        if (filters.page)
+            params.append('page', String(filters.page));
+        if (filters.order_by)
+            params.append('order_by', filters.order_by);
+        if (filters.reverse)
+            params.append('reverse', String(filters.reverse));
+        // Array parameters
+        if (filters.statuses && filters.statuses.length > 0) {
+            filters.statuses.forEach(status => params.append('statuses[]', status));
+        }
+        if (filters.assignees && filters.assignees.length > 0) {
+            filters.assignees.forEach(assignee => params.append('assignees[]', assignee));
+        }
+        // Team tasks endpoint specific parameters
+        if (filters.tags && filters.tags.length > 0) {
+            filters.tags.forEach(tag => params.append('tags[]', tag));
+        }
+        if (filters.list_ids && filters.list_ids.length > 0) {
+            filters.list_ids.forEach(id => params.append('list_ids[]', id));
+        }
+        if (filters.folder_ids && filters.folder_ids.length > 0) {
+            filters.folder_ids.forEach(id => params.append('folder_ids[]', id));
+        }
+        if (filters.space_ids && filters.space_ids.length > 0) {
+            filters.space_ids.forEach(id => params.append('space_ids[]', id));
+        }
+        if (filters.archived !== undefined)
+            params.append('archived', String(filters.archived));
+        if (filters.include_closed_lists !== undefined)
+            params.append('include_closed_lists', String(filters.include_closed_lists));
+        if (filters.include_archived_lists !== undefined)
+            params.append('include_archived_lists', String(filters.include_archived_lists));
+        if (filters.include_compact_time_entries !== undefined)
+            params.append('include_compact_time_entries', String(filters.include_compact_time_entries));
+        // Date filters
+        if (filters.due_date_gt)
+            params.append('due_date_gt', String(filters.due_date_gt));
+        if (filters.due_date_lt)
+            params.append('due_date_lt', String(filters.due_date_lt));
+        if (filters.date_created_gt)
+            params.append('date_created_gt', String(filters.date_created_gt));
+        if (filters.date_created_lt)
+            params.append('date_created_lt', String(filters.date_created_lt));
+        if (filters.date_updated_gt)
+            params.append('date_updated_gt', String(filters.date_updated_gt));
+        if (filters.date_updated_lt)
+            params.append('date_updated_lt', String(filters.date_updated_lt));
+        // Handle custom fields if present
+        if (filters.custom_fields) {
+            Object.entries(filters.custom_fields).forEach(([key, value]) => {
+                params.append(`custom_fields[${key}]`, String(value));
+            });
+        }
+        return params;
+    }
+    /**
+     * Extract priority value from a task
+     * @param task The task to extract priority from
+     * @returns TaskPriority or null
+     */
+    extractPriorityValue(task) {
+        if (!task.priority || !task.priority.id) {
+            return null;
+        }
+        const priorityValue = parseInt(task.priority.id);
+        // Ensure it's in the valid range 1-4
+        if (isNaN(priorityValue) || priorityValue < 1 || priorityValue > 4) {
+            return null;
+        }
+        return priorityValue;
+    }
+    /**
+     * Extract task data for creation/duplication
+     * @param task The source task
+     * @param nameOverride Optional override for the task name
+     * @returns CreateTaskData object
+     */
+    extractTaskData(task, nameOverride) {
+        return {
+            name: nameOverride || task.name,
+            description: task.description || '',
+            status: task.status?.status,
+            priority: this.extractPriorityValue(task),
+            due_date: task.due_date ? Number(task.due_date) : undefined,
+            assignees: task.assignees?.map(a => a.id) || []
+        };
+    }
+    /**
+     * Create a new task in the specified list
+     * @param listId The ID of the list to create the task in
+     * @param taskData The data for the new task
+     * @returns The created task
+     */
+    async createTask(listId, taskData) {
+        this.logOperation('createTask', { listId, ...taskData });
+        try {
+            return await this.makeRequest(async () => {
+                const response = await this.client.post(`/list/${listId}/task`, taskData);
+                return response.data;
+            });
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to create task in list ${listId}`);
+        }
+    }
+    /**
+     * Get a specific task by ID
+     * @param taskId The ID of the task to retrieve
+     * @returns The task details
+     */
+    async getTask(taskId) {
+        this.logOperation('getTask', { taskId });
+        try {
+            return await this.makeRequest(async () => {
+                const response = await this.client.get(`/task/${taskId}`);
+                return response.data;
+            });
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get task ${taskId}`);
+        }
+    }
+    /**
+     * Get all tasks in a list with optional filtering
+     * @param listId The ID of the list to get tasks from
+     * @param filters Optional filters to apply
+     * @returns List of tasks matching the filters
+     */
+    async getTasks(listId, filters = {}) {
+        this.logOperation('getTasks', { listId, filters });
+        try {
+            return await this.makeRequest(async () => {
+                const params = this.buildTaskFilterParams(filters);
+                const response = await this.client.get(`/list/${listId}/task?${params.toString()}`);
+                return response.data.tasks;
+            });
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get tasks from list ${listId}`);
+        }
+    }
+    /**
+     * Get subtasks of a specific task
+     * @param taskId The ID of the parent task
+     * @returns Array of subtask details
+     */
+    async getSubtasks(taskId) {
+        this.logOperation('getSubtasks', { taskId });
+        try {
+            return await this.makeRequest(async () => {
+                const response = await this.client.get(`/task/${taskId}`);
+                // Return subtasks if present, otherwise empty array
+                return response.data.subtasks || [];
+            });
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get subtasks for task ${taskId}`);
+        }
+    }
+    /**
+     * Get a task by its custom ID
+     * @param customTaskId The custom ID of the task (e.g., "ABC-123")
+     * @param listId Optional list ID to limit the search
+     * @returns The task details
+     */
+    async getTaskByCustomId(customTaskId, listId) {
+        this.logOperation('getTaskByCustomId', { customTaskId, listId });
+        try {
+            return await this.makeRequest(async () => {
+                // Construct the URL with optional list ID
+                const url = `/task/custom_task_ids?custom_task_id=${encodeURIComponent(customTaskId)}${listId ? `&list_id=${listId}` : ''}`;
+                const response = await this.client.get(url);
+                return response.data;
+            });
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get task with custom ID ${customTaskId}`);
+        }
+    }
+    /**
+     * Update an existing task
+     * @param taskId The ID of the task to update
+     * @param updateData The data to update
+     * @returns The updated task
+     */
+    async updateTask(taskId, updateData) {
+        this.logOperation('updateTask', { taskId, ...updateData });
+        try {
+            return await this.makeRequest(async () => {
+                const response = await this.client.put(`/task/${taskId}`, updateData);
+                return response.data;
+            });
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to update task ${taskId}`);
+        }
+    }
+    /**
+     * Delete a task
+     * @param taskId The ID of the task to delete
+     * @returns A ServiceResponse indicating success
+     */
+    async deleteTask(taskId) {
+        this.logOperation('deleteTask', { taskId });
+        try {
+            await this.makeRequest(async () => {
+                await this.client.delete(`/task/${taskId}`);
+            });
+            return {
+                success: true,
+                data: undefined,
+                error: undefined
+            };
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to delete task ${taskId}`);
+        }
+    }
+    /**
+     * Move a task to a different list
+     * @param taskId The ID of the task to move
+     * @param destinationListId The ID of the list to move the task to
+     * @returns The updated task
+     */
+    async moveTask(taskId, destinationListId) {
+        const startTime = Date.now();
+        this.logOperation('moveTask', { taskId, destinationListId, operation: 'start' });
+        try {
+            // First, get both the task and list info in parallel
+            const [task, listResult] = await Promise.all([
+                this.validateTaskExists(taskId),
+                this.validateListExists(destinationListId).then(() => this.listService.getList(destinationListId))
+            ]);
+            const originalTask = task;
+            const destinationList = listResult;
+            // Log parallel request timing
+            const parallelRequestTime = Date.now() - startTime;
+            this.logOperation('moveTask', {
+                taskId,
+                destinationListId,
+                operation: 'parallel_requests_complete',
+                timing: { parallelRequestTime }
+            });
+            const currentStatus = originalTask.status?.status;
+            const availableStatuses = destinationList.statuses?.map(s => s.status) || [];
+            // Enhanced status mapping logic
+            let newStatus = currentStatus;
+            if (currentStatus && availableStatuses.length > 0) {
+                // Only map status if current status isn't available in destination list
+                if (!availableStatuses.includes(currentStatus)) {
+                    // Try to find a similar status
+                    const similarStatus = availableStatuses.find(s => s.toLowerCase().includes(currentStatus.toLowerCase()) ||
+                        currentStatus.toLowerCase().includes(s.toLowerCase()));
+                    // If no similar status found, use the first available status
+                    newStatus = similarStatus || availableStatuses[0];
+                    this.logger.debug('Status mapping', {
+                        original: currentStatus,
+                        mapped: newStatus,
+                        available: availableStatuses
+                    });
+                }
+            }
+            // Make the move request
+            const movedTask = await this.makeRequest(async () => {
+                const response = await this.client.post(`/task/${taskId}`, {
+                    list: destinationListId,
+                    status: newStatus
+                });
+                return response.data;
+            });
+            // Cache the moved task
+            this.validationCache.tasks.set(taskId, {
+                validatedAt: Date.now(),
+                task: movedTask
+            });
+            const totalTime = Date.now() - startTime;
+            this.logOperation('moveTask', {
+                taskId,
+                destinationListId,
+                operation: 'complete',
+                timing: {
+                    totalTime,
+                    parallelRequestTime,
+                    moveOperationTime: totalTime - parallelRequestTime
+                },
+                statusMapping: {
+                    original: currentStatus,
+                    new: newStatus,
+                    wasMapped: currentStatus !== newStatus
+                }
+            });
+            return movedTask;
+        }
+        catch (error) {
+            // Log failure
+            this.logOperation('moveTask', {
+                taskId,
+                destinationListId,
+                operation: 'failed',
+                error: error.message,
+                timing: { totalTime: Date.now() - startTime }
+            });
+            throw this.handleError(error, 'Failed to move task');
+        }
+    }
+    /**
+     * Duplicate a task, optionally to a different list
+     * @param taskId The ID of the task to duplicate
+     * @param listId Optional ID of list to create duplicate in (defaults to same list)
+     * @returns The duplicated task
+     */
+    async duplicateTask(taskId, listId) {
+        this.logOperation('duplicateTask', { taskId, listId });
+        try {
+            // Get source task and validate destination list if provided
+            const [sourceTask, _] = await Promise.all([
+                this.validateTaskExists(taskId),
+                listId ? this.validateListExists(listId) : Promise.resolve()
+            ]);
+            // Create duplicate in specified list or original list
+            const targetListId = listId || sourceTask.list.id;
+            const taskData = this.extractTaskData(sourceTask);
+            return await this.createTask(targetListId, taskData);
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to duplicate task ${taskId}`);
+        }
+    }
+    /**
+     * Validate a task exists and cache the result
+     * @param taskId The ID of the task to validate
+     * @returns The validated task
+     */
+    async validateTaskExists(taskId) {
+        // Check cache first
+        const cached = this.validationCache.tasks.get(taskId);
+        if (cached && Date.now() - cached.validatedAt < this.CACHE_TTL) {
+            this.logger.debug('Using cached task validation', { taskId });
+            return cached.task;
+        }
+        // Not in cache or expired, fetch task
+        const task = await this.getTask(taskId);
+        // Cache the validation result
+        this.validationCache.tasks.set(taskId, {
+            validatedAt: Date.now(),
+            task
+        });
+        return task;
+    }
+    /**
+     * Validate that multiple tasks exist
+     * @param taskIds Array of task IDs to validate
+     * @returns Map of task IDs to task objects
+     */
+    async validateTasksExist(taskIds) {
+        const results = new Map();
+        const toFetch = [];
+        // Check cache first
+        for (const taskId of taskIds) {
+            const cached = this.validationCache.tasks.get(taskId);
+            if (cached && Date.now() - cached.validatedAt < this.CACHE_TTL) {
+                results.set(taskId, cached.task);
+            }
+            else {
+                toFetch.push(taskId);
+            }
+        }
+        if (toFetch.length > 0) {
+            // Fetch uncached tasks in parallel batches
+            const batchSize = 5;
+            for (let i = 0; i < toFetch.length; i += batchSize) {
+                const batch = toFetch.slice(i, i + batchSize);
+                const tasks = await Promise.all(batch.map(id => this.getTask(id)));
+                // Cache and store results
+                tasks.forEach((task, index) => {
+                    const taskId = batch[index];
+                    this.validationCache.tasks.set(taskId, {
+                        validatedAt: Date.now(),
+                        task
+                    });
+                    results.set(taskId, task);
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Validate a list exists and cache the result
+     * @param listId The ID of the list to validate
+     */
+    async validateListExists(listId) {
+        // Check cache first
+        const cached = this.validationCache.lists.get(listId);
+        if (cached && Date.now() - cached.validatedAt < this.CACHE_TTL) {
+            this.logger.debug('Using cached list validation', { listId });
+            if (!cached.valid) {
+                throw new ClickUpServiceError(`List ${listId} does not exist`, ErrorCode.NOT_FOUND);
+            }
+            return;
+        }
+        try {
+            await this.listService.getList(listId);
+            // Cache the successful validation
+            this.validationCache.lists.set(listId, {
+                validatedAt: Date.now(),
+                valid: true
+            });
+        }
+        catch (error) {
+            // Cache the failed validation
+            this.validationCache.lists.set(listId, {
+                validatedAt: Date.now(),
+                valid: false
+            });
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1,97 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * ClickUp Task Service - Custom Fields Module
+ *
+ * Handles custom fields operations for ClickUp tasks, including:
+ * - Setting custom field values
+ * - Retrieving custom field values
+ */
+import { TaskServiceTags } from './task-tags.js';
+/**
+ * Custom fields functionality for the TaskService
+ */
+export class TaskServiceCustomFields extends TaskServiceTags {
+    /**
+     * Set a single custom field value on a task
+     *
+     * @param taskId ID of the task
+     * @param fieldId ID of the custom field
+     * @param value Value to set for the custom field
+     * @returns Success response
+     */
+    async setCustomFieldValue(taskId, fieldId, value) {
+        this.logOperation('setCustomFieldValue', { taskId, fieldId, value });
+        try {
+            const payload = {
+                value
+            };
+            await this.client.post(`/task/${taskId}/field/${fieldId}`, payload);
+            return true;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to set custom field "${fieldId}" value`);
+        }
+    }
+    /**
+     * Set multiple custom field values on a task
+     *
+     * @param taskId ID of the task
+     * @param customFields Array of custom field ID and value pairs
+     * @returns Success response
+     */
+    async setCustomFieldValues(taskId, customFields) {
+        this.logOperation('setCustomFieldValues', { taskId, customFields });
+        try {
+            // Execute each update sequentially
+            for (const field of customFields) {
+                await this.setCustomFieldValue(taskId, field.id, field.value);
+            }
+            return true;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to set custom field values');
+        }
+    }
+    /**
+     * Get all custom field values for a task
+     *
+     * @param taskId ID of the task
+     * @returns Record mapping field IDs to their values
+     */
+    async getCustomFieldValues(taskId) {
+        this.logOperation('getCustomFieldValues', { taskId });
+        try {
+            // We need to fetch the full task to get its custom fields
+            const task = await this.getTask(taskId);
+            return task.custom_fields || {};
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get custom field values');
+        }
+    }
+    /**
+     * Get a specific custom field value for a task
+     *
+     * @param taskId ID of the task
+     * @param fieldId ID of the custom field
+     * @returns The value of the custom field
+     * @throws ClickUpServiceError if the field doesn't exist
+     */
+    async getCustomFieldValue(taskId, fieldId) {
+        this.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`);
+            }
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get custom field "${fieldId}" value`);
+        }
+    }
+}