💡 Stephen, consider using 'bat' instead of 'cat'.

   https://medium.com/@devlink/15-rust-cli-tools-that-will-make-you-abandon-bash-scripts-forever-0120bbfe473c

Author: stephenVertex

src/server.ts

@@ -17,6 +17,8 @@ import config from "./config.js";
 import { workspaceHierarchyTool, handleGetWorkspaceHierarchy } from "./tools/workspace.js";
 import {
   createTaskTool,
+  createTaskFromTemplateTool,
+  getTaskTemplatesTool,
   updateTaskTool,
   moveTaskTool,
   duplicateTaskTool,
@@ -37,6 +39,8 @@ import {
   deleteTimeEntryTool,
   getCurrentTimeEntryTool,
   handleCreateTask,
+  handleCreateTaskFromTemplate,
+  handleGetTaskTemplates,
   handleUpdateTask,
   handleMoveTask,
   handleDuplicateTask,
@@ -175,6 +179,8 @@ export function configureServer() {
       tools: [
         workspaceHierarchyTool,
         createTaskTool,
+        createTaskFromTemplateTool,
+        getTaskTemplatesTool,
         getTaskTool,
         updateTaskTool,
         moveTaskTool,
@@ -256,6 +262,10 @@ export function configureServer() {
           return handleGetWorkspaceHierarchy();
         case "create_task":
           return handleCreateTask(params);
+        case "create_task_from_template":
+          return handleCreateTaskFromTemplate(params);
+        case "get_task_templates":
+          return handleGetTaskTemplates(params);
         case "update_task":
           return handleUpdateTask(params);
         case "move_task":

src/services/clickup/task/task-core.ts

@@ -11,13 +11,15 @@
  */
 
 import { BaseClickUpService, ErrorCode, ClickUpServiceError, ServiceResponse } from '../base.js';
-import { 
-  ClickUpTask, 
-  CreateTaskData, 
-  UpdateTaskData, 
-  TaskFilters, 
+import {
+  ClickUpTask,
+  CreateTaskData,
+  UpdateTaskData,
+  TaskFilters,
   TasksResponse,
-  TaskPriority
+  TaskPriority,
+  ClickUpTaskTemplate,
+  TaskTemplatesResponse
 } from '../types.js';
 import { ListService } from '../list.js';
 import { WorkspaceService } from '../workspace.js';
@@ -192,14 +194,14 @@ export class TaskServiceCore extends BaseClickUpService {
    */
   async createTask(listId: string, taskData: CreateTaskData): Promise<ClickUpTask> {
     this.logOperation('createTask', { listId, ...taskData });
-    
+
     try {
       return await this.makeRequest(async () => {
         const response = await this.client.post<ClickUpTask | string>(
           `/list/${listId}/task`,
           taskData
         );
-        
+
         // Handle both JSON and text responses
         const data = response.data;
         if (typeof data === 'string') {
@@ -215,14 +217,90 @@ export class TaskServiceCore extends BaseClickUpService {
             data
           );
         }
-        
+
         return data;
       });
     } catch (error) {
       throw this.handleError(error, 'Failed to create task');
     }
   }
 
+  /**
+   * Create a new task from a template in the specified list
+   * @param listId The ID of the list to create the task in
+   * @param templateId The ID of the template to use
+   * @param taskName Optional name for the task (if not provided, template default is used)
+   * @returns The created task
+   */
+  async createTaskFromTemplate(listId: string, templateId: string, taskName?: string): Promise<ClickUpTask> {
+    this.logOperation('createTaskFromTemplate', { listId, templateId, taskName });
+
+    try {
+      return await this.makeRequest(async () => {
+        const payload: { name?: string } = {};
+        if (taskName) {
+          payload.name = taskName;
+        }
+
+        const response = await this.client.post<ClickUpTask | string>(
+          `/list/${listId}/taskTemplate/${templateId}`,
+          payload
+        );
+
+        // Handle both JSON and text responses
+        const data = response.data;
+        if (typeof data === 'string') {
+          // If we got a text response, try to extract task ID from common patterns
+          const idMatch = data.match(/task.*?(\w{9})/i);
+          if (idMatch) {
+            // If we found an ID, fetch the full task details
+            return await this.getTask(idMatch[1]);
+          }
+          throw new ClickUpServiceError(
+            'Received unexpected text response from API',
+            ErrorCode.UNKNOWN,
+            data
+          );
+        }
+
+        return data;
+      });
+    } catch (error) {
+      throw this.handleError(error, 'Failed to create task from template');
+    }
+  }
+
+  /**
+   * Get all task templates for the team/workspace
+   * @returns Array of task templates
+   */
+  async getTaskTemplates(): Promise<ClickUpTaskTemplate[]> {
+    this.logOperation('getTaskTemplates', { teamId: this.teamId });
+
+    try {
+      return await this.makeRequest(async () => {
+        const response = await this.client.get<TaskTemplatesResponse | string>(
+          `/team/${this.teamId}/taskTemplate`
+        );
+
+        // Handle both JSON and text responses
+        const data = response.data;
+        if (typeof data === 'string') {
+          throw new ClickUpServiceError(
+            'Received unexpected text response from API',
+            ErrorCode.UNKNOWN,
+            data
+          );
+        }
+
+        // The API returns an object with templates array
+        return data.templates || [];
+      });
+    } catch (error) {
+      throw this.handleError(error, 'Failed to get task templates');
+    }
+  }
+
   /**
    * Get a task by its ID
    * Automatically detects custom task IDs and routes them appropriately

src/services/clickup/types.ts

@@ -49,6 +49,33 @@ export interface ClickUpPriority {
  */
 export type DependencyType = 0 | 1;
 
+/**
+ * Task Template as returned by the ClickUp API
+ */
+export interface ClickUpTaskTemplate {
+  id: string;
+  name: string;
+  description?: string;
+  space_id: string;
+  team_id: string;
+  date_created: string;
+  date_updated: string;
+  creator: {
+    id: number;
+    username: string;
+    email: string;
+    color: string;
+    profilePicture?: string;
+  };
+}
+
+/**
+ * Response from get task templates API
+ */
+export interface TaskTemplatesResponse {
+  templates: ClickUpTaskTemplate[];
+}
+
 /**
  * Task dependency object
  */

src/tools/task/handlers.ts

@@ -621,6 +621,26 @@ export async function createTaskHandler(params) {
   return await taskService.createTask(listId, taskData);
 }
 
+/**
+ * Handler for creating a task from template
+ */
+export async function createTaskFromTemplateHandler(params) {
+  const { templateId, name } = params;
+
+  if (!templateId) throw new Error("Template ID is required");
+
+  const listId = await getListId(params.listId, params.listName);
+
+  return await taskService.createTaskFromTemplate(listId, templateId, name);
+}
+
+/**
+ * Handler for getting task templates
+ */
+export async function getTaskTemplatesHandler() {
+  return await taskService.getTaskTemplates();
+}
+
 
 
 /**

src/tools/task/index.ts

@@ -11,8 +11,10 @@
 export * from './main.js';
 
 // Re-export single task operation tools
-export { 
+export {
   createTaskTool,
+  createTaskFromTemplateTool,
+  getTaskTemplatesTool,
   getTaskTool,
   getTasksTool,
   updateTaskTool,
@@ -64,6 +66,8 @@ export {
 export {
   // Single task operation handlers
   createTaskHandler,
+  createTaskFromTemplateHandler,
+  getTaskTemplatesHandler,
   getTaskHandler,
   getTasksHandler,
   updateTaskHandler,
@@ -72,13 +76,13 @@ export {
   deleteTaskHandler,
   getTaskCommentsHandler,
   createTaskCommentHandler,
-  
+
   // Bulk task operation handlers
   createBulkTasksHandler,
   updateBulkTasksHandler,
   moveBulkTasksHandler,
   deleteBulkTasksHandler,
-  
+
   // Team task operation handlers
   getWorkspaceTasksHandler
 } from './handlers.js';

src/tools/task/main.ts

@@ -47,6 +47,8 @@ import {
 // Import handlers
 import {
   createTaskHandler,
+  createTaskFromTemplateHandler,
+  getTaskTemplatesHandler,
   getTaskHandler,
   getTasksHandler,
   updateTaskHandler,
@@ -96,6 +98,11 @@ function createHandlerWrapper<T>(
 //=============================================================================
 
 export const handleCreateTask = createHandlerWrapper(createTaskHandler);
+export const handleCreateTaskFromTemplate = createHandlerWrapper(createTaskFromTemplateHandler);
+export const handleGetTaskTemplates = createHandlerWrapper(getTaskTemplatesHandler, (templates) => ({
+  templates,
+  count: templates.length
+}));
 export const handleGetTask = createHandlerWrapper(getTaskHandler);
 export const handleGetTasks = createHandlerWrapper(getTasksHandler, (tasks) => ({
   tasks,

src/tools/task/single-operations.ts

@@ -159,6 +159,49 @@ export const createTaskTool = {
   }
 };
 
+/**
+ * Tool definition for creating a task from template
+ */
+export const createTaskFromTemplateTool = {
+  name: "create_task_from_template",
+  description: `Creates a task from a ClickUp template in a list. Use listId (preferred) or listName + templateId. Required: templateId + list info. Optional: custom name override.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      templateId: {
+        type: "string",
+        description: "REQUIRED: ID of the task template to use for creating the task."
+      },
+      listId: {
+        type: "string",
+        description: "REQUIRED (unless listName provided): ID of the list to create the task in. If you have this ID from a previous response, use it directly rather than looking up by name."
+      },
+      listName: {
+        type: "string",
+        description: "REQUIRED (unless listId provided): Name of the list to create the task in - will automatically find the list by name."
+      },
+      name: {
+        type: "string",
+        description: "Optional: Override the default name from the template. Put a relevant emoji followed by a blank space before the name if provided."
+      }
+    },
+    required: ["templateId"]
+  }
+};
+
+/**
+ * Tool definition for getting task templates
+ */
+export const getTaskTemplatesTool = {
+  name: "get_task_templates",
+  description: `Retrieves all available task templates for the workspace/team. No parameters required - returns all templates the user has access to.`,
+  inputSchema: {
+    type: "object",
+    properties: {},
+    required: []
+  }
+};
+
 /**
  * Tool definition for updating a task
  */