backlog-mcp-server 0.8.0 → 0.9.0

package/build/backlog/backlogErrorHandler.js

@@ -0,0 +1,8 @@
+import { parseBacklogAPIError } from './parseBacklogAPIError.js';
+export const backlogErrorHandler = (err) => {
+    const parsed = parseBacklogAPIError(err);
+    return {
+        kind: 'error',
+        message: parsed.message,
+    };
+};

package/build/backlog/customFields.js

@@ -0,0 +1,70 @@
+/**
+ * Converts Backlog-style customFields array into proper payload format
+ */
+export function customFieldsToPayload(customFields) {
+    if (customFields == null) {
+        return {};
+    }
+    const result = {};
+    for (const field of customFields) {
+        if (field.value !== undefined) {
+            result[`customField_${field.id}`] = field.value;
+        }
+        if (field.otherValue !== undefined) {
+            result[`customField_${field.id}_otherValue`] = field.otherValue;
+        }
+    }
+    return result;
+}
+export function customFieldFiltersToPayload(customFields) {
+    if (!customFields || customFields.length === 0) {
+        return {};
+    }
+    const result = {};
+    for (const field of customFields) {
+        const baseKey = `customField_${field.id}`;
+        switch (field.type) {
+            case 'text': {
+                if (field.value.trim().length > 0) {
+                    result[baseKey] = field.value;
+                }
+                break;
+            }
+            case 'numeric': {
+                if (field.min !== undefined) {
+                    result[`${baseKey}_min`] = field.min;
+                }
+                if (field.max !== undefined) {
+                    result[`${baseKey}_max`] = field.max;
+                }
+                break;
+            }
+            case 'date': {
+                if (field.min) {
+                    result[`${baseKey}_min`] = field.min;
+                }
+                if (field.max) {
+                    result[`${baseKey}_max`] = field.max;
+                }
+                break;
+            }
+            case 'list': {
+                if (Array.isArray(field.value)) {
+                    const values = field.value.filter((value) => Number.isFinite(value));
+                    if (values.length > 0) {
+                        result[`${baseKey}[]`] = values;
+                    }
+                }
+                else if (Number.isFinite(field.value)) {
+                    result[baseKey] = field.value;
+                }
+                break;
+            }
+            default: {
+                const exhaustiveCheck = field;
+                throw new Error(`Unsupported custom field filter type: ${exhaustiveCheck}`);
+            }
+        }
+    }
+    return result;
+}

package/build/backlog/parseBacklogAPIError.js

@@ -0,0 +1,38 @@
+export function parseBacklogAPIError(err) {
+    const e = err;
+    if (e._name && e._status && e._url) {
+        const status = e._status;
+        const url = e._url;
+        const code = e._body?.errors?.[0]?.code;
+        const message = e._body?.errors?.[0]?.message ?? 'An unknown error occurred.';
+        if (e._name === 'BacklogAuthError') {
+            return {
+                type: 'BacklogAuthError',
+                message: `Authentication failed (HTTP ${status}). Please check your API key or permissions.`,
+                status,
+                url,
+            };
+        }
+        if (e._name === 'BacklogApiError') {
+            return {
+                type: 'BacklogApiError',
+                message: `Backlog API error (code: ${code}, status: ${status})\n${message}`,
+                status,
+                code,
+                url,
+            };
+        }
+        if (e._name === 'UnexpectedError') {
+            return {
+                type: 'UnexpectedError',
+                message: `Unexpected error (HTTP ${status}) while accessing ${url}.`,
+                status,
+                url,
+            };
+        }
+    }
+    return {
+        type: 'UnknownError',
+        message: err?.message ?? 'An unknown error occurred.',
+    };
+}

package/build/createTranslationHelper.js

