@divyacon/piece-trello 0.0.0-stage → 0.1.0

package/src/lib/actions/ai/archive-card.ts

@@ -0,0 +1,58 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpRequest,
+  HttpMethod,
+} from '@agnocon/pieces-common';
+import { trelloCommon } from '../../common';
+import { trelloAuth } from '../../..';
+import { withAuthParams, rethrowTrelloError } from './ai-common';
+import { archiveCardActionOutputSchema } from '../../output-schemas';
+
+export const archiveCard = createAction({
+  auth: trelloAuth,
+  name: 'archive_card',
+  displayName: 'Archive Card (Agent)',
+  description: 'Archive or unarchive a Trello card.',
+  audience: 'ai',
+  outputSchema: archiveCardActionOutputSchema,
+  aiMetadata: {
+    description:
+      'Archives (closed=true) or unarchives (closed=false) a Trello card. Archiving is recoverable, so prefer this over Delete Card. Obtain card_id from Search Cards. Setting the same closed state again converges, so it is idempotent.',
+    idempotent: true,
+  },
+  props: {
+    card_id: Property.ShortText({
+      displayName: 'Card ID',
+      description: 'The ID of the card. Obtain it from Search Cards.',
+      required: true,
+    }),
+    archived: Property.Checkbox({
+      displayName: 'Archived',
+      description: 'True to archive the card, false to unarchive it.',
+      required: false,
+      defaultValue: true,
+    }),
+  },
+
+  async run(context) {
+    const archived = context.propsValue['archived'] ?? true;
+    try {
+      const request: HttpRequest = {
+        method: HttpMethod.PUT,
+        url: `${trelloCommon.baseUrl}cards/${context.propsValue['card_id']}/closed`,
+        headers: { Accept: 'application/json' },
+        queryParams: withAuthParams(context.auth, {
+          value: archived ? 'true' : 'false',
+        }),
+      };
+      const response = await httpClient.sendRequest(request);
+      return response.body;
+    } catch (error: any) {
+      rethrowTrelloError(
+        error,
+        'Card not found. Verify the card_id (resolve it via Search Cards).'
+      );
+    }
+  },
+});

package/src/lib/actions/ai/archive-list.ts

@@ -0,0 +1,58 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpRequest,
+  HttpMethod,
+} from '@agnocon/pieces-common';
+import { trelloCommon } from '../../common';
+import { trelloAuth } from '../../..';
+import { withAuthParams, rethrowTrelloError } from './ai-common';
+import { archiveListActionOutputSchema } from '../../output-schemas';
+
+export const archiveList = createAction({
+  auth: trelloAuth,
+  name: 'archive_list',
+  displayName: 'Archive List (Agent)',
+  description: 'Archive or unarchive a Trello list.',
+  audience: 'ai',
+  outputSchema: archiveListActionOutputSchema,
+  aiMetadata: {
+    description:
+      'Archives (closed=true) or unarchives (closed=false) a Trello list identified by list_id. Obtain list_id from List Lists. Setting the same closed state again converges, so it is idempotent.',
+    idempotent: true,
+  },
+  props: {
+    list_id: Property.ShortText({
+      displayName: 'List ID',
+      description: 'The ID of the list. Obtain it from List Lists.',
+      required: true,
+    }),
+    archived: Property.Checkbox({
+      displayName: 'Archived',
+      description: 'True to archive the list, false to unarchive it.',
+      required: false,
+      defaultValue: true,
+    }),
+  },
+
+  async run(context) {
+    const archived = context.propsValue['archived'] ?? true;
+    try {
+      const request: HttpRequest = {
+        method: HttpMethod.PUT,
+        url: `${trelloCommon.baseUrl}lists/${context.propsValue['list_id']}/closed`,
+        headers: { Accept: 'application/json' },
+        queryParams: withAuthParams(context.auth, {
+          value: archived ? 'true' : 'false',
+        }),
+      };
+      const response = await httpClient.sendRequest(request);
+      return response.body;
+    } catch (error: any) {
+      rethrowTrelloError(
+        error,
+        'List not found. Verify the list_id (resolve it via List Lists).'
+      );
+    }
+  },
+});

package/src/lib/actions/ai/create-board-label.ts

