@taazkareem/clickup-mcp-server 0.4.67 → 0.4.69

package/build/tools/list.js

@@ -5,15 +5,10 @@
  * retrieving, and deleting lists. It supports creating lists both in spaces
  * and in folders.
  */
-import { createClickUpServices } from '../services/clickup/index.js';
+import { clickUpServices } from '../services/shared.js';
 import config from '../config.js';
-// Initialize ClickUp services using the factory function
-const services = createClickUpServices({
-    apiKey: config.clickupApiKey,
-    teamId: config.clickupTeamId
-});
-// Extract the services we need for list operations
-const { list: listService, workspace: workspaceService } = services;
+// Use shared services instance
+const { list: listService, workspace: workspaceService } = clickUpServices;
 /**
  * Tool definition for creating a list directly in a space
  */

package/build/tools/logs.js

@@ -0,0 +1,55 @@
+/**
+ * Simple Logs Tool
+ *
+ * Provides a basic tool for reading server logs.
+ */
+import { promises as fs } from 'fs';
+import { join, dirname } from 'path';
+// Define the log file path - using __dirname to get absolute path
+const LOG_FILE = join(dirname(__dirname), 'server.log');
+// Tool definition
+export const checkLogsTool = {
+    name: "check_logs",
+    description: "Check server logs with optional filtering by log level",
+    parameters: {
+        type: "object",
+        properties: {
+            level: {
+                type: "string",
+                enum: ["TRACE", "DEBUG", "INFO", "WARN", "ERROR"],
+                description: "Filter logs by level"
+            },
+            limit: {
+                type: "number",
+                description: "Maximum number of log entries to return (default: 50)"
+            }
+        }
+    }
+};
+// Simple handler implementation using async/await with promises
+export async function handleCheckLogs(params) {
+    try {
+        // Read log file using promises
+        const content = await fs.readFile(LOG_FILE, 'utf-8');
+        // Split into lines and filter out empty lines
+        let lines = content.split('\n').filter(Boolean);
+        // Apply level filtering if specified
+        if (params?.level) {
+            lines = lines.filter(line => line.includes(`${params.level}:`));
+        }
+        // Apply limit (default to 50)
+        const limit = params?.limit || 50;
+        const result = lines.slice(-limit);
+        // Return results
+        return {
+            logs: result.length > 0 ? result : ['No matching logs found.']
+        };
+    }
+    catch (error) {
+        // Simple error handling
+        if (error.code === 'ENOENT') {
+            return { logs: ['Log file not found.'] };
+        }
+        return { logs: [`Error reading logs: ${error.message}`] };
+    }
+}

package/build/tools/task.js

@@ -5,17 +5,11 @@
  * moving, duplicating, and deleting tasks. It also provides tools for
  * retrieving task details.
  */
-import { createClickUpServices } from '../services/clickup/index.js';
-import config from '../config.js';
+import { clickUpServices } from '../services/shared.js';
 import { findListIDByName } from './list.js';
 import { parseDueDate, formatDueDate } from './utils.js';
-// Initialize ClickUp services using the factory function
-const services = createClickUpServices({
-    apiKey: config.clickupApiKey,
-    teamId: config.clickupTeamId
-});
-// Extract the services we need for task operations
-const { task: taskService, workspace: workspaceService } = services;
+// Use shared services instance
+const { task: taskService, workspace: workspaceService } = clickUpServices;
 /**
  * Tool definition for creating a single task
  */
@@ -171,9 +165,8 @@ export const updateTaskTool = {
                 }
                 listId = listInfo.id;
             }
-            // Now find the task
-            const tasks = await taskService.getTasks(listId || '');
-            const foundTask = tasks.find(t => t.name.toLowerCase() === taskName.toLowerCase());
+            // Use the improved findTaskByName method
+            const foundTask = await taskService.findTaskByName(listId || '', taskName);
             if (!foundTask) {
                 throw new Error(`Task "${taskName}" not found${listName ? ` in list "${listName}"` : ""}`);
             }
@@ -268,9 +261,8 @@ export const moveTaskTool = {
                 }
                 sourceListId = listInfo.id;
             }
