Recovers lost files and commits work from the past 5-6 days. Holy shit that was a close call.
This commit is contained in:
Eyal Toledano
100
tasks/tasks.json
100
tasks/tasks.json
@@ -2469,6 +2469,106 @@
|
||||
"priority": "medium",
|
||||
"details": "Implement a new flag '--from-github' for the add-task command that allows users to create tasks directly from GitHub issues. The implementation should:\n\n1. Accept a GitHub issue URL as an argument (e.g., 'taskmaster add-task --from-github https://github.com/owner/repo/issues/123')\n2. Parse the URL to extract the repository owner, name, and issue number\n3. Use the GitHub API to fetch the issue details including:\n - Issue title (to be used as task title)\n - Issue description (to be used as task description)\n - Issue labels (to be potentially used as tags)\n - Issue assignees (for reference)\n - Issue status (open/closed)\n4. Generate a well-formatted task with this information\n5. Include a reference link back to the original GitHub issue\n6. Handle authentication for private repositories using GitHub tokens from environment variables or config file\n7. Implement proper error handling for:\n - Invalid URLs\n - Non-existent issues\n - API rate limiting\n - Authentication failures\n - Network issues\n8. Allow users to override or supplement the imported details with additional command-line arguments\n9. Add appropriate documentation in help text and user guide",
|
||||
"testStrategy": "Testing should cover the following scenarios:\n\n1. Unit tests:\n - Test URL parsing functionality with valid and invalid GitHub issue URLs\n - Test GitHub API response parsing with mocked API responses\n - Test error handling for various failure cases\n\n2. Integration tests:\n - Test with real GitHub public issues (use well-known repositories)\n - Test with both open and closed issues\n - Test with issues containing various elements (labels, assignees, comments)\n\n3. Error case tests:\n - Invalid URL format\n - Non-existent repository\n - Non-existent issue number\n - API rate limit exceeded\n - Authentication failures for private repos\n\n4. End-to-end tests:\n - Verify that a task created from a GitHub issue contains all expected information\n - Verify that the task can be properly managed after creation\n - Test the interaction with other flags and commands\n\nCreate mock GitHub API responses for testing to avoid hitting rate limits during development and testing. Use environment variables to configure test credentials if needed."
|
||||
},
|
||||
{
|
||||
"id": 46,
|
||||
"title": "Implement ICE Analysis Command for Task Prioritization",
|
||||
"description": "Create a new command that analyzes and ranks tasks based on Impact, Confidence, and Ease (ICE) scoring methodology, generating a comprehensive prioritization report.",
|
||||
"status": "pending",
|
||||
"dependencies": [],
|
||||
"priority": "medium",
|
||||
"details": "Develop a new command called `analyze-ice` that evaluates non-completed tasks (excluding those marked as done, cancelled, or deferred) and ranks them according to the ICE methodology:\n\n1. Core functionality:\n - Calculate an Impact score (how much value the task will deliver)\n - Calculate a Confidence score (how certain we are about the impact)\n - Calculate an Ease score (how easy it is to implement)\n - Compute a total ICE score (sum or product of the three components)\n\n2. Implementation details:\n - Reuse the filtering logic from `analyze-complexity` to select relevant tasks\n - Leverage the LLM to generate scores for each dimension on a scale of 1-10\n - For each task, prompt the LLM to evaluate and justify each score based on task description and details\n - Create an `ice_report.md` file similar to the complexity report\n - Sort tasks by total ICE score in descending order\n\n3. CLI rendering:\n - Implement a sister command `show-ice-report` that displays the report in the terminal\n - Format the output with colorized scores and rankings\n - Include options to sort by individual components (impact, confidence, or ease)\n\n4. Integration:\n - If a complexity report exists, reference it in the ICE report for additional context\n - Consider adding a combined view that shows both complexity and ICE scores\n\nThe command should follow the same design patterns as `analyze-complexity` for consistency and code reuse.",
|
||||
"testStrategy": "1. Unit tests:\n - Test the ICE scoring algorithm with various mock task inputs\n - Verify correct filtering of tasks based on status\n - Test the sorting functionality with different ranking criteria\n\n2. Integration tests:\n - Create a test project with diverse tasks and verify the generated ICE report\n - Test the integration with existing complexity reports\n - Verify that changes to task statuses correctly update the ICE analysis\n\n3. CLI tests:\n - Verify the `analyze-ice` command generates the expected report file\n - Test the `show-ice-report` command renders correctly in the terminal\n - Test with various flag combinations and sorting options\n\n4. Validation criteria:\n - The ICE scores should be reasonable and consistent\n - The report should clearly explain the rationale behind each score\n - The ranking should prioritize high-impact, high-confidence, easy-to-implement tasks\n - Performance should be acceptable even with a large number of tasks\n - The command should handle edge cases gracefully (empty projects, missing data)"
|
||||
},
|
||||
{
|
||||
"id": 47,
|
||||
"title": "Enhance Task Suggestion Actions Card Workflow",
|
||||
"description": "Redesign the suggestion actions card to implement a structured workflow for task expansion, subtask creation, context addition, and task management.",
|
||||
"status": "pending",
|
||||
"dependencies": [],
|
||||
"priority": "medium",
|
||||
"details": "Implement a new workflow for the suggestion actions card that guides users through a logical sequence when working with tasks and subtasks:\n\n1. Task Expansion Phase:\n - Add a prominent 'Expand Task' button at the top of the suggestion card\n - Implement an 'Add Subtask' button that becomes active after task expansion\n - Allow users to add multiple subtasks sequentially\n - Provide visual indication of the current phase (expansion phase)\n\n2. Context Addition Phase:\n - After subtasks are created, transition to the context phase\n - Implement an 'Update Subtask' action that allows appending context to each subtask\n - Create a UI element showing which subtask is currently being updated\n - Provide a progress indicator showing which subtasks have received context\n - Include a mechanism to navigate between subtasks for context addition\n\n3. Task Management Phase:\n - Once all subtasks have context, enable the 'Set as In Progress' button\n - Add a 'Start Working' button that directs the agent to begin with the first subtask\n - Implement an 'Update Task' action that consolidates all notes and reorganizes them into improved subtask details\n - Provide a confirmation dialog when restructuring task content\n\n4. UI/UX Considerations:\n - Use visual cues (colors, icons) to indicate the current phase\n - Implement tooltips explaining each action's purpose\n - Add a progress tracker showing completion status across all phases\n - Ensure the UI adapts responsively to different screen sizes\n\nThe implementation should maintain all existing functionality while guiding users through this more structured approach to task management.",
|
||||
"testStrategy": "Testing should verify the complete workflow functions correctly:\n\n1. Unit Tests:\n - Test each button/action individually to ensure it performs its specific function\n - Verify state transitions between phases work correctly\n - Test edge cases (e.g., attempting to set a task in progress before adding context)\n\n2. Integration Tests:\n - Verify the complete workflow from task expansion to starting work\n - Test that context added to subtasks is properly saved and displayed\n - Ensure the 'Update Task' functionality correctly consolidates and restructures content\n\n3. UI/UX Testing:\n - Verify visual indicators correctly show the current phase\n - Test responsive design on various screen sizes\n - Ensure tooltips and help text are displayed correctly\n\n4. User Acceptance Testing:\n - Create test scenarios covering the complete workflow:\n a. Expand a task and add 3 subtasks\n b. Add context to each subtask\n c. Set the task as in progress\n d. Use update-task to restructure the content\n e. Verify the agent correctly begins work on the first subtask\n - Test with both simple and complex tasks to ensure scalability\n\n5. Regression Testing:\n - Verify that existing functionality continues to work\n - Ensure compatibility with keyboard shortcuts and accessibility features"
|
||||
},
|
||||
{
|
||||
"id": 48,
|
||||
"title": "Refactor Prompts into Centralized Structure",
|
||||
"description": "Create a dedicated 'prompts' folder and move all prompt definitions from inline function implementations to individual files, establishing a centralized prompt management system.",
|
||||
"status": "pending",
|
||||
"dependencies": [],
|
||||
"priority": "medium",
|
||||
"details": "This task involves restructuring how prompts are managed in the codebase:\n\n1. Create a new 'prompts' directory at the appropriate level in the project structure\n2. For each existing prompt currently embedded in functions:\n - Create a dedicated file with a descriptive name (e.g., 'task_suggestion_prompt.js')\n - Extract the prompt text/object into this file\n - Export the prompt using the appropriate module pattern\n3. Modify all functions that currently contain inline prompts to import them from the new centralized location\n4. Establish a consistent naming convention for prompt files (e.g., feature_action_prompt.js)\n5. Consider creating an index.js file in the prompts directory to provide a clean import interface\n6. Document the new prompt structure in the project documentation\n7. Ensure that any prompt that requires dynamic content insertion maintains this capability after refactoring\n\nThis refactoring will improve maintainability by making prompts easier to find, update, and reuse across the application.",
|
||||
"testStrategy": "Testing should verify that the refactoring maintains identical functionality while improving code organization:\n\n1. Automated Tests:\n - Run existing test suite to ensure no functionality is broken\n - Create unit tests for the new prompt import mechanism\n - Verify that dynamically constructed prompts still receive their parameters correctly\n\n2. Manual Testing:\n - Execute each feature that uses prompts and compare outputs before and after refactoring\n - Verify that all prompts are properly loaded from their new locations\n - Check that no prompt text is accidentally modified during the migration\n\n3. Code Review:\n - Confirm all prompts have been moved to the new structure\n - Verify consistent naming conventions are followed\n - Check that no duplicate prompts exist\n - Ensure imports are correctly implemented in all files that previously contained inline prompts\n\n4. Documentation:\n - Verify documentation is updated to reflect the new prompt organization\n - Confirm the index.js export pattern works as expected for importing prompts"
|
||||
},
|
||||
{
|
||||
"id": 49,
|
||||
"title": "Implement Code Quality Analysis Command",
|
||||
"description": "Create a command that analyzes the codebase to identify patterns and verify functions against current best practices, generating improvement recommendations and potential refactoring tasks.",
|
||||
"status": "pending",
|
||||
"dependencies": [],
|
||||
"priority": "medium",
|
||||
"details": "Develop a new command called `analyze-code-quality` that performs the following functions:\n\n1. **Pattern Recognition**:\n - Scan the codebase to identify recurring patterns in code structure, function design, and architecture\n - Categorize patterns by frequency and impact on maintainability\n - Generate a report of common patterns with examples from the codebase\n\n2. **Best Practice Verification**:\n - For each function in specified files, extract its purpose, parameters, and implementation details\n - Create a verification checklist for each function that includes:\n - Function naming conventions\n - Parameter handling\n - Error handling\n - Return value consistency\n - Documentation quality\n - Complexity metrics\n - Use an API integration with Perplexity or similar AI service to evaluate each function against current best practices\n\n3. **Improvement Recommendations**:\n - Generate specific refactoring suggestions for functions that don't align with best practices\n - Include code examples of the recommended improvements\n - Estimate the effort required for each refactoring suggestion\n\n4. **Task Integration**:\n - Create a mechanism to convert high-value improvement recommendations into Taskmaster tasks\n - Allow users to select which recommendations to convert to tasks\n - Generate properly formatted task descriptions that include the current implementation, recommended changes, and justification\n\nThe command should accept parameters for targeting specific directories or files, setting the depth of analysis, and filtering by improvement impact level.",
|
||||
"testStrategy": "Testing should verify all aspects of the code analysis command:\n\n1. **Functionality Testing**:\n - Create a test codebase with known patterns and anti-patterns\n - Verify the command correctly identifies all patterns in the test codebase\n - Check that function verification correctly flags issues in deliberately non-compliant functions\n - Confirm recommendations are relevant and implementable\n\n2. **Integration Testing**:\n - Test the AI service integration with mock responses to ensure proper handling of API calls\n - Verify the task creation workflow correctly generates well-formed tasks\n - Test integration with existing Taskmaster commands and workflows\n\n3. **Performance Testing**:\n - Measure execution time on codebases of various sizes\n - Ensure memory usage remains reasonable even on large codebases\n - Test with rate limiting on API calls to ensure graceful handling\n\n4. **User Experience Testing**:\n - Have developers use the command on real projects and provide feedback\n - Verify the output is actionable and clear\n - Test the command with different parameter combinations\n\n5. **Validation Criteria**:\n - Command successfully analyzes at least 95% of functions in the codebase\n - Generated recommendations are specific and actionable\n - Created tasks follow the project's task format standards\n - Analysis results are consistent across multiple runs on the same codebase"
|
||||
},
|
||||
{
|
||||
"id": 50,
|
||||
"title": "Implement Test Coverage Tracking System by Task",
|
||||
"description": "Create a system that maps test coverage to specific tasks and subtasks, enabling targeted test generation and tracking of code coverage at the task level.",
|
||||
"status": "pending",
|
||||
"dependencies": [],
|
||||
"priority": "medium",
|
||||
"details": "Develop a comprehensive test coverage tracking system with the following components:\n\n1. Create a `tests.json` file structure in the `tasks/` directory that associates test suites and individual tests with specific task IDs or subtask IDs.\n\n2. Build a generator that processes code coverage reports and updates the `tests.json` file to maintain an accurate mapping between tests and tasks.\n\n3. Implement a parser that can extract code coverage information from standard coverage tools (like Istanbul/nyc, Jest coverage reports) and convert it to the task-based format.\n\n4. Create CLI commands that can:\n - Display test coverage for a specific task/subtask\n - Identify untested code related to a particular task\n - Generate test suggestions for uncovered code using LLMs\n\n5. Extend the MCP (Mission Control Panel) to visualize test coverage by task, showing percentage covered and highlighting areas needing tests.\n\n6. Develop an automated test generation system that uses LLMs to create targeted tests for specific uncovered code sections within a task.\n\n7. Implement a workflow that integrates with the existing task management system, allowing developers to see test requirements alongside implementation requirements.\n\nThe system should maintain bidirectional relationships: from tests to tasks and from tasks to the code they affect, enabling precise tracking of what needs testing for each development task.",
|
||||
"testStrategy": "Testing should verify all components of the test coverage tracking system:\n\n1. **File Structure Tests**: Verify the `tests.json` file is correctly created and follows the expected schema with proper task/test relationships.\n\n2. **Coverage Report Processing**: Create mock coverage reports and verify they are correctly parsed and integrated into the `tests.json` file.\n\n3. **CLI Command Tests**: Test each CLI command with various inputs:\n - Test coverage display for existing tasks\n - Edge cases like tasks with no tests\n - Tasks with partial coverage\n\n4. **Integration Tests**: Verify the entire workflow from code changes to coverage reporting to task-based test suggestions.\n\n5. **LLM Test Generation**: Validate that generated tests actually cover the intended code paths by running them against the codebase.\n\n6. **UI/UX Tests**: Ensure the MCP correctly displays coverage information and that the interface for viewing and managing test coverage is intuitive.\n\n7. **Performance Tests**: Measure the performance impact of the coverage tracking system, especially for large codebases.\n\nCreate a test suite that can run in CI/CD to ensure the test coverage tracking system itself maintains high coverage and reliability."
|
||||
},
|
||||
{
|
||||
"id": 51,
|
||||
"title": "Implement Perplexity Research Command",
|
||||
"description": "Create a command that allows users to quickly research topics using Perplexity AI, with options to include task context or custom prompts.",
|
||||
"status": "pending",
|
||||
"dependencies": [],
|
||||
"priority": "medium",
|
||||
"details": "Develop a new command called 'research' that integrates with Perplexity AI's API to fetch information on specified topics. The command should:\n\n1. Accept the following parameters:\n - A search query string (required)\n - A task or subtask ID for context (optional)\n - A custom prompt to guide the research (optional)\n\n2. When a task/subtask ID is provided, extract relevant information from it to enrich the research query with context.\n\n3. Implement proper API integration with Perplexity, including authentication and rate limiting handling.\n\n4. Format and display the research results in a readable format in the terminal, with options to:\n - Save the results to a file\n - Copy results to clipboard\n - Generate a summary of key points\n\n5. Cache research results to avoid redundant API calls for the same queries.\n\n6. Provide a configuration option to set the depth/detail level of research (quick overview vs. comprehensive).\n\n7. Handle errors gracefully, especially network issues or API limitations.\n\nThe command should follow the existing CLI structure and maintain consistency with other commands in the system.",
|
||||
"testStrategy": "1. Unit tests:\n - Test the command with various combinations of parameters (query only, query+task, query+custom prompt, all parameters)\n - Mock the Perplexity API responses to test different scenarios (successful response, error response, rate limiting)\n - Verify that task context is correctly extracted and incorporated into the research query\n\n2. Integration tests:\n - Test actual API calls to Perplexity with valid credentials (using a test account)\n - Verify the caching mechanism works correctly for repeated queries\n - Test error handling with intentionally invalid requests\n\n3. User acceptance testing:\n - Have team members use the command for real research needs and provide feedback\n - Verify the command works in different network environments\n - Test the command with very long queries and responses\n\n4. Performance testing:\n - Measure and optimize response time for queries\n - Test behavior under poor network conditions\n\nValidate that the research results are properly formatted, readable, and that all output options (save, copy) function correctly."
|
||||
},
|
||||
{
|
||||
"id": 52,
|
||||
"title": "Implement Task Suggestion Command for CLI",
|
||||
"description": "Create a new CLI command 'suggest-task' that generates contextually relevant task suggestions based on existing tasks and allows users to accept, decline, or regenerate suggestions.",
|
||||
"status": "pending",
|
||||
"dependencies": [],
|
||||
"priority": "medium",
|
||||
"details": "Implement a new command 'suggest-task' that can be invoked from the CLI to generate intelligent task suggestions. The command should:\n\n1. Collect a snapshot of all existing tasks including their titles, descriptions, statuses, and dependencies\n2. Extract parent task subtask titles (not full objects) to provide context\n3. Use this information to generate a contextually appropriate new task suggestion\n4. Present the suggestion to the user in a clear format\n5. Provide an interactive interface with options to:\n - Accept the suggestion (creating a new task with the suggested details)\n - Decline the suggestion (exiting without creating a task)\n - Regenerate a new suggestion (requesting an alternative)\n\nThe implementation should follow a similar pattern to the 'generate-subtask' command but operate at the task level rather than subtask level. The command should use the project's existing AI integration to analyze the current task structure and generate relevant suggestions. Ensure proper error handling for API failures and implement a timeout mechanism for suggestion generation.\n\nThe command should accept optional flags to customize the suggestion process, such as:\n- `--parent=<task-id>` to suggest a task related to a specific parent task\n- `--type=<task-type>` to suggest a specific type of task (feature, bugfix, refactor, etc.)\n- `--context=<additional-context>` to provide additional information for the suggestion",
|
||||
"testStrategy": "Testing should verify both the functionality and user experience of the suggest-task command:\n\n1. Unit tests:\n - Test the task collection mechanism to ensure it correctly gathers existing task data\n - Test the context extraction logic to verify it properly isolates relevant subtask titles\n - Test the suggestion generation with mocked AI responses\n - Test the command's parsing of various flag combinations\n\n2. Integration tests:\n - Test the end-to-end flow with a mock project structure\n - Verify the command correctly interacts with the AI service\n - Test the task creation process when a suggestion is accepted\n\n3. User interaction tests:\n - Test the accept/decline/regenerate interface works correctly\n - Verify appropriate feedback is displayed to the user\n - Test handling of unexpected user inputs\n\n4. Edge cases:\n - Test behavior when run in an empty project with no existing tasks\n - Test with malformed task data\n - Test with API timeouts or failures\n - Test with extremely large numbers of existing tasks\n\nManually verify the command produces contextually appropriate suggestions that align with the project's current state and needs."
|
||||
},
|
||||
{
|
||||
"id": 53,
|
||||
"title": "Implement Subtask Suggestion Feature for Parent Tasks",
|
||||
"description": "Create a new CLI command that suggests contextually relevant subtasks for existing parent tasks, allowing users to accept, decline, or regenerate suggestions before adding them to the system.",
|
||||
"status": "pending",
|
||||
"dependencies": [],
|
||||
"priority": "medium",
|
||||
"details": "Develop a new command `suggest-subtask <task-id>` that generates intelligent subtask suggestions for a specified parent task. The implementation should:\n\n1. Accept a parent task ID as input and validate it exists\n2. Gather a snapshot of all existing tasks in the system (titles only, with their statuses and dependencies)\n3. Retrieve the full details of the specified parent task\n4. Use this context to generate a relevant subtask suggestion that would logically help complete the parent task\n5. Present the suggestion to the user in the CLI with options to:\n - Accept (a): Add the subtask to the system under the parent task\n - Decline (d): Reject the suggestion without adding anything\n - Regenerate (r): Generate a new alternative subtask suggestion\n - Edit (e): Accept but allow editing the title/description before adding\n\nThe suggestion algorithm should consider:\n- The parent task's description and requirements\n- Current progress (% complete) of the parent task\n- Existing subtasks already created for this parent\n- Similar patterns from other tasks in the system\n- Logical next steps based on software development best practices\n\nWhen a subtask is accepted, it should be properly linked to the parent task and assigned appropriate default values for priority and status.",
|
||||
"testStrategy": "Testing should verify both the functionality and the quality of suggestions:\n\n1. Unit tests:\n - Test command parsing and validation of task IDs\n - Test snapshot creation of existing tasks\n - Test the suggestion generation with mocked data\n - Test the user interaction flow with simulated inputs\n\n2. Integration tests:\n - Create a test parent task and verify subtask suggestions are contextually relevant\n - Test the accept/decline/regenerate workflow end-to-end\n - Verify proper linking of accepted subtasks to parent tasks\n - Test with various types of parent tasks (frontend, backend, documentation, etc.)\n\n3. Quality assessment:\n - Create a benchmark set of 10 diverse parent tasks\n - Generate 3 subtask suggestions for each and have team members rate relevance on 1-5 scale\n - Ensure average relevance score exceeds 3.5/5\n - Verify suggestions don't duplicate existing subtasks\n\n4. Edge cases:\n - Test with a parent task that has no description\n - Test with a parent task that already has many subtasks\n - Test with a newly created system with minimal task history"
|
||||
},
|
||||
{
|
||||
"id": 54,
|
||||
"title": "Add Research Flag to Add-Task Command",
|
||||
"description": "Enhance the add-task command with a --research flag that allows users to perform quick research on the task topic before finalizing task creation.",
|
||||
"status": "pending",
|
||||
"dependencies": [],
|
||||
"priority": "medium",
|
||||
"details": "Modify the existing add-task command to accept a new optional flag '--research'. When this flag is provided, the system should pause the task creation process and invoke the Perplexity research functionality (similar to Task #51) to help users gather information about the task topic before finalizing the task details. The implementation should:\n\n1. Update the command parser to recognize the new --research flag\n2. When the flag is present, extract the task title/description as the research topic\n3. Call the Perplexity research functionality with this topic\n4. Display research results to the user\n5. Allow the user to refine their task based on the research (modify title, description, etc.)\n6. Continue with normal task creation flow after research is complete\n7. Ensure the research results can be optionally attached to the task as reference material\n8. Add appropriate help text explaining this feature in the command help\n\nThe implementation should leverage the existing Perplexity research command from Task #51, ensuring code reuse where possible.",
|
||||
"testStrategy": "Testing should verify both the functionality and usability of the new feature:\n\n1. Unit tests:\n - Verify the command parser correctly recognizes the --research flag\n - Test that the research functionality is properly invoked with the correct topic\n - Ensure task creation proceeds correctly after research is complete\n\n2. Integration tests:\n - Test the complete flow from command invocation to task creation with research\n - Verify research results are properly attached to the task when requested\n - Test error handling when research API is unavailable\n\n3. Manual testing:\n - Run the command with --research flag and verify the user experience\n - Test with various task topics to ensure research is relevant\n - Verify the help documentation correctly explains the feature\n - Test the command without the flag to ensure backward compatibility\n\n4. Edge cases:\n - Test with very short/vague task descriptions\n - Test with complex technical topics\n - Test cancellation of task creation during the research phase"
|
||||
},
|
||||
{
|
||||
"id": 55,
|
||||
"title": "Implement Positional Arguments Support for CLI Commands",
|
||||
"description": "Upgrade CLI commands to support positional arguments alongside the existing flag-based syntax, allowing for more intuitive command usage.",
|
||||
"status": "pending",
|
||||
"dependencies": [],
|
||||
"priority": "medium",
|
||||
"details": "This task involves modifying the command parsing logic in commands.js to support positional arguments as an alternative to the current flag-based approach. The implementation should:\n\n1. Update the argument parsing logic to detect when arguments are provided without flag prefixes (--)\n2. Map positional arguments to their corresponding parameters based on their order\n3. For each command in commands.js, define a consistent positional argument order (e.g., for set-status: first arg = id, second arg = status)\n4. Maintain backward compatibility with the existing flag-based syntax\n5. Handle edge cases such as:\n - Commands with optional parameters\n - Commands with multiple parameters\n - Commands that accept arrays or complex data types\n6. Update the help text for each command to show both usage patterns\n7. Modify the cursor rules to work with both input styles\n8. Ensure error messages are clear when positional arguments are provided incorrectly\n\nExample implementations:\n- `task-master set-status 25 done` should be equivalent to `task-master set-status --id=25 --status=done`\n- `task-master add-task \"New task name\" \"Task description\"` should be equivalent to `task-master add-task --name=\"New task name\" --description=\"Task description\"`\n\nThe code should prioritize maintaining the existing functionality while adding this new capability.",
|
||||
"testStrategy": "Testing should verify both the new positional argument functionality and continued support for flag-based syntax:\n\n1. Unit tests:\n - Create tests for each command that verify it works with both positional and flag-based arguments\n - Test edge cases like missing arguments, extra arguments, and mixed usage (some positional, some flags)\n - Verify help text correctly displays both usage patterns\n\n2. Integration tests:\n - Test the full CLI with various commands using both syntax styles\n - Verify that output is identical regardless of which syntax is used\n - Test commands with different numbers of arguments\n\n3. Manual testing:\n - Run through a comprehensive set of real-world usage scenarios with both syntax styles\n - Verify cursor behavior works correctly with both input methods\n - Check that error messages are helpful when incorrect positional arguments are provided\n\n4. Documentation verification:\n - Ensure README and help text accurately reflect the new dual syntax support\n - Verify examples in documentation show both styles where appropriate\n\nAll tests should pass with 100% of commands supporting both argument styles without any regression in existing functionality."
|
||||
}
|
||||
]
|
||||
}
|
||||
Reference in New Issue
Block a user