@rv404/mcp-launchpad 1.0.0

package/dist/backends/clickup.js

@@ -0,0 +1,1550 @@
+import axios from 'axios';
+const CLICKUP_API_KEY = process.env.CLICKUP_API_KEY || '';
+const CLICKUP_TEAM_ID = process.env.CLICKUP_TEAM_ID || '';
+const BASE_URL = 'https://api.clickup.com/api/v2';
+const headers = () => ({
+    'Authorization': CLICKUP_API_KEY,
+    'Content-Type': 'application/json',
+});
+const actions = [
+    // ===================
+    // WORKSPACE / HIERARCHY
+    // ===================
+    {
+        name: 'get_workspace_hierarchy',
+        description: 'Gets complete workspace hierarchy (spaces, folders, lists). Returns tree structure with names and IDs for navigation.',
+        params: [],
+    },
+    {
+        name: 'get_workspace_members',
+        description: 'Returns all members (users) in the ClickUp workspace.',
+        params: [],
+    },
+    {
+        name: 'find_member_by_name',
+        description: 'Finds a member by name or email.',
+        params: [
+            { name: 'nameOrEmail', type: 'string', required: true, description: 'Name or email to search' },
+        ],
+    },
+    // ===================
+    // SPACES
+    // ===================
+    {
+        name: 'get_spaces',
+        description: 'Gets all spaces in the workspace.',
+        params: [
+            { name: 'archived', type: 'boolean', required: false, description: 'Include archived spaces (default: false)' },
+        ],
+    },
+    {
+        name: 'get_space',
+        description: 'Gets a space by ID or name.',
+        params: [
+            { name: 'spaceId', type: 'string', required: false, description: 'Space ID' },
+            { name: 'spaceName', type: 'string', required: false, description: 'Space name' },
+        ],
+    },
+    {
+        name: 'create_space',
+        description: 'Creates a new space in the workspace.',
+        params: [
+            { name: 'name', type: 'string', required: true, description: 'Space name' },
+            { name: 'features', type: 'object', required: false, description: 'Space features configuration' },
+        ],
+    },
+    {
+        name: 'update_space',
+        description: 'Updates a space.',
+        params: [
+            { name: 'spaceId', type: 'string', required: false, description: 'Space ID' },
+            { name: 'spaceName', type: 'string', required: false, description: 'Space name to find' },
+            { name: 'name', type: 'string', required: false, description: 'New space name' },
+            { name: 'color', type: 'string', required: false, description: 'Space color' },
+            { name: 'private', type: 'boolean', required: false, description: 'Make space private' },
+        ],
+    },
+    {
+        name: 'delete_space',
+        description: 'Deletes a space (DESTRUCTIVE).',
+        params: [
+            { name: 'spaceId', type: 'string', required: false, description: 'Space ID' },
+            { name: 'spaceName', type: 'string', required: false, description: 'Space name' },
+        ],
+    },
+    // ===================
+    // FOLDERS
+    // ===================
+    {
+        name: 'create_folder',
+        description: 'Creates a folder in a ClickUp space.',
+        params: [
+            { name: 'spaceId', type: 'string', required: false, description: 'Space ID' },
+            { name: 'spaceName', type: 'string', required: false, description: 'Space name' },
+            { name: 'name', type: 'string', required: true, description: 'Folder name' },
+        ],
+    },
+    {
+        name: 'get_folder',
+        description: 'Gets folder details.',
+        params: [
+            { name: 'folderId', type: 'string', required: false, description: 'Folder ID' },
+            { name: 'folderName', type: 'string', required: false, description: 'Folder name' },
+            { name: 'spaceId', type: 'string', required: false, description: 'Space ID' },
+            { name: 'spaceName', type: 'string', required: false, description: 'Space name' },
+        ],
+    },
+    {
+        name: 'update_folder',
+        description: 'Updates a folder.',
+        params: [
+            { name: 'folderId', type: 'string', required: true, description: 'Folder ID' },
+            { name: 'name', type: 'string', required: false, description: 'New folder name' },
+        ],
+    },
+    {
+        name: 'delete_folder',
+        description: 'Deletes a folder (DESTRUCTIVE).',
+        params: [
+            { name: 'folderId', type: 'string', required: true, description: 'Folder ID' },
+        ],
+    },
+    // ===================
+    // LISTS
+    // ===================
+    {
+        name: 'create_list',
+        description: 'Creates a list in a ClickUp space or folder.',
+        params: [
+            { name: 'spaceId', type: 'string', required: false, description: 'Space ID (for folderless list)' },
+            { name: 'spaceName', type: 'string', required: false, description: 'Space name' },
+            { name: 'folderId', type: 'string', required: false, description: 'Folder ID (to create in folder)' },
+            { name: 'name', type: 'string', required: true, description: 'List name' },
+            { name: 'content', type: 'string', required: false, description: 'List description' },
+        ],
+    },
+    {
+        name: 'get_list',
+        description: 'Gets details of a ClickUp list.',
+        params: [
+            { name: 'listId', type: 'string', required: false, description: 'List ID' },
+            { name: 'listName', type: 'string', required: false, description: 'List name' },
+        ],
+    },
+    {
+        name: 'update_list',
+        description: 'Updates a list.',
+        params: [
+            { name: 'listId', type: 'string', required: false, description: 'List ID' },
+            { name: 'listName', type: 'string', required: false, description: 'List name to find' },
+            { name: 'name', type: 'string', required: false, description: 'New list name' },
+            { name: 'content', type: 'string', required: false, description: 'New description' },
+            { name: 'status', type: 'string', required: false, description: 'List status (red, yellow, green)' },
+        ],
+    },
+    {
+        name: 'delete_list',
+        description: 'Deletes a list (DESTRUCTIVE).',
+        params: [
+            { name: 'listId', type: 'string', required: false, description: 'List ID' },
+            { name: 'listName', type: 'string', required: false, description: 'List name' },
+        ],
+    },
+    // ===================
+    // TASKS - Core CRUD
+    // ===================
+    {
+        name: 'list_tasks',
+        description: 'Gets tasks from a list or across the workspace with filtering. Essential for "what\'s on my plate" queries.',
+        params: [
+            { name: 'listId', type: 'string', required: false, description: 'List ID to get tasks from' },
+            { name: 'listName', type: 'string', required: false, description: 'List name to get tasks from' },
+            { name: 'spaceId', type: 'string', required: false, description: 'Space ID (for cross-list search)' },
+            { name: 'spaceName', type: 'string', required: false, description: 'Space name (for cross-list search)' },
+            { name: 'archived', type: 'boolean', required: false, description: 'Include archived tasks' },
+            { name: 'page', type: 'number', required: false, description: 'Page number (0-indexed)' },
+            { name: 'orderBy', type: 'string', required: false, description: 'Order by: id, created, updated, due_date' },
+            { name: 'reverse', type: 'boolean', required: false, description: 'Reverse order' },
+            { name: 'subtasks', type: 'boolean', required: false, description: 'Include subtasks' },
+            { name: 'statuses', type: 'array', required: false, description: 'Filter by statuses (e.g., ["to do", "in progress"])' },
+            { name: 'includeClosed', type: 'boolean', required: false, description: 'Include closed/completed tasks' },
+            { name: 'assignees', type: 'array', required: false, description: 'Filter by assignee user IDs' },
+            { name: 'tags', type: 'array', required: false, description: 'Filter by tag names' },
+            { name: 'dueDateGt', type: 'number', required: false, description: 'Due date greater than (Unix ms)' },
+            { name: 'dueDateLt', type: 'number', required: false, description: 'Due date less than (Unix ms)' },
+            { name: 'dateCreatedGt', type: 'number', required: false, description: 'Created after (Unix ms)' },
+            { name: 'dateCreatedLt', type: 'number', required: false, description: 'Created before (Unix ms)' },
+            { name: 'dateUpdatedGt', type: 'number', required: false, description: 'Updated after (Unix ms)' },
+            { name: 'dateUpdatedLt', type: 'number', required: false, description: 'Updated before (Unix ms)' },
+            { name: 'customFields', type: 'array', required: false, description: 'Filter by custom field values' },
+        ],
+    },
+    {
+        name: 'search_tasks',
+        description: 'Search for tasks across the entire workspace by name or custom task ID.',
+        params: [
+            { name: 'query', type: 'string', required: true, description: 'Search query (task name or custom ID)' },
+            { name: 'includeClosed', type: 'boolean', required: false, description: 'Include closed tasks' },
+        ],
+    },
+    {
+        name: 'get_my_tasks',
+        description: 'Gets tasks assigned to you (or a specific user) due today, overdue, or upcoming.',
+        params: [
+            { name: 'userId', type: 'string', required: false, description: 'User ID (defaults to API key owner)' },
+            { name: 'filter', type: 'string', required: false, description: 'Filter: today, overdue, upcoming, all (default: all)' },
+            { name: 'includeClosed', type: 'boolean', required: false, description: 'Include closed tasks' },
+        ],
+    },
+    {
+        name: 'create_task',
+        description: 'Creates a single task in a ClickUp list. Use listId (preferred) or listName.',
+        params: [
+            { name: 'listId', type: 'string', required: false, description: 'ID of the list to create the task in (preferred)' },
+            { name: 'listName', type: 'string', required: false, description: 'Name of the list (alternative to listId)' },
+            { name: 'name', type: 'string', required: true, description: 'Name of the task (put emoji prefix if appropriate)' },
+            { name: 'description', type: 'string', required: false, description: 'Plain text description' },
+            { name: 'markdown_description', type: 'string', required: false, description: 'Markdown description (takes precedence)' },
+            { name: 'priority', type: 'number', required: false, description: 'Priority 1-4 (1=urgent, 4=low)' },
+            { name: 'dueDate', type: 'string', required: false, description: 'Due date (Unix ms or natural language)' },
+            { name: 'startDate', type: 'string', required: false, description: 'Start date (Unix ms or natural language)' },
+            { name: 'timeEstimate', type: 'number', required: false, description: 'Time estimate in milliseconds' },
+            { name: 'status', type: 'string', required: false, description: 'Task status' },
+            { name: 'assignees', type: 'array', required: false, description: 'Array of user IDs, emails, or usernames' },
+            { name: 'tags', type: 'array', required: false, description: 'Array of tag names' },
+            { name: 'parent', type: 'string', required: false, description: 'Parent task ID for subtasks' },
+            { name: 'customFields', type: 'array', required: false, description: 'Custom field values [{id, value}]' },
+        ],
+    },
+    {
+        name: 'get_task',
+        description: 'Gets task details by taskId or taskName. Set subtasks=true to include subtask details.',
+        params: [
+            { name: 'taskId', type: 'string', required: false, description: 'Task ID (handles both regular and custom IDs)' },
+            { name: 'taskName', type: 'string', required: false, description: 'Task name to search for' },
+            { name: 'listName', type: 'string', required: false, description: 'List name to narrow search' },
+            { name: 'subtasks', type: 'boolean', required: false, description: 'Include subtask details' },
+            { name: 'includeCustomFields', type: 'boolean', required: false, description: 'Include custom fields' },
+        ],
+    },
+    {
+        name: 'update_task',
+        description: 'Updates task properties. Use taskId (preferred) or taskName.',
+        params: [
+            { name: 'taskId', type: 'string', required: false, description: 'Task ID to update' },
+            { name: 'taskName', type: 'string', required: false, description: 'Task name to find and update' },
+            { name: 'listName', type: 'string', required: false, description: 'List name to narrow search' },
+            { name: 'name', type: 'string', required: false, description: 'New task name' },
+            { name: 'description', type: 'string', required: false, description: 'New description' },
+            { name: 'status', type: 'string', required: false, description: 'New status' },
+            { name: 'priority', type: 'number', required: false, description: 'New priority (1-4)' },
+            { name: 'dueDate', type: 'string', required: false, description: 'New due date' },
+            { name: 'startDate', type: 'string', required: false, description: 'New start date' },
+            { name: 'timeEstimate', type: 'number', required: false, description: 'Time estimate in ms' },
+            { name: 'assignees', type: 'object', required: false, description: 'Assignees {add: [], rem: []}' },
+            { name: 'archived', type: 'boolean', required: false, description: 'Archive/unarchive task' },
+        ],
+    },
+    {
+        name: 'delete_task',
+        description: 'Deletes a task (DESTRUCTIVE - moves to trash).',
+        params: [
+            { name: 'taskId', type: 'string', required: false, description: 'Task ID' },
+            { name: 'taskName', type: 'string', required: false, description: 'Task name' },
+            { name: 'listName', type: 'string', required: false, description: 'List name to narrow search' },
+        ],
+    },
+    // ===================
+    // TASK COMMENTS
+    // ===================
+    {
+        name: 'get_task_comments',
+        description: 'Gets task comments by taskId or taskName.',
+        params: [
+            { name: 'taskId', type: 'string', required: false, description: 'Task ID' },
+            { name: 'taskName', type: 'string', required: false, description: 'Task name' },
+            { name: 'listName', type: 'string', required: false, description: 'List name' },
+        ],
+    },
+    {
+        name: 'create_task_comment',
+        description: 'Creates a comment on a task.',
+        params: [
+            { name: 'taskId', type: 'string', required: false, description: 'Task ID' },
+            { name: 'taskName', type: 'string', required: false, description: 'Task name' },
+            { name: 'listName', type: 'string', required: false, description: 'List name' },
+            { name: 'commentText', type: 'string', required: true, description: 'Comment text' },
+            { name: 'assignee', type: 'number', required: false, description: 'User ID to assign comment to' },
+            { name: 'notifyAll', type: 'boolean', required: false, description: 'Notify all assignees' },
+        ],
+    },
+    {
+        name: 'update_comment',
+        description: 'Updates a comment.',
+        params: [
+            { name: 'commentId', type: 'string', required: true, description: 'Comment ID' },
+            { name: 'commentText', type: 'string', required: true, description: 'New comment text' },
+            { name: 'resolved', type: 'boolean', required: false, description: 'Resolve/unresolve comment' },
+        ],
+    },
+    {
+        name: 'delete_comment',
+        description: 'Deletes a comment.',
+        params: [
+            { name: 'commentId', type: 'string', required: true, description: 'Comment ID' },
+        ],
+    },
+    // ===================
+    // TASK CHECKLISTS
+    // ===================
+    {
+        name: 'create_checklist',
+        description: 'Creates a checklist on a task.',
+        params: [
+            { name: 'taskId', type: 'string', required: false, description: 'Task ID' },
+            { name: 'taskName', type: 'string', required: false, description: 'Task name' },
+            { name: 'listName', type: 'string', required: false, description: 'List name' },
+            { name: 'name', type: 'string', required: true, description: 'Checklist name' },
+        ],
+    },
+    {
+        name: 'update_checklist',
+        description: 'Updates a checklist name or position.',
+        params: [
+            { name: 'checklistId', type: 'string', required: true, description: 'Checklist ID' },
+            { name: 'name', type: 'string', required: false, description: 'New checklist name' },
+            { name: 'position', type: 'number', required: false, description: 'New position' },
+        ],
+    },
+    {
+        name: 'delete_checklist',
+        description: 'Deletes a checklist.',
+        params: [
+            { name: 'checklistId', type: 'string', required: true, description: 'Checklist ID' },
+        ],
+    },
+    {
+        name: 'create_checklist_item',
+        description: 'Adds an item to a checklist.',
+        params: [
+            { name: 'checklistId', type: 'string', required: true, description: 'Checklist ID' },
+            { name: 'name', type: 'string', required: true, description: 'Item name' },
+            { name: 'assignee', type: 'number', required: false, description: 'Assignee user ID' },
+        ],
+    },
+    {
+        name: 'update_checklist_item',
+        description: 'Updates a checklist item (name, resolved status, assignee).',
+        params: [
+            { name: 'checklistId', type: 'string', required: true, description: 'Checklist ID' },
+            { name: 'checklistItemId', type: 'string', required: true, description: 'Checklist item ID' },
+            { name: 'name', type: 'string', required: false, description: 'New item name' },
+            { name: 'resolved', type: 'boolean', required: false, description: 'Mark as resolved/unresolved' },
+            { name: 'assignee', type: 'number', required: false, description: 'New assignee' },
+        ],
+    },
+    {
+        name: 'delete_checklist_item',
+        description: 'Deletes a checklist item.',
+        params: [
+            { name: 'checklistId', type: 'string', required: true, description: 'Checklist ID' },
+            { name: 'checklistItemId', type: 'string', required: true, description: 'Checklist item ID' },
+        ],
+    },
+    // ===================
+    // TIME TRACKING
+    // ===================
+    {
+        name: 'get_task_time_entries',
+        description: 'Gets all time entries for a task.',
+        params: [
+            { name: 'taskId', type: 'string', required: false, description: 'Task ID' },
+            { name: 'taskName', type: 'string', required: false, description: 'Task name' },
+            { name: 'listName', type: 'string', required: false, description: 'List name' },
+        ],
+    },
+    {
+        name: 'create_time_entry',
+        description: 'Creates a manual time entry for a task.',
+        params: [
+            { name: 'taskId', type: 'string', required: false, description: 'Task ID' },
+            { name: 'taskName', type: 'string', required: false, description: 'Task name' },
+            { name: 'listName', type: 'string', required: false, description: 'List name' },
+            { name: 'start', type: 'number', required: true, description: 'Start time (Unix ms)' },
+            { name: 'duration', type: 'number', required: true, description: 'Duration in milliseconds' },
+            { name: 'description', type: 'string', required: false, description: 'Time entry description' },
+            { name: 'billable', type: 'boolean', required: false, description: 'Mark as billable' },
+        ],
+    },
+    {
+        name: 'start_time_entry',
+        description: 'Starts a timer on a task.',
+        params: [
+            { name: 'taskId', type: 'string', required: false, description: 'Task ID' },
+            { name: 'taskName', type: 'string', required: false, description: 'Task name' },
+            { name: 'listName', type: 'string', required: false, description: 'List name' },
+            { name: 'description', type: 'string', required: false, description: 'Timer description' },
+            { name: 'billable', type: 'boolean', required: false, description: 'Mark as billable' },
+        ],
+    },
+    {
+        name: 'stop_time_entry',
+        description: 'Stops the running timer.',
+        params: [],
+    },
+    {
+        name: 'get_running_time_entry',
+        description: 'Gets the currently running time entry.',
+        params: [],
+    },
+    {
+        name: 'delete_time_entry',
+        description: 'Deletes a time entry.',
+        params: [
+            { name: 'timeEntryId', type: 'string', required: true, description: 'Time entry ID' },
+        ],
+    },
+    // ===================
+    // TASK DEPENDENCIES
+    // ===================
+    {
+        name: 'add_task_dependency',
+        description: 'Adds a dependency between tasks (task depends on dependsOnTaskId).',
+        params: [
+            { name: 'taskId', type: 'string', required: true, description: 'Task that has the dependency' },
+            { name: 'dependsOnTaskId', type: 'string', required: true, description: 'Task that must be completed first' },
+        ],
+    },
+    {
+        name: 'delete_task_dependency',
+        description: 'Removes a dependency between tasks.',
+        params: [
+            { name: 'taskId', type: 'string', required: true, description: 'Task ID' },
+            { name: 'dependsOnTaskId', type: 'string', required: true, description: 'Dependency to remove' },
+        ],
+    },
+    {
+        name: 'add_task_link',
+        description: 'Links two tasks together (bidirectional relationship).',
+        params: [
+            { name: 'taskId', type: 'string', required: true, description: 'First task ID' },
+            { name: 'linksToTaskId', type: 'string', required: true, description: 'Second task ID' },
+        ],
+    },
+    {
+        name: 'delete_task_link',
+        description: 'Removes a link between tasks.',
+        params: [
+            { name: 'taskId', type: 'string', required: true, description: 'First task ID' },
+            { name: 'linksToTaskId', type: 'string', required: true, description: 'Second task ID' },
+        ],
+    },
+    // ===================
+    // TAGS
+    // ===================
+    {
+        name: 'get_space_tags',
+        description: 'Gets all tags in a ClickUp space.',
+        params: [
+            { name: 'spaceId', type: 'string', required: false, description: 'Space ID' },
+            { name: 'spaceName', type: 'string', required: false, description: 'Space name' },
+        ],
+    },
+    {
+        name: 'create_tag',
+        description: 'Creates a new tag in a space.',
+        params: [
+            { name: 'spaceId', type: 'string', required: false, description: 'Space ID' },
+            { name: 'spaceName', type: 'string', required: false, description: 'Space name' },
+            { name: 'name', type: 'string', required: true, description: 'Tag name' },
+            { name: 'bgColor', type: 'string', required: false, description: 'Background color hex' },
+        ],
+    },
+    {
+        name: 'update_tag',
+        description: 'Updates a tag.',
+        params: [
+            { name: 'spaceId', type: 'string', required: false, description: 'Space ID' },
+            { name: 'spaceName', type: 'string', required: false, description: 'Space name' },
+            { name: 'tagName', type: 'string', required: true, description: 'Current tag name' },
+            { name: 'newName', type: 'string', required: false, description: 'New tag name' },
+            { name: 'bgColor', type: 'string', required: false, description: 'New background color' },
+        ],
+    },
+    {
+        name: 'delete_tag',
+        description: 'Deletes a tag from a space.',
+        params: [
+            { name: 'spaceId', type: 'string', required: false, description: 'Space ID' },
+            { name: 'spaceName', type: 'string', required: false, description: 'Space name' },
+            { name: 'tagName', type: 'string', required: true, description: 'Tag name to delete' },
+        ],
+    },
+    {
+        name: 'add_tag_to_task',
+        description: 'Adds an existing tag to a task.',
+        params: [
+            { name: 'taskId', type: 'string', required: false, description: 'Task ID' },
+            { name: 'taskName', type: 'string', required: false, description: 'Task name' },
+            { name: 'listName', type: 'string', required: false, description: 'List name' },
+            { name: 'tagName', type: 'string', required: true, description: 'Tag name to add' },
+        ],
+    },
+    {
+        name: 'remove_tag_from_task',
+        description: 'Removes a tag from a task.',
+        params: [
+            { name: 'taskId', type: 'string', required: false, description: 'Task ID' },
+            { name: 'taskName', type: 'string', required: false, description: 'Task name' },
+            { name: 'listName', type: 'string', required: false, description: 'List name' },
+            { name: 'tagName', type: 'string', required: true, description: 'Tag name to remove' },
+        ],
+    },
+    // ===================
+    // CUSTOM FIELDS
+    // ===================
+    {
+        name: 'get_custom_fields',
+        description: 'Gets accessible custom fields for a list.',
+        params: [
+            { name: 'listId', type: 'string', required: false, description: 'List ID' },
+            { name: 'listName', type: 'string', required: false, description: 'List name' },
+        ],
+    },
+    {
+        name: 'set_custom_field_value',
+        description: 'Sets a custom field value on a task.',
+        params: [
+            { name: 'taskId', type: 'string', required: true, description: 'Task ID' },
+            { name: 'fieldId', type: 'string', required: true, description: 'Custom field ID' },
+            { name: 'value', type: 'any', required: true, description: 'Value to set (type depends on field)' },
+        ],
+    },
+    {
+        name: 'remove_custom_field_value',
+        description: 'Removes a custom field value from a task.',
+        params: [
+            { name: 'taskId', type: 'string', required: true, description: 'Task ID' },
+            { name: 'fieldId', type: 'string', required: true, description: 'Custom field ID' },
+        ],
+    },
+    // ===================
+    // GOALS
+    // ===================
+    {
+        name: 'get_goals',
+        description: 'Gets all goals in the workspace.',
+        params: [
+            { name: 'includeCompleted', type: 'boolean', required: false, description: 'Include completed goals' },
+        ],
+    },
+    {
+        name: 'get_goal',
+        description: 'Gets a specific goal by ID.',
+        params: [
+            { name: 'goalId', type: 'string', required: true, description: 'Goal ID' },
+        ],
+    },
+    {
+        name: 'create_goal',
+        description: 'Creates a new goal.',
+        params: [
+            { name: 'name', type: 'string', required: true, description: 'Goal name' },
+            { name: 'dueDate', type: 'number', required: false, description: 'Due date (Unix ms)' },
+            { name: 'description', type: 'string', required: false, description: 'Goal description' },
+            { name: 'color', type: 'string', required: false, description: 'Goal color hex' },
+        ],
+    },
+    {
+        name: 'update_goal',
+        description: 'Updates a goal.',
+        params: [
+            { name: 'goalId', type: 'string', required: true, description: 'Goal ID' },
+            { name: 'name', type: 'string', required: false, description: 'New goal name' },
+            { name: 'dueDate', type: 'number', required: false, description: 'New due date' },
+            { name: 'description', type: 'string', required: false, description: 'New description' },
+            { name: 'color', type: 'string', required: false, description: 'New color' },
+        ],
+    },
+    {
+        name: 'delete_goal',
+        description: 'Deletes a goal.',
+        params: [
+            { name: 'goalId', type: 'string', required: true, description: 'Goal ID' },
+        ],
+    },
+    {
+        name: 'create_key_result',
+        description: 'Creates a key result for a goal.',
+        params: [
+            { name: 'goalId', type: 'string', required: true, description: 'Goal ID' },
+            { name: 'name', type: 'string', required: true, description: 'Key result name' },
+            { name: 'type', type: 'string', required: true, description: 'Type: number, currency, boolean, percentage, automatic' },
+            { name: 'stepsStart', type: 'number', required: false, description: 'Start value' },
+            { name: 'stepsEnd', type: 'number', required: false, description: 'Target value' },
+            { name: 'unit', type: 'string', required: false, description: 'Unit label' },
+            { name: 'taskIds', type: 'array', required: false, description: 'Task IDs (for automatic type)' },
+            { name: 'listIds', type: 'array', required: false, description: 'List IDs (for automatic type)' },
+        ],
+    },
+    {
+        name: 'update_key_result',
+        description: 'Updates a key result.',
+        params: [
+            { name: 'keyResultId', type: 'string', required: true, description: 'Key result ID' },
+            { name: 'stepsCurrent', type: 'number', required: false, description: 'Current progress value' },
+            { name: 'note', type: 'string', required: false, description: 'Progress note' },
+        ],
+    },
+    {
+        name: 'delete_key_result',
+        description: 'Deletes a key result.',
+        params: [
+            { name: 'keyResultId', type: 'string', required: true, description: 'Key result ID' },
+        ],
+    },
+    // ===================
+    // WEBHOOKS
+    // ===================
+    {
+        name: 'get_webhooks',
+        description: 'Gets all webhooks in the workspace.',
+        params: [],
+    },
+    {
+        name: 'create_webhook',
+        description: 'Creates a webhook for events.',
+        params: [
+            { name: 'endpoint', type: 'string', required: true, description: 'Webhook endpoint URL' },
+            { name: 'events', type: 'array', required: true, description: 'Events to subscribe to (e.g., taskCreated, taskUpdated)' },
+            { name: 'spaceId', type: 'string', required: false, description: 'Filter to specific space' },
+            { name: 'folderId', type: 'string', required: false, description: 'Filter to specific folder' },
+            { name: 'listId', type: 'string', required: false, description: 'Filter to specific list' },
+            { name: 'taskId', type: 'string', required: false, description: 'Filter to specific task' },
+        ],
+    },
+    {
+        name: 'update_webhook',
+        description: 'Updates a webhook.',
+        params: [
+            { name: 'webhookId', type: 'string', required: true, description: 'Webhook ID' },
+            { name: 'endpoint', type: 'string', required: false, description: 'New endpoint URL' },
+            { name: 'events', type: 'array', required: false, description: 'New events list' },
+            { name: 'status', type: 'string', required: false, description: 'active or suspended' },
+        ],
+    },
+    {
+        name: 'delete_webhook',
+        description: 'Deletes a webhook.',
+        params: [
+            { name: 'webhookId', type: 'string', required: true, description: 'Webhook ID' },
+        ],
+    },
+];
+// ===================
+// HELPER FUNCTIONS
+// ===================
+async function findSpaceByName(spaceName) {
+    const response = await axios.get(`${BASE_URL}/team/${CLICKUP_TEAM_ID}/space`, {
+        headers: headers(),
+        params: { archived: false },
+    });
+    return response.data.spaces?.find((s) => s.name.toLowerCase() === spaceName.toLowerCase()) || null;
+}
+async function findListByName(listName) {
+    const hierarchy = await getWorkspaceHierarchy();
+    for (const space of hierarchy.spaces || []) {
+        for (const list of space.lists || []) {
+            if (list.name.toLowerCase() === listName.toLowerCase()) {
+                return list.id;
+            }
+        }
+        for (const folder of space.folders || []) {
+            for (const list of folder.lists || []) {
+                if (list.name.toLowerCase() === listName.toLowerCase()) {
+                    return list.id;
+                }
+            }
+        }
+    }
+    return null;
+}
+async function findTaskByName(taskName, listName) {
+    if (listName) {
+        const listId = await findListByName(listName);
+        if (listId) {
+            const response = await axios.get(`${BASE_URL}/list/${listId}/task`, {
+                headers: headers(),
+                params: { subtasks: true },
+            });
+            const task = response.data.tasks?.find((t) => t.name.toLowerCase() === taskName.toLowerCase());
+            if (task)
+                return task;
+        }
+    }
+    const response = await axios.get(`${BASE_URL}/team/${CLICKUP_TEAM_ID}/task`, {
+        headers: headers(),
+        params: { subtasks: true, include_closed: true },
+    });
+    return response.data.tasks?.find((t) => t.name.toLowerCase() === taskName.toLowerCase()) || null;
+}
+async function resolveTaskId(params) {
+    let taskId = params.taskId;
+    if (!taskId && params.taskName) {
+        const task = await findTaskByName(params.taskName, params.listName);
+        if (!task)
+            throw new Error(`Task not found: ${params.taskName}`);
+        taskId = task.id;
+    }
+    if (!taskId)
+        throw new Error('taskId or taskName is required');
+    return taskId;
+}
+async function resolveSpaceId(params) {
+    let spaceId = params.spaceId;
+    if (!spaceId && params.spaceName) {
+        const space = await findSpaceByName(params.spaceName);
+        if (space)
+            spaceId = space.id;
+    }
+    if (!spaceId)
+        throw new Error('spaceId or spaceName is required');
+    return spaceId;
+}
+async function resolveListId(params) {
+    let listId = params.listId;
+    if (!listId && params.listName) {
+        listId = await findListByName(params.listName) || '';
+    }
+    if (!listId)
+        throw new Error('listId or listName is required');
+    return listId;
+}
+// ===================
+// IMPLEMENTATION FUNCTIONS
+// ===================
+async function getWorkspaceHierarchy() {
+    const response = await axios.get(`${BASE_URL}/team/${CLICKUP_TEAM_ID}/space`, {
+        headers: headers(),
+        params: { archived: false },
+    });
+    const spaces = await Promise.all(response.data.spaces.map(async (space) => {
+        const foldersRes = await axios.get(`${BASE_URL}/space/${space.id}/folder`, {
+            headers: headers(),
+            params: { archived: false },
+        });
+        const listsRes = await axios.get(`${BASE_URL}/space/${space.id}/list`, {
+            headers: headers(),
+            params: { archived: false },
+        });
+        return {
+            id: space.id,
+            name: space.name,
+            folders: foldersRes.data.folders,
+            lists: listsRes.data.lists,
+        };
+    }));
+    return { spaces };
+}
+async function getWorkspaceMembers() {
+    const response = await axios.get(`${BASE_URL}/team/${CLICKUP_TEAM_ID}`, {
+        headers: headers(),
+    });
+    return response.data.team?.members || [];
+}
+async function findMemberByName(params) {
+    if (!params.nameOrEmail)
+        throw new Error('nameOrEmail is required');
+    const members = await getWorkspaceMembers();
+    const search = params.nameOrEmail.toLowerCase();
+    return members.find((m) => m.user?.username?.toLowerCase().includes(search) ||
+        m.user?.email?.toLowerCase().includes(search) ||
+        `${m.user?.first_name} ${m.user?.last_name}`.toLowerCase().includes(search)) || null;
+}
+// SPACES
+async function getSpaces(params) {
+    const response = await axios.get(`${BASE_URL}/team/${CLICKUP_TEAM_ID}/space`, {
+        headers: headers(),
+        params: { archived: params.archived || false },
+    });
+    return response.data.spaces;
+}
+async function getSpace(params) {
+    const spaceId = await resolveSpaceId(params);
+    const response = await axios.get(`${BASE_URL}/space/${spaceId}`, { headers: headers() });
+    return response.data;
+}
+async function createSpace(params) {
+    if (!params.name)
+        throw new Error('name is required');
+    const response = await axios.post(`${BASE_URL}/team/${CLICKUP_TEAM_ID}/space`, {
+        name: params.name,
+        features: params.features || {},
+    }, { headers: headers() });
+    return response.data;
+}
+async function updateSpace(params) {
+    const spaceId = await resolveSpaceId(params);
+    const body = {};
+    if (params.name)
+        body.name = params.name;
+    if (params.color)
+        body.color = params.color;
+    if (params.private !== undefined)
+        body.private = params.private;
+    const response = await axios.put(`${BASE_URL}/space/${spaceId}`, body, { headers: headers() });
+    return response.data;
+}
+async function deleteSpace(params) {
+    const spaceId = await resolveSpaceId(params);
+    const response = await axios.delete(`${BASE_URL}/space/${spaceId}`, { headers: headers() });
+    return response.data;
+}
+// FOLDERS
+async function createFolder(params) {
+    const spaceId = await resolveSpaceId(params);
+    if (!params.name)
+        throw new Error('name is required');
+    const response = await axios.post(`${BASE_URL}/space/${spaceId}/folder`, {
+        name: params.name,
+    }, { headers: headers() });
+    return response.data;
+}
+async function getFolder(params) {
+    let folderId = params.folderId;
+    if (!folderId && params.folderName) {
+        const hierarchy = await getWorkspaceHierarchy();
+        for (const space of hierarchy.spaces || []) {
+            if (params.spaceId && space.id !== params.spaceId)
+                continue;
+            if (params.spaceName && space.name.toLowerCase() !== params.spaceName.toLowerCase())
+                continue;
+            const folder = space.folders?.find((f) => f.name.toLowerCase() === params.folderName.toLowerCase());
+            if (folder) {
+                folderId = folder.id;
+                break;
+            }
+        }
+    }
+    if (!folderId)
+        throw new Error('folderId or folderName is required');
+    const response = await axios.get(`${BASE_URL}/folder/${folderId}`, { headers: headers() });
+    return response.data;
+}
+async function updateFolder(params) {
+    if (!params.folderId)
+        throw new Error('folderId is required');
+    const body = {};
+    if (params.name)
+        body.name = params.name;
+    const response = await axios.put(`${BASE_URL}/folder/${params.folderId}`, body, { headers: headers() });
+    return response.data;
+}
+async function deleteFolder(params) {
+    if (!params.folderId)
+        throw new Error('folderId is required');
+    const response = await axios.delete(`${BASE_URL}/folder/${params.folderId}`, { headers: headers() });
+    return response.data;
+}
+// LISTS
+async function createList(params) {
+    if (!params.name)
+        throw new Error('name is required');
+    // Create in folder if folderId provided, otherwise in space
+    if (params.folderId) {
+        const response = await axios.post(`${BASE_URL}/folder/${params.folderId}/list`, {
+            name: params.name,
+            content: params.content || '',
+        }, { headers: headers() });
+        return response.data;
+    }
+    const spaceId = await resolveSpaceId(params);
+    const response = await axios.post(`${BASE_URL}/space/${spaceId}/list`, {
+        name: params.name,
+        content: params.content || '',
+    }, { headers: headers() });
+    return response.data;
+}
+async function getList(params) {
+    const listId = await resolveListId(params);
+    const response = await axios.get(`${BASE_URL}/list/${listId}`, { headers: headers() });
+    return response.data;
+}
+async function updateList(params) {
+    const listId = await resolveListId(params);
+    const body = {};
+    if (params.name)
+        body.name = params.name;
+    if (params.content)
+        body.content = params.content;
+    if (params.status)
+        body.status = params.status;
+    const response = await axios.put(`${BASE_URL}/list/${listId}`, body, { headers: headers() });
+    return response.data;
+}
+async function deleteList(params) {
+    const listId = await resolveListId(params);
+    const response = await axios.delete(`${BASE_URL}/list/${listId}`, { headers: headers() });
+    return response.data;
+}
+// TASKS
+async function listTasks(params) {
+    // Build query params
+    const queryParams = {
+        archived: params.archived || false,
+        page: params.page || 0,
+        subtasks: params.subtasks || false,
+        include_closed: params.includeClosed || false,
+    };
+    if (params.orderBy)
+        queryParams.order_by = params.orderBy;
+    if (params.reverse)
+        queryParams.reverse = params.reverse;
+    if (params.statuses)
+        queryParams.statuses = params.statuses;
+    if (params.assignees)
+        queryParams.assignees = params.assignees;
+    if (params.tags)
+        queryParams.tags = params.tags;
+    if (params.dueDateGt)
+        queryParams.due_date_gt = params.dueDateGt;
+    if (params.dueDateLt)
+        queryParams.due_date_lt = params.dueDateLt;
+    if (params.dateCreatedGt)
+        queryParams.date_created_gt = params.dateCreatedGt;
+    if (params.dateCreatedLt)
+        queryParams.date_created_lt = params.dateCreatedLt;
+    if (params.dateUpdatedGt)
+        queryParams.date_updated_gt = params.dateUpdatedGt;
+    if (params.dateUpdatedLt)
+        queryParams.date_updated_lt = params.dateUpdatedLt;
+    if (params.customFields)
+        queryParams.custom_fields = JSON.stringify(params.customFields);
+    // If listId/listName provided, get tasks from that list
+    if (params.listId || params.listName) {
+        const listId = await resolveListId(params);
+        const response = await axios.get(`${BASE_URL}/list/${listId}/task`, {
+            headers: headers(),
+            params: queryParams,
+        });
+        return response.data;
+    }
+    // If spaceId/spaceName provided, get filtered team tasks
+    // Otherwise get all team tasks
+    const response = await axios.get(`${BASE_URL}/team/${CLICKUP_TEAM_ID}/task`, {
+        headers: headers(),
+        params: queryParams,
+    });
+    return response.data;
+}
+async function searchTasks(params) {
+    if (!params.query)
+        throw new Error('query is required');
+    // ClickUp doesn't have a direct search endpoint, so we get all tasks and filter
+    const response = await axios.get(`${BASE_URL}/team/${CLICKUP_TEAM_ID}/task`, {
+        headers: headers(),
+        params: {
+            include_closed: params.includeClosed || false,
+            subtasks: true,
+        },
+    });
+    const query = params.query.toLowerCase();
+    const filtered = response.data.tasks?.filter((t) => t.name.toLowerCase().includes(query) ||
+        t.custom_id?.toLowerCase() === query) || [];
+    return { tasks: filtered };
+}
+async function getMyTasks(params) {
+    const now = Date.now();
+    const today = new Date();
+    today.setHours(23, 59, 59, 999);
+    const endOfToday = today.getTime();
+    const queryParams = {
+        include_closed: params.includeClosed || false,
+        subtasks: true,
+    };
+    // If userId specified, filter by assignee
+    if (params.userId) {
+        queryParams.assignees = [params.userId];
+    }
+    const response = await axios.get(`${BASE_URL}/team/${CLICKUP_TEAM_ID}/task`, {
+        headers: headers(),
+        params: queryParams,
+    });
+    let tasks = response.data.tasks || [];
+    // Apply filter
+    const filter = params.filter || 'all';
+    if (filter === 'today') {
+        tasks = tasks.filter((t) => t.due_date && parseInt(t.due_date) <= endOfToday && parseInt(t.due_date) >= now - 86400000);
+    }
+    else if (filter === 'overdue') {
+        tasks = tasks.filter((t) => t.due_date && parseInt(t.due_date) < now);
+    }
+    else if (filter === 'upcoming') {
+        tasks = tasks.filter((t) => t.due_date && parseInt(t.due_date) > endOfToday);
+    }
+    return { tasks };
+}
+async function createTask(params) {
+    const listId = await resolveListId(params);
+    if (!params.name)
+        throw new Error('name is required');
+    const body = { name: params.name };
+    if (params.description)
+        body.description = params.description;
+    if (params.markdown_description)
+        body.markdown_description = params.markdown_description;
+    if (params.priority)
+        body.priority = params.priority;
+    if (params.dueDate)
+        body.due_date = params.dueDate;
+    if (params.startDate)
+        body.start_date = params.startDate;
+    if (params.timeEstimate)
+        body.time_estimate = params.timeEstimate;
+    if (params.status)
+        body.status = params.status;
+    if (params.assignees)
+        body.assignees = params.assignees;
+    if (params.tags)
+        body.tags = params.tags;
+    if (params.parent)
+        body.parent = params.parent;
+    if (params.customFields)
+        body.custom_fields = params.customFields;
+    const response = await axios.post(`${BASE_URL}/list/${listId}/task`, body, { headers: headers() });
+    return response.data;
+}
+async function getTask(params) {
+    const taskId = await resolveTaskId(params);
+    const response = await axios.get(`${BASE_URL}/task/${taskId}`, {
+        headers: headers(),
+        params: {
+            include_subtasks: params.subtasks === true,
+            custom_fields: params.includeCustomFields === true,
+        },
+    });
+    return response.data;
+}
+async function updateTask(params) {
+    const taskId = await resolveTaskId(params);
+    const body = {};
+    if (params.name)
+        body.name = params.name;
+    if (params.description)
+        body.description = params.description;
+    if (params.status)
+        body.status = params.status;
+    if (params.priority)
+        body.priority = params.priority;
+    if (params.dueDate)
+        body.due_date = params.dueDate;
+    if (params.startDate)
+        body.start_date = params.startDate;
+    if (params.timeEstimate)
+        body.time_estimate = params.timeEstimate;
+    if (params.assignees)
+        body.assignees = params.assignees;
+    if (params.archived !== undefined)
+        body.archived = params.archived;
+    const response = await axios.put(`${BASE_URL}/task/${taskId}`, body, { headers: headers() });
+    return response.data;
+}
+async function deleteTask(params) {
+    const taskId = await resolveTaskId(params);
+    const response = await axios.delete(`${BASE_URL}/task/${taskId}`, { headers: headers() });
+    return response.data;
+}
+// COMMENTS
+async function getTaskComments(params) {
+    const taskId = await resolveTaskId(params);
+    const response = await axios.get(`${BASE_URL}/task/${taskId}/comment`, { headers: headers() });
+    return response.data;
+}
+async function createTaskComment(params) {
+    const taskId = await resolveTaskId(params);
+    if (!params.commentText)
+        throw new Error('commentText is required');
+    const body = {
+        comment_text: params.commentText,
+        notify_all: params.notifyAll || false,
+    };
+    if (params.assignee)
+        body.assignee = params.assignee;
+    const response = await axios.post(`${BASE_URL}/task/${taskId}/comment`, body, { headers: headers() });
+    return response.data;
+}
+async function updateComment(params) {
+    if (!params.commentId)
+        throw new Error('commentId is required');
+    if (!params.commentText)
+        throw new Error('commentText is required');
+    const body = { comment_text: params.commentText };
+    if (params.resolved !== undefined)
+        body.resolved = params.resolved;
+    const response = await axios.put(`${BASE_URL}/comment/${params.commentId}`, body, { headers: headers() });
+    return response.data;
+}
+async function deleteComment(params) {
+    if (!params.commentId)
+        throw new Error('commentId is required');
+    const response = await axios.delete(`${BASE_URL}/comment/${params.commentId}`, { headers: headers() });
+    return response.data;
+}
+// CHECKLISTS
+async function createChecklist(params) {
+    const taskId = await resolveTaskId(params);
+    if (!params.name)
+        throw new Error('name is required');
+    const response = await axios.post(`${BASE_URL}/task/${taskId}/checklist`, {
+        name: params.name,
+    }, { headers: headers() });
+    return response.data;
+}
+async function updateChecklist(params) {
+    if (!params.checklistId)
+        throw new Error('checklistId is required');
+    const body = {};
+    if (params.name)
+        body.name = params.name;
+    if (params.position !== undefined)
+        body.position = params.position;
+    const response = await axios.put(`${BASE_URL}/checklist/${params.checklistId}`, body, { headers: headers() });
+    return response.data;
+}
+async function deleteChecklist(params) {
+    if (!params.checklistId)
+        throw new Error('checklistId is required');
+    const response = await axios.delete(`${BASE_URL}/checklist/${params.checklistId}`, { headers: headers() });
+    return response.data;
+}
+async function createChecklistItem(params) {
+    if (!params.checklistId)
+        throw new Error('checklistId is required');
+    if (!params.name)
+        throw new Error('name is required');
+    const body = { name: params.name };
+    if (params.assignee)
+        body.assignee = params.assignee;
+    const response = await axios.post(`${BASE_URL}/checklist/${params.checklistId}/checklist_item`, body, { headers: headers() });
+    return response.data;
+}
+async function updateChecklistItem(params) {
+    if (!params.checklistId)
+        throw new Error('checklistId is required');
+    if (!params.checklistItemId)
+        throw new Error('checklistItemId is required');
+    const body = {};
+    if (params.name)
+        body.name = params.name;
+    if (params.resolved !== undefined)
+        body.resolved = params.resolved;
+    if (params.assignee)
+        body.assignee = params.assignee;
+    const response = await axios.put(`${BASE_URL}/checklist/${params.checklistId}/checklist_item/${params.checklistItemId}`, body, { headers: headers() });
+    return response.data;
+}
+async function deleteChecklistItem(params) {
+    if (!params.checklistId)
+        throw new Error('checklistId is required');
+    if (!params.checklistItemId)
+        throw new Error('checklistItemId is required');
+    const response = await axios.delete(`${BASE_URL}/checklist/${params.checklistId}/checklist_item/${params.checklistItemId}`, { headers: headers() });
+    return response.data;
+}
+// TIME TRACKING
+async function getTaskTimeEntries(params) {
+    const taskId = await resolveTaskId(params);
+    const response = await axios.get(`${BASE_URL}/task/${taskId}/time`, { headers: headers() });
+    return response.data;
+}
+async function createTimeEntry(params) {
+    const taskId = await resolveTaskId(params);
+    if (!params.start)
+        throw new Error('start is required');
+    if (!params.duration)
+        throw new Error('duration is required');
+    const body = {
+        start: params.start,
+        duration: params.duration,
+        tid: taskId,
+    };
+    if (params.description)
+        body.description = params.description;
+    if (params.billable !== undefined)
+        body.billable = params.billable;
+    const response = await axios.post(`${BASE_URL}/team/${CLICKUP_TEAM_ID}/time_entries`, body, { headers: headers() });
+    return response.data;
+}
+async function startTimeEntry(params) {
+    const taskId = await resolveTaskId(params);
+    const body = { tid: taskId };
+    if (params.description)
+        body.description = params.description;
+    if (params.billable !== undefined)
+        body.billable = params.billable;
+    const response = await axios.post(`${BASE_URL}/team/${CLICKUP_TEAM_ID}/time_entries/start`, body, { headers: headers() });
+    return response.data;
+}
+async function stopTimeEntry() {
+    const response = await axios.post(`${BASE_URL}/team/${CLICKUP_TEAM_ID}/time_entries/stop`, {}, { headers: headers() });
+    return response.data;
+}
+async function getRunningTimeEntry() {
+    const response = await axios.get(`${BASE_URL}/team/${CLICKUP_TEAM_ID}/time_entries/current`, { headers: headers() });
+    return response.data;
+}
+async function deleteTimeEntry(params) {
+    if (!params.timeEntryId)
+        throw new Error('timeEntryId is required');
+    const response = await axios.delete(`${BASE_URL}/team/${CLICKUP_TEAM_ID}/time_entries/${params.timeEntryId}`, { headers: headers() });
+    return response.data;
+}
+// DEPENDENCIES
+async function addTaskDependency(params) {
+    if (!params.taskId)
+        throw new Error('taskId is required');
+    if (!params.dependsOnTaskId)
+        throw new Error('dependsOnTaskId is required');
+    const response = await axios.post(`${BASE_URL}/task/${params.taskId}/dependency`, {
+        depends_on: params.dependsOnTaskId,
+    }, { headers: headers() });
+    return response.data;
+}
+async function deleteTaskDependency(params) {
+    if (!params.taskId)
+        throw new Error('taskId is required');
+    if (!params.dependsOnTaskId)
+        throw new Error('dependsOnTaskId is required');
+    const response = await axios.delete(`${BASE_URL}/task/${params.taskId}/dependency`, {
+        headers: headers(),
+        params: { depends_on: params.dependsOnTaskId },
+    });
+    return response.data;
+}
+async function addTaskLink(params) {
+    if (!params.taskId)
+        throw new Error('taskId is required');
+    if (!params.linksToTaskId)
+        throw new Error('linksToTaskId is required');
+    const response = await axios.post(`${BASE_URL}/task/${params.taskId}/link/${params.linksToTaskId}`, {}, { headers: headers() });
+    return response.data;
+}
+async function deleteTaskLink(params) {
+    if (!params.taskId)
+        throw new Error('taskId is required');
+    if (!params.linksToTaskId)
+        throw new Error('linksToTaskId is required');
+    const response = await axios.delete(`${BASE_URL}/task/${params.taskId}/link/${params.linksToTaskId}`, { headers: headers() });
+    return response.data;
+}
+// TAGS
+async function getSpaceTags(params) {
+    const spaceId = await resolveSpaceId(params);
+    const response = await axios.get(`${BASE_URL}/space/${spaceId}/tag`, { headers: headers() });
+    return response.data;
+}
+async function createTag(params) {
+    const spaceId = await resolveSpaceId(params);
+    if (!params.name)
+        throw new Error('name is required');
+    const body = { tag: { name: params.name } };
+    if (params.bgColor)
+        body.tag.tag_bg = params.bgColor;
+    const response = await axios.post(`${BASE_URL}/space/${spaceId}/tag`, body, { headers: headers() });
+    return response.data;
+}
+async function updateTag(params) {
+    const spaceId = await resolveSpaceId(params);
+    if (!params.tagName)
+        throw new Error('tagName is required');
+    const body = { tag: {} };
+    if (params.newName)
+        body.tag.name = params.newName;
+    if (params.bgColor)
+        body.tag.tag_bg = params.bgColor;
+    const response = await axios.put(`${BASE_URL}/space/${spaceId}/tag/${params.tagName}`, body, { headers: headers() });
+    return response.data;
+}
+async function deleteTag(params) {
+    const spaceId = await resolveSpaceId(params);
+    if (!params.tagName)
+        throw new Error('tagName is required');
+    const response = await axios.delete(`${BASE_URL}/space/${spaceId}/tag/${params.tagName}`, { headers: headers() });
+    return response.data;
+}
+async function addTagToTask(params) {
+    const taskId = await resolveTaskId(params);
+    if (!params.tagName)
+        throw new Error('tagName is required');
+    const response = await axios.post(`${BASE_URL}/task/${taskId}/tag/${params.tagName}`, {}, { headers: headers() });
+    return response.data;
+}
+async function removeTagFromTask(params) {
+    const taskId = await resolveTaskId(params);
+    if (!params.tagName)
+        throw new Error('tagName is required');
+    const response = await axios.delete(`${BASE_URL}/task/${taskId}/tag/${params.tagName}`, { headers: headers() });
+    return response.data;
+}
+// CUSTOM FIELDS
+async function getCustomFields(params) {
+    const listId = await resolveListId(params);
+    const response = await axios.get(`${BASE_URL}/list/${listId}/field`, { headers: headers() });
+    return response.data;
+}
+async function setCustomFieldValue(params) {
+    if (!params.taskId)
+        throw new Error('taskId is required');
+    if (!params.fieldId)
+        throw new Error('fieldId is required');
+    if (params.value === undefined)
+        throw new Error('value is required');
+    const response = await axios.post(`${BASE_URL}/task/${params.taskId}/field/${params.fieldId}`, { value: params.value }, { headers: headers() });
+    return response.data;
+}
+async function removeCustomFieldValue(params) {
+    if (!params.taskId)
+        throw new Error('taskId is required');
+    if (!params.fieldId)
+        throw new Error('fieldId is required');
+    const response = await axios.delete(`${BASE_URL}/task/${params.taskId}/field/${params.fieldId}`, { headers: headers() });
+    return response.data;
+}
+// GOALS
+async function getGoals(params) {
+    const response = await axios.get(`${BASE_URL}/team/${CLICKUP_TEAM_ID}/goal`, {
+        headers: headers(),
+        params: { include_completed: params.includeCompleted || false },
+    });
+    return response.data;
+}
+async function getGoal(params) {
+    if (!params.goalId)
+        throw new Error('goalId is required');
+    const response = await axios.get(`${BASE_URL}/goal/${params.goalId}`, { headers: headers() });
+    return response.data;
+}
+async function createGoal(params) {
+    if (!params.name)
+        throw new Error('name is required');
+    const body = { name: params.name };
+    if (params.dueDate)
+        body.due_date = params.dueDate;
+    if (params.description)
+        body.description = params.description;
+    if (params.color)
+        body.color = params.color;
+    const response = await axios.post(`${BASE_URL}/team/${CLICKUP_TEAM_ID}/goal`, body, { headers: headers() });
+    return response.data;
+}
+async function updateGoal(params) {
+    if (!params.goalId)
+        throw new Error('goalId is required');
+    const body = {};
+    if (params.name)
+        body.name = params.name;
+    if (params.dueDate)
+        body.due_date = params.dueDate;
+    if (params.description)
+        body.description = params.description;
+    if (params.color)
+        body.color = params.color;
+    const response = await axios.put(`${BASE_URL}/goal/${params.goalId}`, body, { headers: headers() });
+    return response.data;
+}
+async function deleteGoal(params) {
+    if (!params.goalId)
+        throw new Error('goalId is required');
+    const response = await axios.delete(`${BASE_URL}/goal/${params.goalId}`, { headers: headers() });
+    return response.data;
+}
+async function createKeyResult(params) {
+    if (!params.goalId)
+        throw new Error('goalId is required');
+    if (!params.name)
+        throw new Error('name is required');
+    if (!params.type)
+        throw new Error('type is required');
+    const body = {
+        name: params.name,
+        type: params.type,
+    };
+    if (params.stepsStart !== undefined)
+        body.steps_start = params.stepsStart;
+    if (params.stepsEnd !== undefined)
+        body.steps_end = params.stepsEnd;
+    if (params.unit)
+        body.unit = params.unit;
+    if (params.taskIds)
+        body.task_ids = params.taskIds;
+    if (params.listIds)
+        body.list_ids = params.listIds;
+    const response = await axios.post(`${BASE_URL}/goal/${params.goalId}/key_result`, body, { headers: headers() });
+    return response.data;
+}
+async function updateKeyResult(params) {
+    if (!params.keyResultId)
+        throw new Error('keyResultId is required');
+    const body = {};
+    if (params.stepsCurrent !== undefined)
+        body.steps_current = params.stepsCurrent;
+    if (params.note)
+        body.note = params.note;
+    const response = await axios.put(`${BASE_URL}/key_result/${params.keyResultId}`, body, { headers: headers() });
+    return response.data;
+}
+async function deleteKeyResult(params) {
+    if (!params.keyResultId)
+        throw new Error('keyResultId is required');
+    const response = await axios.delete(`${BASE_URL}/key_result/${params.keyResultId}`, { headers: headers() });
+    return response.data;
+}
+// WEBHOOKS
+async function getWebhooks() {
+    const response = await axios.get(`${BASE_URL}/team/${CLICKUP_TEAM_ID}/webhook`, { headers: headers() });
+    return response.data;
+}
+async function createWebhook(params) {
+    if (!params.endpoint)
+        throw new Error('endpoint is required');
+    if (!params.events)
+        throw new Error('events is required');
+    const body = {
+        endpoint: params.endpoint,
+        events: params.events,
+    };
+    if (params.spaceId)
+        body.space_id = params.spaceId;
+    if (params.folderId)
+        body.folder_id = params.folderId;
+    if (params.listId)
+        body.list_id = params.listId;
+    if (params.taskId)
+        body.task_id = params.taskId;
+    const response = await axios.post(`${BASE_URL}/team/${CLICKUP_TEAM_ID}/webhook`, body, { headers: headers() });
+    return response.data;
+}
+async function updateWebhook(params) {
+    if (!params.webhookId)
+        throw new Error('webhookId is required');
+    const body = {};
+    if (params.endpoint)
+        body.endpoint = params.endpoint;
+    if (params.events)
+        body.events = params.events;
+    if (params.status)
+        body.status = params.status;
+    const response = await axios.put(`${BASE_URL}/webhook/${params.webhookId}`, body, { headers: headers() });
+    return response.data;
+}
+async function deleteWebhook(params) {
+    if (!params.webhookId)
+        throw new Error('webhookId is required');
+    const response = await axios.delete(`${BASE_URL}/webhook/${params.webhookId}`, { headers: headers() });
+    return response.data;
+}
+// ===================
+// BACKEND EXPORT
+// ===================
+export const clickupBackend = {
+    name: 'clickup',
+    description: 'ClickUp project management: tasks, lists, folders, spaces, goals, time tracking, checklists, custom fields, and webhooks. Comprehensive API for full ClickUp automation.',
+    actions,
+    async execute(action, params) {
+        switch (action) {
+            // Workspace
+            case 'get_workspace_hierarchy': return getWorkspaceHierarchy();
+            case 'get_workspace_members': return getWorkspaceMembers();
+            case 'find_member_by_name': return findMemberByName(params);
+            // Spaces
+            case 'get_spaces': return getSpaces(params);
+            case 'get_space': return getSpace(params);
+            case 'create_space': return createSpace(params);
+            case 'update_space': return updateSpace(params);
+            case 'delete_space': return deleteSpace(params);
+            // Folders
+            case 'create_folder': return createFolder(params);
+            case 'get_folder': return getFolder(params);
+            case 'update_folder': return updateFolder(params);
+            case 'delete_folder': return deleteFolder(params);
+            // Lists
+            case 'create_list': return createList(params);
+            case 'get_list': return getList(params);
+            case 'update_list': return updateList(params);
+            case 'delete_list': return deleteList(params);
+            // Tasks
+            case 'list_tasks': return listTasks(params);
+            case 'search_tasks': return searchTasks(params);
+            case 'get_my_tasks': return getMyTasks(params);
+            case 'create_task': return createTask(params);
+            case 'get_task': return getTask(params);
+            case 'update_task': return updateTask(params);
+            case 'delete_task': return deleteTask(params);
+            // Comments
+            case 'get_task_comments': return getTaskComments(params);
+            case 'create_task_comment': return createTaskComment(params);
+            case 'update_comment': return updateComment(params);
+            case 'delete_comment': return deleteComment(params);
+            // Checklists
+            case 'create_checklist': return createChecklist(params);
+            case 'update_checklist': return updateChecklist(params);
+            case 'delete_checklist': return deleteChecklist(params);
+            case 'create_checklist_item': return createChecklistItem(params);
+            case 'update_checklist_item': return updateChecklistItem(params);
+            case 'delete_checklist_item': return deleteChecklistItem(params);
+            // Time Tracking
+            case 'get_task_time_entries': return getTaskTimeEntries(params);
+            case 'create_time_entry': return createTimeEntry(params);
+            case 'start_time_entry': return startTimeEntry(params);
+            case 'stop_time_entry': return stopTimeEntry();
+            case 'get_running_time_entry': return getRunningTimeEntry();
+            case 'delete_time_entry': return deleteTimeEntry(params);
+            // Dependencies
+            case 'add_task_dependency': return addTaskDependency(params);
+            case 'delete_task_dependency': return deleteTaskDependency(params);
+            case 'add_task_link': return addTaskLink(params);
+            case 'delete_task_link': return deleteTaskLink(params);
+            // Tags
+            case 'get_space_tags': return getSpaceTags(params);
+            case 'create_tag': return createTag(params);
+            case 'update_tag': return updateTag(params);
+            case 'delete_tag': return deleteTag(params);
+            case 'add_tag_to_task': return addTagToTask(params);
+            case 'remove_tag_from_task': return removeTagFromTask(params);
+            // Custom Fields
+            case 'get_custom_fields': return getCustomFields(params);
+            case 'set_custom_field_value': return setCustomFieldValue(params);
+            case 'remove_custom_field_value': return removeCustomFieldValue(params);
+            // Goals
+            case 'get_goals': return getGoals(params);
+            case 'get_goal': return getGoal(params);
+            case 'create_goal': return createGoal(params);
+            case 'update_goal': return updateGoal(params);
+            case 'delete_goal': return deleteGoal(params);
+            case 'create_key_result': return createKeyResult(params);
+            case 'update_key_result': return updateKeyResult(params);
+            case 'delete_key_result': return deleteKeyResult(params);
+            // Webhooks
+            case 'get_webhooks': return getWebhooks();
+            case 'create_webhook': return createWebhook(params);
+            case 'update_webhook': return updateWebhook(params);
+            case 'delete_webhook': return deleteWebhook(params);
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+    },
+    async healthCheck() {
+        if (!CLICKUP_API_KEY || !CLICKUP_TEAM_ID) {
+            return { status: 'unavailable', latency_ms: 0, error: 'ClickUp credentials not configured' };
+        }
+        try {
+            const start = Date.now();
+            await axios.get(`${BASE_URL}/team/${CLICKUP_TEAM_ID}`, { headers: headers() });
+            return { status: 'healthy', latency_ms: Date.now() - start };
+        }
+        catch (error) {
+            return { status: 'unavailable', latency_ms: 0, error: error instanceof Error ? error.message : String(error) };
+        }
+    },
+};
+//# sourceMappingURL=clickup.js.map