veryfront 0.0.48 → 0.0.50

package/dist/integrations/clickup/files/ai/tools/create-task.ts

@@ -0,0 +1,64 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createTask } from "../../lib/clickup-client.ts";
+
+export default tool({
+  id: "create-task",
+  description: "Create a new task in a ClickUp list.",
+  inputSchema: z.object({
+    listId: z.string().describe("The ID of the list to create the task in"),
+    name: z.string().describe("The name/title of the task"),
+    description: z.string().optional().describe("Description or details for the task"),
+    assignees: z.array(z.number()).optional().describe("Array of user IDs to assign the task to"),
+    tags: z.array(z.string()).optional().describe("Array of tag names to add to the task"),
+    status: z.string().optional().describe("Status name for the task"),
+    priority: z.number().min(1).max(4).optional().describe(
+      "Priority level: 1 (urgent), 2 (high), 3 (normal), 4 (low)",
+    ),
+    dueDate: z.number().optional().describe("Due date in Unix timestamp (milliseconds)"),
+    startDate: z.number().optional().describe("Start date in Unix timestamp (milliseconds)"),
+    timeEstimate: z.number().optional().describe("Time estimate in milliseconds"),
+    notifyAll: z.boolean().default(false).describe("Notify all assignees when task is created"),
+  }),
+  async execute({
+    listId,
+    name,
+    description,
+    assignees,
+    tags,
+    status,
+    priority,
+    dueDate,
+    startDate,
+    timeEstimate,
+    notifyAll,
+  }) {
+    const task = await createTask({
+      listId,
+      name,
+      description,
+      assignees,
+      tags,
+      status,
+      priority,
+      dueDate,
+      startDate,
+      timeEstimate,
+      notifyAll,
+    });
+
+    return {
+      success: true,
+      task: {
+        id: task.id,
+        name: task.name,
+        status: task.status.status,
+        dueDate: task.due_date ? new Date(parseInt(task.due_date)).toISOString() : null,
+        priority: task.priority?.priority || "none",
+        assignees: task.assignees.map((a) => a.username),
+        list: task.list.name,
+        url: `https://app.clickup.com/t/${task.id}`,
+      },
+    };
+  },
+});

package/dist/integrations/clickup/files/ai/tools/get-task.ts

@@ -0,0 +1,59 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getTask } from "../../lib/clickup-client.ts";
+
+export default tool({
+  id: "get-task",
+  description: "Get detailed information about a specific ClickUp task by ID.",
+  inputSchema: z.object({
+    taskId: z.string().describe("The ID of the task to retrieve"),
+    includeSubtasks: z.boolean().default(false).describe("Include subtasks in the response"),
+    customTaskIds: z.boolean().default(false).describe(
+      "Use custom task IDs instead of internal IDs",
+    ),
+    teamId: z.string().optional().describe("Team ID (required when using custom task IDs)"),
+  }),
+  async execute({ taskId, includeSubtasks, customTaskIds, teamId }) {
+    const task = await getTask(taskId, {
+      includeSubtasks,
+      customTaskIds,
+      teamId,
+    });
+
+    return {
+      id: task.id,
+      name: task.name,
+      description: task.description,
+      status: task.status.status,
+      priority: task.priority?.priority || "none",
+      dueDate: task.due_date ? new Date(parseInt(task.due_date)).toISOString() : null,
+      startDate: task.start_date ? new Date(parseInt(task.start_date)).toISOString() : null,
+      dateCreated: task.date_created,
+      dateUpdated: task.date_updated,
+      dateClosed: task.date_closed,
+      creator: {
+        id: task.creator.id,
+        username: task.creator.username,
+        email: task.creator.email,
+      },
+      assignees: task.assignees.map((assignee) => ({
+        id: assignee.id,
+        username: assignee.username,
+        email: assignee.email,
+      })),
+      tags: task.tags.map((tag) => tag.name),
+      list: {
+        id: task.list.id,
+        name: task.list.name,
+      },
+      folder: {
+        id: task.folder.id,
+        name: task.folder.name,
+      },
+      space: {
+        id: task.space.id,
+        name: task.space.name,
+      },
+    };
+  },
+});

package/dist/integrations/clickup/files/ai/tools/list-lists.ts

