Files

Eyal Toledano 5119cd2d8e v017 polish (#778 )

* fix(research, tasks): Make research command and task updates tag-aware

* refactor(tasks): Prevent automatic task file generation across other locations

This commit refactors several core task management functions to prevent them from automatically regenerating individual task files after modifying the main `tasks.json`.

Previously, operations like `add-task`, `clear-subtasks`, `expand-task`, and `update-task-by-id` would immediately trigger `generateTaskFiles`. This could be slow and was often unnecessary.

The calls to `generateTaskFiles` have been removed or commented out from the core task functions. Users should now run `task-master generate` explicitly to update their individual task files.

Additionally, this commit includes fixes to the `move` command to make it fully tag-aware.

* fix: move and clear subtasks mcp commands

* chore: fix format

* chore: fix unit tests

---------

Co-authored-by: Ralph Khreish <35776126+Crunchyman-ralph@users.noreply.github.com>

2025-06-15 03:47:56 +03:00

7.6 KiB

Raw Blame History

title, query, date, time, timestamp, exchanges

title	query	date	time	timestamp	exchanges
Research Session	how can i improve the scope-up and scope-down command	6/14/2025	4:35:03 PM	2025-06-14T20:35:03.231Z	2

Research Session

Initial Query

Question: how can i improve the scope-up and scope-down command

Response:

Improving the `scope-up` and `scope-down` Commands

Clarify Command Purpose and User Experience

Ensure the commands have clear, intuitive behavior. For example, scope-up should consistently broaden the context or task view, while scope-down should reliably narrow it.
Provide immediate, user-friendly feedback after each command, indicating what changed (e.g., "Now viewing parent task and all subtasks" or "Focused on subtask: X").
Document the commands with examples in your docs/command-reference.md and docs/examples.md to help users understand their effects and use cases.

Enhance Context Awareness

Make the commands context-sensitive: if the user is already at the top or bottom of the scope hierarchy, return a helpful message instead of failing silently.
Allow optional arguments to specify the exact level or target (e.g., scope-up 2 to move up two levels, or scope-down <subtask-id> to jump directly to a subtask).

Robust Error Handling and Validation

Implement checks to prevent invalid operations, such as attempting to scope up from the root or scope down when no subtasks exist.
Provide clear error messages and suggestions for next steps, improving user trust and reducing confusion[1][5].

Integrate with Task and Tag Systems

Ensure scope-up and scope-down interact smoothly with your tagging and task hierarchy features. For example, scoping up from a subtask should show the parent task and its context, while scoping down should allow selection from available subtasks or related tags.
Consider supporting batch operations, such as scoping down into all subtasks and displaying them in a summarized view.

Improve Performance and Synchronization

Optimize the underlying logic to minimize delays, especially in large task trees. Use asynchronous operations where possible to keep the UI responsive.
If the commands trigger data loading or context switching, ensure synchronization so that subsequent commands operate on the correct, updated context[2][4].

Testing and Stakeholder Feedback

Add or expand unit and integration tests for these commands (see tests/unit/commands.test.js and integration/cli/commands.test.js) to cover edge cases and ensure reliability.
Gather feedback from users and stakeholders to identify pain points and desired enhancements, then iterate on the command design and implementation[1][5].

Example Improvements Table

Area	Current Issue	Suggested Improvement
User Feedback	Minimal or unclear output	Add explicit, contextual messages
Error Handling	Silent failures	Informative errors and recovery suggestions
Flexibility	Only single-level movement	Support multi-level and targeted navigation
Integration	Limited context awareness	Sync with tags, parent/child relationships
Performance	Slow on large hierarchies	Optimize data access and UI updates

By focusing on these areas, you can make scope-up and scope-down more robust, user-friendly, and aligned with best practices in scope management and command design[1][5].

Follow-up 1

Question: how might i do this relative to the tag system?

Response:

Integrating Scope-Up and Scope-Down with the Tag System

Conceptual Mapping

In your project, scope-up and scope-down commands currently operate on the task hierarchy, broadening or narrowing the context by moving between parent and child tasks.
The tag system provides a parallel, orthogonal way to group and filter tasks—tags can represent categories, priorities, or any custom grouping, independent of strict parent/child relationships.

How to Make Scope Commands Tag-Aware

Scoping by Tag: Allow users to "scope-down" into a tag, viewing only tasks associated with that tag. Conversely, "scope-up" could move from a specific tag context back to the broader task list or to a parent tag grouping if you support tag hierarchies.
Tag-Scoped Views: When a tag is active as the current scope, all navigation and operations (listing, editing, etc.) are limited to tasks with that tag. This is similar to how some systems let you set the "Tag Scope" to filter navigation and search to only tagged items[1][5].
Combining Hierarchy and Tags: Enable compound scoping, such as "all subtasks of Task X that also have Tag Y." This can be implemented by intersecting the results of hierarchical and tag-based queries.

Implementation Strategies

Scope Stack or Context Object: Maintain a stack or context object that tracks both the current task scope and any active tag filters. Each scope change (up/down or tag in/out) updates this context.
Commands:
- scope-down --tag <tag>: Narrows the view to tasks with the specified tag.
- scope-up --tag: Removes the tag filter, broadening the view.
- scope-down <subtask-id> --tag <tag>: Narrows to a specific subtask and applies a tag filter.
Tag Hierarchies (Optional): If your tag system supports parent/child tags or tag groups, allow "scope-up" to move from a specific tag to its parent tag or group, and "scope-down" to move into a child tag[4][5].

Example User Flows

Scoping Down by Tag:
User runs scope-down --tag urgent → Only tasks tagged "urgent" are shown.
Combining Task and Tag:
User runs scope-down <task-id> --tag frontend → Only subtasks of <task-id> that are tagged "frontend" are shown.
Scoping Up from Tag:
User runs scope-up --tag → Removes the tag filter, returning to the previous broader context.

Technical Considerations

Efficient Filtering: Use indexed queries or in-memory filtering to efficiently combine tag and hierarchy filters, especially for large task sets.
Feedback and UI: Always display the current scope context (e.g., "Viewing tasks tagged 'urgent' under 'Feature X'") so users understand what they're seeing.
Extensibility: Design the scope system so new types of scopes (e.g., by status, assignee) can be added in the future, not just tags and hierarchy.

Relevant Precedents

Tag-based file systems and management tools often implement "scopes" as dynamic groups defined by tag criteria, allowing users to build up complex views by combining tags and other filters[5].
Some systems allow scoping into tag management itself, where you can create, edit, or view tags and their associated objects, which could be mirrored in your CLI or UI[4].

Summary Table

Command Example	Resulting Scope
`scope-down --tag bug`	All tasks tagged "bug"
`scope-down <task-id> --tag api`	Subtasks of `<task-id>` tagged "api"
`scope-up --tag`	Removes tag filter, returns to previous scope
`scope-down --tag frontend`	All tasks tagged "frontend"

By integrating tag-based scoping, you make your scope commands more flexible and powerful, supporting both hierarchical and ad-hoc organizational strategies[1][5].

Generated by Task Master Research Command
Timestamp: 2025-06-14T20:35:03.231Z

7.6 KiB Raw Blame History