@@ -0,0 +1,69 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpRequest,
+  HttpMethod,
+  QueryParams,
+} from '@agnocon/pieces-common';
+import { trelloCommon } from '../../common';
+import { trelloAuth } from '../../..';
+import { withAuthParams, rethrowTrelloError } from './ai-common';
+import { createBoardLabelActionOutputSchema } from '../../output-schemas';
+
+export const createBoardLabel = createAction({
+  auth: trelloAuth,
+  name: 'create_board_label',
+  displayName: 'Create Board Label (Agent)',
+  description: 'Define a reusable label on a Trello board.',
+  audience: 'ai',
+  outputSchema: createBoardLabelActionOutputSchema,
+  aiMetadata: {
+    description:
+      'Creates a reusable label (name + color) on a Trello board. Returns the new label id, which you can then attach to cards with Add Label To Card. Obtain board_id from List Boards. Each call creates a distinct label, so it is not idempotent.',
+    idempotent: false,
+  },
+  props: {
+    board_id: Property.ShortText({
+      displayName: 'Board ID',
+      description: 'The board to create the label on. Obtain it from List Boards.',
+      required: true,
+    }),
+    name: Property.ShortText({
+      displayName: 'Label Name',
+      required: false,
+    }),
+    color: Property.ShortText({
+      displayName: 'Color',
+      description:
+        'Label color (e.g. green, yellow, orange, red, purple, blue, sky, lime, pink, black) or leave empty for no color.',
+      required: false,
+    }),
+  },
+
+  async run(context) {
+    const params: QueryParams = {
+      idBoard: context.propsValue['board_id'],
+    };
+    if (context.propsValue['name']) {
+      params['name'] = context.propsValue['name'] as string;
+    }
+    if (context.propsValue['color']) {
+      params['color'] = context.propsValue['color'] as string;
+    }
+    try {
+      const request: HttpRequest = {
+        method: HttpMethod.POST,
+        url: `${trelloCommon.baseUrl}labels`,
+        headers: { Accept: 'application/json' },
+        queryParams: withAuthParams(context.auth, params),
+      };
+      const response = await httpClient.sendRequest(request);
+      return response.body;
+    } catch (error: any) {
+      rethrowTrelloError(
+        error,
+        'Board not found. Verify the board_id (resolve it via List Boards).'
+      );
+    }
+  },
+});

package/src/lib/actions/ai/create-board.ts

@@ -0,0 +1,66 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpRequest,
+  HttpMethod,
+  QueryParams,
+} from '@agnocon/pieces-common';
+import { trelloCommon } from '../../common';
+import { trelloAuth } from '../../..';
+import { withAuthParams, rethrowTrelloError } from './ai-common';
+import { createBoardActionOutputSchema } from '../../output-schemas';
+
+export const createBoard = createAction({
+  auth: trelloAuth,
+  name: 'create_board',
+  displayName: 'Create Board (Agent)',
+  description: 'Create a new Trello board.',
+  audience: 'ai',
+  outputSchema: createBoardActionOutputSchema,
+  aiMetadata: {
+    description:
+      'Creates a new Trello board with a name and optional description, optionally inside a workspace (organization). Returns the new board id. Obtain org_id (if used) from List Boards / Get My Member. Each call creates a distinct board, so it is not idempotent.',
+    idempotent: false,
+  },
+  props: {
+    name: Property.ShortText({
+      displayName: 'Board Name',
+      required: true,
+    }),
+    description: Property.LongText({
+      displayName: 'Description',
+      required: false,
+    }),
+    org_id: Property.ShortText({
+      displayName: 'Organization ID',
+      description:
+        'The workspace (organization) id to create the board in (optional).',
+      required: false,
+    }),
+  },
+
+  async run(context) {
+    const params: QueryParams = { name: context.propsValue['name'] };
+    if (context.propsValue['description']) {
+      params['desc'] = context.propsValue['description'] as string;
+    }
+    if (context.propsValue['org_id']) {
+      params['idOrganization'] = context.propsValue['org_id'] as string;
+    }
+    try {
+      const request: HttpRequest = {
+        method: HttpMethod.POST,
+        url: `${trelloCommon.baseUrl}boards`,
+        headers: { Accept: 'application/json' },
+        queryParams: withAuthParams(context.auth, params),
+      };
+      const response = await httpClient.sendRequest(request);
+      return response.body;
+    } catch (error: any) {
+      rethrowTrelloError(
+        error,
+        'Organization not found. Verify the org_id, or omit it to create a personal board.'
+      );
+    }
+  },
+});

