@taazkareem/clickup-mcp-server 0.6.4 → 0.6.6

package/build/services/clickup/workspace.js

@@ -7,6 +7,9 @@
  * Handles workspace hierarchy and space-related operations
  */
 import { BaseClickUpService, ClickUpServiceError, ErrorCode } from './base.js';
+import { Logger } from '../../logger.js';
+// Create a logger instance for workspace service
+const logger = new Logger('WorkspaceService');
 /**
  * Service for workspace-related operations
  */
@@ -29,8 +32,7 @@ export class WorkspaceService extends BaseClickUpService {
      * @returns - A standardized ClickUpServiceError
      */
     handleError(error, message) {
-        // Log the error for debugging
-        console.error('WorkspaceService error:', error);
+        logger.error('WorkspaceService error:', error);
         // If the error is already a ClickUpServiceError, return it
         if (error instanceof ClickUpServiceError) {
             return error;
@@ -104,11 +106,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');
+                logger.debug('Returning cached workspace hierarchy');
                 return this.workspaceHierarchy;
             }
             const startTime = Date.now();
-            this.logger.info('Starting workspace hierarchy fetch');
+            logger.info('Starting workspace hierarchy fetch');
             // Start building the workspace tree
             const workspaceTree = {
                 root: {
@@ -121,7 +123,7 @@ export class WorkspaceService extends BaseClickUpService {
             const spacesStartTime = Date.now();
             const spaces = await this.getSpaces();
             const spacesTime = Date.now() - spacesStartTime;
-            this.logger.info(`Fetched ${spaces.length} spaces in ${spacesTime}ms`);
+            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 = [];
@@ -130,7 +132,7 @@ export class WorkspaceService extends BaseClickUpService {
             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)`);
+                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 = {
@@ -173,12 +175,12 @@ export class WorkspaceService extends BaseClickUpService {
                         }));
                         folderNodes.push(...batchFolderNodes);
                         const folderBatchTime = Date.now() - folderBatchStartTime;
-                        this.logger.debug(`Processed folder batch in space ${space.name} in ${folderBatchTime}ms (${folderBatch.length} folders)`);
+                        logger.debug(`Processed folder batch in space ${space.name} in ${folderBatchTime}ms (${folderBatch.length} folders)`);
                     }
                     // 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}`);
+                    logger.debug(`Adding ${listsInSpace.length} lists directly to space ${space.name}`);
                     const listNodes = listsInSpace.map(list => ({
                         id: list.id,
                         name: list.name,
@@ -187,17 +189,17 @@ export class WorkspaceService extends BaseClickUpService {
                     }));
                     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)`);
+                    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)`);
+                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', {
+            logger.info('Workspace hierarchy fetch completed', {
                 duration: totalTime,
                 spaces: spaces.length,
                 folders: totalFolders,
@@ -293,7 +295,7 @@ export class WorkspaceService extends BaseClickUpService {
         try {
             // The /space/{space_id}/list endpoint already returns folderless lists only
             const lists = await this.getFolderlessLists(spaceId);
-            this.logger.debug(`Found ${lists.length} folderless lists in space ${spaceId}`);
+            logger.debug(`Found ${lists.length} folderless lists in space ${spaceId}`);
             // Return all lists without filtering since the API already returns folderless lists
             return lists;
         }

package/build/tools/tag.js

@@ -13,8 +13,11 @@ import { clickUpServices } from '../services/shared.js';
 import { Logger } from '../logger.js';
 import { sponsorService } from '../utils/sponsor-service.js';
 import { processColorCommand } from '../utils/color-processor.js';
+import { validateTaskIdentification } from './task/utilities.js';
 // Create a logger specific to tag tools
 const logger = new Logger('TagTools');
+// Use shared services instance
+const { task: taskService } = clickUpServices;
 //=============================================================================
 // TOOL DEFINITIONS
 //=============================================================================
@@ -201,17 +204,18 @@ export const addTagToTaskTool = {
 
 Valid Usage:
 1. Provide taskId (preferred if available)
-2. Provide taskName + listName
+2. Provide taskName (optionally with listName for disambiguation)
 
 Requirements:
 - tagName: REQUIRED
-- EITHER taskId OR (taskName + listName): REQUIRED
+- EITHER taskId OR customTaskId OR taskName: REQUIRED
 - The tag MUST exist in the space containing the task before calling this tool
 
 Warning:
 - The operation will fail if the tag does not exist in the space
 - Always use get_space_tags first to verify the tag exists
 - If the tag doesn't exist, create it using create_space_tag before adding it to the task
+- If multiple tasks have the same name, provide listName to disambiguate
 
 Notes:
 - Use get_space_tags to see available tags
@@ -229,11 +233,11 @@ Notes:
             },
             taskName: {
                 type: "string",
-                description: "Name of the task to add tag to. When using this parameter, you MUST also provide listName."
+                description: "Name of the task to add tag to. Will search across all lists unless listName is provided."
             },
             listName: {
                 type: "string",
-                description: "Name of the list containing the task. REQUIRED when using taskName."
+                description: "Optional: Name of the list containing the task. Use to disambiguate when multiple tasks have the same name."
             },
             tagName: {
                 type: "string",
@@ -252,15 +256,16 @@ export const removeTagFromTaskTool = {
 
 Valid Usage:
 1. Provide taskId (preferred if available)
-2. Provide taskName + listName
+2. Provide taskName (optionally with listName for disambiguation)
 
 Requirements:
 - tagName: REQUIRED
-- EITHER taskId OR (taskName + listName): REQUIRED
+- EITHER taskId OR customTaskId OR taskName: REQUIRED
 
 Notes:
 - This only removes the association between the tag and task
-- The tag will still exist in the space`,
+- The tag will still exist in the space
+- If multiple tasks have the same name, provide listName to disambiguate`,
     inputSchema: {
         type: "object",
         properties: {
@@ -274,11 +279,11 @@ Notes:
             },
             taskName: {
                 type: "string",
-                description: "Name of the task to remove tag from. When using this parameter, you MUST also provide listName."
+                description: "Name of the task to remove tag from. Will search across all lists unless listName is provided."
             },
             listName: {
                 type: "string",
-                description: "Name of the list containing the task. REQUIRED when using taskName."
+                description: "Optional: Name of the list containing the task. Use to disambiguate when multiple tasks have the same name."
             },
             tagName: {
                 type: "string",
@@ -341,10 +346,18 @@ export const handleDeleteSpaceTag = createHandlerWrapper(deleteSpaceTag, () => (
 /**
  * Wrapper for addTagToTask handler
  */
-export const handleAddTagToTask = createHandlerWrapper(addTagToTask, () => ({
-    success: true,
-    message: "Tag added to task successfully"
-}));
+export const handleAddTagToTask = createHandlerWrapper(addTagToTask, (result) => {
+    if (!result.success) {
+        return {
+            success: false,
+            error: result.error
+        };
+    }
+    return {
+        success: true,
+        message: "Tag added to task successfully"
+    };
+});
 /**
  * Wrapper for removeTagFromTask handler
  */
@@ -673,28 +686,42 @@ export async function deleteSpaceTag(params) {
  */
 async function resolveTaskId(params) {
     const { taskId, customTaskId, taskName, listName } = params;
-    // If we have a direct taskId, use it
-    if (taskId) {
-        return { success: true, taskId };
-    }
-    // Custom task ID handling
-    if (customTaskId) {
-        return { success: true, taskId: customTaskId };
+    try {
+        // First validate task identification with global lookup enabled
+        const validationResult = validateTaskIdentification({ taskId, customTaskId, taskName, listName }, { useGlobalLookup: true });
+        if (!validationResult.isValid) {
+            return {
+                success: false,
+                error: { message: validationResult.errorMessage }
+            };
+        }
+        const result = await taskService.findTasks({
+            taskId,
+            customTaskId,
+            taskName,
+            listName,
+            allowMultipleMatches: false,
+            useSmartDisambiguation: true,
+            includeFullDetails: false
+        });
+        if (!result || Array.isArray(result)) {
+            return {
+                success: false,
+                error: { message: 'Task not found with the provided identification' }
+            };
+        }
+        return { success: true, taskId: result.id };
     }
-    // Task name lookup (requires list name)
-    if (taskName && listName) {
-        // Implementation would go here
+    catch (error) {
         return {
             success: false,
-            error: { message: 'Task name resolution not implemented yet' }
+            error: {
+                message: error.message || 'Failed to resolve task ID',
+                code: error.code,
+                details: error.data
+            }
         };
     }
-    return {
-        success: false,
-        error: {
-            message: 'Task identifier is required (taskId, customTaskId, or taskName+listName)'
-        }
-    };
 }
 /**
  * Add a tag to a task
@@ -712,12 +739,12 @@ export async function addTagToTask(params) {
             }
         };
     }
-    if (!taskId && !customTaskId && !(taskName && listName)) {
-        logger.error('addTagToTask called without proper task identifier');
+    if (!taskId && !customTaskId && !taskName) {
+        logger.error('addTagToTask called without task identifier');
         return {
             success: false,
             error: {
-                message: 'Either taskId, customTaskId, or both taskName and listName are required'
+                message: 'Either taskId, customTaskId, or taskName is required'
             }
         };
     }
@@ -735,6 +762,31 @@ export async function addTagToTask(params) {
         const result = await clickUpServices.tag.addTagToTask(taskIdResult.taskId, tagName);
         if (!result.success) {
             logger.error('Failed to add tag to task', result.error);
+            // Provide more specific error messages based on error code
+            if (result.error?.code === 'TAG_NOT_FOUND') {
+                return {
+                    success: false,
+                    error: {
+                        message: `The tag "${tagName}" does not exist in the space. Please create it first using create_space_tag.`
+                    }
+                };
+            }
+            else if (result.error?.code === 'SPACE_NOT_FOUND') {
+                return {
+                    success: false,
+                    error: {
+                        message: 'Could not determine which space the task belongs to.'
+                    }
+                };
+            }
+            else if (result.error?.code === 'TAG_VERIFICATION_FAILED') {
+                return {
+                    success: false,
+                    error: {
+                        message: 'The tag addition could not be verified. Please check if the tag was added manually.'
+                    }
+                };
+            }
             return {
                 success: false,
                 error: result.error || {
@@ -775,12 +827,12 @@ export async function removeTagFromTask(params) {
             }
         };
     }
-    if (!taskId && !customTaskId && !(taskName && listName)) {
-        logger.error('removeTagFromTask called without proper task identifier');
+    if (!taskId && !customTaskId && !taskName) {
+        logger.error('removeTagFromTask called without task identifier');
         return {
             success: false,
             error: {
-                message: 'Either taskId, customTaskId, or both taskName and listName are required'
+                message: 'Either taskId, customTaskId, or taskName is required'
             }
         };
     }

package/build/tools/task/attachments.js

@@ -10,8 +10,11 @@
 import { clickUpServices } from '../../services/shared.js';
 import { validateTaskIdentification } from './utilities.js';
 import { sponsorService } from '../../utils/sponsor-service.js';
+import { Logger } from '../../logger.js';
 // Use shared services instance
 const { task: taskService } = clickUpServices;
+// Create a logger instance for attachments
+const logger = new Logger('TaskAttachments');
 // Session storage for chunked uploads (in-memory for demonstration)
 const chunkSessions = new Map();
 // Clean up expired sessions periodically
@@ -21,7 +24,7 @@ setInterval(() => {
     for (const [token, session] of chunkSessions.entries()) {
         if (now - session.timestamp > expired) {
             chunkSessions.delete(token);
-            console.log(`Cleaned up expired upload session: ${token}`);
+            logger.debug(`Cleaned up expired upload session: ${token}`);
         }
     }
 }, 3600 * 1000); // Check every hour
@@ -122,9 +125,12 @@ Warning:
  */
 async function attachTaskFileHandler(params) {
     // Extract common parameters
-    const { taskId, taskName, listName, file_name, file_data, file_url, auth_header, chunk_total, chunk_size, chunk_index, session_id } = params;
+    const { taskId, taskName, listName, customTaskId, file_name, file_data, file_url, auth_header, chunk_total, chunk_size, chunk_index, session_id } = params;
     // Validate task identification
-    validateTaskIdentification(params);
+    const validationResult = validateTaskIdentification({ taskId, taskName, listName, customTaskId }, { useGlobalLookup: true });
+    if (!validationResult.isValid) {
+        throw new Error(validationResult.errorMessage);
+    }
     // Validate file source - either file_data or file_url must be provided
     if (!file_data && !file_url && !session_id) {
         throw new Error("Either file_data, file_url, or session_id must be provided");
@@ -150,13 +156,13 @@ async function attachTaskFileHandler(params) {
         // CASE 2: URL-based upload or local file path
         if (file_url) {
             // Check if it's a local file path
-            console.log(`Checking if path is local: ${file_url}`);
+            logger.debug(`Checking if path is local: ${file_url}`);
             if (file_url.startsWith('/') || /^[A-Za-z]:\\/.test(file_url)) {
-                console.log(`Detected as local path, proceeding to handle: ${file_url}`);
+                logger.debug(`Detected as local path, proceeding to handle: ${file_url}`);
                 return await handleLocalFileUpload(resolvedTaskId, file_url, file_name);
             }
             else if (file_url.startsWith('http://') || file_url.startsWith('https://')) {
-                console.log(`Detected as URL, proceeding with URL upload: ${file_url}`);
+                logger.debug(`Detected as URL, proceeding with URL upload: ${file_url}`);
                 return await handleUrlUpload(resolvedTaskId, file_url, file_name, auth_header);
             }
             else {
@@ -183,7 +189,7 @@ async function attachTaskFileHandler(params) {
         throw new Error("Invalid parameters: Unable to determine upload method");
     }
     catch (error) {
-        console.error(`Error attaching file to task:`, error);
+        logger.error(`Error attaching file to task:`, error);
         throw error;
     }
 }
@@ -331,7 +337,7 @@ async function handleLocalFileUpload(taskId, filePath, fileName) {
         // Import fs and path modules
         const fs = await import('fs');
         const path = await import('path');
-        console.log(`Processing absolute file path: ${filePath}`);
+        logger.debug(`Processing absolute file path: ${filePath}`);
         // Normalize the path to prevent directory traversal attacks
         const normalizedPath = path.normalize(filePath);
         // Check if file exists
@@ -348,7 +354,7 @@ async function handleLocalFileUpload(taskId, filePath, fileName) {
         // Read file
         const fileBuffer = fs.readFileSync(normalizedPath);
         const fileSize = fileBuffer.length;
-        console.log(`Successfully read file: ${extractedFileName} (${fileSize} bytes)`);
+        logger.debug(`Successfully read file: ${extractedFileName} (${fileSize} bytes)`);
         // Choose upload method based on file size
         if (fileSize > 10 * 1024 * 1024) {
             // For large files, start chunked upload process