claude-task-master/mcp-server/src/core/direct-functions/add-task.js

/**
 * add-task.js
 * Direct function implementation for adding a new task
 */

import { addTask } from '../../../../scripts/modules/task-manager.js';
import { findTasksJsonPath } from '../utils/path-utils.js';
import {
	enableSilentMode,
	disableSilentMode
} from '../../../../scripts/modules/utils.js';
import {
	getAnthropicClientForMCP,
	getModelConfig
} from '../utils/ai-client-utils.js';
import {
	_buildAddTaskPrompt,
	parseTaskJsonResponse,
	_handleAnthropicStream
} from '../../../../scripts/modules/ai-services.js';

/**
 * Direct function wrapper for adding a new task with error handling.
 *
 * @param {Object} args - Command arguments
 * @param {string} args.prompt - Description of the task to add
 * @param {Array<number>} [args.dependencies=[]] - Task dependencies as array of IDs
 * @param {string} [args.priority='medium'] - Task priority (high, medium, low)
 * @param {string} [args.file] - Path to the tasks file
 * @param {string} [args.projectRoot] - Project root directory
 * @param {boolean} [args.research] - Whether to use research capabilities for task creation
 * @param {Object} log - Logger object
 * @param {Object} context - Additional context (reportProgress, session)
 * @returns {Promise<Object>} - Result object { success: boolean, data?: any, error?: { code: string, message: string } }
 */
export async function addTaskDirect(args, log, context = {}) {
	try {
		// Enable silent mode to prevent console logs from interfering with JSON response
		enableSilentMode();

		// Find the tasks.json path
		const tasksPath = findTasksJsonPath(args, log);

		// Check required parameters
		if (!args.prompt) {
			log.error('Missing required parameter: prompt');
			disableSilentMode();
			return {
				success: false,
				error: {
					code: 'MISSING_PARAMETER',
					message: 'The prompt parameter is required for adding a task'
				}
			};
		}

		// Extract and prepare parameters
		const prompt = args.prompt;
		const dependencies = Array.isArray(args.dependencies)
			? args.dependencies
			: args.dependencies
				? String(args.dependencies)
						.split(',')
						.map((id) => parseInt(id.trim(), 10))
				: [];
		const priority = args.priority || 'medium';

		log.info(
			`Adding new task with prompt: "${prompt}", dependencies: [${dependencies.join(', ')}], priority: ${priority}`
		);

		// Extract context parameters for advanced functionality
		// Commenting out reportProgress extraction
		// const { reportProgress, session } = context;
		const { session } = context; // Keep session

		// Initialize AI client with session environment
		let localAnthropic;
		try {
			localAnthropic = getAnthropicClientForMCP(session, log);
		} catch (error) {
			log.error(`Failed to initialize Anthropic client: ${error.message}`);
			disableSilentMode();
			return {
				success: false,
				error: {
					code: 'AI_CLIENT_ERROR',
					message: `Cannot initialize AI client: ${error.message}`
				}
			};
		}

		// Get model configuration from session
		const modelConfig = getModelConfig(session);

		// Read existing tasks to provide context
		let tasksData;
		try {
			const fs = await import('fs');
			tasksData = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
		} catch (error) {
			log.warn(`Could not read existing tasks for context: ${error.message}`);
			tasksData = { tasks: [] };
		}

		// Build prompts for AI
		const { systemPrompt, userPrompt } = _buildAddTaskPrompt(
			prompt,
			tasksData.tasks
		);

		// Make the AI call using the streaming helper
		let responseText;
		try {
			responseText = await _handleAnthropicStream(
				localAnthropic,
				{
					model: modelConfig.model,
					max_tokens: modelConfig.maxTokens,
					temperature: modelConfig.temperature,
					messages: [{ role: 'user', content: userPrompt }],
					system: systemPrompt
				},
				{
					// reportProgress: context.reportProgress, // Commented out to prevent Cursor stroking out
					mcpLog: log
				}
			);
		} catch (error) {
			log.error(`AI processing failed: ${error.message}`);
			disableSilentMode();
			return {
				success: false,
				error: {
					code: 'AI_PROCESSING_ERROR',
					message: `Failed to generate task with AI: ${error.message}`
				}
			};
		}

		// Parse the AI response
		let taskDataFromAI;
		try {
			taskDataFromAI = parseTaskJsonResponse(responseText);
		} catch (error) {
			log.error(`Failed to parse AI response: ${error.message}`);
			disableSilentMode();
			return {
				success: false,
				error: {
					code: 'RESPONSE_PARSING_ERROR',
					message: `Failed to parse AI response: ${error.message}`
				}
			};
		}

		// Call the addTask function with 'json' outputFormat to prevent console output when called via MCP
		const newTaskId = await addTask(
			tasksPath,
			prompt,
			dependencies,
			priority,
			{
				// reportProgress, // Commented out
				mcpLog: log,
				session,
				taskDataFromAI // Pass the parsed AI result
			},
			'json'
		);

		// Restore normal logging
		disableSilentMode();

		return {
			success: true,
			data: {
				taskId: newTaskId,
				message: `Successfully added new task #${newTaskId}`
			}
		};
	} catch (error) {
		// Make sure to restore normal logging even if there's an error
		disableSilentMode();

		log.error(`Error in addTaskDirect: ${error.message}`);
		return {
			success: false,
			error: {
				code: 'ADD_TASK_ERROR',
				message: error.message
			}
		};
	}
}