### Starting TaskFlow MCP Server (Local)

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/README.md

Starts the TaskFlow MCP server when installed locally within a project. This command uses npx to execute the installed package.

```bash
npx taskflow-mcp
```

--------------------------------

### Basic System Prompt for TaskFlow MCP

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/example-system-prompt.md

This prompt guides an AI assistant on using TaskFlow MCP tools for task management. It details phases like planning, execution, and documentation, emphasizing structured workflows and user interaction.

```text
When managing tasks or projects, use the TaskFlow MCP tools to create a structured workflow. Follow these guidelines:

1. PLANNING PHASE:
   - When starting a new project or complex task, use the 'plan_task' tool to break it down into manageable tasks.
   - Include subtasks for complex tasks to make them more manageable.
   - Add project dependencies and notes about user preferences or requirements.
   - Use absolute paths when exporting task plans (e.g., "C:/Users/username/Documents/task-plan.md").

2. EXECUTION PHASE:
   - Always use 'get_next_task' to retrieve the next pending task.
   - If a task has subtasks, complete and mark each subtask as done using 'mark_subtask_done' before marking the main task as done.
   - After completing a task, use 'mark_task_done' and provide detailed completion notes.
   - IMPORTANT: After marking a task as done, wait for user approval before proceeding to the next task.
   - Use 'export_task_status' periodically to save the current state of all tasks for reference.

3. DOCUMENTATION:
   - Add notes using 'add_note' when the user mentions important preferences or requirements.
   - Track dependencies with 'add_dependency' when specific tools or libraries are needed.
   - Update task details as needed using 'update_task' or 'update_subtask'.

4. COMPLETION:
   - After all tasks are completed and approved, inform the user that the project is complete.
   - Offer to export a final status report using 'export_task_status'.

Always maintain a structured approach to task management, and keep the user informed about progress.
```

--------------------------------

### Starting TaskFlow MCP Server (Global)

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/README.md

Starts the TaskFlow MCP server when installed globally. This command makes the server accessible for managing tasks.

```bash
taskflow-mcp
```

--------------------------------

### Advanced System Prompt with TaskFlow MCP API Example

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/example-system-prompt.md

This advanced prompt provides detailed instructions for AI assistants using TaskFlow MCP, including a JSON schema example for task planning. It covers initial planning, task execution, and documentation steps with specific tool usage.

```text
# TaskFlow MCP Workflow Instructions

When managing tasks or projects, you must use the TaskFlow MCP tools to create a structured workflow. This ensures proper tracking, documentation, and user approval at each step.

## Initial Planning

When a user requests help with a project or complex task:

1. ANALYZE THE REQUEST:
   - Understand the full scope of what the user is trying to accomplish
   - Identify major components or phases of the work
   - Determine any dependencies, prerequisites, or user preferences

2. CREATE A TASK PLAN:
   - Use the 'plan_task' tool with the following parameters:
     - originalRequest: The user's original request
     - tasks: Break down the project into logical, manageable tasks
     - subtasks: For complex tasks, add subtasks to make them more granular
     - dependencies: List required tools, libraries, or resources
     - notes: Document user preferences or important context
     - outputPath: Use an absolute path to save the plan (e.g., "C:/Users/username/Documents/task-plan.md")
   
   Example structure:
   ```json
   {
     "originalRequest": "User's request",
     "outputPath": "C:/Users/username/Documents/project-plan.md",
     "dependencies": [
       {
         "name": "Required tool/library",
         "version": "Version if applicable",
         "description": "Why it's needed"
       }
     ],
     "notes": [
       {
         "title": "User Preference",
         "content": "Details about the preference"
       }
     ],
     "tasks": [
       {
         "title": "Task title",
         "description": "Detailed description",
         "subtasks": [
           {
             "title": "Subtask title",
             "description": "Detailed description"
           }
         ]
       }
     ]
   }
   ```

3. EXPLAIN THE PLAN:
   - Present the task breakdown to the user
   - Explain how you'll tackle each task sequentially
   - Confirm this approach meets their needs before proceeding

## Task Execution

For each task in the plan:

1. GET THE NEXT TASK:
   - Use 'get_next_task' to retrieve the next pending task
   - Explain what you'll be working on next

2. COMPLETE SUBTASKS FIRST:
   - If the task has subtasks, address each one in order
   - Use 'mark_subtask_done' after completing each subtask
   - Provide a brief summary of what was done for each subtask

3. MARK TASK COMPLETION:
   - Use 'mark_task_done' with detailed completedDetails
   - Include what was done, any challenges faced, and the outcome

4. WAIT FOR APPROVAL:
   - After marking a task as done, ALWAYS wait for explicit user approval
   - Do not proceed to the next task until the user has approved the current one
   - If the user requests changes, make them and mark the task as done again

5. DOCUMENT AS YOU GO:
   - Add notes using 'add_note' when new information emerges
   - Add dependencies using 'add_dependency' when new requirements are discovered
   - Use 'export_task_status' periodically to save progress (especially for long projects)
```

