Skip to main content
Glama

create_folder

Create a new folder in a specified space to organize documents and manage workspace structure, supporting custom titles, descriptions, and folder types.

Instructions

Create a new folder in a space

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
space_duidYesSpace DUID to create the folder in
titleYesTitle of the folder
descriptionNoDescription of the folder
kindNoKind of folderDefault

Implementation Reference

  • Handler for the 'create_folder' tool. Constructs embedded Python code using Dart library's FolderCreate and Operation to create a folder in a space, then executes it via runDartCommand method.
                    case 'create_folder': {
                        console.error('[Debug] Handling create_folder request');
                        const pythonCode = `    # Create a new folder
    print("[Debug] Creating folder", file=sys.stderr)
    try:
        from dart import Operation, OperationKind, OperationModelKind, FolderCreate, TransactionKind
        from dart.generated.models.folder_kind import FolderKind
        from dart.generated.models.validation_error_response import ValidationErrorResponse
        from dart.dart import _make_duid
        
        space_duid = "${args.space_duid}"
        title = '''${args.title.replace(/'/g, "\\'")}'''
        description = '''${args.description ? args.description.replace(/'/g, "\\'") : ''}'''
        kind_str = "${args.kind || 'Default'}"
        
        print(f"[Debug] Creating folder in space: {space_duid}", file=sys.stderr)
        print(f"[Debug] Folder title: {title}", file=sys.stderr)
        print(f"[Debug] Folder kind: {kind_str}", file=sys.stderr)
        
        # Create the folder object with required fields
        folder = FolderCreate(
            duid=_make_duid(),
            space_duid=space_duid,
            order="0",  # Default order at the top
            title=title,
            description=description if description else "",  # Use empty string instead of None
            kind=FolderKind(kind_str)  # Convert string to enum
        )
        print("[Debug] Folder object created:", folder, file=sys.stderr)
        
        # Create the operation
        folder_op = Operation(
            model=OperationModelKind.FOLDER,
            kind=OperationKind.CREATE,
            data=folder
        )
        print("[Debug] Operation created:", folder_op, file=sys.stderr)
        
        # Execute the transaction
        print("[Debug] Executing transaction", file=sys.stderr)
        try:
            response = client.transact([folder_op], TransactionKind.FOLDER_CREATE)
            print("[Debug] Transaction completed", file=sys.stderr)
            print("[Debug] Response type:", type(response), file=sys.stderr)
            print("[Debug] Response:", response, file=sys.stderr)
            
            if isinstance(response, ValidationErrorResponse):
                print("[Debug] Validation error:", response.items.additional_properties, file=sys.stderr)
                print(f"Validation error: {response.items.additional_properties}")
                sys.exit(1)
            
            if response.results and response.results[0].success:
                folder = response.results[0].models.folders[0]
                print(f"Folder created successfully")
                print(f"Title: {folder.title}")
                print(f"DUID: {folder.duid}")
                print(f"[Debug] Folder DUID: {folder.duid}", file=sys.stderr)
            else:
                print("[Debug] Folder creation failed", file=sys.stderr)
                if response.results:
                    print(f"[Debug] Result: {response.results[0]}", file=sys.stderr)
                sys.exit(1)
        except Exception as e:
            print(f"[Debug] Transaction error: {str(e)}", file=sys.stderr)
            print("[Debug] Error type:", type(e), file=sys.stderr)
            traceback.print_exc(file=sys.stderr)
            sys.exit(1)
    except Exception as e:
        print(f"[Debug] Error creating folder: {str(e)}", file=sys.stderr)
        print("[Debug] Error type:", type(e), file=sys.stderr)
        traceback.print_exc(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 folder creation');
                        const output = await this.runDartCommand(command);
                        console.error('[Debug] Folder creation output:', output);
                        const response = {
                            content: [{
                                type: 'text',
                                text: output,
                            }],
                        };
                        return response;
                    }
  • Input schema for the create_folder tool, defining parameters like space_duid, title, description, and kind.
        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'],
        },
    },
  • src/index.ts:230-513 (registration)
    Registration of all tools including create_folder via the ListToolsRequestSchema handler.
    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 };
    });

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