@@ -0,0 +1,109 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getTeams, listFolders, listFolderlessLists, listLists, listSpaces } from "../../lib/clickup-client.ts";
+
+export default tool({
+  id: "list-lists",
+  description:
+    "List all lists in ClickUp. Can filter by folder or space. Lists are containers for tasks.",
+  inputSchema: z.object({
+    folderId: z.string().optional().describe("Folder ID to list lists from"),
+    spaceId: z.string().optional().describe("Space ID to list folderless lists from"),
+    includeAll: z.boolean().default(false).describe(
+      "List all lists from all folders in the first space",
+    ),
+  }),
+  async execute({ folderId, spaceId, includeAll }) {
+    if (folderId) {
+      const lists = await listLists(folderId);
+      return lists.map((list) => ({
+        id: list.id,
+        name: list.name,
+        taskCount: list.task_count,
+        dueDate: list.due_date ? new Date(parseInt(list.due_date)).toISOString() : null,
+        status: list.status?.status || "active",
+        priority: list.priority?.priority || "none",
+        assignee: list.assignee?.username || null,
+        folder: list.folder.name,
+        space: list.space.name,
+        archived: list.archived,
+      }));
+    }
+
+    if (spaceId) {
+      const lists = await listFolderlessLists(spaceId);
+      return lists.map((list) => ({
+        id: list.id,
+        name: list.name,
+        taskCount: list.task_count,
+        dueDate: list.due_date ? new Date(parseInt(list.due_date)).toISOString() : null,
+        status: list.status?.status || "active",
+        priority: list.priority?.priority || "none",
+        assignee: list.assignee?.username || null,
+        folder: list.folder.name,
+        space: list.space.name,
+        archived: list.archived,
+      }));
+    }
+
+    if (includeAll) {
+      const teams = await getTeams();
+      if (teams.length === 0) {
+        return { lists: [], message: "No teams found" };
+      }
+
+      const spaces = await listSpaces(teams[0].id);
+      if (spaces.length === 0) {
+        return { lists: [], message: "No spaces found in team" };
+      }
+
+      const firstSpace = spaces[0];
+      const folders = await listFolders(firstSpace.id);
+      const folderlessLists = await listFolderlessLists(firstSpace.id);
+
+      const allLists = [];
+
+      // Add folderless lists
+      allLists.push(
+        ...folderlessLists.map((list) => ({
+          id: list.id,
+          name: list.name,
+          taskCount: list.task_count,
+          dueDate: list.due_date ? new Date(parseInt(list.due_date)).toISOString() : null,
+          status: list.status?.status || "active",
+          priority: list.priority?.priority || "none",
+          assignee: list.assignee?.username || null,
+          folder: "No Folder",
+          space: list.space.name,
+          archived: list.archived,
+        })),
+      );
+
+      // Add lists from each folder
+      for (const folder of folders) {
+        const lists = await listLists(folder.id);
+        allLists.push(
+          ...lists.map((list) => ({
+            id: list.id,
+            name: list.name,
+            taskCount: list.task_count,
+            dueDate: list.due_date ? new Date(parseInt(list.due_date)).toISOString() : null,
+            status: list.status?.status || "active",
+            priority: list.priority?.priority || "none",
+            assignee: list.assignee?.username || null,
+            folder: folder.name,
+            space: list.space.name,
+            archived: list.archived,
+          })),
+        );
+      }
+
+      return allLists;
+    }
+
+    return {
+      lists: [],
+      message: "Please specify either a folderId, spaceId, or set includeAll to true",
+    };
+  },
+});

package/dist/integrations/clickup/files/ai/tools/list-tasks.ts

@@ -0,0 +1,95 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getAuthorizedUser, getTeams, listSpaces, listTasks } from "../../lib/clickup-client.ts";
+
+export default tool({
+  id: "list-tasks",
+  description:
+    "List tasks from ClickUp. Can filter by list, folder, space, or get tasks assigned to the current user.",
+  inputSchema: z.object({
+    listId: z.string().optional().describe("List ID to list tasks from"),
+    folderId: z.string().optional().describe("Folder ID to list tasks from"),
+    spaceId: z.string().optional().describe("Space ID to list tasks from"),
+    assignedToMe: z.boolean().default(false).describe("List tasks assigned to the current user"),
+    includeClosed: z.boolean().default(false).describe("Include completed/closed tasks"),
+    statuses: z.array(z.string()).optional().describe("Filter by specific status names"),
+    orderBy: z.string().optional().describe(
+      "Order results by field (e.g., 'due_date', 'created', 'updated')",
+    ),
+    limit: z.number().min(1).max(50).default(20).describe("Maximum number of tasks to return"),
+  }),
+  async execute({
+    listId,
+    folderId,
+    spaceId,
+    assignedToMe,
+    includeClosed,
+    statuses,
+    orderBy,
+    limit,
+  }) {
+    let tasks;
+
+    if (assignedToMe) {
+      const user = await getAuthorizedUser();
+      const teams = await getTeams();
+      if (teams.length === 0) {
+        return { tasks: [], message: "No teams found" };
+      }
+
+      // Get the first team's first space
+      const spaces = await listSpaces(teams[0].id);
+      if (spaces.length === 0) {
+        return { tasks: [], message: "No spaces found in team" };
+      }
+
+      tasks = await listTasks({
+        spaceId: spaces[0].id,
+        assignees: [user.user.id],
+        includeClosed,
+        statuses,
+        orderBy,
+      });
+    } else if (listId) {
+      tasks = await listTasks({
+        listId,
+        includeClosed,
+        statuses,
+        orderBy,
+      });
+    } else if (folderId) {
+      tasks = await listTasks({
+        folderId,
+        includeClosed,
+        statuses,
+        orderBy,
+      });
+    } else if (spaceId) {
+      tasks = await listTasks({
+        spaceId,
+        includeClosed,
+        statuses,
+        orderBy,
+      });
+    } else {
+      return {
+        tasks: [],
+        message:
+          "Please specify either a listId, folderId, spaceId, or set assignedToMe to true",
+      };
+    }
+
+    return tasks.slice(0, limit).map((task) => ({
+      id: task.id,
+      name: task.name,
+      status: task.status.status,
+      dueDate: task.due_date ? new Date(parseInt(task.due_date)).toISOString() : null,
+      priority: task.priority?.priority || "none",
+      assignees: task.assignees.map((a) => a.username),
+      tags: task.tags.map((t) => t.name),
+      list: task.list.name,
+      folder: task.folder.name,
+      space: task.space.name,
+    }));
+  },
+});

