@taazkareem/clickup-mcp-server 0.6.2 → 0.6.3

package/build/services/clickup/workspace.js

@@ -104,8 +104,11 @@ export class WorkspaceService extends BaseClickUpService {
         try {
             // If we have the hierarchy in memory and not forcing refresh, return it
             if (this.workspaceHierarchy && !forceRefresh) {
+                this.logger.debug('Returning cached workspace hierarchy');
                 return this.workspaceHierarchy;
             }
+            const startTime = Date.now();
+            this.logger.info('Starting workspace hierarchy fetch');
             // Start building the workspace tree
             const workspaceTree = {
                 root: {
@@ -115,51 +118,93 @@ export class WorkspaceService extends BaseClickUpService {
                 }
             };
             // Get all spaces
+            const spacesStartTime = Date.now();
             const spaces = await this.getSpaces();
-            // Process each space
-            for (const space of spaces) {
-                const spaceNode = {
-                    id: space.id,
-                    name: space.name,
-                    type: 'space',
-                    children: []
-                };
-                // Get folders for the space
-                const folders = await this.getFoldersInSpace(space.id);
-                for (const folder of folders) {
-                    const folderNode = {
-                        id: folder.id,
-                        name: folder.name,
-                        type: 'folder',
-                        parentId: space.id,
+            const spacesTime = Date.now() - spacesStartTime;
+            this.logger.info(`Fetched ${spaces.length} spaces in ${spacesTime}ms`);
+            // Process spaces in batches to respect rate limits
+            const batchSize = 3; // Process 3 spaces at a time
+            const spaceNodes = [];
+            let totalFolders = 0;
+            let totalLists = 0;
+            for (let i = 0; i < spaces.length; i += batchSize) {
+                const batchStartTime = Date.now();
+                const spaceBatch = spaces.slice(i, i + batchSize);
+                this.logger.debug(`Processing space batch ${i / batchSize + 1} of ${Math.ceil(spaces.length / batchSize)} (${spaceBatch.length} spaces)`);
+                const batchNodes = await Promise.all(spaceBatch.map(async (space) => {
+                    const spaceStartTime = Date.now();
+                    const spaceNode = {
+                        id: space.id,
+                        name: space.name,
+                        type: 'space',
                         children: []
                     };
-                    // Get lists in the folder
-                    const listsInFolder = await this.getListsInFolder(folder.id);
-                    for (const list of listsInFolder) {
-                        folderNode.children?.push({
-                            id: list.id,
-                            name: list.name,
-                            type: 'list',
-                            parentId: folder.id
-                        });
+                    // Fetch initial space data
+                    const [folders, listsInSpace] = await Promise.all([
+                        this.getFoldersInSpace(space.id),
+                        this.getListsInSpace(space.id)
+                    ]);
+                    totalFolders += folders.length;
+                    totalLists += listsInSpace.length;
+                    // Process folders in smaller batches
+                    const folderBatchSize = 5; // Process 5 folders at a time
+                    const folderNodes = [];
+                    for (let j = 0; j < folders.length; j += folderBatchSize) {
+                        const folderBatchStartTime = Date.now();
+                        const folderBatch = folders.slice(j, j + folderBatchSize);
+                        const batchFolderNodes = await Promise.all(folderBatch.map(async (folder) => {
+                            const folderNode = {
+                                id: folder.id,
+                                name: folder.name,
+                                type: 'folder',
+                                parentId: space.id,
+                                children: []
+                            };
+                            // Get lists in the folder
+                            const listsInFolder = await this.getListsInFolder(folder.id);
+                            totalLists += listsInFolder.length;
+                            folderNode.children = listsInFolder.map(list => ({
+                                id: list.id,
+                                name: list.name,
+                                type: 'list',
+                                parentId: folder.id
+                            }));
+                            return folderNode;
+                        }));
+                        folderNodes.push(...batchFolderNodes);
+                        const folderBatchTime = Date.now() - folderBatchStartTime;
+                        this.logger.debug(`Processed folder batch in space ${space.name} in ${folderBatchTime}ms (${folderBatch.length} folders)`);
                     }
-                    spaceNode.children?.push(folderNode);
-                }
-                // Get lists directly in the space (not in any folder)
-                const listsInSpace = await this.getListsInSpace(space.id);
-                this.logger.debug(`Adding ${listsInSpace.length} lists directly to space ${space.name} (${space.id})`);
-                for (const list of listsInSpace) {
-                    this.logger.debug(`Adding list directly to space: ${list.name} (${list.id})`);
-                    spaceNode.children?.push({
+                    // Add folder nodes to space
+                    spaceNode.children?.push(...folderNodes);
+                    // Add folderless lists to space
+                    this.logger.debug(`Adding ${listsInSpace.length} lists directly to space ${space.name}`);
+                    const listNodes = listsInSpace.map(list => ({
                         id: list.id,
                         name: list.name,
                         type: 'list',
                         parentId: space.id
-                    });
-                }
-                workspaceTree.root.children.push(spaceNode);
+                    }));
+                    spaceNode.children?.push(...listNodes);
+                    const spaceTime = Date.now() - spaceStartTime;
+                    this.logger.info(`Processed space ${space.name} in ${spaceTime}ms (${folders.length} folders, ${listsInSpace.length} lists)`);
+                    return spaceNode;
+                }));
+                spaceNodes.push(...batchNodes);
+                const batchTime = Date.now() - batchStartTime;
+                this.logger.info(`Processed space batch in ${batchTime}ms (${spaceBatch.length} spaces)`);
             }
+            // Add all space nodes to the workspace tree
+            workspaceTree.root.children.push(...spaceNodes);
+            const totalTime = Date.now() - startTime;
+            this.logger.info('Workspace hierarchy fetch completed', {
+                duration: totalTime,
+                spaces: spaces.length,
+                folders: totalFolders,
+                lists: totalLists,
+                averageTimePerSpace: totalTime / spaces.length,
+                averageTimePerNode: totalTime / (spaces.length + totalFolders + totalLists)
+            });
             // Store the hierarchy for later use
             this.workspaceHierarchy = workspaceTree;
             return workspaceTree;

package/build/tools/folder.js

@@ -156,7 +156,7 @@ Requirements:
 - EITHER folderId OR (folderName + space information) is REQUIRED
 - When using folderName, you MUST provide EITHER spaceId OR spaceName
 
-⚠️ CRITICAL WARNING:
+Warning:
 - This action CANNOT be undone
 - All lists and tasks within the folder will also be permanently deleted
 - Using folderName is risky as names may not be unique across different spaces`,

package/build/tools/list.js

@@ -8,11 +8,9 @@
  * retrieving, and deleting lists. It supports creating lists both in spaces
  * and in folders.
  */
-import { clickUpServices } from '../services/shared.js';
+import { listService, workspaceService } from '../services/shared.js';
 import config from '../config.js';
 import { sponsorService } from '../utils/sponsor-service.js';
-// Use shared services instance
-const { list: listService, workspace: workspaceService } = clickUpServices;
 /**
  * Tool definition for creating a list directly in a space
  */
@@ -216,7 +214,7 @@ Valid Usage:
 Requirements:
 - EITHER listId OR listName: REQUIRED
 
-⚠️ CRITICAL WARNING:
+Warning:
 - This action CANNOT be undone
 - All tasks within the list will also be permanently deleted
 - Using listName is risky as names may not be unique`,

package/build/tools/task/attachments.js

@@ -7,11 +7,12 @@
  * This module implements a tool for attaching files to ClickUp tasks
  * with automatic method selection based on file source and size.
  */
-import { taskService } from '../../services/shared.js';
-import { validateTaskIdentification, resolveTaskIdWithValidation } from './utilities.js';
+import { clickUpServices } from '../../services/shared.js';
+import { validateTaskIdentification } from './utilities.js';
 import { sponsorService } from '../../utils/sponsor-service.js';
+// Use shared services instance
+const { task: taskService } = clickUpServices;
 // Session storage for chunked uploads (in-memory for demonstration)
-// In production, this should use a more persistent store
 const chunkSessions = new Map();
 // Clean up expired sessions periodically
 setInterval(() => {
@@ -113,7 +114,18 @@ async function attachTaskFileHandler(params) {
         throw new Error("Either file_data, file_url, or session_id must be provided");
     }
     // Resolve task ID
-    const resolvedTaskId = await resolveTaskIdWithValidation(taskId, taskName, listName);
+    const result = await taskService.findTasks({
+        taskId,
+        taskName,
+        listName,
+        allowMultipleMatches: false,
+        useSmartDisambiguation: true,
+        includeFullDetails: false
+    });
+    if (!result || Array.isArray(result)) {
+        throw new Error("Task not found");
+    }
+    const resolvedTaskId = result.id;
     try {
         // CASE 1: Chunked upload continuation
         if (session_id) {
@@ -254,7 +266,8 @@ async function handleChunkUpload(taskId, sessionToken, chunkIndex, chunkData, is
         // Sort chunks by index
         const sortedChunks = Array.from(session.chunks.entries())
             .sort((a, b) => a[0] - b[0]);
-        for (const [index, chunk] of sortedChunks) {
+        for (const entry of sortedChunks) {
+            const [index, chunk] = entry;
             chunk.copy(fileData, offset);
             offset += chunk.length;
         }

package/build/tools/task/attachments.types.js

@@ -0,0 +1,9 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * ClickUp MCP Task Attachment Types
+ *
+ * This module defines types for file attachment operations.
+ */
+export {};

package/build/tools/task/bulk-operations.js

@@ -86,18 +86,11 @@ Requirements:
 Notes:
 - Configure batch size and concurrency via options for performance
 - Each task should have a name with emoji prefix
-- All tasks will be created in the same list`,
+- All tasks will be created in the same list
+- Custom fields can be set for each task using the custom_fields property (array of {id, value} objects)`,
     inputSchema: {
         type: "object",
         properties: {
-            listId: {
-                type: "string",
-                description: "ID of list for new tasks (preferred). Use this instead of listName if you have it."
-            },
-            listName: {
-                type: "string",
-                description: "Name of list for new tasks. Only use if you don't have listId."
-            },
             tasks: {
                 type: "array",
                 description: "Array of tasks to create. Each task must have at least a name.",
@@ -134,18 +127,73 @@ Notes:
                                 type: "string"
                             },
                             description: "Optional array of tag names to assign to the task. The tags must already exist in the space."
+                        },
+                        custom_fields: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    id: {
+                                        type: "string",
+                                        description: "ID of the custom field"
+                                    },
+                                    value: {
+                                        description: "Value for the custom field. Type depends on the field type."
+                                    }
+                                },
+                                required: ["id", "value"]
+                            },
+                            description: "Optional array of custom field values to set on the task."
                         }
                     },
                     required: ["name"]
                 }
             },
-            options: bulkOptionsSchema
+            listId: {
+                type: "string",
+                description: "ID of list for new tasks (preferred). Use this instead of listName if you have it."
+            },
+            listName: {
+                type: "string",
+                description: "Name of list for new tasks. Only use if you don't have listId."
+            },
+            options: {
+                description: "Processing options (or JSON string representing options)",
+                oneOf: [
+                    {
+                        type: "object",
+                        description: "Optional processing settings",
+                        properties: {
+                            batchSize: {
+                                type: "number",
+                                description: "Tasks per batch (default: 10)"
+                            },
+                            concurrency: {
+                                type: "number",
+                                description: "Parallel operations (default: 3)"
+                            },
+                            continueOnError: {
+                                type: "boolean",
+                                description: "Continue if some tasks fail"
+                            },
+                            retryCount: {
+                                type: "number",
+                                description: "Retry attempts for failures"
+                            }
+                        }
+                    },
+                    {
+                        type: "string",
+                        description: "JSON string representing options. Will be parsed automatically."
+                    }
+                ]
+            }
         },
         required: ["tasks"]
     }
 };
 /**
- * Tool definition for updating multiple tasks at once
+ * Tool definition for updating multiple tasks efficiently
  */
 export const updateBulkTasksTool = {
     name: "update_bulk_tasks",
@@ -163,7 +211,8 @@ Requirements:
 Notes:
 - Only specified fields will be updated for each task
 - Configure batch size and concurrency via options for performance
-- Each task can have different fields to update`,
+- Each task can have different fields to update
+- Custom fields can be updated using the custom_fields property (array of {id, value} objects)`,
     inputSchema: {
         type: "object",
         properties: {
@@ -198,11 +247,58 @@ Notes:
                         dueDate: {
                             type: "string",
                             description: "New due date. Supports Unix timestamps (in milliseconds) and natural language expressions like '1 hour from now', 'tomorrow', etc."
+                        },
+                        custom_fields: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    id: {
+                                        type: "string",
+                                        description: "ID of the custom field"
+                                    },
+                                    value: {
+                                        description: "Value for the custom field. Type depends on the field type."
+                                    }
+                                },
+                                required: ["id", "value"]
+                            },
+                            description: "Optional array of custom field values to set on the task."
                         }
                     }
                 }
             },
-            options: bulkOptionsSchema
+            options: {
+                description: "Processing options (or JSON string representing options)",
+                oneOf: [
+                    {
+                        type: "object",
+                        description: "Optional processing settings",
+                        properties: {
+                            batchSize: {
+                                type: "number",
+                                description: "Tasks per batch (default: 10)"
+                            },
+                            concurrency: {
+                                type: "number",
+                                description: "Parallel operations (default: 3)"
+                            },
+                            continueOnError: {
+                                type: "boolean",
+                                description: "Continue if some tasks fail"
+                            },
+                            retryCount: {
+                                type: "number",
+                                description: "Retry attempts for failures"
+                            }
+                        }
+                    },
+                    {
+                        type: "string",
+                        description: "JSON string representing options. Will be parsed automatically."
+                    }
+                ]
+            }
         },
         required: ["tasks"]
     }
@@ -227,7 +323,7 @@ Notes:
 - Configure batch size and concurrency via options for performance
 - All tasks will be moved to the same destination list
 
-⚠️ Warning:
+Warning:
 - Task statuses may reset if destination list has different status options
 - Using taskName without listName will fail as tasks may have identical names across lists`,
     inputSchema: {
@@ -274,7 +370,7 @@ Requirements:
 Notes:
 - Configure batch size and concurrency via options for performance
 
-⚠️ CRITICAL WARNING:
+Warning:
 - This action CANNOT be undone for any of the tasks
 - Using taskName without listName is dangerous as names may not be unique
 - Always provide listName when using taskName for safer targeting`,