@@ -0,0 +1,28 @@
+import { cosmiconfigSync } from 'cosmiconfig';
+import os from 'os';
+export function createTranslationHelper(options) {
+    const usedKeys = {};
+    const configName = options?.configName ?? 'backlog-mcp-server';
+    // Load config file
+    const explorer = cosmiconfigSync(configName);
+    const searchPath = options?.searchDir ?? os.homedir();
+    const configResult = explorer.search(searchPath);
+    const config = configResult?.config || {};
+    function toEnvKey(key) {
+        return `BACKLOG_MCP_${key}`;
+    }
+    function t(key, fallback) {
+        const upperKey = key.toUpperCase();
+        if (usedKeys[upperKey]) {
+            return usedKeys[upperKey];
+        }
+        // Priority：ENV → config → fallback
+        const value = process.env[toEnvKey(upperKey)] || config[upperKey] || fallback;
+        usedKeys[upperKey] = value;
+        return value;
+    }
+    function dump() {
+        return { ...usedKeys };
+    }
+    return { t, dump };
+}

package/build/handlers/builders/composeToolHandler.js

@@ -0,0 +1,26 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { wrapWithErrorHandling } from '../transformers/wrapWithErrorHandling.js';
+import { wrapWithFieldPicking } from '../transformers/wrapWithFieldPicking.js';
+import { wrapWithTokenLimit } from '../transformers/wrapWithTokenLimit.js';
+import { wrapWithToolResult } from '../transformers/wrapWithToolResult.js';
+import { z } from 'zod';
+import { generateFieldsDescription } from '../../utils/generateFieldsDescription.js';
+export function composeToolHandler(tool, options) {
+    const { useFields, errorHandler, maxTokens } = options;
+    // Step 1: Add `fields` to schema if needed
+    if (useFields) {
+        const fieldDesc = generateFieldsDescription(tool.outputSchema, tool.importantFields ?? [], tool.name);
+        tool.schema = extendSchema(tool.schema, fieldDesc);
+    }
+    // Step 2: Compose
+    let handler = wrapWithErrorHandling(tool.handler, errorHandler);
+    if (useFields) {
+        handler = wrapWithFieldPicking(handler);
+    }
+    return wrapWithToolResult(wrapWithTokenLimit(handler, maxTokens));
+}
+function extendSchema(schema, desc) {
+    return schema.extend({
+        fields: z.string().describe(desc),
+    });
+}

package/build/handlers/transformers/wrapWithErrorHandling.js

@@ -0,0 +1,4 @@
+import { runToolSafely } from '../../utils/runToolSafely.js';
+export function wrapWithErrorHandling(fn, onError) {
+    return runToolSafely(fn, onError);
+}

package/build/handlers/transformers/wrapWithFieldPicking.js

@@ -0,0 +1,55 @@
+import { parse } from 'graphql';
+import { isErrorLike } from '../../types/result.js';
+export function wrapWithFieldPicking(fn) {
+    return async (input) => {
+        const { fields, ...rest } = input;
+        const result = await fn(rest);
+        if (!fields || isErrorLike(result)) {
+            return result;
+        }
+        const selectionSet = parseFieldsSelection(fields);
+        const resultData = result.data;
+        if (Array.isArray(resultData)) {
+            return {
+                kind: 'ok',
+                data: resultData.map((item) => pickFieldsFromData(item, selectionSet)),
+            };
+        }
+        else if (typeof result === 'object' && result !== null) {
+            return {
+                kind: 'ok',
+                data: pickFieldsFromData(resultData, selectionSet),
+            };
+        }
+        else {
+            return result;
+        }
+    };
+}
+function parseFieldsSelection(fieldsString) {
+    const query = `query Dummy ${fieldsString}`;
+    const ast = parse(query);
+    const opDef = ast.definitions[0];
+    if (opDef.kind !== 'OperationDefinition' || !opDef.selectionSet) {
+        throw new Error('Invalid GraphQL fields');
+    }
+    return opDef.selectionSet;
+}
+function pickFieldsFromData(data, selectionSet) {
+    const result = {};
+    for (const selection of selectionSet.selections) {
+        if (selection.kind === 'Field') {
+            const key = selection.name.value;
+            if (data != null && key in data) {
+                const value = data[key];
+                if (selection.selectionSet && value != null) {
+                    result[key] = pickFieldsFromData(data[key], selection.selectionSet);
+                }
+                else {
+                    result[key] = data[key];
+                }
+            }
+        }
+    }
+    return result;
+}

package/build/handlers/transformers/wrapWithTokenLimit.js