package/src/lib/actions/ai/create-card-ai.ts

@@ -0,0 +1,103 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpRequest,
+  HttpMethod,
+} from '@agnocon/pieces-common';
+import { trelloCommon } from '../../common';
+import { TrelloCard } from '../../common/props/card';
+import { trelloAuth } from '../../..';
+import { createCardAiActionOutputSchema } from '../../output-schemas';
+
+export const createCardAi = createAction({
+  auth: trelloAuth,
+  name: 'create_card_ai',
+  displayName: 'Create Card (Agent)',
+  description: 'Create a new card in a Trello list.',
+  audience: 'ai',
+  outputSchema: createCardAiActionOutputSchema,
+  aiMetadata: {
+    description:
+      'Creates a new Trello card in a specific list, optionally with a description, position (top/bottom), and label ids. Requires the target list_id (resolve it via List Lists for a board, which you can find via List Boards). Each call creates a distinct card, so it is not idempotent.',
+    idempotent: false,
+  },
+  props: {
+    list_id: Property.ShortText({
+      displayName: 'List ID',
+      description:
+        'The ID of the list to create the card in. Obtain it from List Lists (which takes a board_id from List Boards).',
+      required: true,
+    }),
+    name: Property.ShortText({
+      displayName: 'Card Name',
+      description: 'The name of the card to create.',
+      required: true,
+    }),
+    description: Property.LongText({
+      displayName: 'Card Description',
+      description: 'The description of the card to create.',
+      required: false,
+    }),
+    position: Property.StaticDropdown({
+      displayName: 'Position',
+      description: 'Place the card on top or bottom of the list.',
+      required: false,
+      options: {
+        options: [
+          { label: 'Top', value: 'top' },
+          { label: 'Bottom', value: 'bottom' },
+        ],
+      },
+    }),
+    labels: Property.Array({
+      displayName: 'Label IDs',
+      description:
+        'Label ids to attach to the card. Obtain them from List Board Labels.',
+      required: false,
+    }),
+  },
+
+  async run(context) {
+    try {
+      const request: HttpRequest = {
+        method: HttpMethod.POST,
+        url:
+          `${trelloCommon.baseUrl}cards` +
+          `?idList=` +
+          context.propsValue['list_id'] +
+          `&key=` +
+          context.auth.username +
+          `&token=` +
+          context.auth.password,
+        headers: {
+          Accept: 'application/json',
+        },
+        body: {
+          name: context.propsValue['name'],
+          desc: context.propsValue['description'],
+          pos: context.propsValue['position'],
+          idLabels: context.propsValue['labels'] as string[] | undefined,
+        },
+        queryParams: {},
+      };
+      const response = await httpClient.sendRequest<TrelloCard>(request);
+      return response.body;
+    } catch (error: any) {
+      const status = error?.response?.status;
+      if (status === 401 || status === 403) {
+        throw new Error(
+          'Permission denied creating the card. Check the connection token and that you can write to the list.'
+        );
+      }
+      if (status === 404) {
+        throw new Error(
+          'List not found. Verify the list_id (resolve it via List Lists).'
+        );
+      }
+      if (status === 429) {
+        throw new Error('Trello rate limit exceeded. Retry after a short delay.');
+      }
+      throw error;
+    }
+  },
+});

package/src/lib/actions/ai/create-list.ts