package/dist/integrations/clickup/files/ai/tools/update-task.ts

@@ -0,0 +1,85 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { updateTask } from "../../lib/clickup-client.ts";
+
+export default tool({
+  id: "update-task",
+  description: "Update an existing ClickUp task.",
+  inputSchema: z.object({
+    taskId: z.string().describe("The ID of the task to update"),
+    name: z.string().optional().describe("New name/title for the task"),
+    description: z.string().optional().describe("New description for the task"),
+    status: z.string().optional().describe("New status name for the task"),
+    priority: z.number().min(1).max(4).optional().describe(
+      "Priority level: 1 (urgent), 2 (high), 3 (normal), 4 (low). Use null to remove priority.",
+    ),
+    dueDate: z.number().optional().describe(
+      "Due date in Unix timestamp (milliseconds). Use null to remove due date.",
+    ),
+    startDate: z.number().optional().describe(
+      "Start date in Unix timestamp (milliseconds). Use null to remove start date.",
+    ),
+    timeEstimate: z.number().optional().describe(
+      "Time estimate in milliseconds. Use null to remove time estimate.",
+    ),
+    addAssignees: z.array(z.number()).optional().describe("Array of user IDs to add as assignees"),
+    removeAssignees: z.array(z.number()).optional().describe("Array of user IDs to remove from assignees"),
+    archived: z.boolean().optional().describe("Archive or unarchive the task"),
+    customTaskIds: z.boolean().default(false).describe(
+      "Use custom task IDs instead of internal IDs",
+    ),
+    teamId: z.string().optional().describe("Team ID (required when using custom task IDs)"),
+  }),
+  async execute({
+    taskId,
+    name,
+    description,
+    status,
+    priority,
+    dueDate,
+    startDate,
+    timeEstimate,
+    addAssignees,
+    removeAssignees,
+    archived,
+    customTaskIds,
+    teamId,
+  }) {
+    const updates: Record<string, unknown> = {};
+
+    if (name !== undefined) updates.name = name;
+    if (description !== undefined) updates.description = description;
+    if (status !== undefined) updates.status = status;
+    if (priority !== undefined) updates.priority = priority;
+    if (dueDate !== undefined) updates.dueDate = dueDate;
+    if (startDate !== undefined) updates.startDate = startDate;
+    if (timeEstimate !== undefined) updates.timeEstimate = timeEstimate;
+    if (archived !== undefined) updates.archived = archived;
+
+    if (addAssignees || removeAssignees) {
+      updates.assignees = {
+        ...(addAssignees && { add: addAssignees }),
+        ...(removeAssignees && { rem: removeAssignees }),
+      };
+    }
+
+    const task = await updateTask(
+      taskId,
+      updates,
+      customTaskIds ? { customTaskIds, teamId } : undefined,
+    );
+
+    return {
+      success: true,
+      task: {
+        id: task.id,
+        name: task.name,
+        status: task.status.status,
+        dueDate: task.due_date ? new Date(parseInt(task.due_date)).toISOString() : null,
+        priority: task.priority?.priority || "none",
+        assignees: task.assignees.map((a) => a.username),
+        url: `https://app.clickup.com/t/${task.id}`,
+      },
+    };
+  },
+});

package/dist/integrations/clickup/files/app/api/auth/clickup/callback/route.ts

@@ -0,0 +1,11 @@
+/**
+ * ClickUp OAuth Callback
+ */
+
+import { clickupConfig, createOAuthCallbackHandler, memoryTokenStore } from "veryfront/oauth";
+
+export const GET = createOAuthCallbackHandler(clickupConfig, {
+  tokenStore: memoryTokenStore,
+  onSuccess: () => "/",
+  onError: () => "/",
+});

package/dist/integrations/clickup/files/app/api/auth/clickup/route.ts

@@ -0,0 +1,7 @@
+/**
+ * ClickUp OAuth Init
+ */
+
+import { clickupConfig, createOAuthInitHandler } from "veryfront/oauth";
+
+export const GET = createOAuthInitHandler(clickupConfig);