@@ -0,0 +1,21 @@
+import { countTokens } from '../../utils/tokenCounter.js';
+export function wrapWithTokenLimit(fn, maxTokens) {
+    return async (input) => {
+        const result = await fn(input);
+        if (result == null ||
+            typeof result !== 'object' ||
+            result.kind == 'error') {
+            return result;
+        }
+        const fullText = JSON.stringify(result.data, null, 2);
+        const tokenCount = countTokens(fullText);
+        if (tokenCount > maxTokens) {
+            const roughCut = fullText.slice(0, Math.floor(maxTokens * 4));
+            return {
+                kind: 'ok',
+                data: `${roughCut}\n...(output truncated due to token limit)`,
+            };
+        }
+        return { kind: 'ok', data: fullText };
+    };
+}

package/build/handlers/transformers/wrapWithToolResult.js

@@ -0,0 +1,39 @@
+import { isErrorLike } from '../../types/result.js';
+/**
+ * Convert SafeResult<T> to CallToolResult
+ */
+export function wrapWithToolResult(fn) {
+    return async (input, _extra) => {
+        const result = await fn(input);
+        if (isErrorLike(result)) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: 'text',
+                        text: result.message,
+                    },
+                ],
+            };
+        }
+        const data = result.data;
+        if (typeof data === 'string') {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: data,
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(data, null, 2),
+                },
+            ],
+        };
+    };
+}

package/build/index.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+// Copyright (c) 2025 Nulab inc.
+// Licensed under the MIT License.
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import * as backlogjs from 'backlog-js';
+import dotenv from 'dotenv';
+import { default as env } from 'env-var';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { createTranslationHelper } from './createTranslationHelper.js';
+import { registerDynamicTools, registerTools } from './registerTools.js';
+import { dynamicTools } from './tools/dynamicTools/toolsets.js';
+import { logger } from './utils/logger.js';
+import { createToolRegistrar } from './utils/toolRegistrar.js';
+import { buildToolsetGroup } from './utils/toolsetUtils.js';
+import { wrapServerWithToolRegistry } from './utils/wrapServerWithToolRegistry.js';
+import packageJson from '../package.json' with { type: 'json' };
+const { version } = packageJson;
+dotenv.config();
+const domain = env.get('BACKLOG_DOMAIN').required().asString();
+const apiKey = env.get('BACKLOG_API_KEY').required().asString();
+const backlog = new backlogjs.Backlog({ host: domain, apiKey: apiKey });
+const argv = yargs(hideBin(process.argv))
+    .option('max-tokens', {
+    type: 'number',
+    describe: 'Maximum number of tokens allowed in the response',
+    default: env.get('MAX_TOKENS').default('50000').asIntPositive(),
+})
+    .option('optimize-response', {
+    type: 'boolean',
+    describe: 'Enable GraphQL-style response optimization to include only requested fields',
+    default: env.get('OPTIMIZE_RESPONSE').default('false').asBool(),
+})
+    .option('prefix', {
+    type: 'string',
+    describe: 'Optional string prefix to prepend to all generated outputs',
+    default: env.get('PREFIX').default('').asString(),
+})
+    .option('export-translations', {
+    type: 'boolean',
+    describe: 'Export translations and exit',
+    default: false,
+})
+    .option('enable-toolsets', {
+    type: 'array',
+    describe: `Specify which toolsets to enable. Defaults to 'all'.
+Available toolsets:
+  - space:       Tools for managing Backlog space settings and general information
+  - project:     Tools for managing projects, categories, custom fields, and issue types
+  - issue:       Tools for managing issues and their comments
+  - wiki:        Tools for managing wiki pages
+  - git:         Tools for managing Git repositories and pull requests
+  - notifications: Tools for managing user notifications`,
+    default: env.get('ENABLE_TOOLSETS').default('all').asArray(','),
+})
+    .option('dynamic-toolsets', {
+    type: 'boolean',
+    describe: 'Enable dynamic toolsets such as enable_toolset, list_available_toolsets, etc.',
+    default: env.get('ENABLE_DYNAMIC_TOOLSETS').default('false').asBool(),
+})
+    .parseSync();
+const useFields = argv.optimizeResponse;
+const server = wrapServerWithToolRegistry(new McpServer({
+    name: 'backlog',
+    title: useFields ? 'backlog (field selection enabled)' : 'backlog',
+    version,
+}));
+const transHelper = createTranslationHelper();
+const maxTokens = argv.maxTokens;
+const prefix = argv.prefix;
+let enabledToolsets = argv.enableToolsets;
+// If dynamic toolsets are enabled, remove "all" to allow for selective enabling via commands
+if (argv.dynamicToolsets) {
+    enabledToolsets = enabledToolsets.filter((a) => a != 'all');
+}
+const mcpOption = { useFields: useFields, maxTokens, prefix };
+const toolsetGroup = buildToolsetGroup(backlog, transHelper, enabledToolsets);
+// Register all tools
+registerTools(server, toolsetGroup, mcpOption);
+// Register dynamic tool management tools if enabled
+if (argv.dynamicToolsets) {
+    const registrar = createToolRegistrar(server, toolsetGroup, mcpOption);
+    const dynamicToolsetGroup = dynamicTools(registrar, transHelper, toolsetGroup);
+    registerDynamicTools(server, dynamicToolsetGroup, prefix);
+}
+if (argv.exportTranslations) {
+    const data = transHelper.dump();
+    // eslint-disable-next-line no-console
+    console.log(JSON.stringify(data, null, 2));
+    process.exit(0);
+}
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    logger.info('Backlog MCP Server running on stdio');
+}
+main().catch((error) => {
+    logger.error({ err: error }, 'Fatal error in main()');
+    process.exit(1);
+});