-            // Now find the task
-            const tasks = await taskService.getTasks(sourceListId || '');
-            const foundTask = tasks.find(t => t.name.toLowerCase() === taskName.toLowerCase());
+            // Use the improved findTaskByName method
+            const foundTask = await taskService.findTaskByName(sourceListId || '', taskName);
             if (!foundTask) {
                 throw new Error(`Task "${taskName}" not found${sourceListName ? ` in list "${sourceListName}"` : ""}`);
             }
@@ -358,8 +350,8 @@ export const duplicateTaskTool = {
         if (!targetTaskId && taskName) {
             // Find the task in the source list if specified, otherwise search all tasks
             if (sourceListId) {
-                const tasks = await taskService.getTasks(sourceListId);
-                const foundTask = tasks.find(t => t.name.toLowerCase() === taskName.toLowerCase());
+                // Use the improved findTaskByName method
+                const foundTask = await taskService.findTaskByName(sourceListId, taskName);
                 if (!foundTask) {
                     throw new Error(`Task "${taskName}" not found in list "${sourceListName}"`);
                 }
@@ -440,9 +432,8 @@ export const getTaskTool = {
                 }
                 listId = listInfo.id;
             }
-            // Now find the task
-            const tasks = await taskService.getTasks(listId || '');
-            const foundTask = tasks.find(t => t.name.toLowerCase() === taskName.toLowerCase());
+            // Use the improved findTaskByName method
+            const foundTask = await taskService.findTaskByName(listId || '', taskName);
             if (!foundTask) {
                 throw new Error(`Task "${taskName}" not found${listName ? ` in list "${listName}"` : ""}`);
             }
@@ -809,6 +800,113 @@ export const moveBulkTasksTool = {
         required: ["tasks"]
     }
 };
+/**
+ * Tool definition for getting task comments
+ */
+export const getTaskCommentsTool = {
+    name: "get_task_comments",
+    description: "Retrieve comments for a ClickUp task. You can identify the task by either taskId or taskName. If using taskName, you can optionally provide listName to help locate the correct task if multiple tasks have the same name.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            taskId: {
+                type: "string",
+                description: "ID of task to retrieve comments for (preferred). Use this instead of taskName if you have it."
+            },
+            taskName: {
+                type: "string",
+                description: "Name of task to retrieve comments for. Warning: Task names may not be unique."
+            },
+            listName: {
+                type: "string",
+                description: "Name of list containing the task. Helps find the right task when using taskName."
+            },
+            start: {
+                type: "number",
+                description: "Timestamp (in milliseconds) to start retrieving comments from. Used for pagination."
+            },
+            startId: {
+                type: "string",
+                description: "Comment ID to start from. Used together with start for pagination."
+            }
+        }
+    },
+    async handler({ taskId, taskName, listName, start, startId }) {
+        let targetTaskId = taskId;
+        // If no taskId but taskName is provided, look up the task ID
+        if (!targetTaskId && taskName) {
+            // First, we need to find the list if list name is provided
+            let listId;
+            if (listName) {
+                // Use workspace service to find list by name
+                const hierarchy = await workspaceService.getWorkspaceHierarchy();
+                const listInfo = workspaceService.findIDByNameInHierarchy(hierarchy, listName, 'list');
+                if (!listInfo) {
+                    throw new Error(`List "${listName}" not found`);
+                }
+                listId = listInfo.id;
+            }
+            // Find task by name in the specific list or across workspace
+            if (listId) {
+                const task = await taskService.findTaskByName(listId, taskName);
+                if (!task) {
+                    throw new Error(`Task "${taskName}" not found in list "${listName}"`);
+                }
+                targetTaskId = task.id;
+            }
+            else {
+                // Search across all accessible tasks (slower, less reliable)
+                const hierarchy = await workspaceService.getWorkspaceHierarchy();
+                // Collect all lists from all spaces and folders
+                const lists = [];
+                // Recursively extract lists from hierarchy nodes
+                const extractLists = (node) => {
+                    if (node.type === 'list') {
+                        lists.push({ id: node.id, name: node.name });
+                    }
+                    if (node.children && Array.isArray(node.children)) {
+                        node.children.forEach(extractLists);
+                    }
+                };
+                // Start extraction from root's children (spaces)
+                if (hierarchy.root && hierarchy.root.children) {
+                    hierarchy.root.children.forEach(extractLists);
+                }
+                // Try to find the task in each list
+                for (const list of lists) {
+                    try {
+                        const task = await taskService.findTaskByName(list.id, taskName);
+                        if (task) {
+                            targetTaskId = task.id;
+                            break;
+                        }
+                    }
+                    catch (error) {
+                        // Continue searching in other lists
+                    }
+                }
+                if (!targetTaskId) {
+                    throw new Error(`Task "${taskName}" not found in any list`);
+                }
+            }
+        }
+        if (!targetTaskId) {
+            throw new Error("Either taskId or taskName must be provided");
+        }
+        // Retrieve comments for the task
+        const comments = await taskService.getTaskComments(targetTaskId, start, startId);
+        return {
+            taskId: targetTaskId,
+            comments: comments,
+            totalComments: comments.length,
+            pagination: {
+                hasMore: comments.length === 25, // API returns max 25 comments at a time
+                nextStart: comments.length > 0 ? new Date(comments[comments.length - 1].date).getTime() : undefined,
+                nextStartId: comments.length > 0 ? comments[comments.length - 1].id : undefined
+            }
+        };
+    }
+};
 /**
  * Handler for bulk task updates
  */
