@taazkareem/clickup-mcp-server 0.2.0 → 0.4.0

package/README.md

@@ -16,18 +16,24 @@ A Model Context Protocol (MCP) server for integrating ClickUp tasks with AI appl
   - Flexible identification using IDs or names
 
 - ✨ **Task Operations**
-  - Create and update tasks
+  - Create single or bulk tasks
   - Move tasks between lists
   - Duplicate tasks
   - Set priorities and due dates
   - Assign team members
 
 - 📊 **Information Retrieval**
-  - Get spaces and lists with their IDs
+  - Get complete hierarchy of spaces, folders, and lists with IDs
   - List available statuses
   - Find items by name (case-insensitive)
   - View task relationships
 
+- 🔍 **Smart Name Resolution**
+  - Use names instead of IDs for lists and folders
+  - Global search across all spaces
+  - Case-insensitive matching
+  - Automatic location of items
+
 - 📝 **AI Integration**
   - Generate task descriptions with AI
   - Summarize tasks and analyze priorities
@@ -58,33 +64,64 @@ CLICKUP_API_KEY=your_api_key_here
 TEAM_ID=your_team_id_here
 ```
 
-## Usage
+## Using with Cursor AI Composer
+
+To add this server to Cursor AI Composer, follow these steps:
+
+1. Go to the Features section in the settings.
+2. Add the following command under MCP Servers:
 
-### Starting the Server
 ```bash
