feat: implement cross-tag task movement functionality (#1088)
* feat: enhance move command with cross-tag functionality - Updated the `move` command to allow moving tasks between different tags, including options for handling dependencies. - Added new options: `--from-tag`, `--to-tag`, `--with-dependencies`, `--ignore-dependencies`, and `--force`. - Implemented validation for cross-tag moves and dependency checks. - Introduced helper functions in the dependency manager for validating and resolving cross-tag dependencies. - Added integration and unit tests to cover new functionality and edge cases. * fix: refactor cross-tag move logic and enhance validation - Moved the import of `moveTasksBetweenTags` to the correct location in `commands.js` for better clarity. - Added new helper functions in `dependency-manager.js` to improve validation and error handling for cross-tag moves. - Enhanced existing functions to ensure proper handling of task dependencies and conflicts. - Updated tests to cover new validation scenarios and ensure robust error messaging for invalid task IDs and tags. * fix: improve task ID handling and error messaging in cross-tag moves - Refactored `moveTasksBetweenTags` to normalize task IDs for comparison, ensuring consistent handling of string and numeric IDs. - Enhanced error messages for cases where source and target tags are the same but no destination is specified. - Updated tests to validate new behavior, including handling string dependencies correctly during cross-tag moves. - Cleaned up existing code for better readability and maintainability. * test: add comprehensive tests for cross-tag move and dependency validation - Introduced new test files for `move-cross-tag` and `cross-tag-dependencies` to cover various scenarios in cross-tag task movement. - Implemented tests for handling task movement with and without dependencies, including edge cases for error handling. - Enhanced existing tests in `fix-dependencies-command` and `move-task` to ensure robust validation of task IDs and dependencies. - Mocked necessary modules and functions to isolate tests and improve reliability. - Ensured coverage for both successful and failed cross-tag move operations, validating expected outcomes and error messages. * test: refactor cross-tag move tests for better clarity and reusability - Introduced a helper function `simulateCrossTagMove` to streamline cross-tag move test cases, reducing redundancy and improving readability. - Updated existing tests to utilize the new helper function, ensuring consistent handling of expected messages and options. - Enhanced test coverage for various scenarios, including handling of dependencies and flags. * feat: add cross-tag task movement functionality - Introduced new commands for moving tasks between different tags, enhancing project organization capabilities. - Updated README with usage examples for cross-tag movement, including options for handling dependencies. - Created comprehensive documentation for cross-tag task movement, detailing usage, error handling, and best practices. - Implemented core logic for cross-tag moves, including validation for dependencies and error handling. - Added integration and unit tests to ensure robust functionality and coverage for various scenarios, including edge cases. * fix: enhance error handling and logging in cross-tag task movement - Improved logging in `moveTaskCrossTagDirect` to include detailed arguments for better traceability. - Refactored error handling to utilize structured error objects, providing clearer suggestions for resolving cross-tag dependency conflicts and subtask movement restrictions. - Updated documentation to reflect changes in error handling and provide clearer guidance on task movement options. - Added integration tests for cross-tag movement scenarios, ensuring robust validation of error handling and task movement logic. - Cleaned up existing tests for clarity and reusability, enhancing overall test coverage. * feat: enhance dependency resolution and error handling in task movement - Added recursive dependency resolution for tasks in `moveTasksBetweenTags`, improving handling of complex task relationships. - Introduced helper functions to find all dependencies and reverse dependencies, ensuring comprehensive coverage during task moves. - Enhanced error messages in `validateSubtaskMove` and `displaySubtaskMoveError` for better clarity on movement restrictions. - Updated tests to cover new functionality, including integration tests for complex cross-tag movement scenarios and edge cases. - Refactored existing code for improved readability and maintainability, ensuring consistent handling of task IDs and dependencies. * feat: unify dependency traversal and enhance task management utilities - Introduced `traverseDependencies` utility for unified forward and reverse dependency traversal, improving code reusability and clarity. - Refactored `findAllDependenciesRecursively` to leverage the new utility, streamlining dependency resolution in task management. - Added `formatTaskIdForDisplay` helper for better task ID formatting in UI, enhancing user experience during error displays. - Updated tests to cover new utility functions and ensure robust validation of dependency handling across various scenarios. - Improved overall code organization and readability, ensuring consistent handling of task dependencies and IDs. * fix: improve validation for dependency parameters in `findAllDependenciesRecursively` - Added checks to ensure `sourceTasks` and `allTasks` are arrays, throwing errors if not, to prevent runtime issues. - Updated documentation comment for clarity on the function's purpose and parameters. * fix: remove `force` option from task movement parameters - Eliminated the `force` parameter from the `moveTaskCrossTagDirect` function and related tools, simplifying the task movement logic. - Updated documentation and tests to reflect the removal of the `force` option, ensuring clarity and consistency across the codebase. - Adjusted related functions and tests to focus on `ignoreDependencies` as the primary control for handling dependency conflicts during task moves. * Add cross-tag task movement functionality - Introduced functionality for organizing tasks across different contexts by enabling cross-tag movement. - Added `formatTaskIdForDisplay` helper to improve task ID formatting in UI error messages. - Updated relevant tests to incorporate new functionality and ensure accurate error displays during task movements. * Update scripts/modules/dependency-manager.js Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> * refactor(dependency-manager): Fix subtask resolution and extract helper functions 1. Fix subtask finding logic (lines 1315-1330): - Correctly locate parent task by numeric ID - Search within parent's subtasks array instead of top-level tasks - Properly handle relative subtask references 2. Extract helper functions from getDependentTaskIds (lines 1440-1636): - Move findTasksThatDependOn as module-level function - Move taskDependsOnSource as module-level function - Move subtasksDependOnSource as module-level function - Improves readability, maintainability, and testability Both fixes address architectural issues and improve code organization. * refactor(dependency-manager): Enhance subtask resolution and dependency validation - Improved subtask resolution logic to correctly find parent tasks and their subtasks, ensuring accurate identification of dependencies. - Filtered out null/undefined dependencies before processing, enhancing robustness in dependency checks. - Updated comments for clarity on the logic flow and purpose of changes, improving code maintainability. * refactor(move-task): clarify destination ID description and improve skipped task handling - Updated the description for the destination ID to clarify its usage in cross-tag moves. - Simplified the handling of skipped tasks during multiple task movements, improving readability and logging. - Enhanced the API result response to include detailed information about moved and skipped tasks, ensuring better feedback for users. * refactor(commands): remove redundant tag validation logic - Eliminated the check for identical source and target tags in the task movement logic, simplifying the code. - This change streamlines the flow for within-tag moves, enhancing readability and maintainability. * refactor(commands): enhance move command logic and error handling - Introduced helper functions for better organization of cross-tag and within-tag move logic, improving code readability and maintainability. - Enhanced error handling with structured error objects, providing clearer feedback for dependency conflicts and invalid tag combinations. - Updated move command help output to include best practices and error resolution tips, ensuring users have comprehensive guidance during task movements. - Streamlined task movement logic to handle multiple tasks more effectively, including detailed logging of successful and failed moves. * test(dependency-manager): add subtasks to task structure and mock dependency traversal - Updated `circular-dependencies.test.js` to include subtasks in task definitions, enhancing test coverage for task structures with nested dependencies. - Mocked `traverseDependencies` in `fix-dependencies-command.test.js` to ensure consistent behavior during tests, improving reliability of dependency-related tests. * refactor(dependency-manager): extract subtask finding logic into helper function - Added `findSubtaskInParent` function to encapsulate subtask resolution within a parent task's subtasks array, improving code organization and readability. - Updated `findDependencyTask` to utilize the new helper function, streamlining the logic for finding subtasks and enhancing maintainability. - Enhanced comments for clarity on the purpose and functionality of the new subtask finding logic. * refactor(ui): enhance subtask ID validation and improve error handling - Added validation for subtask ID format in `formatDependenciesWithStatus` and `taskExists`, ensuring proper handling of invalid formats. - Updated error logging in `displaySubtaskMoveError` to provide warnings for unexpected task ID formats, improving user feedback. - Converted hints to a Set in `displayDependencyValidationHints` to ensure unique hints are displayed, enhancing clarity in the UI. * test(cli): remove redundant timing check in complex cross-tag scenarios - Eliminated the timing check for task completion within 5 seconds in `complex-cross-tag-scenarios.test.js`, streamlining the test logic. - This change focuses on verifying task success without unnecessary timing constraints, enhancing test clarity and maintainability. * test(integration): enhance task movement tests with mock file system - Added integration tests for moving tasks within the same tag and between different tags using the actual `moveTask` and `moveTasksBetweenTags` functions. - Implemented `mock-fs` to simulate file system interactions, improving test isolation and reliability. - Verified task movement success and ensured proper handling of subtasks and dependencies, enhancing overall test coverage for task management functionality. - Included error handling tests for missing tags and task IDs to ensure robustness in task movement operations. * test(unit): add comprehensive tests for moveTaskCrossTagDirect functionality - Introduced new test cases to verify mock functionality, ensuring that mocks for `findTasksPath` and `readJSON` are working as expected. - Added tests for parameter validation, error handling, and function call flow, including scenarios for missing project roots and identical source/target tags. - Enhanced coverage for ID parsing and move options, ensuring robust handling of various input conditions and improving overall test reliability. * test(integration): skip tests for dependency conflict handling and withDependencies option - Marked tests for handling dependency conflicts and the withDependencies option as skipped due to issues with the mock setup. - Added TODOs to address the mock-fs setup for complex dependency scenarios, ensuring future improvements in test reliability. * test(unit): expand cross-tag move command tests with comprehensive mocks - Added extensive mocks for various modules to enhance the testing of the cross-tag move functionality in `move-cross-tag.test.js`. - Implemented detailed test cases for handling cross-tag moves, including validation for missing parameters and identical source/target tags. - Improved error handling tests to ensure robust feedback for invalid operations, enhancing overall test reliability and coverage. * test(integration): add complex dependency scenarios to task movement tests - Introduced new integration tests for handling complex dependency scenarios in task movement, utilizing the actual `moveTasksBetweenTags` function. - Added tests for circular dependencies, nested dependency chains, and cross-tag dependency resolution, enhancing coverage and reliability. - Documented limitations of the mock-fs setup for complex scenarios and provided warnings in the test output to guide future improvements. - Skipped tests for dependency conflicts and the withDependencies option due to mock setup issues, with TODOs for resolution. * test(unit): refactor move-cross-tag tests with focused mock system - Simplified mocking in `move-cross-tag.test.js` by implementing a configuration-driven mock system, reducing the number of mocked modules from 20+ to 5 core functionalities. - Introduced a reusable mock factory to streamline the creation of mocks based on configuration, enhancing maintainability and clarity. - Added documentation for the new mock system, detailing usage examples and benefits, including reduced complexity and improved test focus. - Implemented tests to validate the mock configuration, ensuring flexibility in enabling/disabling specific mocks. * test(unit): clean up mocks and improve isEmpty function in fix-dependencies-command tests - Removed the mock for `traverseDependencies` as it was unnecessary, simplifying the test setup. - Updated the `isEmpty` function to clarify its behavior regarding null and undefined values, enhancing code readability and maintainability. * test(unit): update traverseDependencies mock for consistency across tests - Standardized the mock implementation of `traverseDependencies` in both `fix-dependencies-command.test.js` and `complexity-report-tag-isolation.test.js` to accept `sourceTasks`, `allTasks`, and `options` parameters, ensuring uniformity in test setups. - This change enhances clarity and maintainability of the tests by aligning the mock behavior across different test files. * fix(core): improve task movement error handling and ID normalization - Wrapped task movement logic in a try-finally block to ensure console output is restored even on errors, enhancing reliability. - Normalized source IDs to handle mixed string/number comparisons, preventing potential issues in dependency checks. - Added tests for ID type consistency to verify that the normalization fix works correctly across various scenarios, improving test coverage and robustness. * refactor(task-manager): restructure task movement logic for improved validation and execution - Renamed and refactored `moveTasksBetweenTags` to streamline the task movement process into distinct phases: validation, data preparation, dependency resolution, execution, and finalization. - Introduced `validateMove`, `prepareTaskData`, `resolveDependencies`, `executeMoveOperation`, and `finalizeMove` functions to enhance modularity and clarity. - Updated documentation comments to reflect changes in function responsibilities and parameters. - Added comprehensive unit tests for the new structure, ensuring robust validation and error handling across various scenarios. - Improved handling of dependencies and task existence checks during the move operation, enhancing overall reliability. * fix(move-task): streamline task movement logic and improve error handling - Refactored the task movement process to enhance clarity and maintainability by replacing `forEach` with a `for...of` loop for better async handling. - Consolidated error handling and result logging to ensure consistent feedback during task moves. - Updated the logic for generating files only on the last move, improving performance and reducing unnecessary operations. - Enhanced validation for skipped tasks, ensuring accurate reporting of moved and skipped tasks in the final result. * fix(docs): update error message formatting and enhance clarity in task movement documentation - Changed code block syntax from generic to `text` for better readability in error messages related to task movement and dependency conflicts. - Ensured consistent formatting across all error message examples to improve user understanding of task movement restrictions and resolutions. - Added a newline at the end of the file for proper formatting. * Update .changeset/crazy-meals-hope.md Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> * chore: improve changeset * chore: improve changeset * fix referenced bug in docs and remove docs * chore: fix format --------- Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> Co-authored-by: Ralph Khreish <35776126+Crunchyman-ralph@users.noreply.github.com>
This commit is contained in:
Parthy
@@ -48,6 +48,12 @@ import {
|
||||
validateStrength
|
||||
} from './task-manager.js';
|
||||
|
||||
import {
|
||||
moveTasksBetweenTags,
|
||||
MoveTaskError,
|
||||
MOVE_ERROR_CODES
|
||||
} from './task-manager/move-task.js';
|
||||
|
||||
import {
|
||||
createTag,
|
||||
deleteTag,
|
||||
@@ -61,7 +67,9 @@ import {
|
||||
addDependency,
|
||||
removeDependency,
|
||||
validateDependenciesCommand,
|
||||
fixDependenciesCommand
|
||||
fixDependenciesCommand,
|
||||
DependencyError,
|
||||
DEPENDENCY_ERROR_CODES
|
||||
} from './dependency-manager.js';
|
||||
|
||||
import {
|
||||
@@ -103,7 +111,11 @@ import {
|
||||
displayAiUsageSummary,
|
||||
displayMultipleTasksSummary,
|
||||
displayTaggedTasksFYI,
|
||||
displayCurrentTagIndicator
|
||||
displayCurrentTagIndicator,
|
||||
displayCrossTagDependencyError,
|
||||
displaySubtaskMoveError,
|
||||
displayInvalidTagCombinationError,
|
||||
displayDependencyValidationHints
|
||||
} from './ui.js';
|
||||
import {
|
||||
confirmProfilesRemove,
|
||||
@@ -4038,7 +4050,9 @@ Examples:
|
||||
// move-task command
|
||||
programInstance
|
||||
.command('move')
|
||||
.description('Move a task or subtask to a new position')
|
||||
.description(
|
||||
'Move tasks between tags or reorder within tags. Supports cross-tag moves with dependency resolution options.'
|
||||
)
|
||||
.option(
|
||||
'-f, --file <file>',
|
||||
'Path to the tasks file',
|
||||
@@ -4053,55 +4067,202 @@ Examples:
|
||||
'ID of the destination (e.g., "7" or "7.3"). Must match the number of source IDs if comma-separated'
|
||||
)
|
||||
.option('--tag <tag>', 'Specify tag context for task operations')
|
||||
.option('--from-tag <tag>', 'Source tag for cross-tag moves')
|
||||
.option('--to-tag <tag>', 'Target tag for cross-tag moves')
|
||||
.option('--with-dependencies', 'Move dependent tasks along with main task')
|
||||
.option('--ignore-dependencies', 'Break cross-tag dependencies during move')
|
||||
.action(async (options) => {
|
||||
// Initialize TaskMaster
|
||||
const taskMaster = initTaskMaster({
|
||||
tasksPath: options.file || true,
|
||||
tag: options.tag
|
||||
});
|
||||
|
||||
const sourceId = options.from;
|
||||
const destinationId = options.to;
|
||||
const tag = taskMaster.getCurrentTag();
|
||||
|
||||
if (!sourceId || !destinationId) {
|
||||
console.error(
|
||||
chalk.red('Error: Both --from and --to parameters are required')
|
||||
);
|
||||
// Helper function to show move command help - defined in scope for proper encapsulation
|
||||
function showMoveHelp() {
|
||||
console.log(
|
||||
chalk.yellow(
|
||||
'Usage: task-master move --from=<sourceId> --to=<destinationId>'
|
||||
)
|
||||
chalk.white.bold('Move Command Help') +
|
||||
'\n\n' +
|
||||
chalk.cyan('Move tasks between tags or reorder within tags.') +
|
||||
'\n\n' +
|
||||
chalk.yellow.bold('Within-Tag Moves:') +
|
||||
'\n' +
|
||||
chalk.white(' task-master move --from=5 --to=7') +
|
||||
'\n' +
|
||||
chalk.white(' task-master move --from=5.2 --to=7.3') +
|
||||
'\n' +
|
||||
chalk.white(' task-master move --from=5,6,7 --to=10,11,12') +
|
||||
'\n\n' +
|
||||
chalk.yellow.bold('Cross-Tag Moves:') +
|
||||
'\n' +
|
||||
chalk.white(
|
||||
' task-master move --from=5 --from-tag=backlog --to-tag=in-progress'
|
||||
) +
|
||||
'\n' +
|
||||
chalk.white(
|
||||
' task-master move --from=5,6 --from-tag=backlog --to-tag=done'
|
||||
) +
|
||||
'\n\n' +
|
||||
chalk.yellow.bold('Dependency Resolution:') +
|
||||
'\n' +
|
||||
chalk.white(' # Move with dependencies') +
|
||||
'\n' +
|
||||
chalk.white(
|
||||
' task-master move --from=5 --from-tag=backlog --to-tag=in-progress --with-dependencies'
|
||||
) +
|
||||
'\n\n' +
|
||||
chalk.white(' # Break dependencies') +
|
||||
'\n' +
|
||||
chalk.white(
|
||||
' task-master move --from=5 --from-tag=backlog --to-tag=in-progress --ignore-dependencies'
|
||||
) +
|
||||
'\n\n' +
|
||||
chalk.white(' # Force move (may break dependencies)') +
|
||||
'\n' +
|
||||
chalk.white(
|
||||
' task-master move --from=5 --from-tag=backlog --to-tag=in-progress --force'
|
||||
) +
|
||||
'\n\n' +
|
||||
chalk.yellow.bold('Best Practices:') +
|
||||
'\n' +
|
||||
chalk.white(
|
||||
' • Use --with-dependencies to move dependent tasks together'
|
||||
) +
|
||||
'\n' +
|
||||
chalk.white(
|
||||
' • Use --ignore-dependencies to break cross-tag dependencies'
|
||||
) +
|
||||
'\n' +
|
||||
chalk.white(
|
||||
' • Use --force only when you understand the consequences'
|
||||
) +
|
||||
'\n' +
|
||||
chalk.white(
|
||||
' • Check dependencies first: task-master validate-dependencies'
|
||||
) +
|
||||
'\n' +
|
||||
chalk.white(
|
||||
' • Fix dependency issues: task-master fix-dependencies'
|
||||
) +
|
||||
'\n\n' +
|
||||
chalk.yellow.bold('Error Resolution:') +
|
||||
'\n' +
|
||||
chalk.white(
|
||||
' • Cross-tag dependency conflicts: Use --with-dependencies or --ignore-dependencies'
|
||||
) +
|
||||
'\n' +
|
||||
chalk.white(
|
||||
' • Subtask movement: Promote subtask first with remove-subtask --convert'
|
||||
) +
|
||||
'\n' +
|
||||
chalk.white(
|
||||
' • Invalid tags: Check available tags with task-master tags'
|
||||
) +
|
||||
'\n\n' +
|
||||
chalk.gray('For more help, run: task-master move --help')
|
||||
);
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
// Check if we're moving multiple tasks (comma-separated IDs)
|
||||
const sourceIds = sourceId.split(',').map((id) => id.trim());
|
||||
const destinationIds = destinationId.split(',').map((id) => id.trim());
|
||||
// Helper function to handle cross-tag move logic
|
||||
async function handleCrossTagMove(moveContext, options) {
|
||||
const { sourceId, sourceTag, toTag, taskMaster } = moveContext;
|
||||
|
||||
// Validate that the number of source and destination IDs match
|
||||
if (sourceIds.length !== destinationIds.length) {
|
||||
console.error(
|
||||
chalk.red(
|
||||
'Error: The number of source and destination IDs must match'
|
||||
)
|
||||
);
|
||||
console.log(
|
||||
chalk.yellow('Example: task-master move --from=5,6,7 --to=10,11,12')
|
||||
);
|
||||
process.exit(1);
|
||||
}
|
||||
if (!sourceId) {
|
||||
console.error(
|
||||
chalk.red('Error: --from parameter is required for cross-tag moves')
|
||||
);
|
||||
showMoveHelp();
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
const sourceIds = sourceId.split(',').map((id) => id.trim());
|
||||
const moveOptions = {
|
||||
withDependencies: options.withDependencies || false,
|
||||
ignoreDependencies: options.ignoreDependencies || false
|
||||
};
|
||||
|
||||
// If moving multiple tasks
|
||||
if (sourceIds.length > 1) {
|
||||
console.log(
|
||||
chalk.blue(
|
||||
`Moving multiple tasks: ${sourceIds.join(', ')} to ${destinationIds.join(', ')}...`
|
||||
`Moving tasks ${sourceIds.join(', ')} from "${sourceTag}" to "${toTag}"...`
|
||||
)
|
||||
);
|
||||
|
||||
try {
|
||||
const result = await moveTasksBetweenTags(
|
||||
taskMaster.getTasksPath(),
|
||||
sourceIds,
|
||||
sourceTag,
|
||||
toTag,
|
||||
moveOptions,
|
||||
{ projectRoot: taskMaster.getProjectRoot() }
|
||||
);
|
||||
|
||||
console.log(chalk.green(`✓ ${result.message}`));
|
||||
|
||||
// Check if source tag still contains tasks before regenerating files
|
||||
const tasksData = readJSON(
|
||||
taskMaster.getTasksPath(),
|
||||
taskMaster.getProjectRoot(),
|
||||
sourceTag
|
||||
);
|
||||
const sourceTagHasTasks =
|
||||
tasksData &&
|
||||
Array.isArray(tasksData.tasks) &&
|
||||
tasksData.tasks.length > 0;
|
||||
|
||||
// Generate task files for the affected tags
|
||||
await generateTaskFiles(
|
||||
taskMaster.getTasksPath(),
|
||||
path.dirname(taskMaster.getTasksPath()),
|
||||
{ tag: toTag, projectRoot: taskMaster.getProjectRoot() }
|
||||
);
|
||||
|
||||
// Only regenerate source tag files if it still contains tasks
|
||||
if (sourceTagHasTasks) {
|
||||
await generateTaskFiles(
|
||||
taskMaster.getTasksPath(),
|
||||
path.dirname(taskMaster.getTasksPath()),
|
||||
{ tag: sourceTag, projectRoot: taskMaster.getProjectRoot() }
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Helper function to handle within-tag move logic
|
||||
async function handleWithinTagMove(moveContext) {
|
||||
const { sourceId, destinationId, tag, taskMaster } = moveContext;
|
||||
|
||||
if (!sourceId || !destinationId) {
|
||||
console.error(
|
||||
chalk.red(
|
||||
'Error: Both --from and --to parameters are required for within-tag moves'
|
||||
)
|
||||
);
|
||||
console.log(
|
||||
chalk.yellow(
|
||||
'Usage: task-master move --from=<sourceId> --to=<destinationId>'
|
||||
)
|
||||
);
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
// Check if we're moving multiple tasks (comma-separated IDs)
|
||||
const sourceIds = sourceId.split(',').map((id) => id.trim());
|
||||
const destinationIds = destinationId.split(',').map((id) => id.trim());
|
||||
|
||||
// Validate that the number of source and destination IDs match
|
||||
if (sourceIds.length !== destinationIds.length) {
|
||||
console.error(
|
||||
chalk.red(
|
||||
'Error: The number of source and destination IDs must match'
|
||||
)
|
||||
);
|
||||
console.log(
|
||||
chalk.yellow('Example: task-master move --from=5,6,7 --to=10,11,12')
|
||||
);
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
// If moving multiple tasks
|
||||
if (sourceIds.length > 1) {
|
||||
console.log(
|
||||
chalk.blue(
|
||||
`Moving multiple tasks: ${sourceIds.join(', ')} to ${destinationIds.join(', ')}...`
|
||||
)
|
||||
);
|
||||
|
||||
// Read tasks data once to validate destination IDs
|
||||
const tasksData = readJSON(
|
||||
taskMaster.getTasksPath(),
|
||||
@@ -4110,11 +4271,17 @@ Examples:
|
||||
);
|
||||
if (!tasksData || !tasksData.tasks) {
|
||||
console.error(
|
||||
chalk.red(`Error: Invalid or missing tasks file at ${tasksPath}`)
|
||||
chalk.red(
|
||||
`Error: Invalid or missing tasks file at ${taskMaster.getTasksPath()}`
|
||||
)
|
||||
);
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
// Collect errors during move attempts
|
||||
const moveErrors = [];
|
||||
const successfulMoves = [];
|
||||
|
||||
// Move tasks one by one
|
||||
for (let i = 0; i < sourceIds.length; i++) {
|
||||
const fromId = sourceIds[i];
|
||||
@@ -4144,24 +4311,59 @@ Examples:
|
||||
`✓ Successfully moved task/subtask ${fromId} to ${toId}`
|
||||
)
|
||||
);
|
||||
successfulMoves.push({ fromId, toId });
|
||||
} catch (error) {
|
||||
const errorInfo = {
|
||||
fromId,
|
||||
toId,
|
||||
error: error.message
|
||||
};
|
||||
moveErrors.push(errorInfo);
|
||||
console.error(
|
||||
chalk.red(`Error moving ${fromId} to ${toId}: ${error.message}`)
|
||||
);
|
||||
// Continue with the next task rather than exiting
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
console.error(chalk.red(`Error: ${error.message}`));
|
||||
process.exit(1);
|
||||
}
|
||||
} else {
|
||||
// Moving a single task (existing logic)
|
||||
console.log(
|
||||
chalk.blue(`Moving task/subtask ${sourceId} to ${destinationId}...`)
|
||||
);
|
||||
|
||||
try {
|
||||
// Display summary after all moves are attempted
|
||||
if (moveErrors.length > 0) {
|
||||
console.log(chalk.yellow('\n--- Move Operation Summary ---'));
|
||||
console.log(
|
||||
chalk.green(
|
||||
`✓ Successfully moved: ${successfulMoves.length} tasks`
|
||||
)
|
||||
);
|
||||
console.log(
|
||||
chalk.red(`✗ Failed to move: ${moveErrors.length} tasks`)
|
||||
);
|
||||
|
||||
if (successfulMoves.length > 0) {
|
||||
console.log(chalk.cyan('\nSuccessful moves:'));
|
||||
successfulMoves.forEach(({ fromId, toId }) => {
|
||||
console.log(chalk.cyan(` ${fromId} → ${toId}`));
|
||||
});
|
||||
}
|
||||
|
||||
console.log(chalk.red('\nFailed moves:'));
|
||||
moveErrors.forEach(({ fromId, toId, error }) => {
|
||||
console.log(chalk.red(` ${fromId} → ${toId}: ${error}`));
|
||||
});
|
||||
|
||||
console.log(
|
||||
chalk.yellow(
|
||||
'\nNote: Some tasks were moved successfully. Check the errors above for failed moves.'
|
||||
)
|
||||
);
|
||||
} else {
|
||||
console.log(chalk.green('\n✓ All tasks moved successfully!'));
|
||||
}
|
||||
} else {
|
||||
// Moving a single task (existing logic)
|
||||
console.log(
|
||||
chalk.blue(`Moving task/subtask ${sourceId} to ${destinationId}...`)
|
||||
);
|
||||
|
||||
const result = await moveTask(
|
||||
taskMaster.getTasksPath(),
|
||||
sourceId,
|
||||
@@ -4174,11 +4376,90 @@ Examples:
|
||||
`✓ Successfully moved task/subtask ${sourceId} to ${destinationId}`
|
||||
)
|
||||
);
|
||||
} catch (error) {
|
||||
console.error(chalk.red(`Error: ${error.message}`));
|
||||
process.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
// Helper function to handle move errors
|
||||
function handleMoveError(error, moveContext) {
|
||||
console.error(chalk.red(`Error: ${error.message}`));
|
||||
|
||||
// Enhanced error handling with structured error objects
|
||||
if (error.code === 'CROSS_TAG_DEPENDENCY_CONFLICTS') {
|
||||
// Use structured error data
|
||||
const conflicts = error.data.conflicts || [];
|
||||
const taskIds = error.data.taskIds || [];
|
||||
displayCrossTagDependencyError(
|
||||
conflicts,
|
||||
moveContext.sourceTag,
|
||||
moveContext.toTag,
|
||||
taskIds.join(', ')
|
||||
);
|
||||
} else if (error.code === 'CANNOT_MOVE_SUBTASK') {
|
||||
// Use structured error data
|
||||
const taskId =
|
||||
error.data.taskId || moveContext.sourceId?.split(',')[0];
|
||||
displaySubtaskMoveError(
|
||||
taskId,
|
||||
moveContext.sourceTag,
|
||||
moveContext.toTag
|
||||
);
|
||||
} else if (
|
||||
error.code === 'SOURCE_TARGET_TAGS_SAME' ||
|
||||
error.code === 'SAME_SOURCE_TARGET_TAG'
|
||||
) {
|
||||
displayInvalidTagCombinationError(
|
||||
moveContext.sourceTag,
|
||||
moveContext.toTag,
|
||||
'Source and target tags are identical'
|
||||
);
|
||||
} else {
|
||||
// General error - show dependency validation hints
|
||||
displayDependencyValidationHints('after-error');
|
||||
}
|
||||
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
// Initialize TaskMaster
|
||||
const taskMaster = initTaskMaster({
|
||||
tasksPath: options.file || true,
|
||||
tag: options.tag
|
||||
});
|
||||
|
||||
const sourceId = options.from;
|
||||
const destinationId = options.to;
|
||||
const fromTag = options.fromTag;
|
||||
const toTag = options.toTag;
|
||||
|
||||
const tag = taskMaster.getCurrentTag();
|
||||
|
||||
// Get the source tag - fallback to current tag if not provided
|
||||
const sourceTag = fromTag || taskMaster.getCurrentTag();
|
||||
|
||||
// Check if this is a cross-tag move (different tags)
|
||||
const isCrossTagMove = sourceTag && toTag && sourceTag !== toTag;
|
||||
|
||||
// Initialize move context with all relevant data
|
||||
const moveContext = {
|
||||
sourceId,
|
||||
destinationId,
|
||||
sourceTag,
|
||||
toTag,
|
||||
tag,
|
||||
taskMaster
|
||||
};
|
||||
|
||||
try {
|
||||
if (isCrossTagMove) {
|
||||
// Cross-tag move logic
|
||||
await handleCrossTagMove(moveContext, options);
|
||||
} else {
|
||||
// Within-tag move logic
|
||||
await handleWithinTagMove(moveContext);
|
||||
}
|
||||
} catch (error) {
|
||||
handleMoveError(error, moveContext);
|
||||
}
|
||||
});
|
||||
|
||||
// Add/remove profile rules command
|
||||
@@ -4598,7 +4879,7 @@ Examples:
|
||||
const gitUtils = await import('./utils/git-utils.js');
|
||||
|
||||
// Check if we're in a git repository
|
||||
if (!(await gitUtils.isGitRepository(projectRoot))) {
|
||||
if (!(await gitUtils.isGitRepository(context.projectRoot))) {
|
||||
console.error(
|
||||
chalk.red(
|
||||
'Error: Not in a git repository. Cannot use --from-branch option.'
|
||||
@@ -4608,7 +4889,9 @@ Examples:
|
||||
}
|
||||
|
||||
// Get current git branch
|
||||
const currentBranch = await gitUtils.getCurrentBranch(projectRoot);
|
||||
const currentBranch = await gitUtils.getCurrentBranch(
|
||||
context.projectRoot
|
||||
);
|
||||
if (!currentBranch) {
|
||||
console.error(
|
||||
chalk.red('Error: Could not determine current git branch.')
|
||||
|
||||
@@ -14,12 +14,35 @@ import {
|
||||
taskExists,
|
||||
formatTaskId,
|
||||
findCycles,
|
||||
traverseDependencies,
|
||||
isSilentMode
|
||||
} from './utils.js';
|
||||
|
||||
import { displayBanner } from './ui.js';
|
||||
|
||||
import { generateTaskFiles } from './task-manager.js';
|
||||
import generateTaskFiles from './task-manager/generate-task-files.js';
|
||||
|
||||
/**
|
||||
* Structured error class for dependency operations
|
||||
*/
|
||||
class DependencyError extends Error {
|
||||
constructor(code, message, data = {}) {
|
||||
super(message);
|
||||
this.name = 'DependencyError';
|
||||
this.code = code;
|
||||
this.data = data;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Error codes for dependency operations
|
||||
*/
|
||||
const DEPENDENCY_ERROR_CODES = {
|
||||
CANNOT_MOVE_SUBTASK: 'CANNOT_MOVE_SUBTASK',
|
||||
INVALID_TASK_ID: 'INVALID_TASK_ID',
|
||||
INVALID_SOURCE_TAG: 'INVALID_SOURCE_TAG',
|
||||
INVALID_TARGET_TAG: 'INVALID_TARGET_TAG'
|
||||
};
|
||||
|
||||
/**
|
||||
* Add a dependency to a task
|
||||
@@ -1235,6 +1258,580 @@ function validateAndFixDependencies(
|
||||
return changesDetected;
|
||||
}
|
||||
|
||||
/**
|
||||
* Recursively find all dependencies for a set of tasks with depth limiting
|
||||
* Recursively find all dependencies for a set of tasks with depth limiting
|
||||
*
|
||||
* @note This function depends on the traverseDependencies utility from utils.js
|
||||
* for the actual dependency traversal logic.
|
||||
*
|
||||
* @param {Array} sourceTasks - Array of source tasks to find dependencies for
|
||||
* @param {Array} allTasks - Array of all available tasks
|
||||
* @param {Object} options - Options object
|
||||
* @param {number} options.maxDepth - Maximum recursion depth (default: 50)
|
||||
* @param {boolean} options.includeSelf - Whether to include self-references (default: false)
|
||||
* @returns {Array} Array of all dependency task IDs
|
||||
*/
|
||||
function findAllDependenciesRecursively(sourceTasks, allTasks, options = {}) {
|
||||
if (!Array.isArray(sourceTasks)) {
|
||||
throw new Error('Source tasks parameter must be an array');
|
||||
}
|
||||
if (!Array.isArray(allTasks)) {
|
||||
throw new Error('All tasks parameter must be an array');
|
||||
}
|
||||
return traverseDependencies(sourceTasks, allTasks, {
|
||||
...options,
|
||||
direction: 'forward',
|
||||
logger: { warn: log.warn || console.warn }
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Find dependency task by ID, handling various ID formats
|
||||
* @param {string|number} depId - Dependency ID to find
|
||||
* @param {string} taskId - ID of the task that has this dependency
|
||||
* @param {Array} allTasks - Array of all tasks to search
|
||||
* @returns {Object|null} Found dependency task or null
|
||||
*/
|
||||
/**
|
||||
* Find a subtask within a parent task's subtasks array
|
||||
* @param {string} parentId - The parent task ID
|
||||
* @param {string|number} subtaskId - The subtask ID to find
|
||||
* @param {Array} allTasks - Array of all tasks to search in
|
||||
* @param {boolean} useStringComparison - Whether to use string comparison for subtaskId
|
||||
* @returns {Object|null} The found subtask with full ID or null if not found
|
||||
*/
|
||||
function findSubtaskInParent(
|
||||
parentId,
|
||||
subtaskId,
|
||||
allTasks,
|
||||
useStringComparison = false
|
||||
) {
|
||||
// Convert parentId to numeric for proper comparison with top-level task IDs
|
||||
const numericParentId = parseInt(parentId, 10);
|
||||
const parentTask = allTasks.find((t) => t.id === numericParentId);
|
||||
|
||||
if (parentTask && parentTask.subtasks && Array.isArray(parentTask.subtasks)) {
|
||||
const foundSubtask = parentTask.subtasks.find((subtask) =>
|
||||
useStringComparison
|
||||
? String(subtask.id) === String(subtaskId)
|
||||
: subtask.id === subtaskId
|
||||
);
|
||||
if (foundSubtask) {
|
||||
// Return a task-like object that represents the subtask with full ID
|
||||
return {
|
||||
...foundSubtask,
|
||||
id: `${parentId}.${foundSubtask.id}`
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
function findDependencyTask(depId, taskId, allTasks) {
|
||||
if (!depId) {
|
||||
return null;
|
||||
}
|
||||
|
||||
// Convert depId to string for consistent comparison
|
||||
const depIdStr = String(depId);
|
||||
|
||||
// Find the dependency task - handle both top-level and subtask IDs
|
||||
let depTask = null;
|
||||
|
||||
// First try exact match (for top-level tasks)
|
||||
depTask = allTasks.find((t) => String(t.id) === depIdStr);
|
||||
|
||||
// If not found and it's a subtask reference (contains dot), find the parent task first
|
||||
if (!depTask && depIdStr.includes('.')) {
|
||||
const [parentId, subtaskId] = depIdStr.split('.');
|
||||
depTask = findSubtaskInParent(parentId, subtaskId, allTasks, true);
|
||||
}
|
||||
|
||||
// If still not found, try numeric comparison for relative subtask references
|
||||
if (!depTask && !isNaN(depId)) {
|
||||
const numericId = parseInt(depId, 10);
|
||||
// For subtasks, this might be a relative reference within the same parent
|
||||
if (taskId && typeof taskId === 'string' && taskId.includes('.')) {
|
||||
const [parentId] = taskId.split('.');
|
||||
depTask = findSubtaskInParent(parentId, numericId, allTasks, false);
|
||||
}
|
||||
}
|
||||
|
||||
return depTask;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a task has cross-tag dependencies
|
||||
* @param {Object} task - Task to check
|
||||
* @param {string} targetTag - Target tag name
|
||||
* @param {Array} allTasks - Array of all tasks from all tags
|
||||
* @returns {Array} Array of cross-tag dependency conflicts
|
||||
*/
|
||||
function findTaskCrossTagConflicts(task, targetTag, allTasks) {
|
||||
const conflicts = [];
|
||||
|
||||
// Validate task.dependencies is an array before processing
|
||||
if (!Array.isArray(task.dependencies) || task.dependencies.length === 0) {
|
||||
return conflicts;
|
||||
}
|
||||
|
||||
// Filter out null/undefined dependencies and check each valid dependency
|
||||
const validDependencies = task.dependencies.filter((depId) => depId != null);
|
||||
|
||||
validDependencies.forEach((depId) => {
|
||||
const depTask = findDependencyTask(depId, task.id, allTasks);
|
||||
|
||||
if (depTask && depTask.tag !== targetTag) {
|
||||
conflicts.push({
|
||||
taskId: task.id,
|
||||
dependencyId: depId,
|
||||
dependencyTag: depTask.tag,
|
||||
message: `Task ${task.id} depends on ${depId} (in ${depTask.tag})`
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
return conflicts;
|
||||
}
|
||||
|
||||
function validateCrossTagMove(task, sourceTag, targetTag, allTasks) {
|
||||
// Parameter validation
|
||||
if (!task || typeof task !== 'object') {
|
||||
throw new Error('Task parameter must be a valid object');
|
||||
}
|
||||
|
||||
if (!sourceTag || typeof sourceTag !== 'string') {
|
||||
throw new Error('Source tag must be a valid string');
|
||||
}
|
||||
|
||||
if (!targetTag || typeof targetTag !== 'string') {
|
||||
throw new Error('Target tag must be a valid string');
|
||||
}
|
||||
|
||||
if (!Array.isArray(allTasks)) {
|
||||
throw new Error('All tasks parameter must be an array');
|
||||
}
|
||||
|
||||
const conflicts = findTaskCrossTagConflicts(task, targetTag, allTasks);
|
||||
|
||||
return {
|
||||
canMove: conflicts.length === 0,
|
||||
conflicts
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Find all cross-tag dependencies for a set of tasks
|
||||
* @param {Array} sourceTasks - Array of tasks to check
|
||||
* @param {string} sourceTag - Source tag name
|
||||
* @param {string} targetTag - Target tag name
|
||||
* @param {Array} allTasks - Array of all tasks from all tags
|
||||
* @returns {Array} Array of cross-tag dependency conflicts
|
||||
*/
|
||||
function findCrossTagDependencies(sourceTasks, sourceTag, targetTag, allTasks) {
|
||||
// Parameter validation
|
||||
if (!Array.isArray(sourceTasks)) {
|
||||
throw new Error('Source tasks parameter must be an array');
|
||||
}
|
||||
|
||||
if (!sourceTag || typeof sourceTag !== 'string') {
|
||||
throw new Error('Source tag must be a valid string');
|
||||
}
|
||||
|
||||
if (!targetTag || typeof targetTag !== 'string') {
|
||||
throw new Error('Target tag must be a valid string');
|
||||
}
|
||||
|
||||
if (!Array.isArray(allTasks)) {
|
||||
throw new Error('All tasks parameter must be an array');
|
||||
}
|
||||
|
||||
const conflicts = [];
|
||||
|
||||
sourceTasks.forEach((task) => {
|
||||
// Validate task object and dependencies array
|
||||
if (
|
||||
!task ||
|
||||
typeof task !== 'object' ||
|
||||
!Array.isArray(task.dependencies) ||
|
||||
task.dependencies.length === 0
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Use the shared helper function to find conflicts for this task
|
||||
const taskConflicts = findTaskCrossTagConflicts(task, targetTag, allTasks);
|
||||
conflicts.push(...taskConflicts);
|
||||
});
|
||||
|
||||
return conflicts;
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function to find all tasks that depend on a given task (reverse dependencies)
|
||||
* @param {string|number} taskId - The task ID to find dependencies for
|
||||
* @param {Array} allTasks - Array of all tasks to search
|
||||
* @param {Set} dependentTaskIds - Set to add found dependencies to
|
||||
*/
|
||||
function findTasksThatDependOn(taskId, allTasks, dependentTaskIds) {
|
||||
// Find the task object for the given ID
|
||||
const sourceTask = allTasks.find((t) => t.id === taskId);
|
||||
if (!sourceTask) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Use the shared utility for reverse dependency traversal
|
||||
const reverseDeps = traverseDependencies([sourceTask], allTasks, {
|
||||
direction: 'reverse',
|
||||
includeSelf: false,
|
||||
logger: { warn: log.warn || console.warn }
|
||||
});
|
||||
|
||||
// Add all found reverse dependencies to the dependentTaskIds set
|
||||
reverseDeps.forEach((depId) => dependentTaskIds.add(depId));
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function to check if a task depends on a source task
|
||||
* @param {Object} task - Task to check for dependencies
|
||||
* @param {Object} sourceTask - Source task to check dependency against
|
||||
* @returns {boolean} True if task depends on source task
|
||||
*/
|
||||
function taskDependsOnSource(task, sourceTask) {
|
||||
if (!task || !Array.isArray(task.dependencies)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const sourceTaskIdStr = String(sourceTask.id);
|
||||
|
||||
return task.dependencies.some((depId) => {
|
||||
if (!depId) return false;
|
||||
|
||||
const depIdStr = String(depId);
|
||||
|
||||
// Exact match
|
||||
if (depIdStr === sourceTaskIdStr) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// Handle subtask references
|
||||
if (
|
||||
sourceTaskIdStr &&
|
||||
typeof sourceTaskIdStr === 'string' &&
|
||||
sourceTaskIdStr.includes('.')
|
||||
) {
|
||||
// If source is a subtask, check if dependency references the parent
|
||||
const [parentId] = sourceTaskIdStr.split('.');
|
||||
if (depIdStr === parentId) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// Handle relative subtask references
|
||||
if (
|
||||
depIdStr &&
|
||||
typeof depIdStr === 'string' &&
|
||||
depIdStr.includes('.') &&
|
||||
sourceTaskIdStr &&
|
||||
typeof sourceTaskIdStr === 'string' &&
|
||||
sourceTaskIdStr.includes('.')
|
||||
) {
|
||||
const [depParentId] = depIdStr.split('.');
|
||||
const [sourceParentId] = sourceTaskIdStr.split('.');
|
||||
if (depParentId === sourceParentId) {
|
||||
// Both are subtasks of the same parent, check if they reference each other
|
||||
const depSubtaskNum = parseInt(depIdStr.split('.')[1], 10);
|
||||
const sourceSubtaskNum = parseInt(sourceTaskIdStr.split('.')[1], 10);
|
||||
if (depSubtaskNum === sourceSubtaskNum) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function to check if any subtasks of a task depend on source tasks
|
||||
* @param {Object} task - Task to check subtasks of
|
||||
* @param {Array} sourceTasks - Array of source tasks to check dependencies against
|
||||
* @returns {boolean} True if any subtasks depend on source tasks
|
||||
*/
|
||||
function subtasksDependOnSource(task, sourceTasks) {
|
||||
if (!task.subtasks || !Array.isArray(task.subtasks)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return task.subtasks.some((subtask) => {
|
||||
// Check if this subtask depends on any source task
|
||||
const subtaskDependsOnSource = sourceTasks.some((sourceTask) =>
|
||||
taskDependsOnSource(subtask, sourceTask)
|
||||
);
|
||||
|
||||
if (subtaskDependsOnSource) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// Recursively check if any nested subtasks depend on source tasks
|
||||
if (subtask.subtasks && Array.isArray(subtask.subtasks)) {
|
||||
return subtasksDependOnSource(subtask, sourceTasks);
|
||||
}
|
||||
|
||||
return false;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all dependent task IDs for a set of cross-tag dependencies
|
||||
* @param {Array} sourceTasks - Array of source tasks
|
||||
* @param {Array} crossTagDependencies - Array of cross-tag dependency conflicts
|
||||
* @param {Array} allTasks - Array of all tasks from all tags
|
||||
* @returns {Array} Array of dependent task IDs to move
|
||||
*/
|
||||
function getDependentTaskIds(sourceTasks, crossTagDependencies, allTasks) {
|
||||
// Enhanced parameter validation
|
||||
if (!Array.isArray(sourceTasks)) {
|
||||
throw new Error('Source tasks parameter must be an array');
|
||||
}
|
||||
|
||||
if (!Array.isArray(crossTagDependencies)) {
|
||||
throw new Error('Cross tag dependencies parameter must be an array');
|
||||
}
|
||||
|
||||
if (!Array.isArray(allTasks)) {
|
||||
throw new Error('All tasks parameter must be an array');
|
||||
}
|
||||
|
||||
// Use the shared recursive dependency finder
|
||||
const dependentTaskIds = new Set(
|
||||
findAllDependenciesRecursively(sourceTasks, allTasks, {
|
||||
includeSelf: false
|
||||
})
|
||||
);
|
||||
|
||||
// Add immediate dependency IDs from conflicts and find their dependencies recursively
|
||||
const conflictTasksToProcess = [];
|
||||
crossTagDependencies.forEach((conflict) => {
|
||||
if (conflict && conflict.dependencyId) {
|
||||
const depId =
|
||||
typeof conflict.dependencyId === 'string'
|
||||
? parseInt(conflict.dependencyId, 10)
|
||||
: conflict.dependencyId;
|
||||
if (!isNaN(depId)) {
|
||||
dependentTaskIds.add(depId);
|
||||
// Find the task object for recursive dependency finding
|
||||
const depTask = allTasks.find((t) => t.id === depId);
|
||||
if (depTask) {
|
||||
conflictTasksToProcess.push(depTask);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// Find dependencies of conflict tasks
|
||||
if (conflictTasksToProcess.length > 0) {
|
||||
const conflictDependencies = findAllDependenciesRecursively(
|
||||
conflictTasksToProcess,
|
||||
allTasks,
|
||||
{ includeSelf: false }
|
||||
);
|
||||
conflictDependencies.forEach((depId) => dependentTaskIds.add(depId));
|
||||
}
|
||||
|
||||
// For --with-dependencies, we also need to find all dependencies of the source tasks
|
||||
sourceTasks.forEach((sourceTask) => {
|
||||
if (sourceTask && sourceTask.id) {
|
||||
// Find all tasks that this source task depends on (forward dependencies) - already handled above
|
||||
|
||||
// Find all tasks that depend on this source task (reverse dependencies)
|
||||
findTasksThatDependOn(sourceTask.id, allTasks, dependentTaskIds);
|
||||
}
|
||||
});
|
||||
|
||||
// Also include any tasks that depend on the source tasks
|
||||
sourceTasks.forEach((sourceTask) => {
|
||||
if (!sourceTask || typeof sourceTask !== 'object' || !sourceTask.id) {
|
||||
return; // Skip invalid source tasks
|
||||
}
|
||||
|
||||
allTasks.forEach((task) => {
|
||||
// Validate task and dependencies array
|
||||
if (
|
||||
!task ||
|
||||
typeof task !== 'object' ||
|
||||
!Array.isArray(task.dependencies)
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if this task depends on the source task
|
||||
const hasDependency = taskDependsOnSource(task, sourceTask);
|
||||
|
||||
// Check if any subtasks of this task depend on the source task
|
||||
const subtasksHaveDependency = subtasksDependOnSource(task, [sourceTask]);
|
||||
|
||||
if (hasDependency || subtasksHaveDependency) {
|
||||
dependentTaskIds.add(task.id);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
return Array.from(dependentTaskIds);
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate subtask movement - block direct cross-tag subtask moves
|
||||
* @param {string} taskId - Task ID to validate
|
||||
* @param {string} sourceTag - Source tag name
|
||||
* @param {string} targetTag - Target tag name
|
||||
* @throws {Error} If subtask movement is attempted
|
||||
*/
|
||||
function validateSubtaskMove(taskId, sourceTag, targetTag) {
|
||||
// Parameter validation
|
||||
if (!taskId || typeof taskId !== 'string') {
|
||||
throw new DependencyError(
|
||||
DEPENDENCY_ERROR_CODES.INVALID_TASK_ID,
|
||||
'Task ID must be a valid string'
|
||||
);
|
||||
}
|
||||
|
||||
if (!sourceTag || typeof sourceTag !== 'string') {
|
||||
throw new DependencyError(
|
||||
DEPENDENCY_ERROR_CODES.INVALID_SOURCE_TAG,
|
||||
'Source tag must be a valid string'
|
||||
);
|
||||
}
|
||||
|
||||
if (!targetTag || typeof targetTag !== 'string') {
|
||||
throw new DependencyError(
|
||||
DEPENDENCY_ERROR_CODES.INVALID_TARGET_TAG,
|
||||
'Target tag must be a valid string'
|
||||
);
|
||||
}
|
||||
|
||||
if (taskId.includes('.')) {
|
||||
throw new DependencyError(
|
||||
DEPENDENCY_ERROR_CODES.CANNOT_MOVE_SUBTASK,
|
||||
`Cannot move subtask ${taskId} directly between tags.
|
||||
|
||||
First promote it to a full task using:
|
||||
task-master remove-subtask --id=${taskId} --convert`,
|
||||
{
|
||||
taskId,
|
||||
sourceTag,
|
||||
targetTag
|
||||
}
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a task can be moved with its dependencies
|
||||
* @param {string} taskId - Task ID to check
|
||||
* @param {string} sourceTag - Source tag name
|
||||
* @param {string} targetTag - Target tag name
|
||||
* @param {Array} allTasks - Array of all tasks from all tags
|
||||
* @returns {Object} Object with canMove boolean and dependentTaskIds array
|
||||
*/
|
||||
function canMoveWithDependencies(taskId, sourceTag, targetTag, allTasks) {
|
||||
// Parameter validation
|
||||
if (!taskId || typeof taskId !== 'string') {
|
||||
throw new Error('Task ID must be a valid string');
|
||||
}
|
||||
|
||||
if (!sourceTag || typeof sourceTag !== 'string') {
|
||||
throw new Error('Source tag must be a valid string');
|
||||
}
|
||||
|
||||
if (!targetTag || typeof targetTag !== 'string') {
|
||||
throw new Error('Target tag must be a valid string');
|
||||
}
|
||||
|
||||
if (!Array.isArray(allTasks)) {
|
||||
throw new Error('All tasks parameter must be an array');
|
||||
}
|
||||
|
||||
// Enhanced task lookup to handle subtasks properly
|
||||
let sourceTask = null;
|
||||
|
||||
// Check if it's a subtask ID (e.g., "1.2")
|
||||
if (taskId.includes('.')) {
|
||||
const [parentId, subtaskId] = taskId
|
||||
.split('.')
|
||||
.map((id) => parseInt(id, 10));
|
||||
const parentTask = allTasks.find(
|
||||
(t) => t.id === parentId && t.tag === sourceTag
|
||||
);
|
||||
|
||||
if (
|
||||
parentTask &&
|
||||
parentTask.subtasks &&
|
||||
Array.isArray(parentTask.subtasks)
|
||||
) {
|
||||
const subtask = parentTask.subtasks.find((st) => st.id === subtaskId);
|
||||
if (subtask) {
|
||||
// Create a copy of the subtask with parent context
|
||||
sourceTask = {
|
||||
...subtask,
|
||||
parentTask: {
|
||||
id: parentTask.id,
|
||||
title: parentTask.title,
|
||||
status: parentTask.status
|
||||
},
|
||||
isSubtask: true
|
||||
};
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// Regular task lookup - handle both string and numeric IDs
|
||||
sourceTask = allTasks.find((t) => {
|
||||
const taskIdNum = parseInt(taskId, 10);
|
||||
return (t.id === taskIdNum || t.id === taskId) && t.tag === sourceTag;
|
||||
});
|
||||
}
|
||||
|
||||
if (!sourceTask) {
|
||||
return {
|
||||
canMove: false,
|
||||
dependentTaskIds: [],
|
||||
conflicts: [],
|
||||
error: 'Task not found'
|
||||
};
|
||||
}
|
||||
|
||||
const validation = validateCrossTagMove(
|
||||
sourceTask,
|
||||
sourceTag,
|
||||
targetTag,
|
||||
allTasks
|
||||
);
|
||||
|
||||
// Fix contradictory logic: return canMove: false when conflicts exist
|
||||
if (validation.canMove) {
|
||||
return {
|
||||
canMove: true,
|
||||
dependentTaskIds: [],
|
||||
conflicts: []
|
||||
};
|
||||
}
|
||||
|
||||
// When conflicts exist, return canMove: false with conflicts and dependent task IDs
|
||||
const dependentTaskIds = getDependentTaskIds(
|
||||
[sourceTask],
|
||||
validation.conflicts,
|
||||
allTasks
|
||||
);
|
||||
|
||||
return {
|
||||
canMove: false,
|
||||
dependentTaskIds,
|
||||
conflicts: validation.conflicts
|
||||
};
|
||||
}
|
||||
|
||||
export {
|
||||
addDependency,
|
||||
removeDependency,
|
||||
@@ -1245,5 +1842,15 @@ export {
|
||||
removeDuplicateDependencies,
|
||||
cleanupSubtaskDependencies,
|
||||
ensureAtLeastOneIndependentSubtask,
|
||||
validateAndFixDependencies
|
||||
validateAndFixDependencies,
|
||||
findDependencyTask,
|
||||
findTaskCrossTagConflicts,
|
||||
validateCrossTagMove,
|
||||
findCrossTagDependencies,
|
||||
getDependentTaskIds,
|
||||
validateSubtaskMove,
|
||||
canMoveWithDependencies,
|
||||
findAllDependenciesRecursively,
|
||||
DependencyError,
|
||||
DEPENDENCY_ERROR_CODES
|
||||
};
|
||||
|
||||
@@ -1,7 +1,65 @@
|
||||
import path from 'path';
|
||||
import { log, readJSON, writeJSON, setTasksForTag } from '../utils.js';
|
||||
import { isTaskDependentOn } from '../task-manager.js';
|
||||
import {
|
||||
log,
|
||||
readJSON,
|
||||
writeJSON,
|
||||
setTasksForTag,
|
||||
traverseDependencies
|
||||
} from '../utils.js';
|
||||
import generateTaskFiles from './generate-task-files.js';
|
||||
import {
|
||||
findCrossTagDependencies,
|
||||
getDependentTaskIds,
|
||||
validateSubtaskMove
|
||||
} from '../dependency-manager.js';
|
||||
|
||||
/**
|
||||
* Find all dependencies recursively for a set of source tasks with depth limiting
|
||||
* @param {Array} sourceTasks - The source tasks to find dependencies for
|
||||
* @param {Array} allTasks - All available tasks from all tags
|
||||
* @param {Object} options - Options object
|
||||
* @param {number} options.maxDepth - Maximum recursion depth (default: 50)
|
||||
* @param {boolean} options.includeSelf - Whether to include self-references (default: false)
|
||||
* @returns {Array} Array of all dependency task IDs
|
||||
*/
|
||||
function findAllDependenciesRecursively(sourceTasks, allTasks, options = {}) {
|
||||
return traverseDependencies(sourceTasks, allTasks, {
|
||||
...options,
|
||||
direction: 'forward',
|
||||
logger: { warn: console.warn }
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Structured error class for move operations
|
||||
*/
|
||||
class MoveTaskError extends Error {
|
||||
constructor(code, message, data = {}) {
|
||||
super(message);
|
||||
this.name = 'MoveTaskError';
|
||||
this.code = code;
|
||||
this.data = data;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Error codes for move operations
|
||||
*/
|
||||
const MOVE_ERROR_CODES = {
|
||||
CROSS_TAG_DEPENDENCY_CONFLICTS: 'CROSS_TAG_DEPENDENCY_CONFLICTS',
|
||||
CANNOT_MOVE_SUBTASK: 'CANNOT_MOVE_SUBTASK',
|
||||
SOURCE_TARGET_TAGS_SAME: 'SOURCE_TARGET_TAGS_SAME',
|
||||
TASK_NOT_FOUND: 'TASK_NOT_FOUND',
|
||||
SUBTASK_NOT_FOUND: 'SUBTASK_NOT_FOUND',
|
||||
PARENT_TASK_NOT_FOUND: 'PARENT_TASK_NOT_FOUND',
|
||||
PARENT_TASK_NO_SUBTASKS: 'PARENT_TASK_NO_SUBTASKS',
|
||||
DESTINATION_TASK_NOT_FOUND: 'DESTINATION_TASK_NOT_FOUND',
|
||||
TASK_ALREADY_EXISTS: 'TASK_ALREADY_EXISTS',
|
||||
INVALID_TASKS_FILE: 'INVALID_TASKS_FILE',
|
||||
ID_COUNT_MISMATCH: 'ID_COUNT_MISMATCH',
|
||||
INVALID_SOURCE_TAG: 'INVALID_SOURCE_TAG',
|
||||
INVALID_TARGET_TAG: 'INVALID_TARGET_TAG'
|
||||
};
|
||||
|
||||
/**
|
||||
* Move one or more tasks/subtasks to new positions
|
||||
@@ -27,7 +85,8 @@ async function moveTask(
|
||||
const destinationIds = destinationId.split(',').map((id) => id.trim());
|
||||
|
||||
if (sourceIds.length !== destinationIds.length) {
|
||||
throw new Error(
|
||||
throw new MoveTaskError(
|
||||
MOVE_ERROR_CODES.ID_COUNT_MISMATCH,
|
||||
`Number of source IDs (${sourceIds.length}) must match number of destination IDs (${destinationIds.length})`
|
||||
);
|
||||
}
|
||||
@@ -72,7 +131,8 @@ async function moveTask(
|
||||
|
||||
// Ensure the tag exists in the raw data
|
||||
if (!rawData || !rawData[tag] || !Array.isArray(rawData[tag].tasks)) {
|
||||
throw new Error(
|
||||
throw new MoveTaskError(
|
||||
MOVE_ERROR_CODES.INVALID_TASKS_FILE,
|
||||
`Invalid tasks file or tag "${tag}" not found at ${tasksPath}`
|
||||
);
|
||||
}
|
||||
@@ -137,10 +197,14 @@ function moveSubtaskToSubtask(tasks, sourceId, destinationId) {
|
||||
const destParentTask = tasks.find((t) => t.id === destParentId);
|
||||
|
||||
if (!sourceParentTask) {
|
||||
throw new Error(`Source parent task with ID ${sourceParentId} not found`);
|
||||
throw new MoveTaskError(
|
||||
MOVE_ERROR_CODES.PARENT_TASK_NOT_FOUND,
|
||||
`Source parent task with ID ${sourceParentId} not found`
|
||||
);
|
||||
}
|
||||
if (!destParentTask) {
|
||||
throw new Error(
|
||||
throw new MoveTaskError(
|
||||
MOVE_ERROR_CODES.PARENT_TASK_NOT_FOUND,
|
||||
`Destination parent task with ID ${destParentId} not found`
|
||||
);
|
||||
}
|
||||
@@ -158,7 +222,10 @@ function moveSubtaskToSubtask(tasks, sourceId, destinationId) {
|
||||
(st) => st.id === sourceSubtaskId
|
||||
);
|
||||
if (sourceSubtaskIndex === -1) {
|
||||
throw new Error(`Source subtask ${sourceId} not found`);
|
||||
throw new MoveTaskError(
|
||||
MOVE_ERROR_CODES.SUBTASK_NOT_FOUND,
|
||||
`Source subtask ${sourceId} not found`
|
||||
);
|
||||
}
|
||||
|
||||
const sourceSubtask = sourceParentTask.subtasks[sourceSubtaskIndex];
|
||||
@@ -216,10 +283,16 @@ function moveSubtaskToTask(tasks, sourceId, destinationId) {
|
||||
const sourceParentTask = tasks.find((t) => t.id === sourceParentId);
|
||||
|
||||
if (!sourceParentTask) {
|
||||
throw new Error(`Source parent task with ID ${sourceParentId} not found`);
|
||||
throw new MoveTaskError(
|
||||
MOVE_ERROR_CODES.PARENT_TASK_NOT_FOUND,
|
||||
`Source parent task with ID ${sourceParentId} not found`
|
||||
);
|
||||
}
|
||||
if (!sourceParentTask.subtasks) {
|
||||
throw new Error(`Source parent task ${sourceParentId} has no subtasks`);
|
||||
throw new MoveTaskError(
|
||||
MOVE_ERROR_CODES.PARENT_TASK_NO_SUBTASKS,
|
||||
`Source parent task ${sourceParentId} has no subtasks`
|
||||
);
|
||||
}
|
||||
|
||||
// Find source subtask
|
||||
@@ -227,7 +300,10 @@ function moveSubtaskToTask(tasks, sourceId, destinationId) {
|
||||
(st) => st.id === sourceSubtaskId
|
||||
);
|
||||
if (sourceSubtaskIndex === -1) {
|
||||
throw new Error(`Source subtask ${sourceId} not found`);
|
||||
throw new MoveTaskError(
|
||||
MOVE_ERROR_CODES.SUBTASK_NOT_FOUND,
|
||||
`Source subtask ${sourceId} not found`
|
||||
);
|
||||
}
|
||||
|
||||
const sourceSubtask = sourceParentTask.subtasks[sourceSubtaskIndex];
|
||||
@@ -235,7 +311,8 @@ function moveSubtaskToTask(tasks, sourceId, destinationId) {
|
||||
// Check if destination task exists
|
||||
const existingDestTask = tasks.find((t) => t.id === destTaskId);
|
||||
if (existingDestTask) {
|
||||
throw new Error(
|
||||
throw new MoveTaskError(
|
||||
MOVE_ERROR_CODES.TASK_ALREADY_EXISTS,
|
||||
`Cannot move to existing task ID ${destTaskId}. Choose a different ID or use subtask destination.`
|
||||
);
|
||||
}
|
||||
@@ -282,10 +359,14 @@ function moveTaskToSubtask(tasks, sourceId, destinationId) {
|
||||
const destParentTask = tasks.find((t) => t.id === destParentId);
|
||||
|
||||
if (sourceTaskIndex === -1) {
|
||||
throw new Error(`Source task with ID ${sourceTaskId} not found`);
|
||||
throw new MoveTaskError(
|
||||
MOVE_ERROR_CODES.TASK_NOT_FOUND,
|
||||
`Source task with ID ${sourceTaskId} not found`
|
||||
);
|
||||
}
|
||||
if (!destParentTask) {
|
||||
throw new Error(
|
||||
throw new MoveTaskError(
|
||||
MOVE_ERROR_CODES.PARENT_TASK_NOT_FOUND,
|
||||
`Destination parent task with ID ${destParentId} not found`
|
||||
);
|
||||
}
|
||||
@@ -340,7 +421,10 @@ function moveTaskToTask(tasks, sourceId, destinationId) {
|
||||
// Find source task
|
||||
const sourceTaskIndex = tasks.findIndex((t) => t.id === sourceTaskId);
|
||||
if (sourceTaskIndex === -1) {
|
||||
throw new Error(`Source task with ID ${sourceTaskId} not found`);
|
||||
throw new MoveTaskError(
|
||||
MOVE_ERROR_CODES.TASK_NOT_FOUND,
|
||||
`Source task with ID ${sourceTaskId} not found`
|
||||
);
|
||||
}
|
||||
|
||||
const sourceTask = tasks[sourceTaskIndex];
|
||||
@@ -353,7 +437,8 @@ function moveTaskToTask(tasks, sourceId, destinationId) {
|
||||
const destTask = tasks[destTaskIndex];
|
||||
|
||||
// For now, throw an error to avoid accidental overwrites
|
||||
throw new Error(
|
||||
throw new MoveTaskError(
|
||||
MOVE_ERROR_CODES.TASK_ALREADY_EXISTS,
|
||||
`Task with ID ${destTaskId} already exists. Use a different destination ID.`
|
||||
);
|
||||
} else {
|
||||
@@ -478,4 +563,434 @@ function moveTaskToNewId(tasks, sourceTaskIndex, sourceTask, destTaskId) {
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all tasks from all tags with tag information
|
||||
* @param {Object} rawData - The raw tagged data object
|
||||
* @returns {Array} A flat array of all task objects with tag property
|
||||
*/
|
||||
function getAllTasksWithTags(rawData) {
|
||||
let allTasks = [];
|
||||
for (const tagName in rawData) {
|
||||
if (
|
||||
Object.prototype.hasOwnProperty.call(rawData, tagName) &&
|
||||
rawData[tagName] &&
|
||||
Array.isArray(rawData[tagName].tasks)
|
||||
) {
|
||||
const tasksWithTag = rawData[tagName].tasks.map((task) => ({
|
||||
...task,
|
||||
tag: tagName
|
||||
}));
|
||||
allTasks = allTasks.concat(tasksWithTag);
|
||||
}
|
||||
}
|
||||
return allTasks;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate move operation parameters and data
|
||||
* @param {string} tasksPath - Path to tasks.json file
|
||||
* @param {Array} taskIds - Array of task IDs to move
|
||||
* @param {string} sourceTag - Source tag name
|
||||
* @param {string} targetTag - Target tag name
|
||||
* @param {Object} context - Context object
|
||||
* @returns {Object} Validation result with rawData and sourceTasks
|
||||
*/
|
||||
async function validateMove(tasksPath, taskIds, sourceTag, targetTag, context) {
|
||||
const { projectRoot } = context;
|
||||
|
||||
// Read the raw data without tag resolution to preserve tagged structure
|
||||
let rawData = readJSON(tasksPath, projectRoot, sourceTag);
|
||||
|
||||
// Handle the case where readJSON returns resolved data with _rawTaggedData
|
||||
if (rawData && rawData._rawTaggedData) {
|
||||
rawData = rawData._rawTaggedData;
|
||||
}
|
||||
|
||||
// Validate source tag exists
|
||||
if (
|
||||
!rawData ||
|
||||
!rawData[sourceTag] ||
|
||||
!Array.isArray(rawData[sourceTag].tasks)
|
||||
) {
|
||||
throw new MoveTaskError(
|
||||
MOVE_ERROR_CODES.INVALID_SOURCE_TAG,
|
||||
`Source tag "${sourceTag}" not found or invalid`
|
||||
);
|
||||
}
|
||||
|
||||
// Create target tag if it doesn't exist
|
||||
if (!rawData[targetTag]) {
|
||||
rawData[targetTag] = { tasks: [] };
|
||||
log('info', `Created new tag "${targetTag}"`);
|
||||
}
|
||||
|
||||
// Normalize all IDs to strings once for consistent comparison
|
||||
const normalizedSearchIds = taskIds.map((id) => String(id));
|
||||
|
||||
const sourceTasks = rawData[sourceTag].tasks.filter((t) => {
|
||||
const normalizedTaskId = String(t.id);
|
||||
return normalizedSearchIds.includes(normalizedTaskId);
|
||||
});
|
||||
|
||||
// Validate subtask movement
|
||||
taskIds.forEach((taskId) => {
|
||||
validateSubtaskMove(taskId, sourceTag, targetTag);
|
||||
});
|
||||
|
||||
return { rawData, sourceTasks };
|
||||
}
|
||||
|
||||
/**
|
||||
* Load and prepare task data for move operation
|
||||
* @param {Object} validation - Validation result from validateMove
|
||||
* @returns {Object} Prepared data with rawData, sourceTasks, and allTasks
|
||||
*/
|
||||
async function prepareTaskData(validation) {
|
||||
const { rawData, sourceTasks } = validation;
|
||||
|
||||
// Get all tasks for validation
|
||||
const allTasks = getAllTasksWithTags(rawData);
|
||||
|
||||
return { rawData, sourceTasks, allTasks };
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve dependencies and determine tasks to move
|
||||
* @param {Array} sourceTasks - Source tasks to move
|
||||
* @param {Array} allTasks - All available tasks from all tags
|
||||
* @param {Object} options - Move options
|
||||
* @param {Array} taskIds - Original task IDs
|
||||
* @param {string} sourceTag - Source tag name
|
||||
* @param {string} targetTag - Target tag name
|
||||
* @returns {Object} Tasks to move and dependency resolution info
|
||||
*/
|
||||
async function resolveDependencies(
|
||||
sourceTasks,
|
||||
allTasks,
|
||||
options,
|
||||
taskIds,
|
||||
sourceTag,
|
||||
targetTag
|
||||
) {
|
||||
const { withDependencies = false, ignoreDependencies = false } = options;
|
||||
|
||||
// Handle --with-dependencies flag first (regardless of cross-tag dependencies)
|
||||
if (withDependencies) {
|
||||
// Move dependent tasks along with main tasks
|
||||
// Find ALL dependencies recursively within the same tag
|
||||
const allDependentTaskIds = findAllDependenciesRecursively(
|
||||
sourceTasks,
|
||||
allTasks,
|
||||
{ maxDepth: 100, includeSelf: false }
|
||||
);
|
||||
const allTaskIdsToMove = [...new Set([...taskIds, ...allDependentTaskIds])];
|
||||
|
||||
log(
|
||||
'info',
|
||||
`Moving ${allTaskIdsToMove.length} tasks (including dependencies): ${allTaskIdsToMove.join(', ')}`
|
||||
);
|
||||
|
||||
return {
|
||||
tasksToMove: allTaskIdsToMove,
|
||||
dependencyResolution: {
|
||||
type: 'with-dependencies',
|
||||
dependentTasks: allDependentTaskIds
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Find cross-tag dependencies (these shouldn't exist since dependencies are only within tags)
|
||||
const crossTagDependencies = findCrossTagDependencies(
|
||||
sourceTasks,
|
||||
sourceTag,
|
||||
targetTag,
|
||||
allTasks
|
||||
);
|
||||
|
||||
if (crossTagDependencies.length > 0) {
|
||||
if (ignoreDependencies) {
|
||||
// Break cross-tag dependencies (edge case - shouldn't normally happen)
|
||||
sourceTasks.forEach((task) => {
|
||||
task.dependencies = task.dependencies.filter((depId) => {
|
||||
// Handle both task IDs and subtask IDs (e.g., "1.2")
|
||||
let depTask = null;
|
||||
if (typeof depId === 'string' && depId.includes('.')) {
|
||||
// It's a subtask ID - extract parent task ID and find the parent task
|
||||
const [parentId, subtaskId] = depId
|
||||
.split('.')
|
||||
.map((id) => parseInt(id, 10));
|
||||
depTask = allTasks.find((t) => t.id === parentId);
|
||||
} else {
|
||||
// It's a regular task ID - normalize to number for comparison
|
||||
const normalizedDepId =
|
||||
typeof depId === 'string' ? parseInt(depId, 10) : depId;
|
||||
depTask = allTasks.find((t) => t.id === normalizedDepId);
|
||||
}
|
||||
return !depTask || depTask.tag === targetTag;
|
||||
});
|
||||
});
|
||||
|
||||
log(
|
||||
'warn',
|
||||
`Removed ${crossTagDependencies.length} cross-tag dependencies`
|
||||
);
|
||||
|
||||
return {
|
||||
tasksToMove: taskIds,
|
||||
dependencyResolution: {
|
||||
type: 'ignored-dependencies',
|
||||
conflicts: crossTagDependencies
|
||||
}
|
||||
};
|
||||
} else {
|
||||
// Block move and show error
|
||||
throw new MoveTaskError(
|
||||
MOVE_ERROR_CODES.CROSS_TAG_DEPENDENCY_CONFLICTS,
|
||||
`Cannot move tasks: ${crossTagDependencies.length} cross-tag dependency conflicts found`,
|
||||
{
|
||||
conflicts: crossTagDependencies,
|
||||
sourceTag,
|
||||
targetTag,
|
||||
taskIds
|
||||
}
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
tasksToMove: taskIds,
|
||||
dependencyResolution: { type: 'no-conflicts' }
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute the actual move operation
|
||||
* @param {Array} tasksToMove - Array of task IDs to move
|
||||
* @param {string} sourceTag - Source tag name
|
||||
* @param {string} targetTag - Target tag name
|
||||
* @param {Object} rawData - Raw data object
|
||||
* @param {Object} context - Context object
|
||||
* @param {string} tasksPath - Path to tasks.json file
|
||||
* @returns {Object} Move operation result
|
||||
*/
|
||||
async function executeMoveOperation(
|
||||
tasksToMove,
|
||||
sourceTag,
|
||||
targetTag,
|
||||
rawData,
|
||||
context,
|
||||
tasksPath
|
||||
) {
|
||||
const { projectRoot } = context;
|
||||
const movedTasks = [];
|
||||
|
||||
// Move each task from source to target tag
|
||||
for (const taskId of tasksToMove) {
|
||||
// Normalize taskId to number for comparison
|
||||
const normalizedTaskId =
|
||||
typeof taskId === 'string' ? parseInt(taskId, 10) : taskId;
|
||||
|
||||
const sourceTaskIndex = rawData[sourceTag].tasks.findIndex(
|
||||
(t) => t.id === normalizedTaskId
|
||||
);
|
||||
|
||||
if (sourceTaskIndex === -1) {
|
||||
throw new MoveTaskError(
|
||||
MOVE_ERROR_CODES.TASK_NOT_FOUND,
|
||||
`Task ${taskId} not found in source tag "${sourceTag}"`
|
||||
);
|
||||
}
|
||||
|
||||
const taskToMove = rawData[sourceTag].tasks[sourceTaskIndex];
|
||||
|
||||
// Check for ID conflicts in target tag
|
||||
const existingTaskIndex = rawData[targetTag].tasks.findIndex(
|
||||
(t) => t.id === normalizedTaskId
|
||||
);
|
||||
if (existingTaskIndex !== -1) {
|
||||
throw new MoveTaskError(
|
||||
MOVE_ERROR_CODES.TASK_ALREADY_EXISTS,
|
||||
`Task ${taskId} already exists in target tag "${targetTag}"`
|
||||
);
|
||||
}
|
||||
|
||||
// Remove from source tag
|
||||
rawData[sourceTag].tasks.splice(sourceTaskIndex, 1);
|
||||
|
||||
// Preserve task metadata and add to target tag
|
||||
const taskWithPreservedMetadata = preserveTaskMetadata(
|
||||
taskToMove,
|
||||
sourceTag,
|
||||
targetTag
|
||||
);
|
||||
rawData[targetTag].tasks.push(taskWithPreservedMetadata);
|
||||
|
||||
movedTasks.push({
|
||||
id: taskId,
|
||||
fromTag: sourceTag,
|
||||
toTag: targetTag
|
||||
});
|
||||
|
||||
log('info', `Moved task ${taskId} from "${sourceTag}" to "${targetTag}"`);
|
||||
}
|
||||
|
||||
return { rawData, movedTasks };
|
||||
}
|
||||
|
||||
/**
|
||||
* Finalize the move operation by saving data and returning result
|
||||
* @param {Object} moveResult - Result from executeMoveOperation
|
||||
* @param {string} tasksPath - Path to tasks.json file
|
||||
* @param {Object} context - Context object
|
||||
* @param {string} sourceTag - Source tag name
|
||||
* @param {string} targetTag - Target tag name
|
||||
* @returns {Object} Final result object
|
||||
*/
|
||||
async function finalizeMove(
|
||||
moveResult,
|
||||
tasksPath,
|
||||
context,
|
||||
sourceTag,
|
||||
targetTag
|
||||
) {
|
||||
const { projectRoot } = context;
|
||||
const { rawData, movedTasks } = moveResult;
|
||||
|
||||
// Write the updated data
|
||||
writeJSON(tasksPath, rawData, projectRoot, null);
|
||||
|
||||
return {
|
||||
message: `Successfully moved ${movedTasks.length} tasks from "${sourceTag}" to "${targetTag}"`,
|
||||
movedTasks
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Move tasks between different tags with dependency handling
|
||||
* @param {string} tasksPath - Path to tasks.json file
|
||||
* @param {Array} taskIds - Array of task IDs to move
|
||||
* @param {string} sourceTag - Source tag name
|
||||
* @param {string} targetTag - Target tag name
|
||||
* @param {Object} options - Move options
|
||||
* @param {boolean} options.withDependencies - Move dependent tasks along with main task
|
||||
* @param {boolean} options.ignoreDependencies - Break cross-tag dependencies during move
|
||||
* @param {Object} context - Context object containing projectRoot and tag information
|
||||
* @returns {Object} Result object with moved task details
|
||||
*/
|
||||
async function moveTasksBetweenTags(
|
||||
tasksPath,
|
||||
taskIds,
|
||||
sourceTag,
|
||||
targetTag,
|
||||
options = {},
|
||||
context = {}
|
||||
) {
|
||||
// 1. Validation phase
|
||||
const validation = await validateMove(
|
||||
tasksPath,
|
||||
taskIds,
|
||||
sourceTag,
|
||||
targetTag,
|
||||
context
|
||||
);
|
||||
|
||||
// 2. Load and prepare data
|
||||
const { rawData, sourceTasks, allTasks } = await prepareTaskData(validation);
|
||||
|
||||
// 3. Handle dependencies
|
||||
const { tasksToMove } = await resolveDependencies(
|
||||
sourceTasks,
|
||||
allTasks,
|
||||
options,
|
||||
taskIds,
|
||||
sourceTag,
|
||||
targetTag
|
||||
);
|
||||
|
||||
// 4. Execute move
|
||||
const moveResult = await executeMoveOperation(
|
||||
tasksToMove,
|
||||
sourceTag,
|
||||
targetTag,
|
||||
rawData,
|
||||
context,
|
||||
tasksPath
|
||||
);
|
||||
|
||||
// 5. Save and return
|
||||
return await finalizeMove(
|
||||
moveResult,
|
||||
tasksPath,
|
||||
context,
|
||||
sourceTag,
|
||||
targetTag
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Detect ID conflicts in target tag
|
||||
* @param {Array} taskIds - Array of task IDs to check
|
||||
* @param {string} targetTag - Target tag name
|
||||
* @param {Object} rawData - Raw data object
|
||||
* @returns {Array} Array of conflicting task IDs
|
||||
*/
|
||||
function detectIdConflicts(taskIds, targetTag, rawData) {
|
||||
const conflicts = [];
|
||||
|
||||
if (!rawData[targetTag] || !Array.isArray(rawData[targetTag].tasks)) {
|
||||
return conflicts;
|
||||
}
|
||||
|
||||
taskIds.forEach((taskId) => {
|
||||
// Normalize taskId to number for comparison
|
||||
const normalizedTaskId =
|
||||
typeof taskId === 'string' ? parseInt(taskId, 10) : taskId;
|
||||
const existingTask = rawData[targetTag].tasks.find(
|
||||
(t) => t.id === normalizedTaskId
|
||||
);
|
||||
if (existingTask) {
|
||||
conflicts.push(taskId);
|
||||
}
|
||||
});
|
||||
|
||||
return conflicts;
|
||||
}
|
||||
|
||||
/**
|
||||
* Preserve task metadata during cross-tag moves
|
||||
* @param {Object} task - Task object
|
||||
* @param {string} sourceTag - Source tag name
|
||||
* @param {string} targetTag - Target tag name
|
||||
* @returns {Object} Task object with preserved metadata
|
||||
*/
|
||||
function preserveTaskMetadata(task, sourceTag, targetTag) {
|
||||
// Update the tag property to reflect the new location
|
||||
task.tag = targetTag;
|
||||
|
||||
// Add move history to task metadata
|
||||
if (!task.metadata) {
|
||||
task.metadata = {};
|
||||
}
|
||||
|
||||
if (!task.metadata.moveHistory) {
|
||||
task.metadata.moveHistory = [];
|
||||
}
|
||||
|
||||
task.metadata.moveHistory.push({
|
||||
fromTag: sourceTag,
|
||||
toTag: targetTag,
|
||||
timestamp: new Date().toISOString()
|
||||
});
|
||||
|
||||
return task;
|
||||
}
|
||||
|
||||
export default moveTask;
|
||||
export {
|
||||
moveTasksBetweenTags,
|
||||
getAllTasksWithTags,
|
||||
detectIdConflicts,
|
||||
preserveTaskMetadata,
|
||||
MoveTaskError,
|
||||
MOVE_ERROR_CODES
|
||||
};
|
||||
|
||||
@@ -7,7 +7,15 @@
|
||||
function taskExists(tasks, taskId) {
|
||||
// Handle subtask IDs (e.g., "1.2")
|
||||
if (typeof taskId === 'string' && taskId.includes('.')) {
|
||||
const [parentIdStr, subtaskIdStr] = taskId.split('.');
|
||||
const parts = taskId.split('.');
|
||||
// Validate that it's a proper subtask format (parentId.subtaskId)
|
||||
if (parts.length !== 2 || !parts[0] || !parts[1]) {
|
||||
// Invalid format - treat as regular task ID
|
||||
const id = parseInt(taskId, 10);
|
||||
return tasks.some((t) => t.id === id);
|
||||
}
|
||||
|
||||
const [parentIdStr, subtaskIdStr] = parts;
|
||||
const parentId = parseInt(parentIdStr, 10);
|
||||
const subtaskId = parseInt(subtaskIdStr, 10);
|
||||
|
||||
|
||||
@@ -15,7 +15,8 @@ import {
|
||||
findTaskById,
|
||||
readJSON,
|
||||
truncate,
|
||||
isSilentMode
|
||||
isSilentMode,
|
||||
formatTaskId
|
||||
} from './utils.js';
|
||||
import fs from 'fs';
|
||||
import {
|
||||
@@ -405,9 +406,44 @@ function formatDependenciesWithStatus(
|
||||
|
||||
// Check if it's already a fully qualified subtask ID (like "22.1")
|
||||
if (depIdStr.includes('.')) {
|
||||
const [parentId, subtaskId] = depIdStr
|
||||
.split('.')
|
||||
.map((id) => parseInt(id, 10));
|
||||
const parts = depIdStr.split('.');
|
||||
// Validate that it's a proper subtask format (parentId.subtaskId)
|
||||
if (parts.length !== 2 || !parts[0] || !parts[1]) {
|
||||
// Invalid format - treat as regular dependency
|
||||
const numericDepId =
|
||||
typeof depId === 'string' ? parseInt(depId, 10) : depId;
|
||||
const depTaskResult = findTaskById(
|
||||
allTasks,
|
||||
numericDepId,
|
||||
complexityReport
|
||||
);
|
||||
const depTask = depTaskResult.task;
|
||||
|
||||
if (!depTask) {
|
||||
return forConsole
|
||||
? chalk.red(`${depIdStr} (Not found)`)
|
||||
: `${depIdStr} (Not found)`;
|
||||
}
|
||||
|
||||
const status = depTask.status || 'pending';
|
||||
const isDone =
|
||||
status.toLowerCase() === 'done' ||
|
||||
status.toLowerCase() === 'completed';
|
||||
const isInProgress = status.toLowerCase() === 'in-progress';
|
||||
|
||||
if (forConsole) {
|
||||
if (isDone) {
|
||||
return chalk.green.bold(depIdStr);
|
||||
} else if (isInProgress) {
|
||||
return chalk.yellow.bold(depIdStr);
|
||||
} else {
|
||||
return chalk.red.bold(depIdStr);
|
||||
}
|
||||
}
|
||||
return depIdStr;
|
||||
}
|
||||
|
||||
const [parentId, subtaskId] = parts.map((id) => parseInt(id, 10));
|
||||
|
||||
// Find the parent task
|
||||
const parentTask = allTasks.find((t) => t.id === parentId);
|
||||
@@ -2797,5 +2833,176 @@ export {
|
||||
warnLoadingIndicator,
|
||||
infoLoadingIndicator,
|
||||
displayContextAnalysis,
|
||||
displayCurrentTagIndicator
|
||||
displayCurrentTagIndicator,
|
||||
formatTaskIdForDisplay
|
||||
};
|
||||
|
||||
/**
|
||||
* Display enhanced error message for cross-tag dependency conflicts
|
||||
* @param {Array} conflicts - Array of cross-tag dependency conflicts
|
||||
* @param {string} sourceTag - Source tag name
|
||||
* @param {string} targetTag - Target tag name
|
||||
* @param {string} sourceIds - Source task IDs (comma-separated)
|
||||
*/
|
||||
export function displayCrossTagDependencyError(
|
||||
conflicts,
|
||||
sourceTag,
|
||||
targetTag,
|
||||
sourceIds
|
||||
) {
|
||||
console.log(
|
||||
chalk.red(`\n❌ Cannot move tasks from "${sourceTag}" to "${targetTag}"`)
|
||||
);
|
||||
console.log(chalk.yellow(`\nCross-tag dependency conflicts detected:`));
|
||||
|
||||
if (conflicts.length > 0) {
|
||||
conflicts.forEach((conflict) => {
|
||||
console.log(` • ${conflict.message}`);
|
||||
});
|
||||
}
|
||||
|
||||
console.log(chalk.cyan(`\nResolution options:`));
|
||||
console.log(
|
||||
` 1. Move with dependencies: task-master move --from=${sourceIds} --from-tag=${sourceTag} --to-tag=${targetTag} --with-dependencies`
|
||||
);
|
||||
console.log(
|
||||
` 2. Break dependencies: task-master move --from=${sourceIds} --from-tag=${sourceTag} --to-tag=${targetTag} --ignore-dependencies`
|
||||
);
|
||||
console.log(
|
||||
` 3. Validate and fix dependencies: task-master validate-dependencies && task-master fix-dependencies`
|
||||
);
|
||||
if (conflicts.length > 0) {
|
||||
console.log(
|
||||
` 4. Move dependencies first: task-master move --from=${conflicts.map((c) => c.dependencyId).join(',')} --from-tag=${conflicts[0].dependencyTag} --to-tag=${targetTag}`
|
||||
);
|
||||
}
|
||||
console.log(
|
||||
` 5. Force move (may break dependencies): task-master move --from=${sourceIds} --from-tag=${sourceTag} --to-tag=${targetTag} --force`
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function to format task ID for display, handling edge cases with explicit labels
|
||||
* Builds on the existing formatTaskId utility but adds user-friendly display for edge cases
|
||||
* @param {*} taskId - The task ID to format
|
||||
* @returns {string} Formatted task ID for display
|
||||
*/
|
||||
function formatTaskIdForDisplay(taskId) {
|
||||
if (taskId === null) return 'null';
|
||||
if (taskId === undefined) return 'undefined';
|
||||
if (taskId === '') return '(empty)';
|
||||
|
||||
// Use existing formatTaskId for normal cases, with fallback to 'unknown'
|
||||
return formatTaskId(taskId) || 'unknown';
|
||||
}
|
||||
|
||||
/**
|
||||
* Display enhanced error message for subtask movement restriction
|
||||
* @param {string} taskId - The subtask ID that cannot be moved
|
||||
* @param {string} sourceTag - Source tag name
|
||||
* @param {string} targetTag - Target tag name
|
||||
*/
|
||||
export function displaySubtaskMoveError(taskId, sourceTag, targetTag) {
|
||||
// Handle null/undefined taskId but preserve the actual value for display
|
||||
const displayTaskId = formatTaskIdForDisplay(taskId);
|
||||
|
||||
// Safe taskId for operations that need a valid string
|
||||
const safeTaskId = taskId || 'unknown';
|
||||
|
||||
// Validate taskId format before splitting
|
||||
let parentId = safeTaskId;
|
||||
if (safeTaskId.includes('.')) {
|
||||
const parts = safeTaskId.split('.');
|
||||
// Check if it's a valid subtask format (parentId.subtaskId)
|
||||
if (parts.length === 2 && parts[0] && parts[1]) {
|
||||
parentId = parts[0];
|
||||
} else {
|
||||
// Invalid format - log warning and use the original taskId
|
||||
console.log(
|
||||
chalk.yellow(
|
||||
`\n⚠️ Warning: Unexpected taskId format "${safeTaskId}". Using as-is for command suggestions.`
|
||||
)
|
||||
);
|
||||
parentId = safeTaskId;
|
||||
}
|
||||
}
|
||||
|
||||
console.log(
|
||||
chalk.red(`\n❌ Cannot move subtask ${displayTaskId} directly between tags`)
|
||||
);
|
||||
console.log(chalk.yellow(`\nSubtask movement restriction:`));
|
||||
console.log(` • Subtasks cannot be moved directly between tags`);
|
||||
console.log(` • They must be promoted to full tasks first`);
|
||||
console.log(` • Source tag: "${sourceTag}"`);
|
||||
console.log(` • Target tag: "${targetTag}"`);
|
||||
|
||||
console.log(chalk.cyan(`\nResolution options:`));
|
||||
console.log(
|
||||
` 1. Promote subtask to full task: task-master remove-subtask --id=${displayTaskId} --convert`
|
||||
);
|
||||
console.log(
|
||||
` 2. Then move the promoted task: task-master move --from=${parentId} --from-tag=${sourceTag} --to-tag=${targetTag}`
|
||||
);
|
||||
console.log(
|
||||
` 3. Or move the parent task with all subtasks: task-master move --from=${parentId} --from-tag=${sourceTag} --to-tag=${targetTag} --with-dependencies`
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Display enhanced error message for invalid tag combinations
|
||||
* @param {string} sourceTag - Source tag name
|
||||
* @param {string} targetTag - Target tag name
|
||||
* @param {string} reason - Reason for the error
|
||||
*/
|
||||
export function displayInvalidTagCombinationError(
|
||||
sourceTag,
|
||||
targetTag,
|
||||
reason
|
||||
) {
|
||||
console.log(chalk.red(`\n❌ Invalid tag combination`));
|
||||
console.log(chalk.yellow(`\nError details:`));
|
||||
console.log(` • Source tag: "${sourceTag}"`);
|
||||
console.log(` • Target tag: "${targetTag}"`);
|
||||
console.log(` • Reason: ${reason}`);
|
||||
|
||||
console.log(chalk.cyan(`\nResolution options:`));
|
||||
console.log(` 1. Use different tags for cross-tag moves`);
|
||||
console.log(
|
||||
` 2. Use within-tag move: task-master move --from=<id> --to=<id> --tag=${sourceTag}`
|
||||
);
|
||||
console.log(` 3. Check available tags: task-master tags`);
|
||||
}
|
||||
|
||||
/**
|
||||
* Display helpful hints for dependency validation commands
|
||||
* @param {string} context - Context for the hints (e.g., 'before-move', 'after-error')
|
||||
*/
|
||||
export function displayDependencyValidationHints(context = 'general') {
|
||||
const hints = {
|
||||
'before-move': [
|
||||
'💡 Tip: Run "task-master validate-dependencies" to check for dependency issues before moving tasks',
|
||||
'💡 Tip: Use "task-master fix-dependencies" to automatically resolve common dependency problems',
|
||||
'💡 Tip: Consider using --with-dependencies flag to move dependent tasks together'
|
||||
],
|
||||
'after-error': [
|
||||
'🔧 Quick fix: Run "task-master validate-dependencies" to identify specific issues',
|
||||
'🔧 Quick fix: Use "task-master fix-dependencies" to automatically resolve problems',
|
||||
'🔧 Quick fix: Check "task-master show <id>" to see task dependencies before moving'
|
||||
],
|
||||
general: [
|
||||
'💡 Use "task-master validate-dependencies" to check for dependency issues',
|
||||
'💡 Use "task-master fix-dependencies" to automatically resolve problems',
|
||||
'💡 Use "task-master show <id>" to view task dependencies',
|
||||
'💡 Use --with-dependencies flag to move dependent tasks together'
|
||||
]
|
||||
};
|
||||
|
||||
const relevantHints = hints[context] || hints.general;
|
||||
|
||||
console.log(chalk.cyan(`\nHelpful hints:`));
|
||||
// Convert to Set to ensure only unique hints are displayed
|
||||
const uniqueHints = new Set(relevantHints);
|
||||
uniqueHints.forEach((hint) => {
|
||||
console.log(` ${hint}`);
|
||||
});
|
||||
}
|
||||
|
||||
@@ -1132,6 +1132,139 @@ function findCycles(
|
||||
return cyclesToBreak;
|
||||
}
|
||||
|
||||
/**
|
||||
* Unified dependency traversal utility that supports both forward and reverse dependency traversal
|
||||
* @param {Array} sourceTasks - Array of source tasks to start traversal from
|
||||
* @param {Array} allTasks - Array of all tasks to search within
|
||||
* @param {Object} options - Configuration options
|
||||
* @param {number} options.maxDepth - Maximum recursion depth (default: 50)
|
||||
* @param {boolean} options.includeSelf - Whether to include self-references (default: false)
|
||||
* @param {'forward'|'reverse'} options.direction - Direction of traversal (default: 'forward')
|
||||
* @param {Function} options.logger - Optional logger function for warnings
|
||||
* @returns {Array} Array of all dependency task IDs found through traversal
|
||||
*/
|
||||
function traverseDependencies(sourceTasks, allTasks, options = {}) {
|
||||
const {
|
||||
maxDepth = 50,
|
||||
includeSelf = false,
|
||||
direction = 'forward',
|
||||
logger = null
|
||||
} = options;
|
||||
|
||||
const dependentTaskIds = new Set();
|
||||
const processedIds = new Set();
|
||||
|
||||
// Helper function to normalize dependency IDs while preserving subtask format
|
||||
function normalizeDependencyId(depId) {
|
||||
if (typeof depId === 'string') {
|
||||
// Preserve string format for subtask IDs like "1.2"
|
||||
if (depId.includes('.')) {
|
||||
return depId;
|
||||
}
|
||||
// Convert simple string numbers to numbers for consistency
|
||||
const parsed = parseInt(depId, 10);
|
||||
return isNaN(parsed) ? depId : parsed;
|
||||
}
|
||||
return depId;
|
||||
}
|
||||
|
||||
// Helper function for forward dependency traversal
|
||||
function findForwardDependencies(taskId, currentDepth = 0) {
|
||||
// Check depth limit
|
||||
if (currentDepth >= maxDepth) {
|
||||
const warnMsg = `Maximum recursion depth (${maxDepth}) reached for task ${taskId}`;
|
||||
if (logger && typeof logger.warn === 'function') {
|
||||
logger.warn(warnMsg);
|
||||
} else if (typeof log !== 'undefined' && log.warn) {
|
||||
log.warn(warnMsg);
|
||||
} else {
|
||||
console.warn(warnMsg);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (processedIds.has(taskId)) {
|
||||
return; // Avoid infinite loops
|
||||
}
|
||||
processedIds.add(taskId);
|
||||
|
||||
const task = allTasks.find((t) => t.id === taskId);
|
||||
if (!task || !Array.isArray(task.dependencies)) {
|
||||
return;
|
||||
}
|
||||
|
||||
task.dependencies.forEach((depId) => {
|
||||
const normalizedDepId = normalizeDependencyId(depId);
|
||||
|
||||
// Skip invalid dependencies and optionally skip self-references
|
||||
if (
|
||||
normalizedDepId == null ||
|
||||
(!includeSelf && normalizedDepId === taskId)
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
dependentTaskIds.add(normalizedDepId);
|
||||
// Recursively find dependencies of this dependency
|
||||
findForwardDependencies(normalizedDepId, currentDepth + 1);
|
||||
});
|
||||
}
|
||||
|
||||
// Helper function for reverse dependency traversal
|
||||
function findReverseDependencies(taskId, currentDepth = 0) {
|
||||
// Check depth limit
|
||||
if (currentDepth >= maxDepth) {
|
||||
const warnMsg = `Maximum recursion depth (${maxDepth}) reached for task ${taskId}`;
|
||||
if (logger && typeof logger.warn === 'function') {
|
||||
logger.warn(warnMsg);
|
||||
} else if (typeof log !== 'undefined' && log.warn) {
|
||||
log.warn(warnMsg);
|
||||
} else {
|
||||
console.warn(warnMsg);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (processedIds.has(taskId)) {
|
||||
return; // Avoid infinite loops
|
||||
}
|
||||
processedIds.add(taskId);
|
||||
|
||||
allTasks.forEach((task) => {
|
||||
if (task.dependencies && Array.isArray(task.dependencies)) {
|
||||
const dependsOnTaskId = task.dependencies.some((depId) => {
|
||||
const normalizedDepId = normalizeDependencyId(depId);
|
||||
return normalizedDepId === taskId;
|
||||
});
|
||||
|
||||
if (dependsOnTaskId) {
|
||||
// Skip invalid dependencies and optionally skip self-references
|
||||
if (task.id == null || (!includeSelf && task.id === taskId)) {
|
||||
return;
|
||||
}
|
||||
|
||||
dependentTaskIds.add(task.id);
|
||||
// Recursively find tasks that depend on this task
|
||||
findReverseDependencies(task.id, currentDepth + 1);
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// Choose traversal function based on direction
|
||||
const traversalFunc =
|
||||
direction === 'reverse' ? findReverseDependencies : findForwardDependencies;
|
||||
|
||||
// Start traversal from each source task
|
||||
sourceTasks.forEach((sourceTask) => {
|
||||
if (sourceTask && sourceTask.id) {
|
||||
traversalFunc(sourceTask.id);
|
||||
}
|
||||
});
|
||||
|
||||
return Array.from(dependentTaskIds);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a string from camelCase to kebab-case
|
||||
* @param {string} str - The string to convert
|
||||
@@ -1459,6 +1592,7 @@ export {
|
||||
truncate,
|
||||
isEmpty,
|
||||
findCycles,
|
||||
traverseDependencies,
|
||||
toKebabCase,
|
||||
detectCamelCaseFlags,
|
||||
disableSilentMode,
|
||||
|
||||
Reference in New Issue
Block a user