task-engine-ai-core/docs/command-reference.md

Revolutionary AI-driven task management system with complete transformation trilogy: Frontend v0.1.0, Backend v0.2.0, CLI v0.3.0 - Enterprise-grade performance with 95% improvements

# Task Master Command Reference

Here's a comprehensive reference of all available commands:

## Parse PRD

```bash
# Parse a PRD file and generate tasks
task-engine parse-prd <prd-file.txt>

# Limit the number of tasks generated
task-engine parse-prd <prd-file.txt> --num-tasks=10
```

## List Tasks

```bash
# List all tasks
task-engine list

# List tasks with a specific status
task-engine list --status=<status>

# List tasks with subtasks
task-engine list --with-subtasks

# List tasks with a specific status and include subtasks
task-engine list --status=<status> --with-subtasks
```

## Show Next Task

```bash
# Show the next task to work on based on dependencies and status
task-engine next
```

## Show Specific Task

```bash
# Show details of a specific task
task-engine show <id>
# or
task-engine show --id=<id>

# View a specific subtask (e.g., subtask 2 of task 1)
task-engine show 1.2
```

## Update Tasks

```bash
# Update tasks from a specific ID and provide context
task-engine update --from=<id> --prompt="<prompt>"

# Update tasks using research role
task-engine update --from=<id> --prompt="<prompt>" --research
```

## Update a Specific Task

```bash
# Update a single task by ID with new information
task-engine update-task --id=<id> --prompt="<prompt>"

# Use research-backed updates
task-engine update-task --id=<id> --prompt="<prompt>" --research
```

## Update a Subtask

```bash
# Append additional information to a specific subtask
task-engine update-subtask --id=<parentId.subtaskId> --prompt="<prompt>"

# Example: Add details about API rate limiting to subtask 2 of task 5
task-engine update-subtask --id=5.2 --prompt="Add rate limiting of 100 requests per minute"

# Use research-backed updates
task-engine update-subtask --id=<parentId.subtaskId> --prompt="<prompt>" --research
```

Unlike the `update-task` command which replaces task information, the `update-subtask` command _appends_ new information to the existing subtask details, marking it with a timestamp. This is useful for iteratively enhancing subtasks while preserving the original content.

## Generate Task Files

```bash
# Generate individual task files from tasks.json
task-engine generate
```

## Set Task Status

```bash
# Set status of a single task
task-engine set-status --id=<id> --status=<status>

# Set status for multiple tasks
task-engine set-status --id=1,2,3 --status=<status>

# Set status for subtasks
task-engine set-status --id=1.1,1.2 --status=<status>
```

When marking a task as "done", all of its subtasks will automatically be marked as "done" as well.

## Expand Tasks

```bash
# Expand a specific task with subtasks
task-engine expand --id=<id> --num=<number>

# Expand with additional context
task-engine expand --id=<id> --prompt="<context>"

# Expand all pending tasks
task-engine expand --all

# Force regeneration of subtasks for tasks that already have them
task-engine expand --all --force

# Research-backed subtask generation for a specific task
task-engine expand --id=<id> --research

# Research-backed generation for all tasks
task-engine expand --all --research
```

## Clear Subtasks

```bash
# Clear subtasks from a specific task
task-engine clear-subtasks --id=<id>

# Clear subtasks from multiple tasks
task-engine clear-subtasks --id=1,2,3

# Clear subtasks from all tasks
task-engine clear-subtasks --all
```

## Analyze Task Complexity

```bash
# Analyze complexity of all tasks
task-engine analyze-complexity

# Save report to a custom location
task-engine analyze-complexity --output=my-report.json

# Use a specific LLM model
task-engine analyze-complexity --model=claude-3-opus-20240229

# Set a custom complexity threshold (1-10)
task-engine analyze-complexity --threshold=6

# Use an alternative tasks file
task-engine analyze-complexity --file=custom-tasks.json

# Use Perplexity AI for research-backed complexity analysis
task-engine analyze-complexity --research
```

## View Complexity Report

```bash
# Display the task complexity analysis report
task-engine complexity-report

# View a report at a custom location
task-engine complexity-report --file=my-report.json
```

## Managing Task Dependencies

```bash
# Add a dependency to a task
task-engine add-dependency --id=<id> --depends-on=<id>

# Remove a dependency from a task
task-engine remove-dependency --id=<id> --depends-on=<id>

# Validate dependencies without fixing them
task-engine validate-dependencies

# Find and fix invalid dependencies automatically
task-engine fix-dependencies
```

## Move Tasks

```bash
# Move a task or subtask to a new position
task-engine move --from=<id> --to=<id>

# Examples:
# Move task to become a subtask
task-engine move --from=5 --to=7

# Move subtask to become a standalone task
task-engine move --from=5.2 --to=7

# Move subtask to a different parent
task-engine move --from=5.2 --to=7.3

# Reorder subtasks within the same parent
task-engine move --from=5.2 --to=5.4

# Move a task to a new ID position (creates placeholder if doesn't exist)
task-engine move --from=5 --to=25

# Move multiple tasks at once (must have the same number of IDs)
task-engine move --from=10,11,12 --to=16,17,18
```

## Add a New Task

```bash
# Add a new task using AI (main role)
task-engine add-task --prompt="Description of the new task"

# Add a new task using AI (research role)
task-engine add-task --prompt="Description of the new task" --research

# Add a task with dependencies
task-engine add-task --prompt="Description" --dependencies=1,2,3

# Add a task with priority
task-engine add-task --prompt="Description" --priority=high
```

## Initialize a Project

```bash
# Initialize a new project with Task Master structure
task-engine init
```

## Configure AI Models

```bash
# View current AI model configuration and API key status
task-engine models

# Set the primary model for generation/updates (provider inferred if known)
task-engine models --set-main=claude-3-opus-20240229

# Set the research model
task-engine models --set-research=sonar-pro

# Set the fallback model
task-engine models --set-fallback=claude-3-haiku-20240307

# Set a custom Ollama model for the main role
task-engine models --set-main=my-local-llama --ollama

# Set a custom OpenRouter model for the research role
task-engine models --set-research=google/gemini-pro --openrouter

# Run interactive setup to configure models, including custom ones
task-engine models --setup
```

Configuration is stored in `.taskmasterconfig` in your project root. API keys are still managed via `.env` or MCP configuration. Use `task-engine models` without flags to see available built-in models. Use `--setup` for a guided experience.