@divyacon/piece-clickup 0.0.0-stage → 0.1.0

package/src/lib/actions/tags/update-space-tag.ts

@@ -0,0 +1,86 @@
+import {
+  Property,
+  createAction,
+  OAuth2PropertyValue,
+} from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { clickupCommon, callClickUpApi, listTags } from '../../common';
+import { clickupAuth } from '../../auth';
+
+export const clickupUpdateSpaceTag = createAction({
+  auth: clickupAuth,
+  name: 'clickup_update_space_tag',
+  description: 'Rename or recolor an existing tag in a ClickUp space',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Rename or recolor an existing ClickUp space tag, identified by its current name. Use List Space Tags to find the current name; to add a brand-new tag use Create Space Tag instead. This sets the tag to the supplied end state, so repeating the same update is idempotent.',
+    idempotent: true,
+  },
+  displayName: 'Update Space Tag',
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    space_id: clickupCommon.space_id(),
+    tag_name: Property.Dropdown({
+      auth: clickupAuth,
+      displayName: 'Tag',
+      description: 'The current name of the tag to update',
+      required: true,
+      refreshers: ['space_id'],
+      options: async ({ auth, space_id }) => {
+        if (!auth || !space_id) {
+          return {
+            disabled: true,
+            placeholder: 'connect your account first and select a space',
+            options: [],
+          };
+        }
+        const accessToken = getAccessTokenOrThrow(auth as OAuth2PropertyValue);
+        const response = await listTags(accessToken, space_id as string);
+        return {
+          disabled: false,
+          options: response.tags.map((tag) => {
+            return {
+              label: tag.name,
+              value: tag.name,
+            };
+          }),
+        };
+      },
+    }),
+    new_name: Property.ShortText({
+      description: 'The new name for the tag',
+      displayName: 'New Name',
+      required: true,
+    }),
+    tag_fg: Property.ShortText({
+      description: 'Foreground (text) color as a hex value, e.g. #FFFFFF',
+      displayName: 'Foreground Color',
+      required: false,
+    }),
+    tag_bg: Property.ShortText({
+      description: 'Background color as a hex value, e.g. #000000',
+      displayName: 'Background Color',
+      required: false,
+    }),
+  },
+  async run(configValue) {
+    const { space_id, tag_name, new_name, tag_fg, tag_bg } =
+      configValue.propsValue;
+
+    const response = await callClickUpApi(
+      HttpMethod.PUT,
+      `space/${space_id}/tag/${encodeURIComponent(tag_name as string)}`,
+      getAccessTokenOrThrow(configValue.auth),
+      {
+        tag: {
+          name: new_name,
+          tag_fg: tag_fg ?? undefined,
+          tag_bg: tag_bg ?? undefined,
+        },
+      }
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/tasks/clickup-add-tag-to-task.ts

@@ -0,0 +1,66 @@
+import {
+  OAuth2PropertyValue,
+  Property,
+  createAction,
+} from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+
+import { clickupCommon, callClickUpApi, listTags } from '../../common';
+import { clickupAuth } from '../../auth';
+
+export const clickupAddTagToTaskAi = createAction({
+  auth: clickupAuth,
+  name: 'clickup_add_tag_to_task',
+  description: 'Add an existing space tag to a task',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Add an existing space-level tag to a ClickUp task by tag name. The tag must already exist in the space (list them with Get Space Tags or create one with Create Space Tag); this does not create new tags. Use Remove Tag From Task to take a tag off. Re-adding a tag the task already has is a no-op, so it is idempotent.',
+    idempotent: true,
+  },
+  displayName: 'Add Tag To Task',
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    space_id: clickupCommon.space_id(),
+    list_id: clickupCommon.list_id(),
+    task_id: clickupCommon.task_id(),
+    tag_name: Property.Dropdown({
+      auth: clickupAuth,
+      displayName: 'Tag',
+      description: 'The name of the space tag to add.',
+      required: true,
+      refreshers: ['space_id'],
+      options: async ({ auth, space_id }) => {
+        if (!auth || !space_id) {
+          return {
+            disabled: true,
+            placeholder: 'connect your account first and select a space',
+            options: [],
+          };
+        }
+        const accessToken = getAccessTokenOrThrow(auth as OAuth2PropertyValue);
+        const response = await listTags(accessToken, space_id as string);
+        return {
+          disabled: false,
+          options: response.tags.map((tag) => {
+            return {
+              label: tag.name,
+              value: tag.name,
+            };
+          }),
+        };
+      },
+    }),
+  },
+  async run(configValue) {
+    const { task_id, tag_name } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.POST,
+      `task/${task_id}/tag/${encodeURIComponent(tag_name as string)}`,
+      getAccessTokenOrThrow(configValue.auth),
+      {}
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/tasks/clickup-add-task-dependency.ts

@@ -0,0 +1,58 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+
+import { callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+
+export const clickupAddTaskDependencyAi = createAction({
+  auth: clickupAuth,
+  name: 'clickup_add_task_dependency',
+  description: 'Add a dependency between two tasks',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Create a dependency relationship for a ClickUp task. Provide exactly one of "Depends On" (the task that must finish first / blocks this task) or "Blocks" (the task that this task blocks). For a non-blocking association between tasks use Link Tasks instead; to remove a dependency use Delete Task Dependency. Each call creates a new dependency, so it is not idempotent.',
+    idempotent: false,
+  },
+  displayName: 'Add Task Dependency',
+  props: {
+    task_id: Property.ShortText({
+      displayName: 'Task ID',
+      description: 'The task that the dependency is set on.',
+      required: true,
+    }),
+    depends_on: Property.ShortText({
+      displayName: 'Depends On',
+      description:
+        'The ID of the task that must be done first (it blocks this task). Provide exactly one of Depends On or Blocks.',
+      required: false,
+    }),
+    dependency_of: Property.ShortText({
+      displayName: 'Blocks',
+      description:
+        'The ID of the task that this task blocks. Provide exactly one of Depends On or Blocks.',
+      required: false,
+    }),
+  },
+  async run(configValue) {
+    const { task_id, depends_on, dependency_of } = configValue.propsValue;
+    if ((depends_on && dependency_of) || (!depends_on && !dependency_of)) {
+      throw new Error(
+        'Provide exactly one of "Depends On" or "Blocks".'
+      );
+    }
+
+    const body: Record<string, string> = {};
+    if (depends_on) body['depends_on'] = depends_on;
+    if (dependency_of) body['dependency_of'] = dependency_of;
+
+    const response = await callClickUpApi(
+      HttpMethod.POST,
+      `task/${task_id}/dependency`,
+      getAccessTokenOrThrow(configValue.auth),
+      body
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/tasks/clickup-create-task.ts

@@ -0,0 +1,207 @@
+import {
+  OAuth2PropertyValue,
+  Property,
+  createAction,
+} from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { MarkdownVariant } from '@agnocon/pieces-framework';
+
+import {
+  clickupCommon,
+  callClickUpApi,
+  listAccessibleCustomFields,
+} from '../../common';
+import { clickupAuth } from '../../auth';
+import { taskOutputSchema } from '../../output-schemas';
+
+export const clickupCreateTaskAi = createAction({
+  auth: clickupAuth,
+  name: 'clickup_create_task',
+  description: 'Create a new task in a ClickUp workspace and list',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Create a new top-level task in a ClickUp list, with optional status, priority, assignees, description, dates, time estimate, and custom fields. Pick this for a standalone task; for setting only the status of an existing task use Set Task Status, and to modify other fields of an existing task use Update Task. Each call creates a new task, so retries duplicate it.',
+    idempotent: false,
+  },
+  displayName: 'Create Task',
+  outputSchema: taskOutputSchema,
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    space_id: clickupCommon.space_id(),
+    list_id: clickupCommon.list_id(),
+    name: Property.ShortText({
+      description: 'The name of task',
+      displayName: 'Name',
+      required: true,
+    }),
+    status_id: clickupCommon.status_id(),
+    priority_id: clickupCommon.priority_id(),
+    assignee_id: clickupCommon.assignee_id(
+      false,
+      'Assignee Id',
+      'ID of assignee for Clickup Task'
+    ),
+    description: Property.LongText({
+      description: 'The description of task',
+      displayName: 'Description',
+      required: false,
+    }),
+    is_markdown: Property.Checkbox({
+      description: 'Is the description in markdown format',
+      displayName: 'Is Markdown',
+      required: false,
+      defaultValue: false,
+    }),
+    due_date: Property.DateTime({
+      description: 'The due date of the task',
+      displayName: 'Due Date',
+      required: false,
+    }),
+    due_date_time: Property.Checkbox({
+      description: 'Whether to include time in the due date',
+      displayName: 'Due Date Time',
+      required: false,
+      defaultValue: false,
+    }),
+    start_date: Property.DateTime({
+      description: 'The start date of the task',
+      displayName: 'Start Date',
+      required: false,
+    }),
+    start_date_time: Property.Checkbox({
+      description: 'Whether to include time in the start date',
+      displayName: 'Start Date Time',
+      required: false,
+      defaultValue: false,
+    }),
+    time_estimate: Property.Number({
+      description: 'The time estimate for the task in milliseconds',
+      displayName: 'Time Estimate',
+      required: false,
+    }),
+    check_required_custom_fields: Property.Checkbox({
+      description: 'Re-enable required custom fields validation for the task',
+      displayName: 'Check Required Custom Fields',
+      required: false,
+      defaultValue: false,
+    }),
+    custom_fields_info: Property.MarkDown({
+      value: `Select custom fields\n\nFor custom dropdown fields, choose a dropdown value based on the index (in the list, the first option is index 0, second is 1, third is 2, etc.)`,
+      variant: MarkdownVariant.INFO,
+    }),
+    custom_fields: Property.DynamicProperties({
+      auth: clickupAuth,
+      displayName: 'Custom Fields',
+      required: true,
+      refreshers: ['list_id', 'auth'],
+      props: async ({ list_id, auth }) => {
+        if (!list_id || !auth) {
+          return {};
+        }
+
+        const accessToken = getAccessTokenOrThrow(auth as OAuth2PropertyValue);
+
+        const { fields: customFields } = await listAccessibleCustomFields(
+          accessToken,
+          list_id.toString()
+        );
+
+        const dynamicProps: Record<string, any> = {};
+        customFields.forEach((field) => {
+          dynamicProps[field.id] = Property.ShortText({
+            displayName: field.name,
+            description: `Value for the custom field: ${field.name}`,
+            required: false,
+          });
+        });
+
+        return dynamicProps;
+      },
+    }),
+  },
+
+  async run(configValue) {
+    const {
+      list_id,
+      name,
+      description,
+      status_id,
+      priority_id,
+      assignee_id,
+      is_markdown,
+      due_date,
+      due_date_time,
+      start_date,
+      start_date_time,
+      time_estimate,
+      check_required_custom_fields,
+      custom_fields,
+    } = configValue.propsValue;
+
+    type TaskData = {
+      name: string;
+      status?: string | undefined | string[];
+      priority?: number | undefined;
+      assignees?: number[] | undefined;
+      markdown_content?: string;
+      description?: string;
+      due_date?: number;
+      due_date_time?: boolean;
+      start_date?: number;
+      start_date_time?: boolean;
+      time_estimate?: number;
+      check_required_custom_fields?: boolean;
+      custom_fields?: { id: string; value: any }[];
+    };
+
+    const data: TaskData = {
+      name,
+      status: status_id,
+      priority: priority_id,
+      assignees: assignee_id,
+    };
+
+    if (is_markdown && description) {
+      data.markdown_content = description;
+    } else if (description) {
+      data.description = description;
+    }
+
+    if (due_date) {
+      data.due_date = new Date(due_date).getTime();
+      data.due_date_time = due_date_time || false;
+    }
+
+    if (start_date) {
+      data.start_date = new Date(start_date).getTime();
+      data.start_date_time = start_date_time || false;
+    }
+
+    if (time_estimate) {
+      data.time_estimate = time_estimate;
+    }
+
+    if (check_required_custom_fields) {
+      data.check_required_custom_fields = check_required_custom_fields;
+    }
+
+    if (custom_fields) {
+      data.custom_fields = Object.entries(custom_fields).map(
+        ([fieldId, value]) => ({
+          id: fieldId,
+          value,
+        })
+      );
+    }
+
+    const response = await callClickUpApi(
+      HttpMethod.POST,
+      `list/${list_id}/task`,
+      getAccessTokenOrThrow(configValue.auth),
+      data
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/tasks/clickup-delete-task-dependency.ts

@@ -0,0 +1,59 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+
+import { callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+
+export const clickupDeleteTaskDependencyAi = createAction({
+  auth: clickupAuth,
+  name: 'clickup_delete_task_dependency',
+  description: 'Remove a dependency between two tasks',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Remove a dependency relationship from a ClickUp task. Provide exactly one of "Depends On" or "Blocks" matching the dependency to remove (the same way it was created with Add Task Dependency). Removing a dependency that no longer exists is a no-op, so it is idempotent.',
+    idempotent: true,
+  },
+  displayName: 'Delete Task Dependency',
+  props: {
+    task_id: Property.ShortText({
+      displayName: 'Task ID',
+      description: 'The task the dependency is set on.',
+      required: true,
+    }),
+    depends_on: Property.ShortText({
+      displayName: 'Depends On',
+      description:
+        'The ID of the task this task depended on. Provide exactly one of Depends On or Blocks.',
+      required: false,
+    }),
+    dependency_of: Property.ShortText({
+      displayName: 'Blocks',
+      description:
+        'The ID of the task this task blocked. Provide exactly one of Depends On or Blocks.',
+      required: false,
+    }),
+  },
+  async run(configValue) {
+    const { task_id, depends_on, dependency_of } = configValue.propsValue;
+    if ((depends_on && dependency_of) || (!depends_on && !dependency_of)) {
+      throw new Error(
+        'Provide exactly one of "Depends On" or "Blocks".'
+      );
+    }
+
+    const queryParams: Record<string, string> = {};
+    if (depends_on) queryParams['depends_on'] = depends_on;
+    if (dependency_of) queryParams['dependency_of'] = dependency_of;
+
+    const response = await callClickUpApi(
+      HttpMethod.DELETE,
+      `task/${task_id}/dependency`,
+      getAccessTokenOrThrow(configValue.auth),
+      undefined,
+      queryParams
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/tasks/clickup-delete-task.ts

@@ -0,0 +1,35 @@
+import { createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+
+import { clickupCommon, callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+
+export const clickupDeleteTaskAi = createAction({
+  auth: clickupAuth,
+  name: 'clickup_delete_task',
+  description: 'Delete a task in a workspace and list',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Permanently delete a ClickUp task identified by its task ID. Pick this to remove a task entirely; to move it to another list instead use Move Task To List. This is destructive and cannot be undone, and deleting an already-deleted task errors, so it is not idempotent.',
+    idempotent: false,
+  },
+  displayName: 'Delete Task',
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    space_id: clickupCommon.space_id(),
+    list_id: clickupCommon.list_id(),
+    task_id: clickupCommon.task_id(),
+  },
+  async run(configValue) {
+    const { task_id } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.DELETE,
+      `task/${task_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      undefined
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/tasks/clickup-get-bulk-tasks-time-in-status.ts

@@ -0,0 +1,46 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import qs from 'qs';
+
+import { callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+
+export const clickupGetBulkTasksTimeInStatusAi = createAction({
+  auth: clickupAuth,
+  name: 'clickup_get_bulk_tasks_time_in_status',
+  description: 'Get how long several tasks have spent in each status',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Retrieve the status dwell times for several ClickUp tasks in one call, given a list of task IDs. Pick this for multiple tasks; for a single task use Get Task Time In Status. Provide up to about 100 task IDs per call. Read-only and idempotent.',
+    idempotent: true,
+  },
+  displayName: 'Get Bulk Tasks Time In Status',
+  props: {
+    task_ids: Property.Array({
+      displayName: 'Task IDs',
+      description: 'The task IDs to read status dwell times for (up to ~100).',
+      required: true,
+    }),
+  },
+  async run(configValue) {
+    const taskIds = configValue.propsValue.task_ids as string[];
+    if (!taskIds || taskIds.length === 0) {
+      throw new Error('At least one task ID is required.');
+    }
+
+    const query = qs.stringify(
+      { task_ids: taskIds },
+      { arrayFormat: 'repeat' }
+    );
+
+    const response = await callClickUpApi(
+      HttpMethod.GET,
+      `task/bulk_time_in_status/task_ids?${query}`,
+      getAccessTokenOrThrow(configValue.auth),
+      undefined
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/tasks/clickup-get-task-members.ts

@@ -0,0 +1,38 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+
+import { callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { membersOutputSchema } from '../../output-schemas';
+
+export const clickupGetTaskMembersAi = createAction({
+  auth: clickupAuth,
+  name: 'clickup_get_task_members',
+  description: 'List the members who have access to a task',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'List the people who have access to a ClickUp task, identified by its task ID. Use this to discover member IDs (e.g. before assigning) or to check who can see a task. Read-only and idempotent.',
+    idempotent: true,
+  },
+  displayName: 'Get Task Members',
+  outputSchema: membersOutputSchema,
+  props: {
+    task_id: Property.ShortText({
+      displayName: 'Task ID',
+      description: 'The ID of the task to list members for.',
+      required: true,
+    }),
+  },
+  async run(configValue) {
+    const { task_id } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.GET,
+      `task/${task_id}/member`,
+      getAccessTokenOrThrow(configValue.auth),
+      undefined
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/tasks/clickup-get-task.ts

@@ -0,0 +1,45 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { taskOutputSchema } from '../../output-schemas';
+
+export const clickupGetTaskAi = createAction({
+  auth: clickupAuth,
+  name: 'clickup_get_task',
+  description: 'Gets a task in a ClickUp list',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Retrieve a single ClickUp task by its task ID, optionally including its subtasks. Pick this when you already know the task ID; to find a task without an ID use List Tasks or List List Tasks. Read-only and idempotent.',
+    idempotent: true,
+  },
+  displayName: 'Get Task',
+  outputSchema: taskOutputSchema,
+  props: {
+    task_id: Property.ShortText({
+      description: 'The ID of the task to get',
+      displayName: 'Task ID',
+      required: true,
+    }),
+    include_subtasks: Property.Checkbox({
+      description: 'Include subtasks in the response',
+      displayName: 'Include Subtasks',
+      required: false,
+      defaultValue: false,
+    }),
+  },
+  async run(configValue) {
+    const { task_id, include_subtasks } = configValue.propsValue;
+
+    const response = await callClickUpApi(
+      HttpMethod.GET,
+      `task/${task_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      undefined,
+      include_subtasks ? { include_subtasks: 'true' } : undefined
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/tasks/clickup-link-tasks.ts

@@ -0,0 +1,43 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+
+import { callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { taskWrapperOutputSchema } from '../../output-schemas';
+
+export const clickupLinkTasksAi = createAction({
+  auth: clickupAuth,
+  name: 'clickup_link_tasks',
+  description: 'Link two tasks together',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Create a non-dependency link between two ClickUp tasks (a simple association, not a blocking relationship). For a blocking/depends-on relationship use Add Task Dependency instead; to remove a link use Unlink Tasks. Re-linking already-linked tasks is a no-op, so it is idempotent.',
+    idempotent: true,
+  },
+  displayName: 'Link Tasks',
+  outputSchema: taskWrapperOutputSchema,
+  props: {
+    task_id: Property.ShortText({
+      displayName: 'Task ID',
+      description: 'The ID of the first task.',
+      required: true,
+    }),
+    links_to: Property.ShortText({
+      displayName: 'Links To Task ID',
+      description: 'The ID of the task to link to.',
+      required: true,
+    }),
+  },
+  async run(configValue) {
+    const { task_id, links_to } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.POST,
+      `task/${task_id}/link/${links_to}`,
+      getAccessTokenOrThrow(configValue.auth),
+      {}
+    );
+
+    return response.body;
+  },
+});