Skip to main content
Glama

create_task

Create a new Dart task with title, description, priority, tags, size, assignees, and subscribers for AI-assisted task management.

Instructions

Create a new Dart task

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
titleYesTitle of the task
descriptionYesDescription of the task
priorityNoPriority of the task
tagsNoTags for the task
sizeNoSize/complexity of the task (1-5)
assignee_duidsNoList of assignee DUIDs
subscriber_duidsNoList of subscriber DUIDs

Implementation Reference

  • The handler for 'create_task' tool call. It generates embedded Python code to create a TaskCreate object, wraps it in an Operation, executes a transaction via the Dart client, and returns the result.
                    case 'create_task': {
                        console.error('[Debug] Handling create_task request');
                        const pythonCode = `    # Parse optional parameters from JSON
    tags_json = '''${JSON.stringify(args.tags || [])}'''
    assignee_duids_json = '''${JSON.stringify(args.assignee_duids || [])}'''
    subscriber_duids_json = '''${JSON.stringify(args.subscriber_duids || [])}'''
    
    # Convert JSON strings to Python objects
    tags = json.loads(tags_json) if tags_json.strip() != '[]' else []
    assignee_duids = json.loads(assignee_duids_json) if assignee_duids_json.strip() != '[]' else []
    subscriber_duids = json.loads(subscriber_duids_json) if subscriber_duids_json.strip() != '[]' else []
    
    print("[Debug] Creating task object", file=sys.stderr)
    
    # Create the task
    task = TaskCreate(
        source_type=TaskSourceType.CLI,
        duid=_make_duid(),  # Generate a new DUID for the task
        dartboard_duid=dartboard_duid,  # Set the dartboard DUID separately
        title='''${args.title.replace(/'/g, "\\'")}''',
        description='''${args.description.replace(/'/g, "\\'")}''',
        priority="${args.priority || 'Medium'}",
        size=${args.size || 1}
    )
    
    # Add optional parameters if they exist
    if tags:
        print("[Debug] Adding tags:", tags, file=sys.stderr)
        task.tag_duids = tags
    if assignee_duids:
        print("[Debug] Adding assignees:", assignee_duids, file=sys.stderr)
        task.assignee_duids = assignee_duids
    if subscriber_duids:
        print("[Debug] Adding subscribers:", subscriber_duids, file=sys.stderr)
        task.subscriber_duids = subscriber_duids
    
    print("[Debug] Task object created:", task, file=sys.stderr)
    
    print("[Debug] Creating operation", file=sys.stderr)
    task_op = Operation(
        model=OperationModelKind.TASK,
        kind=OperationKind.CREATE,
        data=task
    )
    print("[Debug] Operation created:", task_op, file=sys.stderr)
    
    print("[Debug] Executing transaction", file=sys.stderr)
    response = client.transact([task_op], TransactionKind.TASK_CREATE)
    print("[Debug] Transaction completed", file=sys.stderr)
    
    if response.results and response.results[0].success:
        task = response.results[0].models.tasks[0]
        print(f"Task created successfully with DUID: {task.duid}")
        print(f"[Debug] Task DUID: {task.duid}", file=sys.stderr)
    else:
        print("[Debug] Task creation failed", file=sys.stderr)
        if response.results:
            print(f"[Debug] Result: {response.results[0]}", file=sys.stderr)
        sys.exit(1)`;
                        
                        // Add proper indentation to the Python code
                        const command = pythonCode.split('\n').map(line => line.length > 0 ? '    ' + line : line).join('\n');
    
                        console.error('[Debug] Running Python command for task creation');
                        const output = await this.runDartCommand(command);
                        console.error('[Debug] Task creation output:', output);
                        const response = {
                            content: [{
                                type: 'text',
                                text: output,
                            }],
                        };
                        console.error('[Debug] Sending task creation response:', JSON.stringify(response, null, 2));
                        return response;
                    }
  • Input schema for the create_task tool, specifying required title and description, and optional fields like priority, tags, size, assignees, and subscribers.
        name: 'create_task',
        description: 'Create a new Dart task',
        inputSchema: {
            type: 'object',
            properties: {
                title: {
                    type: 'string',
                    description: 'Title of the task',
                },
                description: {
                    type: 'string',
                    description: 'Description of the task',
                },
                priority: {
                    type: 'string',
                    description: 'Priority of the task',
                    enum: ['Low', 'Medium', 'High', 'Critical'],
                },
                tags: {
                    type: 'array',
                    items: {
                        type: 'string',
                    },
                    description: 'Tags for the task',
                },
                size: {
                    type: 'number',
                    description: 'Size/complexity of the task (1-5)',
                    minimum: 1,
                    maximum: 5,
                },
                assignee_duids: {
                    type: 'array',
                    items: {
                        type: 'string',
                    },
                    description: 'List of assignee DUIDs',
                },
                subscriber_duids: {
                    type: 'array',
                    items: {
                        type: 'string',
                    },
                    description: 'List of subscriber DUIDs',
                }
            },
            required: ['title', 'description'],
        },
    },
  • src/index.ts:230-513 (registration)
    The ListTools request handler registers the create_task tool by including it in the static tools array returned to clients.
    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
        console.error('[Debug] Handling listTools request');
        const tools = [
            {
                name: 'get_default_status',
                description: 'Get the default status DUIDs',
                inputSchema: {
                    type: 'object',
                    properties: {},
                    required: [],
                },
            },
            {
                name: 'get_default_space',
                description: 'Get the default space DUID',
                inputSchema: {
                    type: 'object',
                    properties: {},
                    required: [],
                },
            },
            {
                name: 'create_task',
                description: 'Create a new Dart task',
                inputSchema: {
                    type: 'object',
                    properties: {
                        title: {
                            type: 'string',
                            description: 'Title of the task',
                        },
                        description: {
                            type: 'string',
                            description: 'Description of the task',
                        },
                        priority: {
                            type: 'string',
                            description: 'Priority of the task',
                            enum: ['Low', 'Medium', 'High', 'Critical'],
                        },
                        tags: {
                            type: 'array',
                            items: {
                                type: 'string',
                            },
                            description: 'Tags for the task',
                        },
                        size: {
                            type: 'number',
                            description: 'Size/complexity of the task (1-5)',
                            minimum: 1,
                            maximum: 5,
                        },
                        assignee_duids: {
                            type: 'array',
                            items: {
                                type: 'string',
                            },
                            description: 'List of assignee DUIDs',
                        },
                        subscriber_duids: {
                            type: 'array',
                            items: {
                                type: 'string',
                            },
                            description: 'List of subscriber DUIDs',
                        }
                    },
                    required: ['title', 'description'],
                },
            },
            {
                name: 'update_task',
                description: 'Update an existing task',
                inputSchema: {
                    type: 'object',
                    properties: {
                        duid: {
                            type: 'string',
                            description: 'DUID of the task to update',
                        },
                        status_duid: {
                            type: 'string',
                            description: 'New status DUID',
                        },
                        title: {
                            type: 'string',
                            description: 'New title for the task',
                        },
                        description: {
                            type: 'string',
                            description: 'New description for the task',
                        },
                        priority: {
                            type: 'string',
                            description: 'New priority for the task',
                            enum: ['Low', 'Medium', 'High', 'Critical'],
                        }
                    },
                    required: ['duid'],
                },
            },
            {
                name: 'get_dartboards',
                description: 'Get available dartboards',
                inputSchema: {
                    type: 'object',
                    properties: {
                        space_duid: {
                            type: 'string',
                            description: 'Space DUID to get dartboards from',
                        }
                    },
                    required: ['space_duid'],
                },
            },
            {
                name: 'get_folders',
                description: 'Get available folders',
                inputSchema: {
                    type: 'object',
                    properties: {
                        space_duid: {
                            type: 'string',
                            description: 'Space DUID to get folders from',
                        }
                    },
                    required: ['space_duid'],
                },
            },
            {
                name: 'create_folder',
                description: 'Create a new folder in a space',
                inputSchema: {
                    type: 'object',
                    properties: {
                        space_duid: {
                            type: 'string',
                            description: 'Space DUID to create the folder in',
                        },
                        title: {
                            type: 'string',
                            description: 'Title of the folder',
                        },
                        description: {
                            type: 'string',
                            description: 'Description of the folder',
                        },
                        kind: {
                            type: 'string',
                            description: 'Kind of folder',
                            enum: ['Default', 'Reports', 'Other'],
                            default: 'Default'
                        }
                    },
                    required: ['space_duid', 'title'],
                },
            },
            {
                name: 'create_doc',
                description: 'Create a new document or report',
                inputSchema: {
                    type: 'object',
                    properties: {
                        folder_duid: {
                            type: 'string',
                            description: 'Folder DUID to create the document in',
                        },
                        title: {
                            type: 'string',
                            description: 'Title of the document',
                        },
                        text: {
                            type: 'string',
                            description: 'Content of the document',
                        },
                        text_markdown: {
                            type: 'string',
                            description: 'Markdown content of the document',
                        },
                        report_kind: {
                            type: 'string',
                            description: 'Kind of report (if creating a report)',
                            enum: ['Changelog', 'Standup'],
                        },
                        editor_duids: {
                            type: 'array',
                            items: {
                                type: 'string',
                            },
                            description: 'List of editor DUIDs',
                        },
                        subscriber_duids: {
                            type: 'array',
                            items: {
                                type: 'string',
                            },
                            description: 'List of subscriber DUIDs',
                        }
                    },
                    required: ['folder_duid', 'title'],
                },
            },
            {
                name: 'create_space',
                description: 'Create a new space',
                inputSchema: {
                    type: 'object',
                    properties: {
                        title: {
                            type: 'string',
                            description: 'Title of the space'
                        },
                        description: {
                            type: 'string',
                            description: 'Description of the space'
                        },
                        abrev: {
                            type: 'string',
                            description: 'Short abbreviation for the space'
                        },
                        accessible_by_team: {
                            type: 'boolean',
                            description: 'Whether the space is accessible by the whole team',
                            default: true
                        },
                        accessible_by_user_duids: {
                            type: 'array',
                            items: {
                                type: 'string'
                            },
                            description: 'List of user DUIDs who can access the space'
                        },
                        icon_kind: {
                            type: 'string',
                            enum: ['None', 'Icon', 'Emoji'],
                            description: 'Kind of icon to use',
                            default: 'None'
                        },
                        icon_name_or_emoji: {
                            type: 'string',
                            description: 'Icon name or emoji character'
                        },
                        color_hex: {
                            type: 'string',
                            description: 'Color in hex format (e.g. #FF0000)'
                        },
                        sprint_mode: {
                            type: 'string',
                            enum: ['None', 'ANBA'],
                            description: 'Sprint mode for the space',
                            default: 'None'
                        },
                        sprint_replicate_on_rollover: {
                            type: 'boolean',
                            description: 'Whether to replicate sprints on rollover',
                            default: false
                        },
                        sprint_name_fmt: {
                            type: 'string',
                            description: 'Sprint name format'
                        }
                    },
                    required: ['title']
                }
            },
            {
                name: 'delete_space',
                description: 'Delete a space and all its contents',
                inputSchema: {
                    type: 'object',
                    properties: {
                        space_duid: {
                            type: 'string',
                            description: 'DUID of the space to delete'
                        }
                    },
                    required: ['space_duid']
                }
            }
        ];
        console.error('[Debug] Sending tools response:', JSON.stringify(tools, null, 2));
        return { tools };
    });
  • Helper method runDartCommand used by create_task (and other tools) to execute dynamically generated Python code that interacts with the Dart API via child_process.spawn.
        async runDartCommand(args) {
            return new Promise((resolve, reject) => {
                // Use pyenv Python
                const pythonPath = '/Users/speed/.pyenv/shims/python';
                console.error('[Debug] Running Python command with:', pythonPath);
                
                const command = `import sys
    import os
    import traceback
    import json
    from dart import Dart, Operation, OperationKind, OperationModelKind, TaskCreate, TaskUpdate, TransactionKind, TaskSourceType, SpaceCreate
    from dart.generated.types import UNSET
    from dart.dart import _Session, UserBundle, _make_duid
    from dart.generated.models.icon_kind import IconKind
    from dart.generated.models.sprint_mode import SprintMode
    from dart.generated.models.validation_error_response import ValidationErrorResponse
    
    def initialize():
        print("[Debug] Starting Python execution", file=sys.stderr)
        print("[Debug] Current directory:", os.getcwd(), file=sys.stderr)
        print("[Debug] PYTHONPATH:", os.environ.get('PYTHONPATH'), file=sys.stderr)
        print("[Debug] DART_TOKEN:", os.environ.get('DART_TOKEN'), file=sys.stderr)
        
        session = _Session()
        print("[Debug] Session created", file=sys.stderr)
        bundle = UserBundle(session)
        print("[Debug] UserBundle created", file=sys.stderr)
        dartboard_duid = bundle.default_dartboard["duid"]
        print(f"[Debug] Got dartboard DUID: {dartboard_duid}", file=sys.stderr)
        client = Dart()
        print("[Debug] Dart client created", file=sys.stderr)
        
        return client, bundle, dartboard_duid
    
    def run_command(client, bundle, dartboard_duid):
        ${args}
    
    def main():
        client, bundle, dartboard_duid = initialize()
        run_command(client, bundle, dartboard_duid)
    
    try:
        main()
    except Exception as e:
        print(f"Error: {str(e)}", file=sys.stderr)
        traceback.print_exc(file=sys.stderr)
        sys.exit(1)`;
                
                console.error('[Debug] Python command:', command);
    
                // Create a clean environment without virtual env variables
                const env = { ...process.env };
                delete env.VIRTUAL_ENV;
                delete env.CONDA_PREFIX;
                delete env.CONDA_DEFAULT_ENV;
                delete env.CONDA_PYTHON_EXE;
    
                const childProcess = spawn(pythonPath, ['-c', command], {
                    env: {
                        ...env,
                        PYTHONUNBUFFERED: '1',
                        PYTHONPATH: process.env.PYTHONPATH || process.cwd(),
                        DART_TOKEN: process.env.DART_TOKEN,
                    },
                    stdio: ['pipe', 'pipe', 'pipe'],
                });
    
                let output = '';
                let errorOutput = '';
    
                childProcess.stdout?.on('data', (data) => {
                    const str = data.toString();
                    console.error('[Debug] Python stdout:', str);
                    output += str;
                });
    
                childProcess.stderr?.on('data', (data) => {
                    const str = data.toString();
                    console.error('[Debug] Python stderr:', str);
                    errorOutput += str;
                });
    
                childProcess.on('error', (error) => {
                    console.error('[Debug] Python process error:', error);
                    reject(new Error(`Failed to start Python process: ${error.message}`));
                });
    
                // Add timeout
                const timeout = setTimeout(() => {
                    console.error('[Debug] Python command timed out');
                    childProcess.kill();
                    reject(new Error('Command timed out'));
                }, 30000); // 30 second timeout
    
                childProcess.on('close', (code) => {
                    clearTimeout(timeout);
                    console.error(`[Debug] Python process exited with code ${code}`);
                    if (code === 0) {
                        resolve(output.trim());
                    } else {
                        reject(new Error(errorOutput || `Command failed with exit code ${code}`));
                    }
                });
            });
        }

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/jmanhype/dart-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server