@taazkareem/clickup-mcp-server 0.4.68 → 0.4.70

package/build/services/clickup/task.js

@@ -158,7 +158,7 @@ export class TaskService extends BaseClickUpService {
         }
     }
     /**
-     * Find a task by its name in a specific list
+     * Find a task by name within a list
      * @param listId The list ID to search within
      * @param taskName The name of the task to find
      * @returns The task if found, otherwise null
@@ -167,7 +167,26 @@ export class TaskService extends BaseClickUpService {
         this.logOperation('findTaskByName', { listId, taskName });
         try {
             const tasks = await this.getTasks(listId);
-            const matchingTask = tasks.find(task => task.name.toLowerCase() === taskName.toLowerCase());
+            // Normalize the search term
+            const normalizedSearchTerm = taskName.toLowerCase().trim();
+            // First try exact match
+            let matchingTask = tasks.find(task => task.name.toLowerCase().trim() === normalizedSearchTerm);
+            // If no exact match, try substring match
+            if (!matchingTask) {
+                matchingTask = tasks.find(task => task.name.toLowerCase().trim().includes(normalizedSearchTerm) ||
+                    normalizedSearchTerm.includes(task.name.toLowerCase().trim()));
+            }
+            // If still no match and there are emoji characters, try matching without emoji
+            if (!matchingTask && /[\p{Emoji}]/u.test(normalizedSearchTerm)) {
+                // Remove emoji and try again (simple approximation)
+                const withoutEmoji = normalizedSearchTerm.replace(/[\p{Emoji}]/gu, '').trim();
+                matchingTask = tasks.find(task => {
+                    const taskNameWithoutEmoji = task.name.toLowerCase().replace(/[\p{Emoji}]/gu, '').trim();
+                    return taskNameWithoutEmoji === withoutEmoji ||
+                        taskNameWithoutEmoji.includes(withoutEmoji) ||
+                        withoutEmoji.includes(taskNameWithoutEmoji);
+                });
+            }
             return matchingTask || null;
         }
         catch (error) {
@@ -489,4 +508,29 @@ export class TaskService extends BaseClickUpService {
             throw new ClickUpServiceError(`Failed to delete tasks in bulk: ${error.message}`, ErrorCode.UNKNOWN, error);
         }
     }
+    /**
+     * Get comments for a specific task
+     * @param taskId The ID of the task to retrieve comments for
+     * @param start Optional parameter for pagination, timestamp from which to start fetching comments
+     * @param startId Optional parameter for pagination, comment ID from which to start fetching
+     * @returns Array of task comments
+     */
+    async getTaskComments(taskId, start, startId) {
+        this.logOperation('getTaskComments', { taskId, start, startId });
+        try {
+            return await this.makeRequest(async () => {
+                const params = new URLSearchParams();
+                // Add pagination parameters if provided
+                if (start)
+                    params.append('start', String(start));
+                if (startId)
+                    params.append('start_id', startId);
+                const response = await this.client.get(`/task/${taskId}/comment`, { params });
+                return response.data.comments;
+            });
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to retrieve comments for task ${taskId}`);
+        }
+    }
 }

package/build/services/clickup/workspace.js

@@ -145,7 +145,9 @@ export class WorkspaceService extends BaseClickUpService {
                 }
                 // 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({
                         id: list.id,
                         name: list.name,
@@ -218,11 +220,11 @@ export class WorkspaceService extends BaseClickUpService {
         return space ? space.id : null;
     }
     /**
-     * Get lists from the API (using the appropriate endpoint based on context)
+     * Get folderless lists from the API (lists that are directly in a space)
      * @param spaceId - The ID of the space
      * @returns - Promise resolving to array of lists
      */
-    async getLists(spaceId) {
+    async getFolderlessLists(spaceId) {
         try {
             const response = await this.makeRequest(async () => {
                 const result = await this.client.get(`/space/${spaceId}/list`);
@@ -231,7 +233,24 @@ export class WorkspaceService extends BaseClickUpService {
             return response.lists || [];
         }
         catch (error) {
-            throw this.handleError(error, `Failed to get lists for space ${spaceId}`);
+            throw this.handleError(error, `Failed to get folderless lists for space ${spaceId}`);
+        }
+    }
+    /**
+     * Get lists in a space (not in any folder)
+     * @param spaceId - The ID of the space
+     * @returns - Promise resolving to array of lists
+     */
+    async getListsInSpace(spaceId) {
+        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}`);
+            // Return all lists without filtering since the API already returns folderless lists
+            return lists;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get lists in space ${spaceId}`);
         }
     }
     /**
@@ -267,20 +286,6 @@ export class WorkspaceService extends BaseClickUpService {
             throw this.handleError(error, `Failed to get folder with ID ${folderId}`);
         }
     }
-    /**
-     * Get lists in a space (not in any folder)
-     * @param spaceId - The ID of the space
-     * @returns - Promise resolving to array of lists
-     */
-    async getListsInSpace(spaceId) {
-        try {
-            const lists = await this.getLists(spaceId);
-            return lists.filter((list) => !list.folder); // Filter lists not in a folder
-        }
-        catch (error) {
-            throw this.handleError(error, `Failed to get lists in space ${spaceId}`);
-        }
-    }
     /**
      * Get folders in a space
      * @param spaceId - The ID of the space

package/build/services/shared.js

@@ -6,10 +6,30 @@
  */
 import { createClickUpServices } from './clickup/index.js';
 import config from '../config.js';
+import { Logger } from '../logger.js';
+const logger = new Logger('SharedServices');
+// Singleton instance
+let servicesInstance = null;
+/**
+ * Get or create the ClickUp services instance
+ */
+function getClickUpServices() {
+    if (!servicesInstance) {
+        logger.info('Creating shared ClickUp services singleton');
+        // Create the services instance
+        servicesInstance = createClickUpServices({
+            apiKey: config.clickupApiKey,
+            teamId: config.clickupTeamId
+        });
+        // Log what services were initialized with more clarity
+        logger.info('Services initialization complete', {
+            services: Object.keys(servicesInstance).join(', '),
+            teamId: config.clickupTeamId
+        });
+    }
+    return servicesInstance;
+}
 // Create a single instance of ClickUp services to be shared
-export const clickUpServices = createClickUpServices({
-    apiKey: config.clickupApiKey,
-    teamId: config.clickupTeamId
-});
+export const clickUpServices = getClickUpServices();
 // Export individual services for convenience
 export const { list: listService, task: taskService, folder: folderService, workspace: workspaceService } = clickUpServices;

package/build/tools/cache.js

@@ -0,0 +1,452 @@
+/**
+ * ClickUp MCP Cache Module
+ *
+ * This module provides caching for workspace data including:
+ * - Workspace hierarchy (spaces, folders, lists)
+ * - Task data (names, IDs, and metadata)
+ *
+ * The cache is initialized on server startup and updated when
+ * tasks, lists, folders, or spaces are modified.
+ */
+import { createClickUpServices } from '../services/clickup/index.js';
+import config from '../config.js';
+import { log } from '../logger.js';
+// Initialize ClickUp services
+const services = createClickUpServices({
+    apiKey: config.clickupApiKey,
+    teamId: config.clickupTeamId
+});
+const { workspace: workspaceService, task: taskService, list: listService, folder: folderService } = services;
+/**
+ * Singleton cache instance
+ */
+let workspaceCache = null;
+/**
+ * Normalize a name for case-insensitive lookups
+ */
+function normalizeName(name) {
+    return name.toLowerCase().trim();
+}
+/**
+ * Generate a unique key for task name lookup
+ */
+function getTaskNameKey(listId, taskName) {
+    return `${listId}:${normalizeName(taskName)}`;
+}
+/**
+ * Initialize an empty cache structure
+ */
+function createEmptyCache() {
+    return {
+        hierarchy: {
+            root: {
+                id: config.clickupTeamId,
+                name: 'Workspace',
+                children: []
+            }
+        },
+        tasksById: new Map(),
+        tasksByName: new Map(),
+        listIdsByName: new Map(),
+        folderIdsByName: new Map(),
+        spaceIdsByName: new Map(),
+        lastUpdated: new Date(),
+        initialized: false
+    };
+}
+/**
+ * Process workspace hierarchy to populate ID lookup maps
+ */
+function processHierarchy(hierarchy) {
+    if (!workspaceCache) {
+        workspaceCache = createEmptyCache();
+    }
+    // Clear existing maps
+    workspaceCache.listIdsByName.clear();
+    workspaceCache.folderIdsByName.clear();
+    workspaceCache.spaceIdsByName.clear();
+    // Recursively process all nodes
+    const processNode = (node) => {
+        const normalizedName = normalizeName(node.name);
+        // Store in appropriate map based on node type
+        switch (node.type) {
+            case 'space':
+                workspaceCache.spaceIdsByName.set(normalizedName, node.id);
+                break;
+            case 'folder':
+                workspaceCache.folderIdsByName.set(normalizedName, node.id);
+                break;
+            case 'list':
+                workspaceCache.listIdsByName.set(normalizedName, node.id);
+                break;
+        }
+        // Process children recursively
+        if (node.children && node.children.length > 0) {
+            node.children.forEach(child => processNode(child));
+        }
+    };
+    // Process all space nodes (children of the root)
+    hierarchy.root.children.forEach(node => processNode(node));
+}
+/**
+ * Cache a single task
+ */
+function cacheTask(task) {
+    if (!workspaceCache) {
+        workspaceCache = createEmptyCache();
+    }
+    // Create cached task object
+    const cachedTask = {
+        id: task.id,
+        name: task.name,
+        listId: task.list.id,
+        status: task.status?.status,
+        dueDate: task.due_date,
+        priority: task.priority?.priority ? Number(task.priority.priority) : null,
+        createdDate: task.date_created,
+        updatedDate: task.date_updated
+    };
+    // Store in maps
+    workspaceCache.tasksById.set(task.id, cachedTask);
+    workspaceCache.tasksByName.set(getTaskNameKey(task.list.id, task.name), task.id);
+}
+/**
+ * Remove a task from the cache
+ */
+function removeCachedTask(taskId) {
+    if (!workspaceCache || !workspaceCache.tasksById.has(taskId)) {
+        return;
+    }
+    // Get task details before removing
+    const task = workspaceCache.tasksById.get(taskId);
+    if (task) {
+        // Remove from name lookup
+        const nameKey = getTaskNameKey(task.listId, task.name);
+        workspaceCache.tasksByName.delete(nameKey);
+        // Remove from ID lookup
+        workspaceCache.tasksById.delete(taskId);
+    }
+}
+/**
+ * Update a cached task with new data
+ */
+function updateCachedTask(taskId, updates) {
+    if (!workspaceCache || !workspaceCache.tasksById.has(taskId)) {
+        return;
+    }
+    const task = workspaceCache.tasksById.get(taskId);
+    if (!task)
+        return;
+    // Handle name change - requires updating the tasksByName map
+    if (updates.name && updates.name !== task.name) {
+        // Remove old name lookup
+        const oldNameKey = getTaskNameKey(task.listId, task.name);
+        workspaceCache.tasksByName.delete(oldNameKey);
+        // Add new name lookup
+        const newNameKey = getTaskNameKey(task.listId, updates.name);
+        workspaceCache.tasksByName.set(newNameKey, taskId);
+    }
+    // Handle list change - requires updating the tasksByName map
+    if (updates.listId && updates.listId !== task.listId) {
+        // Remove old list-based lookup
+        const oldNameKey = getTaskNameKey(task.listId, task.name);
+        workspaceCache.tasksByName.delete(oldNameKey);
+        // Add new list-based lookup
+        const newNameKey = getTaskNameKey(updates.listId, task.name);
+        workspaceCache.tasksByName.set(newNameKey, taskId);
+    }
+    // Update the task object with all provided updates
+    Object.assign(task, updates);
+    // Update the task in the cache
+    workspaceCache.tasksById.set(taskId, task);
+    // Update last updated timestamp
+    workspaceCache.lastUpdated = new Date();
+}
+/**
+ * Cache all tasks for a list
+ */
+async function cacheTasksForList(listId) {
+    try {
+        log('debug', `Fetching tasks for list ${listId}...`);
+        const tasks = await taskService.getTasks(listId);
+        log('debug', `Caching ${tasks.length} tasks for list ${listId}`);
+        tasks.forEach(task => {
+            cacheTask(task);
+        });
+        // Update last updated timestamp
+        if (workspaceCache) {
+            workspaceCache.lastUpdated = new Date();
+        }
+    }
+    catch (error) {
+        log('error', `Error caching tasks for list ${listId}:`, error);
+    }
+}
+/**
+ * Initialize the workspace cache
+ * This should be called on server startup
+ */
+export async function initializeCache() {
+    try {
+        log('info', 'Initializing workspace cache...');
+        // Create new cache
+        workspaceCache = createEmptyCache();
+        log('debug', 'Empty cache structure created');
+        // Get workspace hierarchy
+        log('debug', 'Fetching workspace hierarchy from ClickUp API...');
+        const hierarchy = await workspaceService.getWorkspaceHierarchy(true);
+        workspaceCache.hierarchy = hierarchy;
+        // Count spaces, folders, and lists in the hierarchy
+        const stats = countHierarchyItems(hierarchy);
+        log('info', 'Workspace hierarchy fetched successfully', stats);
+        // Process hierarchy to populate ID lookup maps
+        log('debug', 'Processing hierarchy to build lookup maps...');
+        processHierarchy(hierarchy);
+        // Log the number of items in each lookup map
+        log('info', 'Lookup maps populated', {
+            spaces: workspaceCache.spaceIdsByName.size,
+            folders: workspaceCache.folderIdsByName.size,
+            lists: workspaceCache.listIdsByName.size
+        });
+        // Cache tasks for each list
+        log('info', 'Beginning task caching process for all lists...');
+        // Function to find all list IDs in the hierarchy
+        const getAllListIds = (node) => {
+            let listIds = [];
+            if (node.type === 'list') {
+                listIds.push(node.id);
+            }
+            if (node.children && node.children.length > 0) {
+                node.children.forEach(child => {
+                    listIds = [...listIds, ...getAllListIds(child)];
+                });
+            }
+            return listIds;
+        };
+        // Get all list IDs from all spaces
+        const listIds = [];
+        hierarchy.root.children.forEach(spaceNode => {
+            listIds.push(...getAllListIds(spaceNode));
+        });
+        log('info', `Found ${listIds.length} lists to cache tasks from`);
+        // Cache tasks for each list (sequentially to avoid rate limiting)
+        let completedLists = 0;
+        let totalTasksCached = 0;
+        for (const listId of listIds) {
+            // Get list name if available
+            const listName = getListNameById(listId, hierarchy);
+            log('debug', `Processing list ${completedLists + 1}/${listIds.length}: ${listName || listId}`);
+            // Get task count before caching
+            const taskCountBefore = workspaceCache.tasksById.size;
+            await cacheTasksForList(listId);
+            // Calculate how many tasks were added
+            const taskCountAfter = workspaceCache.tasksById.size;
+            const tasksAdded = taskCountAfter - taskCountBefore;
+            totalTasksCached += tasksAdded;
+            completedLists++;
+            // Log progress every 5 lists or for the last list
+            if (completedLists % 5 === 0 || completedLists === listIds.length) {
+                log('info', `Cache progress: ${completedLists}/${listIds.length} lists processed (${Math.round(completedLists / listIds.length * 100)}%)`, {
+                    totalTasksCached,
+                    completedLists,
+                    remainingLists: listIds.length - completedLists
+                });
+            }
+            // Small delay to avoid rate limiting
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        // Mark cache as initialized
+        workspaceCache.initialized = true;
+        workspaceCache.lastUpdated = new Date();
+        // Log final cache stats
+        const cacheStats = getCacheStats();
+        log('info', `Workspace cache initialized successfully`, cacheStats);
+    }
+    catch (error) {
+        log('error', 'Error initializing workspace cache:', error);
+        // Reset cache on error
+        workspaceCache = null;
+        // Re-throw error
+        throw error;
+    }
+}
+/**
+ * Helper function to count items in the hierarchy
+ */
+function countHierarchyItems(hierarchy) {
+    let spaces = 0;
+    let folders = 0;
+    let lists = 0;
+    const countNode = (node) => {
+        switch (node.type) {
+            case 'space':
+                spaces++;
+                break;
+            case 'folder':
+                folders++;
+                break;
+            case 'list':
+                lists++;
+                break;
+        }
+        if (node.children && node.children.length > 0) {
+            node.children.forEach(countNode);
+        }
+    };
+    // Count all spaces (children of root)
+    hierarchy.root.children.forEach(countNode);
+    return { spaces, folders, lists };
+}
+/**
+ * Helper function to get list name by ID
+ */
+function getListNameById(listId, hierarchy) {
+    let result = null;
+    const findListName = (node) => {
+        if (node.type === 'list' && node.id === listId) {
+            result = node.name;
+            return true;
+        }
+        if (node.children) {
+            for (const child of node.children) {
+                if (findListName(child)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+    hierarchy.root.children.forEach(findListName);
+    return result;
+}
+/**
+ * Check if the cache is initialized
+ */
+export function isCacheInitialized() {
+    return !!(workspaceCache && workspaceCache.initialized);
+}
+/**
+ * Get the workspace hierarchy from cache
+ */
+export function getCachedHierarchy() {
+    return workspaceCache?.hierarchy || null;
+}
+/**
+ * Find an entity ID by name from the cache
+ */
+export function findIDByNameInCache(name, type) {
+    if (!workspaceCache || !workspaceCache.initialized) {
+        return null;
+    }
+    const normalizedName = normalizeName(name);
+    switch (type) {
+        case 'space':
+            return workspaceCache.spaceIdsByName.get(normalizedName) || null;
+        case 'folder':
+            return workspaceCache.folderIdsByName.get(normalizedName) || null;
+        case 'list':
+            return workspaceCache.listIdsByName.get(normalizedName) || null;
+        default:
+            return null;
+    }
+}
+/**
+ * Find a task ID by name and list ID from the cache
+ */
+export function findTaskIDByName(taskName, listId) {
+    if (!workspaceCache || !workspaceCache.initialized) {
+        return null;
+    }
+    const nameKey = getTaskNameKey(listId, taskName);
+    return workspaceCache.tasksByName.get(nameKey) || null;
+}
+/**
+ * Get a task by ID from the cache
+ */
+export function getTaskFromCache(taskId) {
+    if (!workspaceCache || !workspaceCache.initialized) {
+        return null;
+    }
+    return workspaceCache.tasksById.get(taskId) || null;
+}
+/**
+ * Add a new task to the cache
+ */
+export function addTaskToCache(task) {
+    if (!workspaceCache || !workspaceCache.initialized) {
+        return;
+    }
+    cacheTask(task);
+    workspaceCache.lastUpdated = new Date();
+}
+/**
+ * Remove a task from the cache
+ */
+export function removeTaskFromCache(taskId) {
+    if (!workspaceCache || !workspaceCache.initialized) {
+        return;
+    }
+    removeCachedTask(taskId);
+    workspaceCache.lastUpdated = new Date();
+}
+/**
+ * Update a task in the cache
+ */
+export function updateTaskInCache(taskId, updates) {
+    if (!workspaceCache || !workspaceCache.initialized) {
+        return;
+    }
+    updateCachedTask(taskId, updates);
+}
+/**
+ * Refresh the tasks for a specific list in the cache
+ */
+export async function refreshListTasksInCache(listId) {
+    if (!workspaceCache || !workspaceCache.initialized) {
+        return;
+    }
+    // Remove existing tasks for this list
+    const tasksToRemove = [];
+    workspaceCache.tasksById.forEach((task, id) => {
+        if (task.listId === listId) {
+            tasksToRemove.push(id);
+        }
+    });
+    tasksToRemove.forEach(taskId => {
+        removeCachedTask(taskId);
+    });
+    // Cache tasks for the list
+    await cacheTasksForList(listId);
+}
+/**
+ * Refresh the entire workspace cache
+ */
+export async function refreshCache() {
+    // Reset cache
+    workspaceCache = null;
+    // Re-initialize
+    await initializeCache();
+}
+/**
+ * Get cache statistics for monitoring
+ */
+export function getCacheStats() {
+    if (!workspaceCache) {
+        return {
+            initialized: false,
+            tasksCount: 0,
+            listsCount: 0,
+            foldersCount: 0,
+            spacesCount: 0,
+            lastUpdated: null
+        };
+    }
+    return {
+        initialized: workspaceCache.initialized,
+        tasksCount: workspaceCache.tasksById.size,
+        listsCount: workspaceCache.listIdsByName.size,
+        foldersCount: workspaceCache.folderIdsByName.size,
+        spacesCount: workspaceCache.spaceIdsByName.size,
+        lastUpdated: workspaceCache.lastUpdated
+    };
+}

package/build/tools/debug.js

@@ -0,0 +1,76 @@
+/**
+ * Debug Tools
+ *
+ * This module provides tools for debugging and monitoring the ClickUp MCP server.
+ */
+// In-memory log storage
+const DEBUG_LOGS = [];
+/**
+ * Log a message to the in-memory debug logs
+ */
+export function logDebug(message, level = 'info') {
+    const timestamp = new Date().toISOString();
+    DEBUG_LOGS.push({ timestamp, message, level });
+    // Optional: Also print to console for development
+    if (level === 'error') {
+        console.error(`[${timestamp}] ERROR: ${message}`);
+    }
+    else if (level === 'warn') {
+        console.warn(`[${timestamp}] WARN: ${message}`);
+    }
+    else {
+        console.log(`[${timestamp}] INFO: ${message}`);
+    }
+}
+/**
+ * Tool definition for checking debug logs
+ */
+export const checkDebugLogsTool = {
+    name: 'check_debug_logs',
+    description: 'Check the server debug logs collected since the server started.',
+    inputSchema: {
+        type: 'object',
+        properties: {}
+    }
+};
+/**
+ * Tool definition for clearing debug logs
+ */
+export const clearDebugLogsTool = {
+    name: 'clear_debug_logs',
+    description: 'Clear all server debug logs.',
+    inputSchema: {
+        type: 'object',
+        properties: {}
+    }
+};
+/**
+ * Handler for the check_debug_logs tool
+ */
+export function handleCheckDebugLogs() {
+    return {
+        content: [
+            {
+                type: "text",
+                text: DEBUG_LOGS.length > 0
+                    ? DEBUG_LOGS.map(log => `[${log.timestamp}] [${log.level.toUpperCase()}] ${log.message}`).join('\n')
+                    : "No debug logs available."
+            }
+        ]
+    };
+}
+/**
+ * Handler for the clear_debug_logs tool
+ */
+export function handleClearDebugLogs() {
+    const count = DEBUG_LOGS.length;
+    DEBUG_LOGS.length = 0;
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Cleared ${count} debug log entries.`
+            }
+        ]
+    };
+}