--------------------------------

### Install Project Dependencies

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/CONTRIBUTING.md

Installs all necessary dependencies for the TaskFlow MCP project using npm. This command should be run after cloning the repository.

```shell
npm install
```

--------------------------------

### MCP Client Configuration for TaskFlow

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/README.md

An example JSON configuration file for an MCP client, setting up the TaskFlow MCP server. It specifies how to run the server, including command arguments and environment variables.

```json
{
  "mcpServers": {
    "taskflow": {
      "command": "npx",
      "args": ["-y", "@pinkpixel/taskflow-mcp"],
      "env": {
        "TASK_MANAGER_FILE_PATH": "/path/to/tasks.json"
      }
    }
  }
}
```

--------------------------------

### Global Installation of TaskFlow MCP

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/README.md

Installs the TaskFlow MCP command-line interface globally using npm. This allows you to run the taskflow-mcp command from any directory.

```bash
npm install -g @pinkpixel/taskflow-mcp
```

--------------------------------

### Local Installation of TaskFlow MCP

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/README.md

Installs the TaskFlow MCP package locally within your project using npm. This is useful for project-specific installations or when managing dependencies.

```bash
npm install @pinkpixel/taskflow-mcp
```

--------------------------------

### TaskFlow MCP Workflow Commands

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/example-system-prompt.md

This section details the core commands used to manage tasks and workflows within the TaskFlow MCP system. It covers planning, execution, status updates, and documentation.

```APIDOC
TaskFlow MCP Workflow Commands:

plan_task
  - Description: Breaks down a request into tasks with subtasks, dependencies, and notes.
  - Usage: plan_task(request_details)

get_next_task
  - Description: Retrieves the next task in the sequence for execution.
  - Usage: get_next_task()

mark_subtask_done
  - Description: Marks a subtask as completed. All subtasks must be completed before the main task can be marked as done.
  - Usage: mark_subtask_done(subtask_id)

mark_task_done
  - Description: Marks a main task as completed. Requires user approval before proceeding.
  - Usage: mark_task_done(task_id)
  - Note: Wait for user approval after execution.

add_note
  - Description: Documents important information or clarifications related to a task.
  - Usage: add_note(task_id, note_content)

add_dependency
  - Description: Establishes a dependency between tasks.
  - Usage: add_dependency(task_id, depends_on_task_id)

export_task_status
  - Description: Exports the current progress or final status report. Supports various formats like HTML.
  - Usage: export_task_status(file_path, format='html')
  - Note: Use absolute file paths for reliable exports.
```

--------------------------------

### TaskFlow MCP Tool API Reference

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/example-system-prompt.md

This section details the API for TaskFlow MCP tools used in task management. It covers the 'plan_task' tool's parameters and expected JSON structure for creating task plans, along with other essential task management commands.

