backlog-mcp-server 0.4.0

package/build/tools/deleteProject.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { ProjectSchema } from '../types/zod/backlogOutputDefinition.js';
+import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
+const deleteProjectSchema = buildToolSchema((t) => ({
+    projectId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_DELETE_PROJECT_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
+    projectKey: z
+        .string()
+        .optional()
+        .describe(t('TOOL_DELETE_PROJECT_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
+}));
+export const deleteProjectTool = (backlog, { t }) => {
+    return {
+        name: 'delete_project',
+        description: t('TOOL_DELETE_PROJECT_DESCRIPTION', 'Deletes a project'),
+        schema: z.object(deleteProjectSchema(t)),
+        outputSchema: ProjectSchema,
+        handler: async ({ projectId, projectKey }) => {
+            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            return backlog.deleteProject(result.value);
+        },
+    };
+};

package/build/tools/downloadDocumentAttachment.js

@@ -0,0 +1 @@
+export {};

package/build/tools/dynamicTools/toolsets.js

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import { buildToolSchema, } from '../../types/tool.js';
+export const dynamicTools = function (toolRegistrar, helper, toolsetGroup) {
+    return {
+        toolsets: [
+            {
+                name: 'dynamic_tools',
+                description: 'Tools for managing Backlog space settings and general information.',
+                enabled: true,
+                tools: [
+                    enableToolsetTool(toolRegistrar, helper),
+                    listAvailableToolsets(helper, toolsetGroup),
+                    getToolsetTools(helper, toolsetGroup),
+                ],
+            },
+        ],
+    };
+};
+const enableToolsetSchema = buildToolSchema((t) => ({
+    toolset: z
+        .string()
+        .describe(t('TOOL_ENABLE_TOOLSET_TOOLSET', 'Enable a toolset')),
+}));
+export const enableToolsetTool = (toolRegistrar, { t }) => {
+    return {
+        name: 'enable_toolset',
+        description: t('TOOL_ENABLE_TOOLSET_DESCRIPTION', 'Enable one of the sets of tools the GitHub MCP server provides, use get_toolset_tools and list_available_toolsets first to see what this will enable'),
+        schema: z.object(enableToolsetSchema(t)),
+        handler: async ({ toolset }) => {
+            const msg = await toolRegistrar.enableToolsetAndRefresh(toolset);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: msg,
+                    },
+                ],
+            };
+        },
+    };
+};
+export const listAvailableToolsets = ({ t }, toolsetGroup) => {
+    return {
+        name: 'list_available_toolsets',
+        description: t('TOOL_LIST_AVAILABLE_TOOLSETS_DESCRIPTION', 'List all available toolsets.'),
+        schema: z.object({}),
+        handler: async () => {
+            const result = toolsetGroup.toolsets.map((ts) => ({
+                name: ts.name,
+                description: ts.description,
+                currentlyEnabled: ts.enabled,
+                canEnable: true,
+            }));
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        },
+    };
+};
+const getToolsetToolsSchema = buildToolSchema((t) => ({
+    toolset: z
+        .string()
+        .describe(t('TOOL_GET_TOOLSET_TOOLS_TOOLSET', 'Toolset name to inspect')),
+}));
+export const getToolsetTools = ({ t }, toolsetGroup) => {
+    return {
+        name: 'get_toolset_tools',
+        description: t('TOOL_GET_TOOLSET_TOOLS_DESCRIPTION', 'List all tools in a specific toolset.'),
+        schema: z.object(getToolsetToolsSchema(t)),
+        handler: async ({ toolset }) => {
+            const found = toolsetGroup.toolsets.find((ts) => ts.name === toolset);
+            if (!found) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Toolset '${toolset}' not found.`,
+                        },
+                    ],
+                };
+            }
+            const tools = found.tools.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                toolset: found.name,
+                canEnable: true,
+            }));
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(tools, null, 2),
+                    },
+                ],
+            };
+        },
+    };
+};

package/build/tools/getCategories.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { CategorySchema } from '../types/zod/backlogOutputDefinition.js';
+import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
+const getCategoriesSchema = buildToolSchema((t) => ({
+    projectId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_CATEGORIES_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
+    projectKey: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_CATEGORIES_PROJECT_ID', "The key of the project (e.g., 'PROJECT')")),
+}));
+export const getCategoriesTool = (backlog, { t }) => {
+    return {
+        name: 'get_categories',
+        description: t('TOOL_GET_CATEGORIES_DESCRIPTION', 'Returns list of categories for a project'),
+        schema: z.object(getCategoriesSchema(t)),
+        importantFields: ['id', 'projectId', 'name'],
+        outputSchema: CategorySchema,
+        handler: async ({ projectId, projectKey }) => {
+            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            return backlog.getCategories(result.value);
+        },
+    };
+};

package/build/tools/getCustomFields.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { CustomFieldSchema } from '../types/zod/backlogOutputDefinition.js';
+import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
+const getCustomFieldsInputSchema = buildToolSchema((t) => ({
+    projectId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_CUSTOM_FIELDS_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
+    projectKey: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_CUSTOM_FIELDS_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
+}));
+export const getCustomFieldsTool = (backlog, { t }) => {
+    const inputSchemaObject = z.object(getCustomFieldsInputSchema(t)); // Create the ZodObject for input
+    return {
+        name: 'get_custom_fields',
+        description: t('TOOL_GET_CUSTOM_FIELDS_DESCRIPTION', 'Returns list of custom fields for a project'),
+        schema: inputSchemaObject,
+        outputSchema: CustomFieldSchema,
+        importantFields: [
+            'id',
+            'name',
+            'typeId',
+            'required',
+            'applicableIssueTypes',
+        ],
+        handler: async ({ projectId, projectKey }) => {
+            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            return backlog.getCustomFields(result.value);
+        },
+    };
+};

package/build/tools/getDocument.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { DocumentItemSchema } from '../types/zod/backlogOutputDefinition.js';
+import { buildToolSchema } from '../types/tool.js';
+const getDocumentSchema = buildToolSchema((t) => ({
+    documentId: z
+        .string()
+        .describe(t('TOOL_GET_DOCUMENT_DOCUMENT_ID', 'Document ID')),
+}));
+export const getDocumentTool = (backlog, { t }) => {
+    return {
+        name: 'get_document',
+        description: t('TOOL_GET_DOCUMENT_DESCRIPTION', 'Gets information about a document.'),
+        schema: z.object(getDocumentSchema(t)),
+        outputSchema: DocumentItemSchema,
+        importantFields: ['id', 'title', 'createdUser'],
+        handler: async ({ documentId }) => {
+            return backlog.getDocument(documentId);
+        },
+    };
+};

package/build/tools/getDocumentTree.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { DocumentTreeFullSchemaZ, } from '../types/zod/backlogOutputDefinition.js';
+import { buildToolSchema } from '../types/tool.js';
+const getDocumentTreeSchema = buildToolSchema((t) => ({
+    projectIdOrKey: z
+        .union([z.string(), z.number()])
+        .describe(t('TOOL_GET_DOCUMENT_TREE_PROJECT_ID_OR_KEY', 'Project ID or Key')),
+}));
+export const getDocumentTreeTool = (backlog, { t }) => {
+    return {
+        name: 'get_document_tree',
+        description: t('TOOL_GET_DOCUMENT_TREE_DESCRIPTION', 'Gets the document tree of a project.'),
+        schema: z.object(getDocumentTreeSchema(t)),
+        outputSchema: DocumentTreeFullSchemaZ,
+        importantFields: ['projectId', 'activeTree', 'trashTree'],
+        handler: async ({ projectIdOrKey }) => {
+            return backlog.getDocumentTree(projectIdOrKey);
+        },
+    };
+};

package/build/tools/getDocuments.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { DocumentItemSchema } from '../types/zod/backlogOutputDefinition.js';
+import { buildToolSchema } from '../types/tool.js';
+const getDocumentsSchema = buildToolSchema((t) => ({
+    projectIds: z
+        .array(z.number())
+        .describe(t('TOOL_GET_DOCUMENTS_PROJECT_ID_LIST', 'Project ID List')),
+    offset: z
+        .number()
+        .optional()
+        .default(0)
+        .describe(t('TOOL_GET_DOCUMENTS_OFFSET', 'Offset for pagination (default is 0)')),
+}));
+export const getDocumentsTool = (backlog, { t }) => {
+    return {
+        name: 'get_documents',
+        description: t('TOOL_GET_DOCUMENTS_DESCRIPTION', 'Gets a list of documents in a project.'),
+        schema: z.object(getDocumentsSchema(t)),
+        outputSchema: DocumentItemSchema,
+        importantFields: ['id', 'projectId', 'title', 'plain'],
+        handler: async ({ projectIds, offset }) => {
+            return backlog.getDocuments({ projectId: projectIds, offset });
+        },
+    };
+};

package/build/tools/getGitRepositories.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { GitRepositorySchema } from '../types/zod/backlogOutputDefinition.js';
+import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
+const getGitRepositoriesSchema = buildToolSchema((t) => ({
+    projectId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_GIT_REPOSITORIES_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
+    projectKey: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_GIT_REPOSITORIES_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
+}));
+export const getGitRepositoriesTool = (backlog, { t }) => {
+    return {
+        name: 'get_git_repositories',
+        description: t('TOOL_GET_GIT_REPOSITORIES_DESCRIPTION', 'Returns list of Git repositories for a project'),
+        schema: z.object(getGitRepositoriesSchema(t)),
+        outputSchema: GitRepositorySchema,
+        handler: async ({ projectId, projectKey }) => {
+            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            return backlog.getGitRepositories(result.value);
+        },
+    };
+};

package/build/tools/getGitRepository.js

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { GitRepositorySchema } from '../types/zod/backlogOutputDefinition.js';
+import { resolveIdOrKey, resolveIdOrName } from '../utils/resolveIdOrKey.js';
+const getGitRepositorySchema = buildToolSchema((t) => ({
+    projectId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_GIT_REPOSITORY_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
+    projectKey: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_GIT_REPOSITORY_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
+    repoId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_GIT_REPOSITORY_REPO_ID', 'Repository ID')),
+    repoName: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_GIT_REPOSITORY_REPO_NAME', 'Repository name')),
+}));
+export const getGitRepositoryTool = (backlog, { t }) => {
+    return {
+        name: 'get_git_repository',
+        description: t('TOOL_GET_GIT_REPOSITORY_DESCRIPTION', 'Returns information about a specific Git repository'),
+        schema: z.object(getGitRepositorySchema(t)),
+        outputSchema: GitRepositorySchema,
+        handler: async ({ projectId, projectKey, repoId, repoName }) => {
+            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            const repoResult = resolveIdOrName('repository', { id: repoId, name: repoName }, t);
+            if (!repoResult.ok) {
+                throw repoResult.error;
+            }
+            return backlog.getGitRepository(result.value, String(repoResult.value));
+        },
+    };
+};

package/build/tools/getIssue.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 getIssueSchema = buildToolSchema((t) => ({
+    issueId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_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 getIssueTool = (backlog, { t }) => {
+    return {
+        name: 'get_issue',
+        description: t('TOOL_GET_ISSUE_DESCRIPTION', 'Returns information about a specific issue'),
+        outputSchema: IssueSchema,
+        schema: z.object(getIssueSchema(t)),
+        handler: async ({ issueId, issueKey }) => {
+            const result = resolveIdOrKey('issue', { id: issueId, key: issueKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            return backlog.getIssue(result.value);
+        },
+    };
+};

package/build/tools/getIssueComments.js

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { IssueCommentSchema } from '../types/zod/backlogOutputDefinition.js';
+import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
+const getIssueCommentsSchema = buildToolSchema((t) => ({
+    issueId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_ISSUE_COMMENTS_ISSUE_ID', 'The numeric ID of the issue (e.g., 12345)')),
+    issueKey: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_ISSUE_COMMENTS_ISSUE_KEY', "The key of the issue (e.g., 'PROJ-123')")),
+    minId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_ISSUE_COMMENTS_MIN_ID', 'Minimum comment ID')),
+    maxId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_ISSUE_COMMENTS_MAX_ID', 'Maximum comment ID')),
+    count: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_ISSUE_COMMENTS_COUNT', 'Number of comments to retrieve')),
+    order: z
+        .enum(['asc', 'desc'])
+        .optional()
+        .describe(t('TOOL_GET_ISSUE_COMMENTS_ORDER', 'Sort order')),
+}));
+export const getIssueCommentsTool = (backlog, { t }) => {
+    return {
+        name: 'get_issue_comments',
+        description: t('TOOL_GET_ISSUE_COMMENTS_DESCRIPTION', 'Returns list of comments for an issue'),
+        schema: z.object(getIssueCommentsSchema(t)),
+        outputSchema: IssueCommentSchema,
+        handler: async ({ issueId, issueKey, ...params }) => {
+            const result = resolveIdOrKey('issue', { id: issueId, key: issueKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            return backlog.getIssueComments(result.value, params);
+        },
+    };
+};

package/build/tools/getIssueTypes.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { IssueTypeSchema } from '../types/zod/backlogOutputDefinition.js';
+import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
+const getIssueTypesSchema = buildToolSchema((t) => ({
+    projectId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_GIT_REPOSITORIES_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
+    projectKey: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_GIT_REPOSITORIES_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
+}));
+export const getIssueTypesTool = (backlog, { t }) => {
+    return {
+        name: 'get_issue_types',
+        description: t('TOOL_GET_ISSUE_TYPES_DESCRIPTION', 'Returns list of issue types for a project'),
+        schema: z.object(getIssueTypesSchema(t)),
+        outputSchema: IssueTypeSchema,
+        importantFields: ['id', 'name'],
+        handler: async ({ projectId, projectKey }) => {
+            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            return backlog.getIssueTypes(result.value);
+        },
+    };
+};

package/build/tools/getIssues.js

@@ -0,0 +1,155 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { IssueSchema } from '../types/zod/backlogOutputDefinition.js';
+import { customFieldsToPayload } from '../backlog/customFields.js';
+const getIssuesSchema = buildToolSchema((t) => ({
+    projectId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_PROJECT_ID', 'Project IDs')),
+    issueTypeId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_ISSUE_TYPE_ID', 'Issue type IDs')),
+    categoryId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_CATEGORY_ID', 'Category IDs')),
+    versionId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_VERSION_ID', 'Version IDs')),
+    milestoneId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_MILESTONE_ID', 'Milestone IDs')),
+    statusId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_STATUS_ID', 'Status IDs')),
+    priorityId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_PRIORITY_ID', 'Priority IDs')),
+    assigneeId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_ASSIGNEE_ID', 'Assignee user IDs')),
+    createdUserId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_CREATED_USER_ID', 'Created user IDs')),
+    resolutionId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_RESOLUTION_ID', 'Resolution IDs')),
+    parentIssueId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_PARENT_ISSUE_ID', 'Parent issue IDs')),
+    keyword: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_KEYWORD', 'Keyword to search for in issues')),
+    startDateSince: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_START_DATE_SINCE', 'Start date since (yyyy-MM-dd)')),
+    startDateUntil: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_START_DATE_UNTIL', 'Start date until (yyyy-MM-dd)')),
+    dueDateSince: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_DUE_DATE_SINCE', 'Due date since (yyyy-MM-dd)')),
+    dueDateUntil: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_DUE_DATE_UNTIL', 'Due date until (yyyy-MM-dd)')),
+    createdSince: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_CREATED_SINCE', 'Created since (yyyy-MM-dd)')),
+    createdUntil: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_CREATED_UNTIL', 'Created until (yyyy-MM-dd)')),
+    updatedSince: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_UPDATED_SINCE', 'Updated since (yyyy-MM-dd)')),
+    updatedUntil: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_UPDATED_UNTIL', 'Updated until (yyyy-MM-dd)')),
+    sort: z
+        .enum([
+        'issueType',
+        'category',
+        'version',
+        'milestone',
+        'summary',
+        'status',
+        'priority',
+        'attachment',
+        'sharedFile',
+        'created',
+        'createdUser',
+        'updated',
+        'updatedUser',
+        'assignee',
+        'startDate',
+        'dueDate',
+        'estimatedHours',
+        'actualHours',
+        'childIssue',
+    ])
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_SORT', 'Sort field')),
+    order: z
+        .enum(['asc', 'desc'])
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_ORDER', 'Sort order')),
+    offset: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_OFFSET', 'Offset for pagination')),
+    count: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_COUNT', 'Number of issues to retrieve')),
+    customFields: z
+        .array(z.object({
+        id: z
+            .number()
+            .describe(t('TOOL_GET_ISSUES_CUSTOM_FIELD_ID', 'Custom field ID')),
+        value: z
+            .union([z.string(), z.number(), z.array(z.string())])
+            .describe(t('TOOL_GET_ISSUES_CUSTOM_FIELD_VALUE', 'Custom field value')),
+    }))
+        .optional()
+        .describe(t('TOOL_GET_ISSUES_CUSTOM_FIELDS', 'Custom fields')),
+}));
+export const getIssuesTool = (backlog, { t }) => {
+    return {
+        name: 'get_issues',
+        description: t('TOOL_GET_ISSUES_DESCRIPTION', 'Returns list of issues'),
+        schema: z.object(getIssuesSchema(t)),
+        importantFields: [
+            'projectId',
+            'issueKey',
+            'keyId',
+            'summary',
+            'description',
+            'issueType',
+        ],
+        outputSchema: IssueSchema,
+        handler: async ({ customFields, ...rest }) => {
+            return backlog.getIssues({
+                ...rest,
+                ...customFieldsToPayload(customFields),
+            });
+        },
+    };
+};

package/build/tools/getMyself.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { UserSchema } from '../types/zod/backlogOutputDefinition.js';
+const getMyselfSchema = buildToolSchema((_t) => ({}));
+export const getMyselfTool = (backlog, { t }) => {
+    return {
+        name: 'get_myself',
+        description: t('TOOL_GET_MYSELF_DESCRIPTION', 'Returns information about the authenticated user'),
+        schema: z.object(getMyselfSchema(t)),
+        outputSchema: UserSchema,
+        importantFields: ['id', 'userId', 'name', 'roleType'],
+        handler: async () => backlog.getMyself(),
+    };
+};

package/build/tools/getNotifications.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { NotificationSchema } from '../types/zod/backlogOutputDefinition.js';
+const getNotificationsSchema = buildToolSchema((t) => ({
+    minId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_NOTIFICATIONS_MIN_ID', 'Minimum notification ID')),
+    maxId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_NOTIFICATIONS_MAX_ID', 'Maximum notification ID')),
+    count: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_NOTIFICATIONS_COUNT', 'Number of notifications to retrieve')),
+    order: z
+        .enum(['asc', 'desc'])
+        .optional()
+        .describe(t('TOOL_GET_NOTIFICATIONS_ORDER', 'Sort order')),
+}));
+export const getNotificationsTool = (backlog, { t }) => {
+    return {
+        name: 'get_notifications',
+        description: t('TOOL_GET_NOTIFICATIONS_DESCRIPTION', 'Returns list of notifications'),
+        schema: z.object(getNotificationsSchema(t)),
+        outputSchema: NotificationSchema,
+        handler: async ({ minId, maxId, count, order }) => backlog.getNotifications({
+            minId,
+            maxId,
+            count,
+            order,
+        }),
+    };
+};