backlog-mcp-server 0.4.0

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,102 @@
+#!/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 { registerDyamicTools, registerTools } from './registerTools.js';
+import { dynamicTools } from './tools/dynamicTools/toolsets.js';
+import { createToolRegistrar } from './utils/toolRegistrar.js';
+import { buildToolsetGroup } from './utils/toolsetUtils.js';
+import { wrapServerWithToolRegistry } from './utils/wrapServerWithToolRegistry.js';
+import { VERSION } from './version.js';
+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',
+    description: useFields
+        ? `You can include only the fields you need using GraphQL-style syntax.
+Start with the example above and customize freely.`
+        : undefined,
+    version: 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);
+    registerDyamicTools(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);
+    console.error('Backlog MCP Server running on stdio');
+}
+main().catch((error) => {
+    console.error('Fatal error in main():', error);
+    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 registerDyamicTools(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/addIssue.js

@@ -0,0 +1,94 @@
+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.string().max(255), z.number(), z.array(z.string())]),
+        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',
+        }),
+    };
+};

package/build/tools/addPullRequest.js

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { PullRequestSchema } from '../types/zod/backlogOutputDefinition.js';
+import { resolveIdOrKey, resolveIdOrName } from '../utils/resolveIdOrKey.js';
+const addPullRequestSchema = buildToolSchema((t) => ({
+    projectId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_ADD_PULL_REQUEST_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
+    projectKey: z
+        .string()
+        .optional()
+        .describe(t('TOOL_ADD_PULL_REQUEST_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
+    repoId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_ADD_PULL_REQUEST_REPO_ID', 'Repository ID')),
+    repoName: z
+        .string()
+        .optional()
+        .describe(t('TOOL_ADD_PULL_REQUEST_REPO_NAME', 'Repository name')),
+    summary: z
+        .string()
+        .describe(t('TOOL_ADD_PULL_REQUEST_SUMMARY', 'Summary of the pull request')),
+    description: z
+        .string()
+        .describe(t('TOOL_ADD_PULL_REQUEST_DESCRIPTION', 'Description of the pull request')),
+    base: z
+        .string()
+        .describe(t('TOOL_ADD_PULL_REQUEST_BASE', 'Base branch name')),
+    branch: z
+        .string()
+        .describe(t('TOOL_ADD_PULL_REQUEST_BRANCH', 'Branch name to merge')),
+    issueId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_ADD_PULL_REQUEST_ISSUE_ID', 'Issue ID to link')),
+    assigneeId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_ADD_PULL_REQUEST_ASSIGNEE_ID', 'User ID of the assignee')),
+    notifiedUserId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_ADD_PULL_REQUEST_NOTIFIED_USER_ID', 'User IDs to notify')),
+}));
+export const addPullRequestTool = (backlog, { t }) => {
+    return {
+        name: 'add_pull_request',
+        description: t('TOOL_ADD_PULL_REQUEST_DESCRIPTION', 'Creates a new pull request'),
+        schema: z.object(addPullRequestSchema(t)),
+        outputSchema: PullRequestSchema,
+        handler: async ({ projectId, projectKey, repoId, repoName, ...params }) => {
+            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            const repoRes = resolveIdOrName('repository', { id: repoId, name: repoName }, t);
+            if (!repoRes.ok) {
+                throw repoRes.error;
+            }
+            return backlog.postPullRequest(result.value, String(repoRes.value), params);
+        },
+    };
+};

package/build/tools/addPullRequestComment.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { PullRequestCommentSchema } from '../types/zod/backlogOutputDefinition.js';
+import { resolveIdOrKey, resolveIdOrName } from '../utils/resolveIdOrKey.js';
+const addPullRequestCommentSchema = buildToolSchema((t) => ({
+    projectId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_ADD_PULL_REQUEST_COMMENT_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
+    projectKey: z
+        .string()
+        .optional()
+        .describe(t('TOOL_ADD_PULL_REQUEST_COMMENT_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
+    repoId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_ADD_PULL_REQUEST_REPO_ID', 'Repository ID')),
+    repoName: z
+        .string()
+        .optional()
+        .describe(t('TOOL_ADD_PULL_REQUEST_REPO_NAME', 'Repository name')),
+    number: z
+        .number()
+        .describe(t('TOOL_ADD_PULL_REQUEST_COMMENT_NUMBER', 'Pull request number')),
+    content: z
+        .string()
+        .describe(t('TOOL_ADD_PULL_REQUEST_COMMENT_CONTENT', 'Comment content')),
+    notifiedUserId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_ADD_PULL_REQUEST_COMMENT_NOTIFIED_USER_ID', 'User IDs to notify')),
+}));
+export const addPullRequestCommentTool = (backlog, { t }) => {
+    return {
+        name: 'add_pull_request_comment',
+        description: t('TOOL_ADD_PULL_REQUEST_COMMENT_DESCRIPTION', 'Adds a comment to a pull request'),
+        schema: z.object(addPullRequestCommentSchema(t)),
+        outputSchema: PullRequestCommentSchema,
+        importantFields: ['id', 'content', 'createdUser'],
+        handler: async ({ projectId, projectKey, repoId, repoName, number, ...params }) => {
+            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            const repoRes = resolveIdOrName('repository', { id: repoId, name: repoName }, t);
+            if (!repoRes.ok) {
+                throw repoRes.error;
+            }
+            return backlog.postPullRequestComments(result.value, String(repoRes.value), number, params);
+        },
+    };
+};

package/build/tools/addWiki.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { WikiSchema } from '../types/zod/backlogOutputDefinition.js';
+const addWikiSchema = buildToolSchema((t) => ({
+    projectId: z.number().describe(t('TOOL_ADD_WIKI_PROJECT_ID', 'Project ID')),
+    name: z.string().describe(t('TOOL_ADD_WIKI_NAME', 'Name of the wiki page')),
+    content: z
+        .string()
+        .describe(t('TOOL_ADD_WIKI_CONTENT', 'Content of the wiki page')),
+    mailNotify: z
+        .boolean()
+        .optional()
+        .describe(t('TOOL_ADD_WIKI_MAIL_NOTIFY', 'Whether to send notification emails (default: false)')),
+}));
+export const addWikiTool = (backlog, { t }) => {
+    return {
+        name: 'add_wiki',
+        description: t('TOOL_ADD_WIKI_DESCRIPTION', 'Creates a new wiki page'),
+        schema: z.object(addWikiSchema(t)),
+        outputSchema: WikiSchema,
+        importantFields: ['id', 'name', 'content', 'createdUser'],
+        handler: async ({ projectId, name, content, mailNotify }) => backlog.postWiki({
+            projectId,
+            name,
+            content,
+            mailNotify,
+        }),
+    };
+};

package/build/tools/countIssues.js

@@ -0,0 +1,111 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { IssueCountSchema } from '../types/zod/backlogOutputDefinition.js';
+import { customFieldsToPayload } from '../backlog/customFields.js';
+const countIssuesSchema = buildToolSchema((t) => ({
+    projectId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_PROJECT_ID', 'Project IDs')),
+    issueTypeId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_ISSUE_TYPE_ID', 'Issue type IDs')),
+    categoryId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_CATEGORY_ID', 'Category IDs')),
+    versionId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_VERSION_ID', 'Version IDs')),
+    milestoneId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_MILESTONE_ID', 'Milestone IDs')),
+    statusId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_STATUS_ID', 'Status IDs')),
+    priorityId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_PRIORITY_ID', 'Priority IDs')),
+    assigneeId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_ASSIGNEE_ID', 'Assignee user IDs')),
+    createdUserId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_CREATED_USER_ID', 'Created user IDs')),
+    resolutionId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_RESOLUTION_ID', 'Resolution IDs')),
+    parentIssueId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_PARENT_ISSUE_ID', 'Parent issue IDs')),
+    keyword: z
+        .string()
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_KEYWORD', 'Keyword to search for in issues')),
+    startDateSince: z
+        .string()
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_START_DATE_SINCE', 'Start date since (yyyy-MM-dd)')),
+    startDateUntil: z
+        .string()
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_START_DATE_UNTIL', 'Start date until (yyyy-MM-dd)')),
+    dueDateSince: z
+        .string()
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_DUE_DATE_SINCE', 'Due date since (yyyy-MM-dd)')),
+    dueDateUntil: z
+        .string()
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_DUE_DATE_UNTIL', 'Due date until (yyyy-MM-dd)')),
+    createdSince: z
+        .string()
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_CREATED_SINCE', 'Created since (yyyy-MM-dd)')),
+    createdUntil: z
+        .string()
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_CREATED_UNTIL', 'Created until (yyyy-MM-dd)')),
+    updatedSince: z
+        .string()
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_UPDATED_SINCE', 'Updated since (yyyy-MM-dd)')),
+    updatedUntil: z
+        .string()
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_UPDATED_UNTIL', 'Updated until (yyyy-MM-dd)')),
+    customFields: z
+        .array(z.object({
+        id: z
+            .number()
+            .describe(t('TOOL_COUNT_ISSUES_CUSTOM_FIELD_ID', 'Custom field ID')),
+        value: z
+            .union([z.string(), z.number(), z.array(z.string())])
+            .describe(t('TOOL_COUNT_ISSUES_CUSTOM_FIELD_VALUE', 'Custom field value')),
+    }))
+        .optional()
+        .describe(t('TOOL_COUNT_ISSUES_CUSTOM_FIELDS', 'Custom fields')),
+}));
+export const countIssuesTool = (backlog, { t }) => {
+    return {
+        name: 'count_issues',
+        description: t('TOOL_COUNT_ISSUES_DESCRIPTION', 'Returns count of issues'),
+        schema: z.object(countIssuesSchema(t)),
+        outputSchema: IssueCountSchema,
+        handler: async ({ customFields, ...rest }) => {
+            return backlog.getIssuesCount({
+                ...rest,
+                ...customFieldsToPayload(customFields),
+            });
+        },
+    };
+};

package/build/tools/deleteIssue.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { IssueSchema } from '../types/zod/backlogOutputDefinition.js';
+import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
+const deleteIssueSchema = buildToolSchema((t) => ({
+    issueId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_DELETE_ISSUE_ISSUE_ID', 'The numeric ID of the issue (e.g., 12345)')),
+    issueKey: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_ISSUE_ISSUE_KEY', "The key of the issue (e.g., 'PROJ-123')")),
+}));
+export const deleteIssueTool = (backlog, { t }) => {
+    return {
+        name: 'delete_issue',
+        description: t('TOOL_DELETE_ISSUE_DESCRIPTION', 'Deletes an issue'),
+        schema: z.object(deleteIssueSchema(t)),
+        outputSchema: IssueSchema,
+        handler: async ({ issueId, issueKey }) => {
+            const result = resolveIdOrKey('issue', { id: issueId, key: issueKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            return backlog.deleteIssue(result.value);
+        },
+    };
+};