@divyacon/piece-clickup 0.0.0-stage → 0.1.0

package/src/lib/actions/lists/ai-get-list-members.ts

@@ -0,0 +1,37 @@
+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 clickupGetListMembers = createAction({
+  auth: clickupAuth,
+  name: 'clickup_get_list_members',
+  description: 'List the members who have access to a ClickUp list',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Read-only: list the people who have access to a specific ClickUp list, returning their user IDs and names. Use to discover who can see or be assigned within a list. Safe to call repeatedly.',
+    idempotent: true,
+  },
+  displayName: 'Get List Members',
+  outputSchema: membersOutputSchema,
+  props: {
+    list_id: Property.ShortText({
+      description: 'The ID of the list to read members for',
+      displayName: 'List ID',
+      required: true,
+    }),
+  },
+  async run(configValue) {
+    const { list_id } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.GET,
+      `list/${list_id}/member`,
+      getAccessTokenOrThrow(configValue.auth),
+      {}
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/lists/ai-get-list.ts

@@ -0,0 +1,37 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { listOutputSchema } from '../../output-schemas';
+
+export const clickupGetList = createAction({
+  auth: clickupAuth,
+  name: 'clickup_get_list',
+  description: 'Get a single ClickUp list by its ID',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Read-only: fetch the details of one ClickUp list (including its available statuses) by list ID. Use when you already know the list ID; to discover list IDs first, use Get Folder Lists or Get Folderless Lists. Safe to call repeatedly.',
+    idempotent: true,
+  },
+  displayName: 'Get List',
+  outputSchema: listOutputSchema,
+  props: {
+    list_id: Property.ShortText({
+      description: 'The ID of the list to get',
+      displayName: 'List ID',
+      required: true,
+    }),
+  },
+  async run(configValue) {
+    const { list_id } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.GET,
+      `list/${list_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      {}
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/lists/ai-update-list.ts

@@ -0,0 +1,50 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { listOutputSchema } from '../../output-schemas';
+
+export const clickupUpdateList = createAction({
+  auth: clickupAuth,
+  name: 'clickup_update_list',
+  description: 'Update an existing ClickUp list',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Update properties of an existing ClickUp list (such as renaming it or changing its content) by list ID. Pick this to modify a list you already have the ID for; use Create List to make a new one. Only the fields you supply are changed, so repeating the same update yields the same end state.',
+    idempotent: true,
+  },
+  displayName: 'Update List',
+  outputSchema: listOutputSchema,
+  props: {
+    list_id: Property.ShortText({
+      description: 'The ID of the list to update',
+      displayName: 'List ID',
+      required: true,
+    }),
+    name: Property.ShortText({
+      description: 'The new name for the list',
+      displayName: 'List Name',
+      required: false,
+    }),
+    content: Property.LongText({
+      description: 'The new description/content for the list',
+      displayName: 'Content',
+      required: false,
+    }),
+  },
+  async run(configValue) {
+    const { list_id, name, content } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.PUT,
+      `list/${list_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      {
+        name,
+        content,
+      }
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/lists/create-folderless-list.ts

@@ -0,0 +1,37 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { clickupCommon, callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { listOutputSchema } from '../../output-schemas';
+
+export const createClickupFolderlessList = createAction({
+  auth: clickupAuth,
+  name: 'create_folderless_list',
+  description: 'Create a new folderless list in a ClickUp workspace and space',
+  audience: 'human',
+  aiMetadata: { description: 'Create a new list directly under a ClickUp space (not inside a folder). Each call creates a separate list even with the same name, so it is not idempotent. Use when you need a top-level list in a space; to create a list inside a folder, use a folder-scoped list action instead.', idempotent: false },
+  displayName: 'Create Folderless List',
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    space_id: clickupCommon.space_id(),
+    name: Property.ShortText({
+      description: 'The name of the list to create',
+      displayName: 'List Name',
+      required: true,
+    }),
+  },
+  outputSchema: listOutputSchema,
+  async run(configValue) {
+    const { space_id, name } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.POST,
+      `space/${space_id}/list`,
+      getAccessTokenOrThrow(configValue.auth),
+      {
+        name,
+      }
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/lists/get-list.ts

@@ -0,0 +1,34 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { listOutputSchema } from '../../output-schemas';
+
+export const getClickupList = createAction({
+  auth: clickupAuth,
+
+  name: 'get_list',
+  description: 'Gets a list in a ClickUp',
+  audience: 'human',
+  aiMetadata: { description: 'Read-only: fetch the details of a single ClickUp list by its list ID. Use when you already know the list ID; does not modify anything and is safe to call repeatedly.', idempotent: true },
+  displayName: 'Get List',
+  props: {
+    list_id: Property.ShortText({
+      description: 'The id of the list to get',
+      displayName: 'List ID',
+      required: true,
+    }),
+  },
+  outputSchema: listOutputSchema,
+  async run(configValue) {
+    const { list_id } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.GET,
+      `list/${list_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      {}
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/members/list-workspace-members.ts

@@ -0,0 +1,40 @@
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { createAction } from '@agnocon/pieces-framework';
+import { clickupAuth } from '../../auth';
+import { callClickUpApi, clickupCommon } from '../../common';
+import { ClickupWorkspace } from '../../common/models';
+import { workspaceMembersOutputSchema } from '../../output-schemas';
+
+export const clickupListWorkspaceMembers = createAction({
+  auth: clickupAuth,
+  name: 'clickup_list_workspace_members',
+  displayName: 'List Workspace Members',
+  description: 'List all members of a ClickUp workspace.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'List every member of a ClickUp workspace, returning each member ID, username, and email. Pick this to resolve a person name or email to the numeric member ID needed for assigning tasks anywhere in the workspace; use Get List Members or Get Task Members to scope the result to a single list or task. Read-only and idempotent.',
+    idempotent: true,
+  },
+  outputSchema: workspaceMembersOutputSchema,
+  props: {
+    workspace_id: clickupCommon.workspace_id(true),
+  },
+  async run(context) {
+    const { workspace_id } = context.propsValue;
+    const auth = getAccessTokenOrThrow(context.auth);
+
+    const response = await callClickUpApi<{ teams: ClickupWorkspace[] }>(
+      HttpMethod.GET,
+      'team',
+      auth,
+      undefined
+    );
+
+    const workspace = response.body.teams.find(
+      (team) => team.id === workspace_id
+    );
+
+    return { members: workspace?.members ?? [] };
+  },
+});

package/src/lib/actions/spaces/ai-create-space.ts

@@ -0,0 +1,47 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { clickupCommon, callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { spaceOutputSchema } from '../../output-schemas';
+
+export const clickupCreateSpace = createAction({
+  auth: clickupAuth,
+  name: 'clickup_create_space',
+  description: 'Create a new space in a ClickUp workspace',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Create a new space in a ClickUp workspace (team) to hold folders and lists. Pick this to add a new top-level container in a workspace; to add a folder or list within an existing space, use Create Folder or Create Folderless List. Each call creates a new space even with the same name, so retries duplicate it.',
+    idempotent: false,
+  },
+  displayName: 'Create Space',
+  outputSchema: spaceOutputSchema,
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    name: Property.ShortText({
+      description: 'The name of the space to create',
+      displayName: 'Space Name',
+      required: true,
+    }),
+    multiple_assignees: Property.Checkbox({
+      description: 'Allow tasks in this space to have multiple assignees',
+      displayName: 'Multiple Assignees',
+      required: false,
+      defaultValue: true,
+    }),
+  },
+  async run(configValue) {
+    const { workspace_id, name, multiple_assignees } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.POST,
+      `team/${workspace_id}/space`,
+      getAccessTokenOrThrow(configValue.auth),
+      {
+        name,
+        multiple_assignees: multiple_assignees ?? true,
+      }
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/spaces/ai-delete-space.ts

@@ -0,0 +1,32 @@
+import { createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { clickupCommon, callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+
+export const clickupDeleteSpace = createAction({
+  auth: clickupAuth,
+  name: 'clickup_delete_space',
+  description: 'Delete a ClickUp space by its ID',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Permanently delete a ClickUp space along with every folder, list, and task inside it, by space ID. This has a large blast radius and cannot be undone, so confirm the ID before calling. Deleting an already-deleted space fails rather than succeeding, so treat it as non-idempotent.',
+    idempotent: false,
+  },
+  displayName: 'Delete Space',
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    space_id: clickupCommon.space_id(),
+  },
+  async run(configValue) {
+    const { space_id } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.DELETE,
+      `space/${space_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      undefined
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/spaces/ai-get-space.ts

@@ -0,0 +1,32 @@
+import { createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { callClickUpApi, clickupCommon } from '../../common';
+import { clickupAuth } from '../../auth';
+import { spaceOutputSchema } from '../../output-schemas';
+
+export const clickupGetSpace = createAction({
+  auth: clickupAuth,
+  name: 'clickup_get_space',
+  description: 'Get a single ClickUp space by its ID',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Read-only: fetch the details of one ClickUp space by space ID. Use when you already know which space you want; to discover space IDs first, use Get Spaces. Safe to call repeatedly.',
+    idempotent: true,
+  },
+  displayName: 'Get Space',
+  outputSchema: spaceOutputSchema,
+  props: {
+    space_id: clickupCommon.space_id(),
+  },
+  async run(configValue) {
+    const { space_id } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.GET,
+      `space/${space_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      {}
+    );
+    return response.body;
+  },
+});

package/src/lib/actions/spaces/ai-get-spaces.ts

@@ -0,0 +1,33 @@
+import { createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { clickupCommon, callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { getSpacesOutputSchema } from '../../output-schemas';
+
+export const clickupGetSpaces = createAction({
+  auth: clickupAuth,
+  name: 'clickup_get_spaces',
+  description: 'List all spaces in a ClickUp workspace',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Read-only: list all spaces in a ClickUp workspace (team), returning their IDs and names. Use to discover available spaces before drilling into a specific space, folder, or list. Safe to call repeatedly.',
+    idempotent: true,
+  },
+  displayName: 'Get Spaces',
+  outputSchema: getSpacesOutputSchema,
+  props: {
+    team_id: clickupCommon.workspace_id(),
+  },
+  async run(configValue) {
+    const { team_id } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.GET,
+      `team/${team_id}/space`,
+      getAccessTokenOrThrow(configValue.auth),
+      {}
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/spaces/ai-update-space.ts

@@ -0,0 +1,48 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { clickupCommon, callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { spaceOutputSchema } from '../../output-schemas';
+
+export const clickupUpdateSpace = createAction({
+  auth: clickupAuth,
+  name: 'clickup_update_space',
+  description: 'Update an existing ClickUp space',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Update properties of an existing ClickUp space (such as renaming it or toggling multiple-assignee support) by space ID. Pick this to modify a space you already have the ID for; use Create Space to make a new one. Only the fields you supply are changed, so repeating the same update yields the same end state.',
+    idempotent: true,
+  },
+  displayName: 'Update Space',
+  outputSchema: spaceOutputSchema,
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    space_id: clickupCommon.space_id(),
+    name: Property.ShortText({
+      description: 'The new name for the space',
+      displayName: 'Space Name',
+      required: false,
+    }),
+    multiple_assignees: Property.Checkbox({
+      description: 'Allow tasks in this space to have multiple assignees',
+      displayName: 'Multiple Assignees',
+      required: false,
+    }),
+  },
+  async run(configValue) {
+    const { space_id, name, multiple_assignees } = configValue.propsValue;
+    const body: Record<string, unknown> = {};
+    if (name !== undefined) body['name'] = name;
+    if (multiple_assignees !== undefined)
+      body['multiple_assignees'] = multiple_assignees;
+    const response = await callClickUpApi(
+      HttpMethod.PUT,
+      `space/${space_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      body
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/spaces/get-space.ts

@@ -0,0 +1,29 @@
+import { createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+
+import { callClickUpApi, clickupCommon } from '../../common';
+import { clickupAuth } from '../../auth';
+import { spaceOutputSchema } from '../../output-schemas';
+
+export const getClickupSpace = createAction({
+  auth: clickupAuth,
+  name: 'get_space',
+  description: 'Gets a space in a ClickUp',
+  audience: 'human',
+  aiMetadata: { description: 'Read-only: fetch the details of a single ClickUp space by its space ID. Use when you already know which space you want; to discover space IDs first, use the list-spaces action instead. Safe to call repeatedly.', idempotent: true },
+  displayName: 'Get Space',
+  props: {
+    space_id: clickupCommon.space_id(),
+  },
+  outputSchema: spaceOutputSchema,
+  async run(configValue) {
+    const { space_id } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.GET,
+      `space/${space_id}`,
+      getAccessTokenOrThrow(configValue.auth),
+      {}
+    );
+    return response.body;
+  },
+});

package/src/lib/actions/spaces/get-spaces.ts

@@ -0,0 +1,29 @@
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { clickupCommon, callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+import { createAction } from '@agnocon/pieces-framework';
+import { getSpacesOutputSchema } from '../../output-schemas';
+
+export const getClickupSpaces = createAction({
+  auth: clickupAuth,
+  name: 'get_spaces',
+  description: 'Gets spaces in a ClickUp workspace',
+  audience: 'human',
+  aiMetadata: { description: 'Read-only: list all spaces in a ClickUp workspace (team). Use to discover available spaces and their IDs before drilling into a specific space, folder, or list. Safe to call repeatedly.', idempotent: true },
+  displayName: 'Get Spaces',
+  props: {
+    team_id: clickupCommon.workspace_id(),
+  },
+  outputSchema: getSpacesOutputSchema,
+  async run(configValue) {
+    const { team_id } = configValue.propsValue;
+    const response = await callClickUpApi(
+      HttpMethod.GET,
+      `team/${team_id}/space`,
+      getAccessTokenOrThrow(configValue.auth),
+      {}
+    );
+
+    return response.body;
+  },
+});

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

@@ -0,0 +1,54 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { HttpMethod, getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { clickupCommon, callClickUpApi } from '../../common';
+import { clickupAuth } from '../../auth';
+
+export const clickupCreateSpaceTag = createAction({
+  auth: clickupAuth,
+  name: 'clickup_create_space_tag',
+  description: 'Create a new tag in a ClickUp space',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Create a new tag in a ClickUp space with a name and optional foreground/background colors. Use this before Add Tag To Task when the tag does not yet exist; to rename or recolor an existing tag use Update Space Tag instead. Creating a tag whose name already exists may fail, so it is not idempotent.',
+    idempotent: false,
+  },
+  displayName: 'Create Space Tag',
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    space_id: clickupCommon.space_id(),
+    name: Property.ShortText({
+      description: 'The name of the new tag',
+      displayName: 'Tag 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, name, tag_fg, tag_bg } = configValue.propsValue;
+
+    const response = await callClickUpApi(
+      HttpMethod.POST,
+      `space/${space_id}/tag`,
+      getAccessTokenOrThrow(configValue.auth),
+      {
+        tag: {
+          name,
+          tag_fg: tag_fg ?? undefined,
+          tag_bg: tag_bg ?? undefined,
+        },
+      }
+    );
+
+    return response.body;
+  },
+});

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

@@ -0,0 +1,64 @@
+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 clickupDeleteSpaceTag = createAction({
+  auth: clickupAuth,
+  name: 'clickup_delete_space_tag',
+  description: 'Delete a tag from a ClickUp space',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Delete a tag from a ClickUp space by name, which also removes it from every task it was applied to in that space. To merely detach a tag from a single task without deleting it, use Remove Tag From Task instead. This is destructive across the space; confirm the name (via List Space Tags) before calling.',
+    idempotent: false,
+  },
+  displayName: 'Delete Space Tag',
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    space_id: clickupCommon.space_id(),
+    tag_name: Property.Dropdown({
+      auth: clickupAuth,
+      displayName: 'Tag',
+      description: 'The name of the tag to delete',
+      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 { space_id, tag_name } = configValue.propsValue;
+
+    const response = await callClickUpApi(
+      HttpMethod.DELETE,
+      `space/${space_id}/tag/${encodeURIComponent(tag_name as string)}`,
+      getAccessTokenOrThrow(configValue.auth),
+      undefined
+    );
+
+    return response.body;
+  },
+});

package/src/lib/actions/tags/get-space-tags.ts

@@ -0,0 +1,30 @@
+import { createAction } from '@agnocon/pieces-framework';
+import { getAccessTokenOrThrow } from '@agnocon/pieces-common';
+import { clickupCommon, listTags } from '../../common';
+import { clickupAuth } from '../../auth';
+import { spaceTagsOutputSchema } from '../../output-schemas';
+
+export const clickupGetSpaceTags = createAction({
+  auth: clickupAuth,
+  name: 'clickup_get_space_tags',
+  description: 'List all tags defined in a ClickUp space',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Read-only: list every tag defined in a ClickUp space. Use this to discover valid tag names before calling Add Tag To Task, Remove Tag From Task, Update Space Tag, or Delete Space Tag. Safe to call repeatedly.',
+    idempotent: true,
+  },
+  displayName: 'List Space Tags',
+  outputSchema: spaceTagsOutputSchema,
+  props: {
+    workspace_id: clickupCommon.workspace_id(),
+    space_id: clickupCommon.space_id(),
+  },
+  async run(configValue) {
+    const { space_id } = configValue.propsValue;
+    return await listTags(
+      getAccessTokenOrThrow(configValue.auth),
+      space_id as string
+    );
+  },
+});