package/build/registerTools.js

@@ -0,0 +1,37 @@
+import { backlogErrorHandler } from './backlog/backlogErrorHandler.js';
+import { composeToolHandler } from './handlers/builders/composeToolHandler.js';
+export function registerTools(server, toolsetGroup, options) {
+    const { useFields, maxTokens, prefix } = options;
+    registerToolsets({
+        server,
+        toolsetGroup,
+        prefix,
+        handlerStrategy: (tool) => 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        composeToolHandler(tool, {
+            useFields,
+            errorHandler: backlogErrorHandler,
+            maxTokens,
+        }),
+    });
+}
+export function registerDynamicTools(server, dynamicToolsetGroup, prefix) {
+    registerToolsets({
+        server,
+        toolsetGroup: dynamicToolsetGroup,
+        prefix,
+        handlerStrategy: (tool) => tool.handler,
+    });
+}
+function registerToolsets({ server, toolsetGroup, prefix, handlerStrategy, }) {
+    for (const toolset of toolsetGroup.toolsets) {
+        if (!toolset.enabled) {
+            continue;
+        }
+        for (const tool of toolset.tools) {
+            const toolNameWithPrefix = `${prefix}${tool.name}`;
+            const handler = handlerStrategy(tool);
+            server.registerOnce(toolNameWithPrefix, tool.description, tool.schema.shape, handler);
+        }
+    }
+}

package/build/tools/addDocument.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { DocumentItemSchema } from '../types/zod/backlogOutputDefinition.js';
+import { buildToolSchema } from '../types/tool.js';
+const addDocumentSchema = buildToolSchema((t) => ({
+    projectId: z
+        .number()
+        .describe(t('TOOL_ADD_DOCUMENT_PROJECT_ID', 'Project ID')),
+    title: z
+        .string()
+        .optional()
+        .describe(t('TOOL_ADD_DOCUMENT_TITLE', 'Title of the document')),
+    content: z
+        .string()
+        .optional()
+        .describe(t('TOOL_ADD_DOCUMENT_CONTENT', 'Content of the document')),
+    emoji: z
+        .string()
+        .optional()
+        .describe(t('TOOL_ADD_DOCUMENT_EMOJI', 'Emoji for the document')),
+    parentId: z
+        .string()
+        .optional()
+        .describe(t('TOOL_ADD_DOCUMENT_PARENT_ID', 'Parent document ID')),
+    addLast: z
+        .boolean()
+        .optional()
+        .describe(t('TOOL_ADD_DOCUMENT_ADD_LAST', 'Add to the end of the list')),
+}));
+export const addDocumentTool = (backlog, { t }) => {
+    return {
+        name: 'addDocument',
+        description: t('TOOL_ADD_DOCUMENT_DESCRIPTION', 'Adds a new document to the specified project.'),
+        schema: z.object(addDocumentSchema(t)),
+        outputSchema: DocumentItemSchema,
+        importantFields: ['id', 'projectId', 'title', 'plain', 'createdUser'],
+        handler: async (params) => {
+            return backlog.addDocument(params);
+        },
+    };
+};

