Implement add-subtask MCP command for adding subtasks to existing tasks

mcp-server/src/core/direct-functions/add-subtask.js

@@ -0,0 +1,113 @@
+/**
+ * Direct function wrapper for addSubtask
+ */
+
+import { addSubtask } from '../../../../scripts/modules/task-manager.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
+
+/**
+ * Add a subtask to an existing task
+ * @param {Object} args - Function arguments
+ * @param {string} args.id - Parent task ID
+ * @param {string} [args.taskId] - Existing task ID to convert to subtask (optional)
+ * @param {string} [args.title] - Title for new subtask (when creating a new subtask)
+ * @param {string} [args.description] - Description for new subtask
+ * @param {string} [args.details] - Implementation details for new subtask
+ * @param {string} [args.status] - Status for new subtask (default: 'pending')
+ * @param {string} [args.dependencies] - Comma-separated list of dependency IDs
+ * @param {string} [args.file] - Path to the tasks file
+ * @param {boolean} [args.skipGenerate] - Skip regenerating task files
+ * @param {string} [args.projectRoot] - Project root directory
+ * @param {Object} log - Logger object
+ * @returns {Promise<{success: boolean, data?: Object, error?: string}>}
+ */
+export async function addSubtaskDirect(args, log) {
+  try {
+    log.info(`Adding subtask with args: ${JSON.stringify(args)}`);
+    
+    if (!args.id) {
+      return {
+        success: false,
+        error: {
+          code: 'INPUT_VALIDATION_ERROR',
+          message: 'Parent task ID is required'
+        }
+      };
+    }
+    
+    // Either taskId or title must be provided
+    if (!args.taskId && !args.title) {
+      return {
+        success: false,
+        error: {
+          code: 'INPUT_VALIDATION_ERROR',
+          message: 'Either taskId or title must be provided'
+        }
+      };
+    }
+
+    // Find the tasks.json path
+    const tasksPath = findTasksJsonPath(args.file, args.projectRoot);
+    
+    // Parse dependencies if provided
+    let dependencies = [];
+    if (args.dependencies) {
+      dependencies = args.dependencies.split(',').map(id => {
+        // Handle both regular IDs and dot notation
+        return id.includes('.') ? id.trim() : parseInt(id.trim(), 10);
+      });
+    }
+    
+    // Convert existingTaskId to a number if provided
+    const existingTaskId = args.taskId ? parseInt(args.taskId, 10) : null;
+    
+    // Convert parent ID to a number
+    const parentId = parseInt(args.id, 10);
+    
+    // Determine if we should generate files
+    const generateFiles = !args.skipGenerate;
+    
+    // Case 1: Convert existing task to subtask
+    if (existingTaskId) {
+      log.info(`Converting task ${existingTaskId} to a subtask of ${parentId}`);
+      const result = await addSubtask(tasksPath, parentId, existingTaskId, null, generateFiles);
+      return {
+        success: true,
+        data: {
+          message: `Task ${existingTaskId} successfully converted to a subtask of task ${parentId}`,
+          subtask: result
+        }
+      };
+    } 
+    // Case 2: Create new subtask
+    else {
+      log.info(`Creating new subtask for parent task ${parentId}`);
+      
+      const newSubtaskData = {
+        title: args.title,
+        description: args.description || '',
+        details: args.details || '',
+        status: args.status || 'pending',
+        dependencies: dependencies
+      };
+      
+      const result = await addSubtask(tasksPath, parentId, null, newSubtaskData, generateFiles);
+      return {
+        success: true,
+        data: {
+          message: `New subtask ${parentId}.${result.id} successfully created`,
+          subtask: result
+        }
+      };
+    }
+  } catch (error) {
+    log.error(`Error in addSubtaskDirect: ${error.message}`);
+    return {
+      success: false,
+      error: {
+        code: 'CORE_FUNCTION_ERROR',
+        message: error.message
+      }
+    };
+  }
+} 

mcp-server/src/core/task-master-core.js

