ros/claude-task-master
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Ensures that the updateTask (single task) doesn't change the title of the task.

Browse Source
This commit is contained in:
Eyal Toledano
2025-03-27 01:46:13 -04:00
parent 707618ca5d
commit cea14b55b3
5 changed files with 144 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
.cursor/mcp.json
View File

@@ -0,0 +1,11 @@
{
"mcpServers": {
"taskmaster-ai": {
"command": "npx",
"args": [
"-y",
"bin/task-master-mcp-server.js"
]
}
}
}

21
scripts/modules/task-manager.js
View File

@@ -456,16 +456,17 @@ You will be given a task and a prompt describing changes or new implementation d
Your job is to update the task to reflect these changes, while preserving its basic structure.
Guidelines:
1. Maintain the same ID, status, and dependencies unless specifically mentioned in the prompt
2. Update the title, description, details, and test strategy to reflect the new information
3. Do not change anything unnecessarily - just adapt what needs to change based on the prompt
4. Return a complete valid JSON object representing the updated task
5. VERY IMPORTANT: Preserve all subtasks marked as "done" or "completed" - do not modify their content
6. For tasks with completed subtasks, build upon what has already been done rather than rewriting everything
7. If an existing completed subtask needs to be changed/undone based on the new context, DO NOT modify it directly
8. Instead, add a new subtask that clearly indicates what needs to be changed or replaced
9. Use the existence of completed subtasks as an opportunity to make new subtasks more specific and targeted
10. Ensure any new subtasks have unique IDs that don't conflict with existing ones
1. VERY IMPORTANT: NEVER change the title of the task - keep it exactly as is
2. Maintain the same ID, status, and dependencies unless specifically mentioned in the prompt
3. Update the description, details, and test strategy to reflect the new information
4. Do not change anything unnecessarily - just adapt what needs to change based on the prompt
5. Return a complete valid JSON object representing the updated task
6. VERY IMPORTANT: Preserve all subtasks marked as "done" or "completed" - do not modify their content
7. For tasks with completed subtasks, build upon what has already been done rather than rewriting everything
8. If an existing completed subtask needs to be changed/undone based on the new context, DO NOT modify it directly
9. Instead, add a new subtask that clearly indicates what needs to be changed or replaced
10. Use the existence of completed subtasks as an opportunity to make new subtasks more specific and targeted
11. Ensure any new subtasks have unique IDs that don't conflict with existing ones
The changes described in the prompt should be thoughtfully applied to make the task more accurate and actionable.`;

105
tasks/task_023.txt
View File

@@ -1,61 +1,48 @@
# Task ID: 23
# Title: Implement MCP Server Functionality for Task Master using FastMCP
# Title: Complete MCP Server Implementation for Task Master using FastMCP
# Status: pending
# Dependencies: 22
# Priority: medium
# Description: Extend Task Master to function as an MCP server by leveraging FastMCP's JavaScript/TypeScript implementation for efficient context management services.
# Description: Finalize the MCP server functionality for Task Master by leveraging FastMCP's capabilities, transitioning from CLI-based execution to direct function imports, and optimizing performance, authentication, and context management.
# Details:
This task involves implementing the Model Context Protocol server capabilities within Task Master. The implementation should:
This task involves completing the Model Context Protocol (MCP) server implementation for Task Master using FastMCP. Key updates include:
1. Create a new module `mcp-server.js` that implements the core MCP server functionality
2. Implement the required MCP endpoints:
- `/context` - For retrieving and updating context
- `/models` - For listing available models
- `/execute` - For executing operations with context
3. Develop a context management system that can:
- Store and retrieve context data efficiently
- Handle context windowing and truncation when limits are reached
- Support context metadata and tagging
4. Add authentication and authorization mechanisms for MCP clients
5. Implement proper error handling and response formatting according to MCP specifications
6. Create configuration options in Task Master to enable/disable the MCP server functionality
7. Add documentation for how to use Task Master as an MCP server
8. Ensure the implementation is compatible with existing MCP clients
9. Optimize for performance, especially for context retrieval operations
10. Add logging for MCP server operations
1. Transition from CLI-based execution to direct Task Master function imports for improved performance and reliability.
2. Enhance authentication and authorization mechanisms using FastMCP's built-in capabilities (e.g., API keys, OAuth, or JWT).
3. Refactor context management to align with best practices for handling large context windows, metadata, and tagging.
4. Optimize server performance by leveraging FastMCP's efficient transport mechanisms (e.g., stdio or SSE) and implementing caching for frequently accessed contexts.
5. Integrate the ModelContextProtocol SDK directly to streamline resource and tool registration.
6. Update documentation to include examples of using the MCP server with FastMCP, detailed setup instructions, and client integration guides.
The implementation should follow RESTful API design principles and should be able to handle concurrent requests from multiple clients.
The implementation must ensure compatibility with existing MCP clients and follow RESTful API design principles, while supporting concurrent requests and maintaining robust error handling.
# Test Strategy:
Testing for the MCP server functionality should include:
Testing for the updated MCP server functionality should include:
1. Unit tests:
- Test each MCP endpoint handler function independently
- Verify context storage and retrieval mechanisms
- Test authentication and authorization logic
- Validate error handling for various failure scenarios
- Validate direct function imports for Task Master tools.
- Test updated authentication and authorization mechanisms.
- Verify context management operations (CRUD, metadata, windowing).
2. Integration tests:
- Set up a test MCP server instance
- Test complete request/response cycles for each endpoint
- Verify context persistence across multiple requests
- Test with various payload sizes and content types
- Test the MCP server with FastMCP's stdio and SSE transport modes.
- Verify end-to-end request/response cycles for each endpoint.
- Ensure compatibility with the ModelContextProtocol SDK.
3. Compatibility tests:
- Test with existing MCP client libraries
- Verify compliance with the MCP specification
- Ensure backward compatibility with any MCP versions supported
3. Performance tests:
- Benchmark response times for context operations with large datasets.
- Test caching mechanisms and concurrent request handling.
- Measure memory usage and server stability under load.
4. Performance tests:
- Measure response times for context operations with various context sizes
- Test concurrent request handling
- Verify memory usage remains within acceptable limits during extended operation
4. Security tests:
- Validate the robustness of authentication/authorization mechanisms.
- Test for vulnerabilities such as injection attacks, CSRF, and unauthorized access.
5. Security tests:
- Verify authentication mechanisms cannot be bypassed
- Test for common API vulnerabilities (injection, CSRF, etc.)
5. Documentation validation:
- Ensure all examples in the documentation are accurate and functional.
- Verify manual testing workflows using tools like curl or Postman.
All tests should be automated and included in the CI/CD pipeline. Documentation should include examples of how to test the MCP server functionality manually using tools like curl or Postman.
All tests should be automated and integrated into the CI/CD pipeline to ensure consistent quality.
# Subtasks:
## 1. Create Core MCP Server Module and Basic Structure [done]
@@ -153,15 +140,17 @@ Testing approach:
### Details:
Implementation steps:
1. Profile the MCP server to identify performance bottlenecks
2. Implement caching mechanisms for frequently accessed contexts
3. Optimize context serialization and deserialization
4. Add connection pooling for database operations (if applicable)
5. Implement request batching for bulk operations
6. Create comprehensive API documentation with examples
7. Add setup and configuration guides to the Task Master documentation
8. Create example client implementations
9. Add monitoring endpoints for server health and metrics
10. Implement graceful degradation under high load
2. Replace CLI-based execution with direct Task Master function imports
3. Implement caching mechanisms for frequently accessed contexts
4. Optimize context serialization and deserialization
5. Leverage FastMCP's efficient transport mechanisms (stdio or SSE)
6. Add connection pooling for database operations (if applicable)
7. Implement request batching for bulk operations
8. Create comprehensive API documentation with examples
9. Add setup and configuration guides to the Task Master documentation
10. Create example client implementations
11. Add monitoring endpoints for server health and metrics
12. Implement graceful degradation under high load
Testing approach:
- Load testing with simulated concurrent clients
@@ -171,3 +160,19 @@ Testing approach:
- Test monitoring endpoints
- Perform stress testing to identify failure points
## 6. Refactor MCP Server to Leverage ModelContextProtocol SDK [pending]
### Dependencies: 23.1, 23.2, 23.3
### Description: Integrate the ModelContextProtocol SDK directly into the MCP server implementation to streamline tool registration and resource handling.
### Details:
Implementation steps:
1. Replace manual tool registration with ModelContextProtocol SDK methods.
2. Use SDK utilities to simplify resource and template management.
3. Ensure compatibility with FastMCP's transport mechanisms.
4. Update server initialization to include SDK-based configurations.
Testing approach:
- Verify SDK integration with all MCP endpoints.
- Test resource and template registration using SDK methods.
- Validate compatibility with existing MCP clients.
- Benchmark performance improvements from SDK integration.

49
tasks/task_037.txt Normal file
View File

@@ -0,0 +1,49 @@
# Task ID: 37
# Title: Add Gemini Support for Main AI Services as Claude Alternative
# Status: pending
# Dependencies: None
# Priority: medium
# Description: Implement Google's Gemini API integration as an alternative to Claude for all main AI services, allowing users to switch between different LLM providers.
# Details:
This task involves integrating Google's Gemini API across all main AI services that currently use Claude:
1. Create a new GeminiService class that implements the same interface as the existing ClaudeService
2. Implement authentication and API key management for Gemini API
3. Map our internal prompt formats to Gemini's expected input format
4. Handle Gemini-specific parameters (temperature, top_p, etc.) and response parsing
5. Update the AI service factory/provider to support selecting Gemini as an alternative
6. Add configuration options in settings to allow users to select Gemini as their preferred provider
7. Implement proper error handling for Gemini-specific API errors
8. Ensure streaming responses are properly supported if Gemini offers this capability
9. Update documentation to reflect the new Gemini option
10. Consider implementing model selection if Gemini offers multiple models (e.g., Gemini Pro, Gemini Ultra)
11. Ensure all existing AI capabilities (summarization, code generation, etc.) maintain feature parity when using Gemini
The implementation should follow the same pattern as the recent Ollama integration (Task #36) to maintain consistency in how alternative AI providers are supported.
# Test Strategy:
Testing should verify Gemini integration works correctly across all AI services:
1. Unit tests:
- Test GeminiService class methods with mocked API responses
- Verify proper error handling for common API errors
- Test configuration and model selection functionality
2. Integration tests:
- Verify authentication and API connection with valid credentials
- Test each AI service with Gemini to ensure proper functionality
- Compare outputs between Claude and Gemini for the same inputs to verify quality
3. End-to-end tests:
- Test the complete user flow of switching to Gemini and using various AI features
- Verify streaming responses work correctly if supported
4. Performance tests:
- Measure and compare response times between Claude and Gemini
- Test with various input lengths to verify handling of context limits
5. Manual testing:
- Verify the quality of Gemini responses across different use cases
- Test edge cases like very long inputs or specialized domain knowledge
All tests should pass with Gemini selected as the provider, and the user experience should be consistent regardless of which provider is selected.

23
tasks/tasks.json
View File

@@ -1336,15 +1336,15 @@
},
{
"id": 23,
"title": "Implement MCP Server Functionality for Task Master using FastMCP",
"description": "Extend Task Master to function as an MCP server by leveraging FastMCP's JavaScript/TypeScript implementation for efficient context management services.",
"title": "Complete MCP Server Implementation for Task Master using FastMCP",
"description": "Finalize the MCP server functionality for Task Master by leveraging FastMCP's capabilities, transitioning from CLI-based execution to direct function imports, and optimizing performance, authentication, and context management.",
"status": "pending",
"dependencies": [
22
],
"priority": "medium",
"details": "This task involves implementing the Model Context Protocol server capabilities within Task Master. The implementation should:\n\n1. Create a new module `mcp-server.js` that implements the core MCP server functionality\n2. Implement the required MCP endpoints:\n - `/context` - For retrieving and updating context\n - `/models` - For listing available models\n - `/execute` - For executing operations with context\n3. Develop a context management system that can:\n - Store and retrieve context data efficiently\n - Handle context windowing and truncation when limits are reached\n - Support context metadata and tagging\n4. Add authentication and authorization mechanisms for MCP clients\n5. Implement proper error handling and response formatting according to MCP specifications\n6. Create configuration options in Task Master to enable/disable the MCP server functionality\n7. Add documentation for how to use Task Master as an MCP server\n8. Ensure the implementation is compatible with existing MCP clients\n9. Optimize for performance, especially for context retrieval operations\n10. Add logging for MCP server operations\n\nThe implementation should follow RESTful API design principles and should be able to handle concurrent requests from multiple clients.",
"testStrategy": "Testing for the MCP server functionality should include:\n\n1. Unit tests:\n - Test each MCP endpoint handler function independently\n - Verify context storage and retrieval mechanisms\n - Test authentication and authorization logic\n - Validate error handling for various failure scenarios\n\n2. Integration tests:\n - Set up a test MCP server instance\n - Test complete request/response cycles for each endpoint\n - Verify context persistence across multiple requests\n - Test with various payload sizes and content types\n\n3. Compatibility tests:\n - Test with existing MCP client libraries\n - Verify compliance with the MCP specification\n - Ensure backward compatibility with any MCP versions supported\n\n4. Performance tests:\n - Measure response times for context operations with various context sizes\n - Test concurrent request handling\n - Verify memory usage remains within acceptable limits during extended operation\n\n5. Security tests:\n - Verify authentication mechanisms cannot be bypassed\n - Test for common API vulnerabilities (injection, CSRF, etc.)\n\nAll tests should be automated and included in the CI/CD pipeline. Documentation should include examples of how to test the MCP server functionality manually using tools like curl or Postman.",
"details": "This task involves completing the Model Context Protocol (MCP) server implementation for Task Master using FastMCP. Key updates include:\n\n1. Transition from CLI-based execution to direct Task Master function imports for improved performance and reliability.\n2. Enhance authentication and authorization mechanisms using FastMCP's built-in capabilities (e.g., API keys, OAuth, or JWT).\n3. Refactor context management to align with best practices for handling large context windows, metadata, and tagging.\n4. Optimize server performance by leveraging FastMCP's efficient transport mechanisms (e.g., stdio or SSE) and implementing caching for frequently accessed contexts.\n5. Integrate the ModelContextProtocol SDK directly to streamline resource and tool registration.\n6. Update documentation to include examples of using the MCP server with FastMCP, detailed setup instructions, and client integration guides.\n\nThe implementation must ensure compatibility with existing MCP clients and follow RESTful API design principles, while supporting concurrent requests and maintaining robust error handling.",
"testStrategy": "Testing for the updated MCP server functionality should include:\n\n1. Unit tests:\n - Validate direct function imports for Task Master tools.\n - Test updated authentication and authorization mechanisms.\n - Verify context management operations (CRUD, metadata, windowing).\n\n2. Integration tests:\n - Test the MCP server with FastMCP's stdio and SSE transport modes.\n - Verify end-to-end request/response cycles for each endpoint.\n - Ensure compatibility with the ModelContextProtocol SDK.\n\n3. Performance tests:\n - Benchmark response times for context operations with large datasets.\n - Test caching mechanisms and concurrent request handling.\n - Measure memory usage and server stability under load.\n\n4. Security tests:\n - Validate the robustness of authentication/authorization mechanisms.\n - Test for vulnerabilities such as injection attacks, CSRF, and unauthorized access.\n\n5. Documentation validation:\n - Ensure all examples in the documentation are accurate and functional.\n - Verify manual testing workflows using tools like curl or Postman.\n\nAll tests should be automated and integrated into the CI/CD pipeline to ensure consistent quality.",
"subtasks": [
{
"id": 1,
@@ -1400,7 +1400,20 @@
3,
4
],
"details": "Implementation steps:\n1. Profile the MCP server to identify performance bottlenecks\n2. Implement caching mechanisms for frequently accessed contexts\n3. Optimize context serialization and deserialization\n4. Add connection pooling for database operations (if applicable)\n5. Implement request batching for bulk operations\n6. Create comprehensive API documentation with examples\n7. Add setup and configuration guides to the Task Master documentation\n8. Create example client implementations\n9. Add monitoring endpoints for server health and metrics\n10. Implement graceful degradation under high load\n\nTesting approach:\n- Load testing with simulated concurrent clients\n- Measure response times for various operations\n- Test with large context sizes to verify performance\n- Verify documentation accuracy with sample requests\n- Test monitoring endpoints\n- Perform stress testing to identify failure points",
"details": "Implementation steps:\n1. Profile the MCP server to identify performance bottlenecks\n2. Replace CLI-based execution with direct Task Master function imports\n3. Implement caching mechanisms for frequently accessed contexts\n4. Optimize context serialization and deserialization\n5. Leverage FastMCP's efficient transport mechanisms (stdio or SSE)\n6. Add connection pooling for database operations (if applicable)\n7. Implement request batching for bulk operations\n8. Create comprehensive API documentation with examples\n9. Add setup and configuration guides to the Task Master documentation\n10. Create example client implementations\n11. Add monitoring endpoints for server health and metrics\n12. Implement graceful degradation under high load\n\nTesting approach:\n- Load testing with simulated concurrent clients\n- Measure response times for various operations\n- Test with large context sizes to verify performance\n- Verify documentation accuracy with sample requests\n- Test monitoring endpoints\n- Perform stress testing to identify failure points",
"status": "pending",
"parentTaskId": 23
},
{
"id": 6,
"title": "Refactor MCP Server to Leverage ModelContextProtocol SDK",
"description": "Integrate the ModelContextProtocol SDK directly into the MCP server implementation to streamline tool registration and resource handling.",
"dependencies": [
1,
2,
3
],
"details": "Implementation steps:\n1. Replace manual tool registration with ModelContextProtocol SDK methods.\n2. Use SDK utilities to simplify resource and template management.\n3. Ensure compatibility with FastMCP's transport mechanisms.\n4. Update server initialization to include SDK-based configurations.\n\nTesting approach:\n- Verify SDK integration with all MCP endpoints.\n- Test resource and template registration using SDK methods.\n- Validate compatibility with existing MCP clients.\n- Benchmark performance improvements from SDK integration.",
"status": "pending",
"parentTaskId": 23
}