@taazkareem/clickup-mcp-server 0.6.7 → 0.6.9

package/build/services/clickup/tools/tag.js

@@ -0,0 +1,149 @@
+/**
+ * Remove a tag from a task
+ * @param taskId Task ID or custom ID
+ * @param taskName Task name (for lookup if ID not provided)
+ * @param listName List name (optional, for improved task name lookup)
+ * @param tagName Tag name to remove
+ * @returns Success response
+ */
+export async function removeTagFromTask(taskId, taskName, listName, tagName) {
+    logger.info(`[TAG REMOVAL] Starting tag removal for ${taskId || taskName}`);
+    try {
+        // Step 1: Find the task
+        let resolvedTaskId;
+        if (taskId) {
+            // If task ID is provided, use it directly
+            resolvedTaskId = taskId;
+            logger.info(`[TAG REMOVAL] Using provided task ID: ${resolvedTaskId}`);
+        }
+        else if (taskName) {
+            // If task name is provided, let's use a more direct approach
+            // First try to get tasks in the list if list name is provided
+            if (listName) {
+                logger.info(`[TAG REMOVAL] Looking up task by name in list "${listName}"`);
+                const list = await findListIDByName(clickUpServices.workspace, listName);
+                if (list) {
+                    const tasks = await clickUpServices.task.getTasks(list.id);
+                    // Try to find the task by name using a direct case-insensitive comparison
+                    const foundTask = tasks.find(t => t.name.toLowerCase() === taskName.toLowerCase());
+                    if (foundTask) {
+                        resolvedTaskId = foundTask.id;
+                        logger.info(`[TAG REMOVAL] Found task in list "${listName}": ${resolvedTaskId}`);
+                    }
+                    else {
+                        // Try to find by substring
+                        const substringMatch = tasks.find(t => t.name.toLowerCase().includes(taskName.toLowerCase()) ||
+                            taskName.toLowerCase().includes(t.name.toLowerCase()));
+                        if (substringMatch) {
+                            resolvedTaskId = substringMatch.id;
+                            logger.info(`[TAG REMOVAL] Found task in list "${listName}" by substring: ${resolvedTaskId}`);
+                        }
+                        else {
+                            // If not found, try the alternative approach
+                            logger.info(`[TAG REMOVAL] Task not found in list, trying global lookup`);
+                            // Get all tasks in workspace
+                            const filters = { list_ids: [list.id], include_closed: true };
+                            const response = await clickUpServices.task.getWorkspaceTasks({ ...filters, detail_level: 'detailed' });
+                            // Direct comparison of all tasks
+                            if ('tasks' in response && response.tasks.length > 0) {
+                                // Log first few tasks to see what's available
+                                logger.info(`[TAG REMOVAL] Workspace search found ${response.tasks.length} tasks in list "${listName}"`);
+                                // Try to find by exact name
+                                const exactMatch = response.tasks.find(t => t.name === taskName);
+                                if (exactMatch) {
+                                    resolvedTaskId = exactMatch.id;
+                                    logger.info(`[TAG REMOVAL] Found exact match: ${resolvedTaskId}`);
+                                }
+                                else {
+                                    // Try case-insensitive
+                                    const caseInsensitiveMatch = response.tasks.find(t => t.name.toLowerCase() === taskName.toLowerCase());
+                                    if (caseInsensitiveMatch) {
+                                        resolvedTaskId = caseInsensitiveMatch.id;
+                                        logger.info(`[TAG REMOVAL] Found case-insensitive match: ${resolvedTaskId}`);
+                                    }
+                                    else {
+                                        throw new Error(`Task "${taskName}" not found in list "${listName}"`);
+                                    }
+                                }
+                            }
+                            else {
+                                throw new Error(`No tasks found in list "${listName}"`);
+                            }
+                        }
+                    }
+                }
+                else {
+                    throw new Error(`List "${listName}" not found`);
+                }
+            }
+            else {
+                // If no list name, search across the workspace
+                logger.info(`[TAG REMOVAL] Searching for task by name across workspace: "${taskName}"`);
+                // Get all tasks across all lists instead of using global lookup
+                const response = await clickUpServices.task.getWorkspaceTasks({ include_closed: true, detail_level: 'detailed' });
+                if ('tasks' in response && response.tasks.length > 0) {
+                    // Try exact match first
+                    const exactMatch = response.tasks.find(t => t.name === taskName);
+                    if (exactMatch) {
+                        resolvedTaskId = exactMatch.id;
+                        logger.info(`[TAG REMOVAL] Found exact match: ${resolvedTaskId}`);
+                    }
+                    else {
+                        // Try case-insensitive
+                        const caseInsensitiveMatch = response.tasks.find(t => t.name.toLowerCase() === taskName.toLowerCase());
+                        if (caseInsensitiveMatch) {
+                            resolvedTaskId = caseInsensitiveMatch.id;
+                            logger.info(`[TAG REMOVAL] Found case-insensitive match: ${resolvedTaskId}`);
+                        }
+                        else {
+                            // Try substring match
+                            const substringMatch = response.tasks.find(t => t.name.toLowerCase().includes(taskName.toLowerCase()) ||
+                                taskName.toLowerCase().includes(t.name.toLowerCase()));
+                            if (substringMatch) {
+                                resolvedTaskId = substringMatch.id;
+                                logger.info(`[TAG REMOVAL] Found substring match: ${resolvedTaskId}`);
+                            }
+                            else {
+                                throw new Error(`Task "${taskName}" not found in workspace`);
+                            }
+                        }
+                    }
+                }
+                else {
+                    throw new Error(`No tasks found in workspace`);
+                }
+            }
+        }
+        else {
+            throw new Error("Either taskId or taskName must be provided");
+        }
+        // Step 2: Get the current task to check for tags
+        const task = await clickUpServices.task.getTask(resolvedTaskId);
+        logger.info(`[TAG REMOVAL] Retrieved task ${resolvedTaskId}, current tags: ${task.tags.map(t => t.name).join(', ')}`);
+        // Step 3: Check if the tag exists on the task
+        const hasTag = task.tags.some(tag => tag.name.toLowerCase() === tagName.toLowerCase());
+        if (!hasTag) {
+            logger.info(`[TAG REMOVAL] Tag "${tagName}" not found on task ${resolvedTaskId}`);
+            return {
+                success: true,
+                message: "Tag removed from task successfully"
+            };
+        }
+        // Step 4: Remove the tag by updating the task
+        // Filter out the tag we want to remove
+        const updatedTags = task.tags.filter(tag => tag.name.toLowerCase() !== tagName.toLowerCase());
+        logger.info(`[TAG REMOVAL] Filtered tags from ${task.tags.length} to ${updatedTags.length}`);
+        // Use directly the ClickUp API to remove tag
+        const encodedTagName = encodeURIComponent(tagName);
+        await clickUpServices.task.client.delete(`/task/${resolvedTaskId}/tag/${encodedTagName}`);
+        logger.info(`[TAG REMOVAL] Successfully removed tag "${tagName}" from task ${resolvedTaskId}`);
+        return {
+            success: true,
+            message: "Tag removed from task successfully"
+        };
+    }
+    catch (error) {
+        logger.error(`[TAG REMOVAL] Error removing tag: ${error instanceof Error ? error.message : String(error)}`);
+        throw clickUpServices.task.handleError(error, `Failed to remove tag: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/build/tools/bulk-tasks.js

@@ -0,0 +1,36 @@
+/**
+ * Alternative implementation for bulk tasks creation
+ */
+import { handleCreateBulkTasks } from './task.js';
+/**
+ * Alternative tool definition for bulk task creation to work around MCP validation issues
+ */
+export const createTasksBulkTool = {
+    name: "create_tasks_bulk",
+    description: "Create multiple tasks in a list efficiently. You MUST provide:\n1. An array of tasks with required properties\n2. Either listId or listName to specify the target list",
+    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: {
+                // Define minimally to avoid validation issues
+                description: "Array of tasks to create. Each task must have at least a name."
+            }
+        },
+        required: ["tasks"]
+    }
+};
+/**
+ * Handler for create_tasks_bulk tool
+ */
+export async function handleCreateTasksBulk(parameters) {
+    // Use the same implementation as handleCreateBulkTasks
+    return handleCreateBulkTasks(parameters);
+}

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.`
+            }
+        ]
+    };
+}

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/handlers.js