-clickup-mcp-server
+npx -y @taazkareem/clickup-mcp-server \
+  --env CLICKUP_API_KEY=your_api_key_here \
+  --env TEAM_ID=your_team_id_here
 ```
+3. Replace `your_api_key_here` and `your_team_id_here` with your actual ClickUp credentials.
+4. Click on 'Save' to add the server.
+
+You can get these values from:
+- `CLICKUP_API_KEY`: Get from [ClickUp Settings > Apps](https://app.clickup.com/settings/apps)
+- `TEAM_ID`: Your ClickUp Team ID (found in the URL when viewing your workspace or via API)
+
+> **Security Note**: Your API key will be stored securely and will not be exposed to AI models.
 
 ### Available Tools
 
-1. **list_spaces**
-   - Lists all spaces and their lists with IDs
+1. **workspace_hierarchy**
+   - Lists complete hierarchy of the ClickUp workspace
+   - Shows spaces, folders, and lists with their IDs
    - Shows available statuses for each list
+   - Provides a tree view of your workspace organization
    - No parameters required
 
 2. **create_task**
    - Creates a new task in ClickUp
    - Required parameters:
-     - `listId`: ID of the list to create the task in
      - `name`: Name of the task
    - Optional parameters:
+     - `listId`: ID of the list (optional if listName provided)
+     - `listName`: Name of the list (optional if listId provided)
      - `description`: Task description
      - `status`: Task status
      - `priority`: Priority level (1-4)
      - `dueDate`: Due date (ISO string)
      - `assignees`: Array of user IDs
 
-3. **create_list**
+3. **create_bulk_tasks**
+   - Creates multiple tasks simultaneously in a list
+   - Required parameters:
+     - `tasks`: Array of task objects, each containing:
+       - `name`: Name of the task (required)
+       - `description`: Task description (optional)
+       - `status`: Task status (optional)
+       - `priority`: Priority level 1-4 (optional)
+       - `dueDate`: Due date ISO string (optional)
+       - `assignees`: Array of user IDs (optional)
+   - Optional parameters:
+     - `listId`: ID of the list (optional if listName provided)
+     - `listName`: Name of the list (optional if listId provided)
+
+4. **create_list**
    - Creates a new list in a space
    - Required parameters:
      - `name`: Name of the list
@@ -96,7 +133,7 @@ clickup-mcp-server
      - `priority`: Priority level (1-4)
      - `dueDate`: Due date (ISO string)
 
-4. **create_folder**
+5. **create_folder**
    - Creates a new folder in a space
    - Required parameters:
      - `name`: Name of the folder
@@ -105,7 +142,7 @@ clickup-mcp-server
      - `spaceName`: Name of the space (optional if spaceId provided)
      - `override_statuses`: Whether to override space statuses
 
-5. **create_list_in_folder**
+6. **create_list_in_folder**
    - Creates a new list within a folder
    - Required parameters:
      - `name`: Name of the list
@@ -117,19 +154,23 @@ clickup-mcp-server
      - `content`: List description
      - `status`: List status
 
-6. **move_task**
+7. **move_task**
    - Moves a task to a different list
    - Required parameters:
      - `taskId`: ID of the task to move
-     - `listId`: ID of the destination list
+   - Optional parameters:
+     - `listId`: ID of destination list (optional if listName provided)
+     - `listName`: Name of destination list (optional if listId provided)
 
-7. **duplicate_task**
+8. **duplicate_task**
    - Creates a copy of a task in a specified list
    - Required parameters:
      - `taskId`: ID of the task to duplicate
-     - `listId`: ID of the destination list
+   - Optional parameters:
+     - `listId`: ID of destination list (optional if listName provided)
+     - `listName`: Name of destination list (optional if listId provided)
 
-8. **update_task**
+9. **update_task**
    - Updates an existing task
    - Required parameters:
      - `taskId`: ID of the task to update
@@ -181,27 +222,6 @@ The server provides clear error messages for common scenarios:
 - Permission issues
 - API errors
 
-## Using with Cursor AI Composer
-
-To add this server to Cursor AI Composer, follow these steps:
-
-1. Go to the Features section in the settings.
-2. Add the following command under MCP Servers:
-
-```bash
-npx -y @taazkareem/clickup-mcp-server \
-  --env CLICKUP_API_KEY=your_api_key_here \
-  --env TEAM_ID=your_team_id_here
-```
-3. Replace `your_api_key_here` and `your_team_id_here` with your actual ClickUp credentials.
-4. Click on 'Save' to add the server.
-
-You can get these values from:
-- `CLICKUP_API_KEY`: Get from [ClickUp Settings > Apps](https://app.clickup.com/settings/apps)
-- `TEAM_ID`: Your ClickUp Team ID (found in the URL when viewing your workspace or via API)
-
-> **Security Note**: Your API key will be stored securely and will not be exposed to AI models.
-
 ## Development
 
 1. Clone the repository:
@@ -226,4 +246,4 @@ Contributions are welcome! Please read our [Contributing Guide](CONTRIBUTING.md)
 
 ## License
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details. 
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details. 

package/build/index.js

@@ -101,8 +101,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
         tools: [
             {
-                name: "list_spaces",
-                description: "List all spaces and their lists with IDs",
+                name: "workspace_hierarchy",
+                description: "List complete hierarchy of the ClickUp workspace, including spaces, folders, lists, and their IDs and available statuses",
                 inputSchema: {
                     type: "object",
                     properties: {},
@@ -117,7 +117,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     properties: {
                         listId: {
                             type: "string",
-                            description: "ID of the list to create the task in"
+                            description: "ID of the list to create the task in (optional if listName is provided)"
+                        },
+                        listName: {
+                            type: "string",
+                            description: "Name of the list to create the task in (optional if listId is provided)"
                         },
                         name: {
                             type: "string",
@@ -140,7 +144,62 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                             description: "Due date of the task (ISO string)"
                         }
                     },
-                    required: ["listId", "name"]
+                    required: ["name"]
+                }
+            },
+            {
+                name: "create_bulk_tasks",
+                description: "Create multiple tasks in a ClickUp list",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        listId: {
+                            type: "string",
+                            description: "ID of the list to create the tasks in (optional if listName is provided)"
+                        },
+                        listName: {
+                            type: "string",
+                            description: "Name of the list to create the tasks in (optional if listId is provided)"
+                        },
+                        tasks: {
+                            type: "array",
+                            description: "Array of tasks to create",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    name: {
+                                        type: "string",
+                                        description: "Name of the task"
+                                    },
+                                    description: {
+                                        type: "string",
+                                        description: "Description of the task"
+                                    },
+                                    status: {
+                                        type: "string",
+                                        description: "Status of the task"
+                                    },
+                                    priority: {
+                                        type: "number",
+                                        description: "Priority level (1-4)"
+                                    },
+                                    dueDate: {
+                                        type: "string",
+                                        description: "Due date (ISO string)"
+                                    },
+                                    assignees: {
+                                        type: "array",
+                                        items: {
+                                            type: "number"
+                                        },
+                                        description: "Array of user IDs to assign to the task"
+                                    }
+                                },
+                                required: ["name"]
+                            }
+                        }
+                    },
+                    required: ["tasks"]
                 }
             },
             {
@@ -261,10 +320,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         },
                         listId: {
                             type: "string",
-                            description: "ID of the destination list"
+                            description: "ID of the destination list (optional if listName is provided)"
+                        },
+                        listName: {
+                            type: "string",
+                            description: "Name of the destination list (optional if listId is provided)"
                         }
                     },
-                    required: ["taskId", "listId"]
+                    required: ["taskId"]
                 }
             },
             {
@@ -279,10 +342,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         },
                         listId: {
                             type: "string",
-                            description: "ID of the list to create the duplicate in"
+                            description: "ID of the destination list (optional if listName is provided)"
+                        },
+                        listName: {
+                            type: "string",
+                            description: "Name of the destination list (optional if listId is provided)"
                         }
                     },
-                    required: ["taskId", "listId"]
+                    required: ["taskId"]
                 }
             },
             {
@@ -329,17 +396,35 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
         switch (request.params.name) {
-            case "list_spaces": {
+            case "workspace_hierarchy": {
                 const spaces = await clickup.getSpaces(config.teamId);
                 const allLists = await clickup.getAllLists(config.teamId);
-                let output = "Available Spaces and Lists:\n\n";
+                let output = "ClickUp Workspace Hierarchy:\n\n";
                 for (const space of spaces) {
                     output += `Space: ${space.name} (ID: ${space.id})\n`;
-                    const spaceLists = allLists.filter(list => list.space.id === space.id);
-                    for (const list of spaceLists) {
-                        const { statuses } = await clickup.getTasks(list.id);
-                        output += `  └─ List: ${list.name} (ID: ${list.id})\n`;
-                        output += `    Available Statuses: ${statuses.join(', ')}\n`;
+                    // Get folders in this space
+                    const folders = await clickup.getFolders(space.id);
+                    for (const folder of folders) {
+                        output += `  ├─ Folder: ${folder.name} (ID: ${folder.id})\n`;
+                        // Get lists in this folder
+                        const folderLists = folder.lists || [];
+                        for (const list of folderLists) {
+                            const { statuses } = await clickup.getTasks(list.id);
+                            output += `  │  └─ List: ${list.name} (ID: ${list.id})\n`;
+                            output += `  │     Available Statuses: ${statuses.join(', ')}\n`;
+                        }
+                    }
+                    // Get lists directly in space (not in folders)
+                    const spaceLists = allLists.filter(list => list.space &&
+                        list.space.id === space.id &&
+                        !folders.some(folder => folder.lists?.some(fl => fl.id === list.id)));
+                    if (spaceLists.length > 0) {
+                        output += "  ├─ Lists (not in folders):\n";
+                        for (const list of spaceLists) {
+                            const { statuses } = await clickup.getTasks(list.id);
+                            output += `  │  └─ List: ${list.name} (ID: ${list.id})\n`;
+                            output += `  │     Available Statuses: ${statuses.join(', ')}\n`;
+                        }
                     }
                     output += "\n";
                 }
@@ -362,10 +447,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
             case "create_task": {
                 const args = request.params.arguments;
-                if (!args.listId || !args.name) {
-                    throw new Error("listId and name are required");
+                let listId = args.listId;
+                if (!listId && args.listName) {
+                    const result = await clickup.findListByNameGlobally(config.teamId, args.listName);
+                    if (!result) {
+                        throw new Error(`List with name "${args.listName}" not found`);
+                    }
+                    listId = result.list.id;
+                }
+                if (!listId) {
+                    throw new Error("Either listId or listName is required");
                 }
-                const { listId, ...taskData } = args;
+                const { listId: _, listName: __, ...taskData } = args;
                 const task = await clickup.createTask(listId, taskData);
                 return {
                     content: [{
@@ -374,11 +467,59 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         }]
                 };
             }
+            case "create_bulk_tasks": {
+                const args = request.params.arguments;
+                let listId = args.listId;
+                if (!listId && args.listName) {
+                    const result = await clickup.findListByNameGlobally(config.teamId, args.listName);
+                    if (!result) {
+                        throw new Error(`List with name "${args.listName}" not found`);
+                    }
+                    listId = result.list.id;
+                }
+                if (!listId) {
+                    throw new Error("Either listId or listName is required");
+                }
+                if (!args.tasks || !args.tasks.length) {
+                    throw new Error("At least one task is required");
+                }
+                const { listId: _, listName: __, tasks } = args;
+                const createdTasks = await clickup.createBulkTasks(listId, { tasks });
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Created ${createdTasks.length} tasks:\n${createdTasks.map(task => `- ${task.id}: ${task.name}`).join('\n')}`
+                        }]
+                };
+            }
             case "create_list": {
                 const args = request.params.arguments;
                 if (!args.name) {
                     throw new Error("name is required");
                 }
+                // If folder is specified, create list in folder
+                if (args.folderName || args.folderId) {
+                    let folderId = args.folderId;
+                    if (!folderId && args.folderName) {
+                        const result = await clickup.findFolderByNameGlobally(config.teamId, args.folderName);
+                        if (!result) {
+                            throw new Error(`Folder with name "${args.folderName}" not found`);
+                        }
+                        folderId = result.folder.id;
+                    }
+                    if (!folderId) {
+                        throw new Error("Either folderId or folderName must be provided");
+                    }
+                    const { spaceId: _, spaceName: __, folderName: ___, folderId: ____, ...listData } = args;
+                    const list = await clickup.createListInFolder(folderId, listData);
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `Created list ${list.id}: ${list.name} in folder`
+                            }]
+                    };
+                }
+                // Otherwise, create list in space
                 let spaceId = args.spaceId;
                 if (!spaceId && args.spaceName) {
                     const space = await clickup.findSpaceByName(config.teamId, args.spaceName);
@@ -390,7 +531,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 if (!spaceId) {
                     throw new Error("Either spaceId or spaceName must be provided");
                 }
-                const { spaceId: _, spaceName: __, ...listData } = args;
+                const { spaceId: _, spaceName: __, folderName: ___, folderId: ____, ...listData } = args;
                 const list = await clickup.createList(spaceId, listData);
                 return {
                     content: [{
@@ -440,18 +581,21 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         spaceId = space.id;
                     }
                     if (!spaceId) {
-                        throw new Error("Either spaceId or spaceName must be provided when using folderName");
+                        throw new Error("Either spaceId or spaceName must be provided");
                     }
-                    const folder = await clickup.findFolderByName(spaceId, args.folderName);
-                    if (!folder) {
-                        throw new Error(`Folder with name "${args.folderName}" not found`);
-                    }
-                    folderId = folder.id;
+                    const { spaceId: _, spaceName: ___, ...listData } = args;
+                    const list = await clickup.createListInFolder(spaceId, listData);
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `Created list ${list.id}: ${list.name} in folder`
+                            }]
+                    };
                 }
                 if (!folderId) {
-                    throw new Error("Either folderId or folderName (with space information) must be provided");
+                    throw new Error("Either folderId or folderName must be provided");
                 }