@@ -1010,9 +1108,8 @@ export async function handleUpdateTask(parameters) {
             }
             listId = listInfo.id;
         }
-        // Now find the task
-        const tasks = await taskService.getTasks(listId || '');
-        const foundTask = tasks.find(t => t.name.toLowerCase() === taskName.toLowerCase());
+        // Use the improved findTaskByName method
+        const foundTask = await taskService.findTaskByName(listId || '', taskName);
         if (!foundTask) {
             throw new Error(`Task "${taskName}" not found${listName ? ` in list "${listName}"` : ""}`);
         }
@@ -1079,8 +1176,8 @@ export async function handleMoveTask(parameters) {
     if (!targetTaskId && taskName) {
         // Find the task in the source list if specified, otherwise search all tasks
         if (sourceListId) {
-            const tasks = await taskService.getTasks(sourceListId);
-            const foundTask = tasks.find(t => t.name.toLowerCase() === taskName.toLowerCase());
+            // Use the improved findTaskByName method
+            const foundTask = await taskService.findTaskByName(sourceListId, taskName);
             if (!foundTask) {
                 throw new Error(`Task "${taskName}" not found in list "${sourceListName}"`);
             }
@@ -1088,7 +1185,6 @@ export async function handleMoveTask(parameters) {
         }
         else {
             // Without a source list, we need to search more broadly
-            // This is less efficient but necessary if source list is unknown
             throw new Error("When using taskName, sourceListName must be provided to find the task");
         }
     }
@@ -1105,9 +1201,6 @@ export async function handleMoveTask(parameters) {
         }
         targetListId = listInfo.id;
     }
-    if (!targetListId) {
-        throw new Error("Either listId or listName must be provided for the target list");
-    }
     // Move the task
     const task = await taskService.moveTask(targetTaskId, targetListId);
     // Format response
@@ -1147,8 +1240,8 @@ export async function handleDuplicateTask(parameters) {
     if (!targetTaskId && taskName) {
         // Find the task in the source list if specified, otherwise search all tasks
         if (sourceListId) {
-            const tasks = await taskService.getTasks(sourceListId);
-            const foundTask = tasks.find(t => t.name.toLowerCase() === taskName.toLowerCase());
+            // Use the improved findTaskByName method
+            const foundTask = await taskService.findTaskByName(sourceListId, taskName);
             if (!foundTask) {
                 throw new Error(`Task "${taskName}" not found in list "${sourceListName}"`);
             }
@@ -1241,62 +1334,6 @@ export async function handleGetTasks(parameters) {
             }]
     };
 }
-/**
- * Handler for the get_task tool
- */
-export async function handleGetTask(parameters) {
-    const { taskId, taskName, listName } = parameters;
-    let targetTaskId = taskId;
-    // If no taskId but taskName is provided, look up the task ID
-    if (!targetTaskId && taskName) {
-        let listId;
-        // If listName is provided, find the list ID first
-        if (listName) {
-            const hierarchy = await workspaceService.getWorkspaceHierarchy();
-            const listInfo = workspaceService.findIDByNameInHierarchy(hierarchy, listName, 'list');
-            if (!listInfo) {
-                throw new Error(`List "${listName}" not found`);
-            }
-            listId = listInfo.id;
-        }
-        // Now find the task
-        const tasks = await taskService.getTasks(listId || '');
-        const foundTask = tasks.find(t => t.name.toLowerCase() === taskName.toLowerCase());
-        if (!foundTask) {
-            throw new Error(`Task "${taskName}" not found${listName ? ` in list "${listName}"` : ""}`);
-        }
-        targetTaskId = foundTask.id;
-    }
-    if (!targetTaskId) {
-        throw new Error("Either taskId or taskName must be provided");
-    }
-    // Get the task
-    const task = await taskService.getTask(targetTaskId);
-    // Format response
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    id: task.id,
-                    name: task.name,
-                    description: task.description,
-                    status: task.status?.status || "Unknown",
-                    priority: task.priority,
-                    due_date: task.due_date ? formatDueDate(Number(task.due_date)) : undefined,
-                    due_date_raw: task.due_date, // Keep raw timestamp for reference if needed
-                    url: task.url,
-                    list: task.list.name,
-                    space: task.space.name,
-                    folder: task.folder?.name,
-                    creator: task.creator,
-                    assignees: task.assignees,
-                    tags: task.tags,
-                    time_estimate: task.time_estimate,
-                    time_spent: task.time_spent,
-                }, null, 2)
-            }]
-    };
-}
 /**
  * Handler for the delete_task tool
  */