@@ -21,6 +21,8 @@ const { task: taskService, list: listService } = clickUpServices;
 const bulkService = new BulkService(taskService);
 // Create a logger instance for task handlers
 const logger = new Logger('TaskHandlers');
+// Token limit constant for workspace tasks
+const WORKSPACE_TASKS_TOKEN_LIMIT = 50000;
 // Cache for task context between sequential operations
 const taskContextCache = new Map();
 const TASK_CONTEXT_TTL = 5 * 60 * 1000; // 5 minutes
@@ -446,6 +448,39 @@ export async function createTaskCommentHandler(params) {
         throw error;
     }
 }
+/**
+ * Estimate tokens for a task response
+ * This is a simplified estimation - adjust based on actual token counting needs
+ */
+function estimateTaskResponseTokens(task) {
+    // Base estimation for task structure
+    let tokenCount = 0;
+    // Core fields
+    tokenCount += (task.name?.length || 0) / 4; // Approximate tokens for name
+    tokenCount += (task.description?.length || 0) / 4; // Approximate tokens for description
+    tokenCount += (task.text_content?.length || 0) / 4; // Use text_content instead of markdown_description
+    // Status and other metadata
+    tokenCount += 5; // Basic metadata fields
+    // Custom fields
+    if (task.custom_fields) {
+        tokenCount += Object.keys(task.custom_fields).length * 10; // Rough estimate per custom field
+    }
+    // Add overhead for JSON structure
+    tokenCount *= 1.1;
+    return Math.ceil(tokenCount);
+}
+/**
+ * Check if response would exceed token limit
+ */
+function wouldExceedTokenLimit(response) {
+    if (!response.tasks?.length)
+        return false;
+    // Calculate total estimated tokens
+    const totalTokens = response.tasks.reduce((sum, task) => sum + estimateTaskResponseTokens(task), 0);
+    // Add overhead for response structure
+    const estimatedTotal = totalTokens * 1.1;
+    return estimatedTotal > WORKSPACE_TASKS_TOKEN_LIMIT;
+}
 /**
  * Handler for getting workspace tasks with filtering
  */
@@ -495,6 +530,16 @@ export async function getWorkspaceTasksHandler(taskService, params) {
         };
         // Get tasks with adaptive response format support
         const response = await taskService.getWorkspaceTasks(filters);
+        // Check token limit at handler level
+        if (params.detail_level !== 'summary' && wouldExceedTokenLimit(response)) {
+            logger.info('Response would exceed token limit, fetching summary format instead');
+            // Refetch with summary format
+            const summaryResponse = await taskService.getWorkspaceTasks({
+                ...filters,
+                detail_level: 'summary'
+            });
+            return summaryResponse;
+        }
         // Return the response without adding the redundant _note field
         return response;
     }