```APIDOC
TaskFlow MCP Tools:

1. plan_task(originalRequest: str, tasks: list, subtasks: list, dependencies: list, notes: list, outputPath: str)
   - Creates a structured plan for a project or complex task.
   - Parameters:
     - originalRequest (str): The user's initial request.
     - tasks (list): A list of main tasks, each with a title and description.
     - subtasks (list, optional): Nested subtasks for complex tasks.
     - dependencies (list, optional): List of required tools, libraries, or resources, including name, version, and description.
     - notes (list, optional): Additional context or user preferences, with title and content.
     - outputPath (str): Absolute path to save the generated task plan file (e.g., "C:/Users/username/Documents/project-plan.md").
   - Returns: Confirmation of plan creation and saved file path.
   - Example JSON Structure for tasks, subtasks, dependencies, and notes:
     {
       "originalRequest": "User's request",
       "outputPath": "C:/Users/username/Documents/project-plan.md",
       "dependencies": [
         {
           "name": "Required tool/library",
           "version": "Version if applicable",
           "description": "Why it's needed"
         }
       ],
       "notes": [
         {
           "title": "User Preference",
           "content": "Details about the preference"
         }
       ],
       "tasks": [
         {
           "title": "Task title",
           "description": "Detailed description",
           "subtasks": [
             {
               "title": "Subtask title",
               "description": "Detailed description"
             }
           ]
         }
       ]
     }

2. get_next_task()
   - Retrieves the next pending task from the workflow.
   - Returns: Details of the next task to be processed.

3. mark_subtask_done(subtaskId: str, completionNotes: str)
   - Marks a specific subtask as completed.
   - Parameters:
     - subtaskId (str): Identifier for the subtask.
     - completionNotes (str): Detailed notes on the subtask's completion.
   - Returns: Status of the subtask update.

4. mark_task_done(taskId: str, completedDetails: str)
   - Marks a main task as completed.
   - Parameters:
     - taskId (str): Identifier for the main task.
     - completedDetails (str): Comprehensive notes on task completion, challenges, and outcome.
   - Returns: Status of the task update.

5. add_note(taskId: str, noteTitle: str, noteContent: str)
   - Adds a note to a specific task.
   - Parameters:
     - taskId (str): Identifier for the task.
     - noteTitle (str): Title of the note.
     - noteContent (str): Content of the note.
   - Returns: Status of the note addition.

6. add_dependency(taskId: str, dependencyName: str, dependencyDetails: str)
   - Adds a dependency to a specific task.
   - Parameters:
     - taskId (str): Identifier for the task.
     - dependencyName (str): Name of the dependency.
     - dependencyDetails (str): Details about the dependency.
   - Returns: Status of the dependency addition.

7. update_task(taskId: str, updatedDetails: dict)
   - Updates details of an existing main task.
   - Parameters:
     - taskId (str): Identifier for the task.
     - updatedDetails (dict): Dictionary containing fields to update.
   - Returns: Status of the task update.

8. update_subtask(subtaskId: str, updatedDetails: dict)
   - Updates details of an existing subtask.
   - Parameters:
     - subtaskId (str): Identifier for the subtask.
     - updatedDetails (dict): Dictionary containing fields to update.
   - Returns: Status of the subtask update.

9. export_task_status(outputPath: str)
   - Exports the current status of all tasks to a file.
   - Parameters:
     - outputPath (str): Path where the status report will be saved.
   - Returns: Confirmation of export and file path.
```

--------------------------------

### Configuring Task Manager File Path

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/README.md

Starts the TaskFlow MCP server while specifying a custom path for the task data file using an environment variable. This allows persistence to a location other than the default.

```bash
TASK_MANAGER_FILE_PATH=/path/to/tasks.json taskflow-mcp
```

--------------------------------

### Zod Schema Validation Example

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/OVERVIEW.md

Shows how Zod is used to define and validate schemas for incoming data, ensuring that task and request payloads conform to expected structures.