package/build/tools/addIssue.js

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+import { IssueSchema } from '../types/zod/backlogOutputDefinition.js';
+import { buildToolSchema } from '../types/tool.js';
+import { customFieldsToPayload } from '../backlog/customFields.js';
+const addIssueSchema = buildToolSchema((t) => ({
+    projectId: z.number().describe(t('TOOL_ADD_ISSUE_PROJECT_ID', 'Project ID')),
+    summary: z
+        .string()
+        .describe(t('TOOL_ADD_ISSUE_SUMMARY', 'Summary of the issue')),
+    issueTypeId: z
+        .number()
+        .describe(t('TOOL_ADD_ISSUE_ISSUE_TYPE_ID', 'Issue type ID')),
+    priorityId: z
+        .number()
+        .describe(t('TOOL_ADD_ISSUE_PRIORITY_ID', 'Priority ID')),
+    description: z
+        .string()
+        .optional()
+        .describe(t('TOOL_ADD_ISSUE_DESCRIPTION', 'Detailed description of the issue')),
+    startDate: z
+        .string()
+        .optional()
+        .describe(t('TOOL_ADD_ISSUE_START_DATE', 'Scheduled start date (yyyy-MM-dd)')),
+    dueDate: z
+        .string()
+        .optional()
+        .describe(t('TOOL_ADD_ISSUE_DUE_DATE', 'Scheduled due date (yyyy-MM-dd)')),
+    estimatedHours: z
+        .number()
+        .optional()
+        .describe(t('TOOL_ADD_ISSUE_ESTIMATED_HOURS', 'Estimated work hours')),
+    actualHours: z
+        .number()
+        .optional()
+        .describe(t('TOOL_ADD_ISSUE_ACTUAL_HOURS', 'Actual work hours')),
+    categoryId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_ADD_ISSUE_CATEGORY_ID', 'Category IDs')),
+    versionId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_ADD_ISSUE_VERSION_ID', 'Version IDs')),
+    milestoneId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_ADD_ISSUE_MILESTONE_ID', 'Milestone IDs')),
+    assigneeId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_ADD_ISSUE_ASSIGNEE_ID', 'User ID of the assignee')),
+    notifiedUserId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_ADD_ISSUE_NOTIFIED_USER_ID', 'User IDs to notify')),
+    attachmentId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_ADD_ISSUE_ATTACHMENT_ID', 'Attachment IDs')),
+    parentIssueId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_ADD_ISSUE_PARENT_ISSUE_ID', 'Parent issue ID')),
+    customFields: z
+        .array(z.object({
+        id: z
+            .number()
+            .describe(t('TOOL_ADD_ISSUE_CUSTOM_FIELD_ID', 'The ID of the custom field (e.g., 12345)')),
+        value: z
+            .union([z.number(), z.array(z.number())])
+            .optional()
+            .describe('The ID(s) of the custom field item. For single-select fields, provide a number. For multi-select fields, provide an array of numbers representing the selected item IDs.'),
+        otherValue: z
+            .string()
+            .optional()
+            .describe(t('TOOL_ADD_ISSUE_CUSTOM_FIELD_OTHER_VALUE', 'Other value for list type fields')),
+    }))
+        .optional()
+        .describe(t('TOOL_ADD_ISSUE_CUSTOM_FIELDS', 'List of custom fields to set on the issue')),
+}));
+export const addIssueTool = (backlog, { t }) => {
+    return {
+        name: 'add_issue',
+        description: t('TOOL_ADD_ISSUE_DESCRIPTION', 'Creates a new issue in the specified project.'),
+        schema: z.object(addIssueSchema(t)),
+        outputSchema: IssueSchema,
+        importantFields: ['summary', 'issueKey', 'description', 'createdUser'],
+        handler: async ({ customFields, ...params }) => {
+            const customFieldPayload = customFieldsToPayload(customFields);
+            const finalPayload = {
+                ...params,
+                ...customFieldPayload,
+            };
+            return backlog.postIssue(finalPayload);
+        },
+    };
+};