@@ -0,0 +1,71 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpRequest,
+  HttpMethod,
+  QueryParams,
+} from '@agnocon/pieces-common';
+import { trelloCommon } from '../../common';
+import { trelloAuth } from '../../..';
+import { withAuthParams, rethrowTrelloError } from './ai-common';
+import { createListActionOutputSchema } from '../../output-schemas';
+
+export const createList = createAction({
+  auth: trelloAuth,
+  name: 'create_list',
+  displayName: 'Create List (Agent)',
+  description: 'Create a list (column) on a Trello board.',
+  audience: 'ai',
+  outputSchema: createListActionOutputSchema,
+  aiMetadata: {
+    description:
+      'Creates a new list (column) on a Trello board. Returns the new list id for use with card actions. Obtain board_id from List Boards. Each call creates a distinct list, so it is not idempotent.',
+    idempotent: false,
+  },
+  props: {
+    board_id: Property.ShortText({
+      displayName: 'Board ID',
+      description: 'The board to create the list on. Obtain it from List Boards.',
+      required: true,
+    }),
+    name: Property.ShortText({
+      displayName: 'List Name',
+      required: true,
+    }),
+    position: Property.StaticDropdown({
+      displayName: 'Position',
+      required: false,
+      options: {
+        options: [
+          { label: 'Top', value: 'top' },
+          { label: 'Bottom', value: 'bottom' },
+        ],
+      },
+    }),
+  },
+
+  async run(context) {
+    const params: QueryParams = {
+      name: context.propsValue['name'],
+      idBoard: context.propsValue['board_id'],
+    };
+    if (context.propsValue['position']) {
+      params['pos'] = context.propsValue['position'] as string;
+    }
+    try {
+      const request: HttpRequest = {
+        method: HttpMethod.POST,
+        url: `${trelloCommon.baseUrl}lists`,
+        headers: { Accept: 'application/json' },
+        queryParams: withAuthParams(context.auth, params),
+      };
+      const response = await httpClient.sendRequest(request);
+      return response.body;
+    } catch (error: any) {
+      rethrowTrelloError(
+        error,
+        'Board not found. Verify the board_id (resolve it via List Boards).'
+      );
+    }
+  },
+});

package/src/lib/actions/ai/delete-card-ai.ts

@@ -0,0 +1,64 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpRequest,
+  HttpMethod,
+} from '@agnocon/pieces-common';
+import { trelloCommon } from '../../common';
+import { trelloAuth } from '../../..';
+
+export const deleteCardAi = createAction({
+  auth: trelloAuth,
+  name: 'delete_card_ai',
+  displayName: 'Delete Card (Agent)',
+  description: 'Permanently delete a Trello card by ID.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Permanently deletes a Trello card by its card_id. This is irreversible; prefer Archive Card (recoverable) unless the card must be erased entirely. Obtain card_id from Search Cards. Deleting the same id again returns an error once it no longer exists, so it is not idempotent.',
+    idempotent: false,
+  },
+  props: {
+    card_id: Property.ShortText({
+      displayName: 'Card ID',
+      description: 'The ID of the card to delete. Obtain it from Search Cards.',
+      required: true,
+    }),
+  },
+
+  async run(context) {
+    try {
+      const request: HttpRequest = {
+        method: HttpMethod.DELETE,
+        url:
+          `${trelloCommon.baseUrl}cards/${context.propsValue['card_id']}` +
+          `?key=` +
+          context.auth.username +
+          `&token=` +
+          context.auth.password,
+        headers: {
+          Accept: 'application/json',
+        },
+        queryParams: {},
+      };
+      const response = await httpClient.sendRequest(request);
+      return response.body;
+    } catch (error: any) {
+      const status = error?.response?.status;
+      if (status === 401 || status === 403) {
+        throw new Error(
+          'Permission denied deleting the card. Check the connection token and your write access.'
+        );
+      }
+      if (status === 404) {
+        throw new Error(
+          'Card not found (it may already be deleted). Verify the card_id.'
+        );
+      }
+      if (status === 429) {
+        throw new Error('Trello rate limit exceeded. Retry after a short delay.');
+      }
+      throw error;
+    }
+  },
+});

package/src/lib/actions/ai/delete-checklist-item.ts

@@ -0,0 +1,54 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpRequest,
+  HttpMethod,
+} from '@agnocon/pieces-common';
+import { trelloCommon } from '../../common';
+import { trelloAuth } from '../../..';
+import { withAuthParams, rethrowTrelloError } from './ai-common';
+
+export const deleteChecklistItem = createAction({
+  auth: trelloAuth,
+  name: 'delete_checklist_item',
+  displayName: 'Delete Checklist Item (Agent)',
+  description: 'Remove one item from a checklist.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Removes a single check item from a checklist. Both ids come from List Card Checklists: checklist_id (idChecklist) and checkitem_id (idCheckItem). Deleting the same item again returns an error once it no longer exists, so it is not idempotent.',
+    idempotent: false,
+  },
+  props: {
+    checklist_id: Property.ShortText({
+      displayName: 'Checklist ID',
+      description:
+        'The checklist id (idChecklist). Obtain it from List Card Checklists.',
+      required: true,
+    }),
+    checkitem_id: Property.ShortText({
+      displayName: 'Check Item ID',
+      description:
+        'The check item id (idCheckItem). Obtain it from List Card Checklists.',
+      required: true,
+    }),
+  },
+
+  async run(context) {
+    try {
+      const request: HttpRequest = {
+        method: HttpMethod.DELETE,
+        url: `${trelloCommon.baseUrl}checklists/${context.propsValue['checklist_id']}/checkItems/${context.propsValue['checkitem_id']}`,
+        headers: { Accept: 'application/json' },
+        queryParams: withAuthParams(context.auth),
+      };
+      const response = await httpClient.sendRequest(request);
+      return response.body;
+    } catch (error: any) {
+      rethrowTrelloError(
+        error,
+        'Checklist or check item not found (it may already be deleted). Verify both ids via List Card Checklists.'
+      );
+    }
+  },
+});