```typescript
import { z } from 'zod';

const subtaskSchema = z.object({
  id: z.string(),
  title: z.string(),
  completed: z.boolean()
});

const taskSchema = z.object({
  id: z.string(),
  title: z.string(),
  description: z.string().optional(),
  status: z.enum(['pending', 'in_progress', 'completed']),
  subtasks: z.array(subtaskSchema).optional(),
  dependencies: z.array(z.string()).optional()
});

const requestSchema = z.object({
  id: z.string(),
  description: z.string(),
  tasks: z.array(taskSchema),
  notes: z.array(z.string()).optional()
});

// Example validation:
const validData = {
  id: 'req-abc',
  description: 'Process user data',
  tasks: [
    {
      id: 'task-456',
      title: 'Fetch data',
      status: 'completed'
    }
  ]
};

try {
  const validatedRequest = requestSchema.parse(validData);
  console.log('Validation successful:', validatedRequest);
} catch (error) {
  console.error('Validation failed:', error);
}
```

--------------------------------

### Get Next Task

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/OVERVIEW.md

Requests the next task to be processed for a specific request. This is typically used by an AI assistant to pick up work.

```json
{
  "requestId": "req-1"
}
```

--------------------------------

### Run TaskFlow MCP in Watch Mode

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/CONTRIBUTING.md

Starts the TaskFlow MCP project in watch mode, which typically recompiles or restarts the application automatically upon detecting file changes. Ideal for active development.

```shell
npm run watch
```

--------------------------------

### TaskFlow MCP Tools and Configuration

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/OVERVIEW.md

Documentation for the TaskFlow MCP server's API, detailing the available tools for AI assistants to manage tasks, requests, and notes, along with configuration options for persistence and execution.

```APIDOC
TaskFlow MCP API Documentation:

Tools for AI Assistants:

1.  plan_task(request_id: string, tasks: Task[], notes?: string[], dependencies?: Dependency[], outputPath?: string)
    - Registers a new user request and plans its associated tasks.
    - Supports optional subtasks, dependencies, notes, and an outputPath.

2.  get_next_task(request_id: string): Task | null
    - Retrieves the next pending task for a given request.
    - Returns the task object or null if no pending tasks are available.

3.  mark_task_done(request_id: string, task_id: string): boolean
    - Marks a task as completed.
    - Requires all subtasks of the specified task to be completed first.
    - Returns true if successful, false otherwise.

4.  approve_task_completion(request_id: string, task_id: string): boolean
    - Approves a completed task.
    - Returns true if successful.

5.  approve_request_completion(request_id: string): boolean
    - Approves an entire request as completed.
    - Returns true if successful.

6.  open_task_details(request_id: string, task_id: string): Task | null
    - Gets details about a specific task, including its subtasks.
    - Returns the task object or null if the task is not found.

7.  list_requests(): Request[]
    - Lists all requests currently in the system.

8.  add_tasks_to_request(request_id: string, tasks: Task[]): boolean
    - Adds more tasks to an existing request.
    - Returns true if successful.

9.  update_task(request_id: string, task_id: string, updates: Partial<Task>): boolean
    - Updates a task's title or description.
    - `updates` is an object containing fields to modify.
    - Returns true if successful.

10. delete_task(request_id: string, task_id: string): boolean
    - Deletes a task from a request.
    - Returns true if successful.

11. add_subtasks(request_id: string, task_id: string, subtasks: Subtask[]): boolean
    - Adds subtasks to an existing task.
    - Returns true if successful.

12. mark_subtask_done(request_id: string, task_id: string, subtask_id: string): boolean
    - Marks a subtask as completed.
    - Returns true if successful.

13. update_subtask(request_id: string, task_id: string, subtask_id: string, updates: Partial<Subtask>): boolean
    - Updates a subtask's title or description.
    - `updates` is an object containing fields to modify.
    - Returns true if successful.

14. delete_subtask(request_id: string, task_id: string, subtask_id: string): boolean
    - Deletes a subtask from a task.
    - Returns true if successful.

15. export_task_status(request_id: string, format: 'markdown' | 'json' | 'html'): string
    - Exports the current status of all tasks for a request to a file.
    - Supports markdown, JSON, or HTML formats.

16. add_note(request_id: string, note: string): boolean
    - Adds a note to a request.
    - Returns true if successful.

17. update_note(request_id: string, note_id: string, new_note: string): boolean
    - Updates an existing note for a request.
    - Returns true if successful.

18. delete_note(request_id: string, note_id: string): boolean
    - Deletes a note from a request.
    - Returns true if successful.

19. add_dependency(request_id: string, task_id: string, depends_on_task_id: string): boolean
    - Adds a dependency to a request or task, specifying that `task_id` depends on `depends_on_task_id`.
    - Returns true if successful.

Configuration Options:

1.  Environment Variable: TASK_MANAGER_FILE_PATH
    - Description: Specifies the file path for persisting task data.
    - Default: "~/Documents/tasks.json"

2.  MCP Configuration File: mcp_config.json
    - Description: Defines how the MCP server should be launched.
    - Example Usage: Specifies running with `npx @pinkpixel-dev/taskflow-mcp`.

3.  System Prompts: example-system-prompt.md
    - Description: Provides example system prompts to guide AI assistants in using the TaskFlow MCP tools correctly.
```