@@ -1380,8 +1417,8 @@ export async function handleDeleteBulkTasks({ tasks }) {
                 if (!listInfo) {
                     throw new Error(`List "${task.listName}" not found`);
                 }
-                const taskList = await taskService.getTasks(listInfo.id);
-                const foundTask = taskList.find(t => t.name.toLowerCase() === task.taskName.toLowerCase());
+                // Use the improved findTaskByName method
+                const foundTask = await taskService.findTaskByName(listInfo.id, task.taskName);
                 if (!foundTask) {
                     throw new Error(`Task "${task.taskName}" not found in list "${task.listName}"`);
                 }
@@ -1517,3 +1554,40 @@ export async function handleMoveBulkTasks(parameters) {
             }]
     };
 }
+/**
+ * Handler for getting task comments
+ */
+export async function handleGetTaskComments(parameters) {
+    const { taskId, taskName, listName, start, startId } = parameters;
+    try {
+        // Call the handler with validation
+        const result = await getTaskCommentsTool.handler({
+            taskId,
+            taskName,
+            listName,
+            start: start ? Number(start) : undefined,
+            startId
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify(result, null, 2)
+                }]
+        };
+    }
+    catch (error) {
+        // Handle and format error response with proper content array
+        console.error('Error getting task comments:', error);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        error: error.message || 'Failed to get task comments',
+                        taskId: taskId || null,
+                        taskName: taskName || null,
+                        listName: listName || null
+                    }, null, 2)
+                }]
+        };
+    }
+}

package/build/tools/workspace.js

@@ -4,6 +4,9 @@
  * This module defines workspace-related tools like retrieving workspace hierarchy.
  * It handles the workspace tool definitions and the implementation of their handlers.
  */
+import { Logger } from '../logger.js';
+// Create a logger for workspace tools
+const logger = new Logger('WorkspaceTool');
 // Use the workspace service imported from the server
 // This is defined when server.ts imports this module
 let workspaceService;
@@ -22,7 +25,15 @@ export const workspaceHierarchyTool = {
  * Initialize the tool with services
  */
 export function initializeWorkspaceTool(services) {
+    logger.info('Initializing workspace tool');
+    if (!services || !services.workspace) {
+        logger.error('Failed to initialize workspace tool: services not provided');
+        throw new Error('Workspace service not available');
+    }
     workspaceService = services.workspace;
+    logger.info('Workspace tool initialized successfully', {
+        serviceType: workspaceService.constructor.name
+    });
 }
 /**
  * Handler for the get_workspace_hierarchy tool

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taazkareem/clickup-mcp-server",
-  "version": "0.4.67",
+  "version": "0.4.69",
   "description": "ClickUp MCP Server - Integrate ClickUp tasks with AI through Model Context Protocol",
   "type": "module",
   "main": "build/index.js",