package/src/lib/actions/ai/delete-checklist.ts

@@ -0,0 +1,48 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpRequest,
+  HttpMethod,
+} from '@agnocon/pieces-common';
+import { trelloCommon } from '../../common';
+import { trelloAuth } from '../../..';
+import { withAuthParams, rethrowTrelloError } from './ai-common';
+
+export const deleteChecklist = createAction({
+  auth: trelloAuth,
+  name: 'delete_checklist',
+  displayName: 'Delete Checklist (Agent)',
+  description: 'Delete a whole checklist.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Deletes an entire checklist (and all of its items) identified by checklist_id. Obtain checklist_id (idChecklist) from List Card Checklists. Deleting the same checklist again returns an error once it no longer exists, so it is not idempotent.',
+    idempotent: false,
+  },
+  props: {
+    checklist_id: Property.ShortText({
+      displayName: 'Checklist ID',
+      description:
+        'The checklist id (idChecklist). Obtain it from List Card Checklists.',
+      required: true,
+    }),
+  },
+
+  async run(context) {
+    try {
+      const request: HttpRequest = {
+        method: HttpMethod.DELETE,
+        url: `${trelloCommon.baseUrl}checklists/${context.propsValue['checklist_id']}`,
+        headers: { Accept: 'application/json' },
+        queryParams: withAuthParams(context.auth),
+      };
+      const response = await httpClient.sendRequest(request);
+      return response.body;
+    } catch (error: any) {
+      rethrowTrelloError(
+        error,
+        'Checklist not found (it may already be deleted). Verify the checklist_id.'
+      );
+    }
+  },
+});

package/src/lib/actions/ai/delete-comment.ts

@@ -0,0 +1,52 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpRequest,
+  HttpMethod,
+} from '@agnocon/pieces-common';
+import { trelloCommon } from '../../common';
+import { trelloAuth } from '../../..';
+import { withAuthParams, rethrowTrelloError } from './ai-common';
+
+export const deleteComment = createAction({
+  auth: trelloAuth,
+  name: 'delete_comment',
+  displayName: 'Delete Comment (Agent)',
+  description: 'Delete a comment from a Trello card.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Deletes a comment on a Trello card, identified by card_id and comment_id (the action id). Obtain card_id from Search Cards and comment_id from List Card Comments. Deleting the same comment again returns an error once it no longer exists, so it is not idempotent.',
+    idempotent: false,
+  },
+  props: {
+    card_id: Property.ShortText({
+      displayName: 'Card ID',
+      description: 'The ID of the card. Obtain it from Search Cards.',
+      required: true,
+    }),
+    comment_id: Property.ShortText({
+      displayName: 'Comment ID',
+      description: 'The comment (action) id. Obtain it from List Card Comments.',
+      required: true,
+    }),
+  },
+
+  async run(context) {
+    try {
+      const request: HttpRequest = {
+        method: HttpMethod.DELETE,
+        url: `${trelloCommon.baseUrl}cards/${context.propsValue['card_id']}/actions/${context.propsValue['comment_id']}/comments`,
+        headers: { Accept: 'application/json' },
+        queryParams: withAuthParams(context.auth),
+      };
+      const response = await httpClient.sendRequest(request);
+      return response.body;
+    } catch (error: any) {
+      rethrowTrelloError(
+        error,
+        'Card or comment not found (it may already be deleted). Verify the card_id and comment_id.'
+      );
+    }
+  },
+});