--------------------------------

### Build TaskFlow MCP Project

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/CONTRIBUTING.md

Builds the TaskFlow MCP project. This command compiles the source code and prepares it for execution or deployment.

```shell
npm run build
```

--------------------------------

### TaskFlow MCP Workflow Steps

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/OVERVIEW.md

Outlines the sequential steps enforced by the TaskFlow MCP server for processing user requests, ensuring structured task management and user oversight.

```APIDOC
Workflow:
  1. Plan Tasks: Break down user requests into tasks and subtasks.
  2. Get Next Task: Retrieve the next pending task from the request.
  3. Complete Subtasks: If a task has subtasks, complete them sequentially.
  4. Mark Task Done: Mark the task as completed after all subtasks are done.
  5. Wait for Approval: Await user approval for the completed task.
  6. Repeat: Proceed to the next task until all tasks for the request are finished.
  7. Final Approval: Obtain user approval for the entire request.
```

--------------------------------

### Clone TaskFlow MCP Repository

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/CONTRIBUTING.md

Clones the TaskFlow MCP project repository from GitHub and navigates into the project directory. This is the first step for setting up the development environment.

```bash
git clone https://github.com/pinkpixel-dev/taskflow-mcp.git
cd taskflow-mcp
```

--------------------------------

### Request Planning and Management

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/README.md

API methods for initiating new requests, retrieving pending tasks, listing all requests, adding tasks to existing requests, and exporting task status.

```APIDOC
plan_task:
  description: Register a new user request and plan its associated tasks (with optional subtasks).
  request_body:
    originalRequest: string
    outputPath: string
    dependencies?: Array<{ name: string, version?: string, description?: string }>
    notes?: Array<{ title: string, content: string }>
    tasks?: Array<{ title: string, description?: string, dependencies?: Array<{ name: string, description?: string }>, subtasks?: Array<{ title: string, description?: string }> }>

get_next_task:
  description: Retrieve the next pending task for a request.
  request_body:
    requestId: string

list_requests:
  description: List all requests in the system.
  request_body: {}

add_tasks_to_request:
  description: Add more tasks to an existing request.
  request_body:
    requestId: string
    tasks: Array<{ title: string, description?: string }>

export_task_status:
  description: Export the current status of all tasks in a request to a file. It's recommended to use absolute paths for more reliable file creation.
  request_body:
    requestId: string
    outputPath: string
    format: "markdown" | "json"
```

--------------------------------

### Plan Tasks with Subtasks

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/OVERVIEW.md

Defines a structured workflow for a user request, including main tasks and their nested subtasks. This is used to initiate a project plan.

