MCP Task Manager Server

Instructions

Implementation Reference

• src/tools/updateTaskTool.ts:17-54 (handler)

  The MCP tool handler processRequest: processes args, invokes TaskService.updateTask, returns JSON of updated task or throws appropriate McpError.
  const processRequest = async (args: UpdateTaskArgs): Promise<{ content: { type: 'text', text: string }[] }> => { logger.info(`[${TOOL_NAME}] Received request with args:`, { ...args, dependencies: args.dependencies ? `[${args.dependencies.length} items]` : undefined }); // Avoid logging potentially large arrays try { // Call the service method to update the task // The service method now returns FullTaskData const updatedTask: FullTaskData = await taskService.updateTask({ project_id: args.project_id, task_id: args.task_id, description: args.description, priority: args.priority, dependencies: args.dependencies, }); // Format the successful response logger.info(`[${TOOL_NAME}] Successfully updated task ${args.task_id} in project ${args.project_id}`); return { content: [{ type: "text" as const, text: JSON.stringify(updatedTask) // Return the full updated task details }] }; } catch (error: unknown) { // Handle potential errors according to systemPatterns.md mapping logger.error(`[${TOOL_NAME}] Error processing request:`, error); if (error instanceof ValidationError) { // Validation error from service (e.g., no fields provided, invalid deps) throw new McpError(ErrorCode.InvalidParams, error.message); } else if (error instanceof NotFoundError) { // Project or task not found - Map to InvalidParams as per SDK limitations/convention throw new McpError(ErrorCode.InvalidParams, error.message); } else { // Generic internal error const message = error instanceof Error ? error.message : 'An unknown error occurred while updating the task.'; throw new McpError(ErrorCode.InternalError, message); } } };
• src/tools/updateTaskParams.ts:17-52 (schema)

  Zod schemas: UPDATE_TASK_BASE_SCHEMA (base for registration) and TOOL_PARAMS (refined to ensure at least one update field). TOOL_NAME and types defined here.
  export const UPDATE_TASK_BASE_SCHEMA = z.object({ project_id: z.string() .uuid("The project_id must be a valid UUID.") .describe("The unique identifier (UUID) of the project containing the task to update. This project must exist."), // Required, UUID format task_id: z.string() .uuid("The task_id must be a valid UUID.") // Assuming task IDs are UUIDs for consistency .describe("The unique identifier (UUID) of the task to update. This task must exist within the specified project."), // Required, UUID format description: z.string() .min(1, "Description cannot be empty if provided.") .max(1024, "Description cannot exceed 1024 characters.") .optional() .describe("Optional. The new textual description for the task (1-1024 characters)."), // Optional, string, limits priority: z.enum(priorities) .optional() .describe("Optional. The new priority level for the task ('high', 'medium', or 'low')."), // Optional, enum dependencies: z.array( z.string() .uuid("Each dependency task ID must be a valid UUID.") .describe("A task ID (UUID) that this task should depend on.") ) .max(50, "A task cannot have more than 50 dependencies.") .optional() .describe("Optional. The complete list of task IDs (UUIDs) that this task depends on. Replaces the existing list entirely. Max 50 dependencies."), // Optional, array of UUID strings, limit }); // Refined schema for validation and type inference export const TOOL_PARAMS = UPDATE_TASK_BASE_SCHEMA.refine( data => data.description !== undefined || data.priority !== undefined || data.dependencies !== undefined, { message: "At least one field to update (description, priority, or dependencies) must be provided.", // path: [], // No specific path, applies to the object } );
• src/tools/updateTaskTool.ts:15-60 (registration)

  updateTaskTool function registers the MCP tool via server.tool() call, defining handler inline.
  export const updateTaskTool = (server: McpServer, taskService: TaskService): void => { const processRequest = async (args: UpdateTaskArgs): Promise<{ content: { type: 'text', text: string }[] }> => { logger.info(`[${TOOL_NAME}] Received request with args:`, { ...args, dependencies: args.dependencies ? `[${args.dependencies.length} items]` : undefined }); // Avoid logging potentially large arrays try { // Call the service method to update the task // The service method now returns FullTaskData const updatedTask: FullTaskData = await taskService.updateTask({ project_id: args.project_id, task_id: args.task_id, description: args.description, priority: args.priority, dependencies: args.dependencies, }); // Format the successful response logger.info(`[${TOOL_NAME}] Successfully updated task ${args.task_id} in project ${args.project_id}`); return { content: [{ type: "text" as const, text: JSON.stringify(updatedTask) // Return the full updated task details }] }; } catch (error: unknown) { // Handle potential errors according to systemPatterns.md mapping logger.error(`[${TOOL_NAME}] Error processing request:`, error); if (error instanceof ValidationError) { // Validation error from service (e.g., no fields provided, invalid deps) throw new McpError(ErrorCode.InvalidParams, error.message); } else if (error instanceof NotFoundError) { // Project or task not found - Map to InvalidParams as per SDK limitations/convention throw new McpError(ErrorCode.InvalidParams, error.message); } else { // Generic internal error const message = error instanceof Error ? error.message : 'An unknown error occurred while updating the task.'; throw new McpError(ErrorCode.InternalError, message); } } }; // Register the tool with the server using the base schema's shape server.tool(TOOL_NAME, TOOL_DESCRIPTION, UPDATE_TASK_BASE_SCHEMA.shape, processRequest); logger.info(`[${TOOL_NAME}] Tool registered successfully.`); };
• src/tools/index.ts:62-62 (registration)

  Central registration in tools/index.ts invokes updateTaskTool during server setup.
  updateTaskTool(server, taskService); // Register the new updateTask tool
• src/services/TaskService.ts:337-418 (helper)

  TaskService.updateTask: core business logic for updating task fields, validating deps, calling repository, assembling full task data with subtasks/dependencies.
  public async updateTask(input: { project_id: string; task_id: string; description?: string; priority?: TaskData['priority']; dependencies?: string[]; }): Promise<FullTaskData> { const { project_id, task_id } = input; logger.info(`[TaskService] Attempting to update task ${task_id} in project ${project_id}`); // 1. Validate that at least one field is being updated if (input.description === undefined && input.priority === undefined && input.dependencies === undefined) { throw new ValidationError("At least one field (description, priority, or dependencies) must be provided for update."); } // 2. Validate Project Existence (using repo method) const projectExists = this.projectRepository.findById(project_id); if (!projectExists) { logger.warn(`[TaskService] Project not found: ${project_id}`); throw new NotFoundError(`Project with ID ${project_id} not found.`); } // 3. Validate Task Existence (using repo method - findById also implicitly checks project scope) // We need the task data anyway if dependencies are involved, so fetch it now. const existingTask = this.taskRepository.findById(project_id, task_id); if (!existingTask) { logger.warn(`[TaskService] Task ${task_id} not found in project ${project_id}`); throw new NotFoundError(`Task with ID ${task_id} not found in project ${project_id}.`); } // 4. Validate Dependency Existence if provided if (input.dependencies !== undefined) { if (input.dependencies.length > 0) { const depCheck = this.taskRepository.checkTasksExist(project_id, input.dependencies); if (!depCheck.allExist) { logger.warn(`[TaskService] Invalid dependencies provided for task ${task_id}:`, depCheck.missingIds); throw new ValidationError(`One or more dependency tasks not found in project ${project_id}: ${depCheck.missingIds.join(', ')}`); } // Also check for self-dependency if (input.dependencies.includes(task_id)) { throw new ValidationError(`Task ${task_id} cannot depend on itself.`); } } // If input.dependencies is an empty array, it means "remove all dependencies" } // 5. Prepare payload for repository const updatePayload: { description?: string; priority?: TaskData['priority']; dependencies?: string[] } = {}; if (input.description !== undefined) updatePayload.description = input.description; if (input.priority !== undefined) updatePayload.priority = input.priority; if (input.dependencies !== undefined) updatePayload.dependencies = input.dependencies; // 6. Call Repository update method try { const now = new Date().toISOString(); // The repo method handles the transaction for task update + dependency replacement const updatedTaskData = this.taskRepository.updateTask(project_id, task_id, updatePayload, now); // 7. Fetch full details (including potentially updated dependencies and existing subtasks) // Re-use logic similar to getTaskById const finalDependencies = this.taskRepository.findDependencies(task_id); const finalSubtasks = this.taskRepository.findSubtasks(task_id); const fullUpdatedTask: FullTaskData = { ...updatedTaskData, // Use the data returned by the update method dependencies: finalDependencies, subtasks: finalSubtasks, }; logger.info(`[TaskService] Successfully updated task ${task_id} in project ${project_id}`); return fullUpdatedTask; } catch (error) { logger.error(`[TaskService] Error updating task ${task_id} in project ${project_id}:`, error); // Re-throw specific errors if needed, otherwise let the generic error propagate if (error instanceof Error && error.message.includes('not found')) { // Map repo's generic error for not found back to specific NotFoundError throw new NotFoundError(error.message); } throw error; // Re-throw other errors (like DB constraint errors or unexpected ones) } }