@@ -17,6 +17,7 @@ import { showTaskDirect } from './direct-functions/show-task.js';
 import { nextTaskDirect } from './direct-functions/next-task.js';
 import { expandTaskDirect } from './direct-functions/expand-task.js';
 import { addTaskDirect } from './direct-functions/add-task.js';
+import { addSubtaskDirect } from './direct-functions/add-subtask.js';
 
 // Re-export utility functions
 export { findTasksJsonPath } from './utils/path-utils.js';
@@ -34,7 +35,8 @@ export const directFunctions = new Map([
   ['showTaskDirect', showTaskDirect],
   ['nextTaskDirect', nextTaskDirect],
   ['expandTaskDirect', expandTaskDirect],
-  ['addTaskDirect', addTaskDirect]
+  ['addTaskDirect', addTaskDirect],
+  ['addSubtaskDirect', addSubtaskDirect]
 ]);
 
 // Re-export all direct function implementations
@@ -50,5 +52,6 @@ export {
   showTaskDirect,
   nextTaskDirect,
   expandTaskDirect,
-  addTaskDirect
+  addTaskDirect,
+  addSubtaskDirect
 }; 

mcp-server/src/tools/add-subtask.js

@@ -0,0 +1,55 @@
+/**
+ * tools/add-subtask.js
+ * Tool for adding subtasks to existing tasks
+ */
+
+import { z } from "zod";
+import {
+  handleApiResult,
+  createErrorResponse
+} from "./utils.js";
+import { addSubtaskDirect } from "../core/task-master-core.js";
+
+/**
+ * Register the addSubtask tool with the MCP server
+ * @param {Object} server - FastMCP server instance
+ */
+export function registerAddSubtaskTool(server) {
+  server.addTool({
+    name: "add_subtask",
+    description: "Add a subtask to an existing task",
+    parameters: z.object({
+      id: z.string().describe("Parent task ID (required)"),
+      taskId: z.string().optional().describe("Existing task ID to convert to subtask"),
+      title: z.string().optional().describe("Title for the new subtask (when creating a new subtask)"),
+      description: z.string().optional().describe("Description for the new subtask"),
+      details: z.string().optional().describe("Implementation details for the new subtask"),
+      status: z.string().optional().describe("Status for the new subtask (default: 'pending')"),
+      dependencies: z.string().optional().describe("Comma-separated list of dependency IDs for the new subtask"),
+      file: z.string().optional().describe("Path to the tasks file (default: tasks/tasks.json)"),
+      skipGenerate: z.boolean().optional().describe("Skip regenerating task files"),
+      projectRoot: z.string().optional().describe("Root directory of the project (default: current working directory)")
+    }),
+    execute: async (args, { log }) => {
+      try {
+        log.info(`Adding subtask with args: ${JSON.stringify(args)}`);
+        
+        // Call the direct function wrapper
+        const result = await addSubtaskDirect(args, log);
+        
+        // Log result
+        if (result.success) {
+          log.info(`Subtask added successfully: ${result.data.message}`);
+        } else {
+          log.error(`Failed to add subtask: ${result.error.message}`);
+        }
+        
+        // Use handleApiResult to format the response
+        return handleApiResult(result, log, 'Error adding subtask');
+      } catch (error) {
+        log.error(`Error in addSubtask tool: ${error.message}`);
+        return createErrorResponse(error.message);
+      }
+    },
+  });
+} 

mcp-server/src/tools/index.js

@@ -15,6 +15,7 @@ import { registerShowTaskTool } from "./show-task.js";
 import { registerNextTaskTool } from "./next-task.js";
 import { registerExpandTaskTool } from "./expand-task.js";
 import { registerAddTaskTool } from "./add-task.js";
+import { registerAddSubtaskTool } from "./add-subtask.js";
 
 /**
  * Register all Task Master tools with the MCP server
@@ -32,6 +33,7 @@ export function registerTaskMasterTools(server) {
   registerNextTaskTool(server);
   registerExpandTaskTool(server);
   registerAddTaskTool(server);
+  registerAddSubtaskTool(server);
   
   logger.info("Registered all Task Master tools with MCP server");
 }