package/build/tools/addIssueComment.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { IssueCommentSchema } from '../types/zod/backlogOutputDefinition.js';
+import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
+const addIssueCommentSchema = buildToolSchema((t) => ({
+    issueId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_ADD_ISSUE_COMMENT_ID', 'The numeric ID of the issue (e.g., 12345)')),
+    issueKey: z
+        .string()
+        .optional()
+        .describe(t('TOOL_ADD_ISSUE_COMMENT_KEY', "The key of the issue (e.g., 'PROJ-123')")),
+    content: z
+        .string()
+        .describe(t('TOOL_ADD_ISSUE_COMMENT_CONTENT', 'Comment content')),
+    notifiedUserId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_ADD_ISSUE_COMMENT_NOTIFIED_USER_ID', 'User IDs to notify')),
+    attachmentId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_ADD_ISSUE_COMMENT_ATTACHMENT_ID', 'Attachment IDs')),
+}));
+export const addIssueCommentTool = (backlog, { t }) => {
+    return {
+        name: 'add_issue_comment',
+        description: t('TOOL_ADD_ISSUE_COMMENT_DESCRIPTION', 'Adds a comment to an issue'),
+        schema: z.object(addIssueCommentSchema(t)),
+        outputSchema: IssueCommentSchema,
+        handler: async ({ issueId, issueKey, content, notifiedUserId, attachmentId, }) => {
+            const result = resolveIdOrKey('issue', { id: issueId, key: issueKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            return backlog.postIssueComments(result.value, {
+                content,
+                notifiedUserId,
+                attachmentId,
+            });
+        },
+    };
+};

package/build/tools/addProject.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { ProjectSchema } from '../types/zod/backlogOutputDefinition.js';
+const addProjectSchema = buildToolSchema((t) => ({
+    name: z.string().describe(t('TOOL_ADD_PROJECT_NAME', 'Project name')),
+    key: z.string().describe(t('TOOL_ADD_PROJECT_KEY', 'Project key')),
+    chartEnabled: z
+        .boolean()
+        .optional()
+        .describe(t('TOOL_ADD_PROJECT_CHART_ENABLED', 'Whether to enable chart (default: false)')),
+    subtaskingEnabled: z
+        .boolean()
+        .optional()
+        .describe(t('TOOL_ADD_PROJECT_SUBTASKING_ENABLED', 'Whether to enable subtasking (default: false)')),
+    projectLeaderCanEditProjectLeader: z
+        .boolean()
+        .optional()
+        .describe(t('TOOL_ADD_PROJECT_LEADER_CAN_EDIT', 'Whether project leaders can edit other project leaders (default: false)')),
+    textFormattingRule: z
+        .enum(['backlog', 'markdown'])
+        .optional()
+        .describe(t('TOOL_ADD_PROJECT_TEXT_FORMATTING', "Text formatting rule (default: 'backlog')")),
+}));
+export const addProjectTool = (backlog, { t }) => {
+    return {
+        name: 'add_project',
+        description: t('TOOL_ADD_PROJECT_DESCRIPTION', 'Creates a new project'),
+        schema: z.object(addProjectSchema(t)),
+        outputSchema: ProjectSchema,
+        handler: async ({ name, key, chartEnabled, subtaskingEnabled, projectLeaderCanEditProjectLeader, textFormattingRule, }) => backlog.postProject({
+            name,
+            key,
+            chartEnabled: chartEnabled ?? false,
+            subtaskingEnabled: subtaskingEnabled ?? false,
+            projectLeaderCanEditProjectLeader: projectLeaderCanEditProjectLeader ?? false,
+            textFormattingRule: textFormattingRule ?? 'backlog',
+        }),
+    };
+};