-                const { folderId: _, folderName: __, spaceId: ___, spaceName: ____, ...listData } = args;
+                const { spaceId: _, spaceName: ___, ...listData } = args;
                 const list = await clickup.createListInFolder(folderId, listData);
                 return {
                     content: [{
@@ -462,37 +606,64 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
             case "move_task": {
                 const args = request.params.arguments;
-                if (!args.taskId || !args.listId) {
-                    throw new Error("taskId and listId are required");
+                if (!args.taskId) {
+                    throw new Error("taskId is required");
+                }
+                let listId = args.listId;
+                if (!listId && args.listName) {
+                    const result = await clickup.findListByNameGlobally(config.teamId, args.listName);
+                    if (!result) {
+                        throw new Error(`List with name "${args.listName}" not found`);
+                    }
+                    listId = result.list.id;
                 }
-                const task = await clickup.moveTask(args.taskId, args.listId);
+                if (!listId) {
+                    throw new Error("Either listId or listName is required");
+                }
+                const task = await clickup.moveTask(args.taskId, listId);
                 return {
                     content: [{
                             type: "text",
-                            text: `Moved task ${task.id} to list ${args.listId}`
+                            text: `Moved task ${task.id} to list ${listId}`
                         }]
                 };
             }
             case "duplicate_task": {
                 const args = request.params.arguments;
-                if (!args.taskId || !args.listId) {
-                    throw new Error("taskId and listId are required");
+                if (!args.taskId) {
+                    throw new Error("taskId is required");
                 }
-                const task = await clickup.duplicateTask(args.taskId, args.listId);
+                let listId = args.listId;
+                if (!listId && args.listName) {
+                    const result = await clickup.findListByNameGlobally(config.teamId, args.listName);
+                    if (!result) {
+                        throw new Error(`List with name "${args.listName}" not found`);
+                    }
+                    listId = result.list.id;
+                }
+                if (!listId) {
+                    throw new Error("Either listId or listName is required");
+                }
+                const task = await clickup.duplicateTask(args.taskId, listId);
                 return {
                     content: [{
                             type: "text",
-                            text: `Duplicated task ${args.taskId} to new task ${task.id} in list ${args.listId}`
+                            text: `Duplicated task ${args.taskId} to new task ${task.id} in list ${listId}`
                         }]
                 };
             }
             case "update_task": {
                 const args = request.params.arguments;
-                if (!args.taskId) {
-                    throw new Error("taskId is required");
+                if (!args.taskId || !args.name || !args.description || !args.status || !args.priority || !args.due_date) {
+                    throw new Error("All arguments are required");
                 }
-                const { taskId, ...updateData } = args;
-                const task = await clickup.updateTask(taskId, updateData);
+                const task = await clickup.updateTask(args.taskId, {
+                    name: args.name,
+                    description: args.description,
+                    status: args.status,
+                    priority: args.priority,
+                    due_date: args.due_date ? new Date(args.due_date).getTime() : undefined
+                });
                 return {
                     content: [{
                             type: "text",
@@ -500,152 +671,119 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         }]
                 };
             }
-            default:
-                throw new Error("Unknown tool");
         }
+        throw new Error("Unknown tool");
     }
     catch (error) {
-        console.error('Error handling tool call:', error);
+        console.error('Error executing tool:', error);
         throw error;
     }
 });
 /**
- * Add handlers for listing and getting prompts.
- * Prompts include summarizing tasks, analyzing priorities, and generating task descriptions.
+ * Handler for listing available prompts.
+ * Exposes prompts for summarizing/analyzing ClickUp tasks.
  */
 server.setRequestHandler(ListPromptsRequestSchema, async () => {
     return {
         prompts: [
             {
                 name: "summarize_tasks",
-                description: "Summarize all tasks in a list",
+                description: "Summarize all ClickUp tasks"
             },
             {
-                name: "analyze_priorities",
-                description: "Analyze task priorities and suggest optimizations",
+                name: "analyze_task_priorities",
+                description: "Analyze task priorities"
             },
             {
-                name: "generate_description",
-                description: "Generate a detailed description for a task",
+                name: "generate_task_descriptions",
+                description: "Generate detailed descriptions for tasks"
             }
         ]
     };
 });
+/**
+ * Handler for getting a specific prompt.
+ * Takes a prompt name and returns the prompt content.
+ */
 server.setRequestHandler(GetPromptRequestSchema, async (request) => {
     try {
         switch (request.params.name) {
             case "summarize_tasks": {
                 const spaces = await clickup.getSpaces(config.teamId);
-                const tasks = [];
-                // Gather all tasks
+                let output = "Summarized Tasks:\n\n";
                 for (const space of spaces) {
                     const lists = await clickup.getLists(space.id);
                     for (const list of lists) {
-                        const { tasks: listTasks } = await clickup.getTasks(list.id);
-                        tasks.push(...listTasks.map((task) => ({
-                            type: "resource",
-                            resource: {
-                                uri: `clickup://task/${task.id}`,
-                                mimeType: "application/json",
-                                text: JSON.stringify(task, null, 2)
-                            }
-                        })));
+                        const { tasks } = await clickup.getTasks(list.id);
+                        for (const task of tasks) {
+                            output += `- ${task.name}: ${task.description}\n`;
+                        }
                     }
                 }
                 return {
-                    messages: [
-                        {
-                            role: "user",
-                            content: {
-                                type: "text",
-                                text: "Please provide a summary of the following ClickUp tasks:"
-                            }
-                        },
-                        ...tasks.map(task => ({
-                            role: "user",
-                            content: task
-                        })),
-                        {
-                            role: "user",
-                            content: {
-                                type: "text",
-                                text: "Please provide:\n1. A high-level overview of all tasks\n2. Group them by status\n3. Highlight any urgent or high-priority items\n4. Suggest any task dependencies or relationships"
-                            }
-                        }
-                    ]
+                    content: [{
+                            type: "text",
+                            text: output
+                        }]
                 };
             }
-            case "analyze_priorities": {
+            case "analyze_task_priorities": {
                 const spaces = await clickup.getSpaces(config.teamId);
-                const tasks = [];
+                const allTasks = [];
                 for (const space of spaces) {
                     const lists = await clickup.getLists(space.id);
                     for (const list of lists) {
-                        const { tasks: listTasks } = await clickup.getTasks(list.id);
-                        tasks.push(...listTasks.map((task) => ({
-                            type: "resource",
-                            resource: {
-                                uri: `clickup://task/${task.id}`,
-                                mimeType: "application/json",
-                                text: JSON.stringify(task, null, 2)
-                            }
-                        })));
+                        const { tasks } = await clickup.getTasks(list.id);
+                        allTasks.push(...tasks);
                     }
                 }
+                const priorities = allTasks.map((task) => task.priority?.priority);
+                const uniquePriorities = [...new Set(priorities.filter(p => p !== undefined))];
+                const priorityCounts = uniquePriorities.map(priority => ({
+                    priority: priority,
+                    count: priorities.filter((p) => p === priority).length
+                }));
+                let output = "Task Priorities Analysis:\n\n";
+                output += "Available Priorities: " + uniquePriorities.join(', ') + "\n\n";
+                output += "Priority Counts:\n";
+                for (const priority of priorityCounts) {
+                    output += `- Priority ${priority.priority}: ${priority.count}\n`;
+                }
                 return {
-                    messages: [
-                        {
-                            role: "user",
-                            content: {
-                                type: "text",
-                                text: "Please analyze the priorities of the following ClickUp tasks:"
-                            }
-                        },
-                        ...tasks.map(task => ({
-                            role: "user",
-                            content: task
-                        })),
-                        {
-                            role: "user",
-                            content: {
-                                type: "text",
-                                text: "Please provide:\n1. Analysis of current priority distribution\n2. Identify any misaligned priorities\n3. Suggest priority adjustments\n4. Recommend task sequencing based on priorities"
-                            }
-                        }
-                    ]
+                    content: [{
+                            type: "text",
+                            text: output
+                        }]
                 };
             }
-            case "generate_description": {
-                return {
-                    messages: [
-                        {
-                            role: "user",
-                            content: {
-                                type: "text",
-                                text: "Please help me generate a detailed description for a ClickUp task. The description should include:\n1. Clear objective\n2. Success criteria\n3. Required resources\n4. Dependencies\n5. Potential risks\n\nPlease ask me about the task details."
-                            }
+            case "generate_task_descriptions": {
+                const spaces = await clickup.getSpaces(config.teamId);
+                let output = "Generated Task Descriptions:\n\n";
+                for (const space of spaces) {
+                    const lists = await clickup.getLists(space.id);
+                    for (const list of lists) {
+                        const { tasks } = await clickup.getTasks(list.id);
+                        for (const task of tasks) {
+                            output += `- ${task.name}: ${task.description}\n`;
                         }
-                    ]
+                    }
+                }
+                return {
+                    content: [{
+                            type: "text",
+                            text: output
+                        }]
                 };
             }
             default:
-                throw new Error("Unknown prompt");
+                throw new Error("Prompt not found");
         }
     }
     catch (error) {
-        console.error('Error handling prompt:', error);
+        console.error('Error getting prompt:', error);
         throw error;
     }
 });
-/**
- * Start the server using stdio transport.
- * This allows the server to communicate via standard input/output streams.
- */
-async function main() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-}
-main().catch((error) => {
-    console.error("Server error:", error);
-    process.exit(1);
-});
+// Start the server
+const transport = new StdioServerTransport();
+transport.start();

package/build/services/clickup.js

@@ -38,6 +38,10 @@ export class ClickUpService {
         const response = await this.client.post(`/list/${listId}/task`, data);
         return response.data;
     }
+    async createBulkTasks(listId, data) {
+        const tasks = await Promise.all(data.tasks.map(taskData => this.createTask(listId, taskData)));
+        return tasks;
+    }
     async updateTask(taskId, data) {
         const response = await this.client.put(`/task/${taskId}`, data);
         return response.data;
@@ -106,6 +110,43 @@ export class ClickUpService {
         });
         return response.data;
     }
+    async findListByNameGlobally(teamId, listName) {
+        const spaces = await this.getSpaces(teamId);
+        for (const space of spaces) {
+            // Check lists in folders
+            const folders = await this.getFolders(space.id);
+            for (const folder of folders) {
+                const folderList = folder.lists?.find(list => list.name.toLowerCase() === listName.toLowerCase());
+                if (folderList) {
+                    return { list: folderList, space, folder };
+                }
+            }
+            // Check lists directly in space
+            const spaceLists = await this.getLists(space.id);
+            const spaceList = spaceLists.find(list => list.name.toLowerCase() === listName.toLowerCase());
+            if (spaceList) {
+                return { list: spaceList, space };
+            }
+        }
+        // Check lists without spaces
+        const allLists = await this.getAllLists(teamId);
+        const list = allLists.find(list => list.name.toLowerCase() === listName.toLowerCase());
+        if (list) {
+            return { list };
+        }
+        return null;
+    }
+    async findFolderByNameGlobally(teamId, folderName) {
+        const spaces = await this.getSpaces(teamId);
+        for (const space of spaces) {
+            const folders = await this.getFolders(space.id);
+            const folder = folders.find(folder => folder.name.toLowerCase() === folderName.toLowerCase());
+            if (folder) {
+                return { folder, space };
+            }
+        }
+        return null;
+    }
     async duplicateTask(taskId, listId) {
         const response = await this.client.post(`/task/${taskId}/duplicate`, {
             list: listId
@@ -119,8 +160,4 @@ export class ClickUpService {
         const response = await this.client.put(`/list/${listId}`, data);
         return response.data;
     }
-    async findListByName(spaceId, listName) {
-        const lists = await this.getLists(spaceId);
-        return lists.find(list => list.name.toLowerCase() === listName.toLowerCase()) || null;
-    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taazkareem/clickup-mcp-server",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "ClickUp MCP Server - Integrate ClickUp tasks with AI through Model Context Protocol",
   "type": "module",
   "main": "build/index.js",
@@ -41,7 +41,7 @@
   },
   "homepage": "https://github.com/taazkareem/clickup-mcp-server#readme",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "0.6.0",
+    "@modelcontextprotocol/sdk": "^1.4.1",
     "axios": "^1.6.7",
     "dotenv": "^16.4.1"
   },