```json
{
  "originalRequest": "Create a new website for my business",
  "tasks": [
    {
      "title": "Design homepage",
      "description": "Create a design for the homepage with logo, navigation, and hero section",
      "subtasks": [
        {
          "title": "Design logo",
          "description": "Create a logo that represents the business brand"
        },
        {
          "title": "Design navigation",
          "description": "Create a user-friendly navigation menu"
        },
        {
          "title": "Design hero section",
          "description": "Create an eye-catching hero section with call-to-action"
        }
      ]
    },
    {
      "title": "Implement HTML/CSS",
      "description": "Convert the design to HTML and CSS",
      "subtasks": [
        {
          "title": "Create HTML structure",
          "description": "Implement the basic HTML structure of the page"
        },
        {
          "title": "Add CSS styling",
          "description": "Style the page according to the design"
        },
        {
          "title": "Ensure responsiveness",
          "description": "Make sure the page looks good on all devices"
        }
      ]
    },
    {
      "title": "Add JavaScript functionality",
      "description": "Implement interactive elements with JavaScript"
    }
  ]
}
```

--------------------------------

### Node.js fs/promises API Usage

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/OVERVIEW.md

Demonstrates the use of Node.js's built-in file system promises API for asynchronous file operations, crucial for persisting task data in the TaskFlow MCP project.

```javascript
import { readFile, writeFile } from 'fs/promises';

async function loadTasks(filePath) {
  try {
    const data = await readFile(filePath, 'utf-8');
    return JSON.parse(data);
  } catch (error) {
    // Handle file not found or parsing errors
    console.error('Error loading tasks:', error);
    return [];
  }
}

async function saveTasks(filePath, tasks) {
  try {
    await writeFile(filePath, JSON.stringify(tasks, null, 2), 'utf-8');
    console.log('Tasks saved successfully.');
  } catch (error) {
    console.error('Error saving tasks:', error);
  }
}
```

--------------------------------

### Add Note

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/OVERVIEW.md

Adds a general note or comment to a request, which can be used for additional context or user preferences.

```json
{
  "requestId": "req-1",
  "title": "Package Manager Preference",
  "content": "User prefers pnpm over npm for package management."
}
```

--------------------------------

### TypeScript for Type Safety

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/OVERVIEW.md

Illustrates basic TypeScript usage for defining interfaces and types, ensuring type safety for task management objects within the project.

```typescript
interface Task {
  id: string;
  title: string;
  description?: string;
  status: 'pending' | 'in_progress' | 'completed';
  subtasks?: Subtask[];
  dependencies?: string[]; // IDs of tasks this task depends on
}

interface Subtask {
  id: string;
  title: string;
  completed: boolean;
}

interface Request {
  id: string;
  description: string;
  tasks: Task[];
  notes?: string[];
}

// Example usage:
const newTask: Task = {
  id: 'task-123',
  title: 'Implement API',
  status: 'pending'
};
```

--------------------------------

### Publish TaskFlow MCP to npm

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/CONTRIBUTING.md

Publishes the TaskFlow MCP package to the npm registry. This command is typically used by project maintainers after updating the version and changelog.

```shell
npm publish
```

--------------------------------

### Request Completion and Notes Management

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/README.md

API methods for approving the completion of an entire request, and for managing notes associated with a request.

```APIDOC
approve_request_completion:
  description: Approve an entire request as completed.
  request_body:
    requestId: string

add_note:
  description: Add a note to a request.
  request_body:
    requestId: string
    title: string
    content: string

update_note:
  description: Update an existing note.
  request_body:
    requestId: string
    noteId: string
    title?: string
    content?: string

delete_note:
  description: Delete a note from a request.
  request_body:
    requestId: string
    noteId: string
```

--------------------------------

### Add Dependency

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/OVERVIEW.md

Associates a dependency, such as a software library or package, with a specific task within a request.

```json
{
  "requestId": "req-1",
  "taskId": "task-2",
  "dependency": {
    "name": "React",
    "version": "^18.2.0",
    "description": "JavaScript library for building user interfaces"
  }
}
```

--------------------------------

### TaskFlow MCP Data Models

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/OVERVIEW.md

Defines the data structures used by the TaskFlow MCP server for managing tasks, requests, and related entities. These models are crucial for understanding the project's data persistence and internal state.

```APIDOC
Dependency:
  name: string
  version: string (optional)
  url: string (optional)
  description: string (optional)

Note:
  id: string
  title: string
  content: string
  createdAt: timestamp
  updatedAt: timestamp

Subtask:
  id: string
  title: string
  description: string
  done: boolean

Task:
  id: string
  title: string
  description: string
  done: boolean
  approved: boolean
  completedDetails: string (optional)
  subtasks: Subtask[]
  dependencies: Dependency[] (optional)

RequestEntry:
  requestId: string
  originalRequest: string
  splitDetails: string (optional)
  tasks: Task[]
  completed: boolean
  dependencies: Dependency[] (optional)
  notes: Note[] (optional)

TaskFlowFile:
  requests: RequestEntry[]
```

--------------------------------

### Task Lifecycle Management

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/README.md

API methods for managing the state and details of individual tasks within a request, including marking as done, approving completion, updating, and deleting.

```APIDOC
mark_task_done:
  description: Mark a task as completed.
  request_body:
    requestId: string
    taskId: string
    completedDetails?: string

approve_task_completion:
  description: Approve a completed task.
  request_body:
    requestId: string
    taskId: string

update_task:
  description: Update a task's title or description.
  request_body:
    requestId: string
    taskId: string
    title?: string
    description?: string

delete_task:
  description: Delete a task from a request.
  request_body:
    requestId: string
    taskId: string

open_task_details:
  description: Get details about a specific task.
  request_body:
    taskId: string
```

--------------------------------

### Mark Task Done

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/OVERVIEW.md

Marks a specific task as completed for a given request, including optional details about the completion.

```json
{
  "requestId": "req-1",
  "taskId": "task-1",
  "completedDetails": "Created a modern design with a clean layout, prominent logo, and clear navigation"
}
```

--------------------------------

### Export Task Status

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/OVERVIEW.md

Requests the export of the current task status for a request to a specified file path and format (e.g., markdown).

```json
{
  "requestId": "req-1",
  "outputPath": "C:/Users/username/Documents/task-status.md",
  "format": "markdown"
}
```

--------------------------------

### Dependency Management

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/README.md

API method for adding dependencies to requests or specific tasks.

```APIDOC
add_dependency:
  description: Add a dependency to a request or task.
  request_body:
    requestId: string
    taskId?: string
    dependency: {
      name: string,
      version?: string,
      description?: string,
      url?: string
    }
```

--------------------------------

### Subtask Management

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/README.md

API methods for adding, updating, marking as done, and deleting subtasks associated with a parent task.

```APIDOC
add_subtasks:
  description: Add subtasks to an existing task.
  request_body:
    requestId: string
    taskId: string
    subtasks: Array<{ title: string, description?: string }>

mark_subtask_done:
  description: Mark a subtask as completed.
  request_body:
    requestId: string
    taskId: string
    subtaskId: string

update_subtask:
  description: Update a subtask's title or description.
  request_body:
    requestId: string
    taskId: string
    subtaskId: string
    title?: string
    description?: string

delete_subtask:
  description: Delete a subtask from a task.
  request_body:
    requestId: string
    taskId: string
    subtaskId: string
```

--------------------------------

### Approve Task Completion

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/OVERVIEW.md

Signals user approval for a completed task, moving it forward in the workflow or marking it as finalized.

```json
{
  "requestId": "req-1",
  "taskId": "task-1"
}
```

--------------------------------

### Add Subtasks to Existing Task

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/OVERVIEW.md

Adds new subtasks to an already defined task within a request. This allows for dynamic expansion of the workflow.

```json
{
  "requestId": "req-1",
  "taskId": "task-2",
  "subtasks": [
    {
      "title": "Add form validation",
      "description": "Implement client-side validation for the contact form"
    },
    {
      "title": "Add form submission",
      "description": "Implement form submission handling"
    }
  ]
}
```

--------------------------------

### Mark Subtask Done

Source: https://github.com/pinkpixel-dev/taskflow-mcp/blob/main/OVERVIEW.md

Marks a specific subtask as completed within a larger task for a given request.

```json
{
  "requestId": "req-1",
  "taskId": "task-1",
  "subtaskId": "subtask-1"
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.