backlog-mcp-server 0.7.0 → 0.8.0

package/build/tools/getPullRequestsCount.js

@@ -1,57 +0,0 @@
-import { z } from 'zod';
-import { buildToolSchema } from '../types/tool.js';
-import { PullRequestCountSchema } from '../types/zod/backlogOutputDefinition.js';
-import { resolveIdOrKey, resolveIdOrName } from '../utils/resolveIdOrKey.js';
-const getPullRequestsCountSchema = buildToolSchema((t) => ({
-    projectId: z
-        .number()
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUESTS_COUNT_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
-    projectKey: z
-        .string()
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUESTS_COUNT_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
-    repoId: z
-        .number()
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUESTS_COUNT_REPO_ID', 'Repository ID')),
-    repoName: z
-        .string()
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUESTS_COUNT_REPO_NAME', 'Repository name')),
-    statusId: z
-        .array(z.number())
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUESTS_COUNT_STATUS_ID', 'Status IDs')),
-    assigneeId: z
-        .array(z.number())
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUESTS_COUNT_ASSIGNEE_ID', 'Assignee user IDs')),
-    issueId: z
-        .array(z.number())
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUESTS_COUNT_ISSUE_ID', 'Issue IDs')),
-    createdUserId: z
-        .array(z.number())
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUESTS_COUNT_CREATED_USER_ID', 'Created user IDs')),
-}));
-export const getPullRequestsCountTool = (backlog, { t }) => {
-    return {
-        name: 'get_pull_requests_count',
-        description: t('TOOL_GET_PULL_REQUESTS_COUNT_DESCRIPTION', 'Returns count of pull requests for a repository'),
-        schema: z.object(getPullRequestsCountSchema(t)),
-        outputSchema: PullRequestCountSchema,
-        handler: async ({ projectId, projectKey, repoId, repoName, ...params }) => {
-            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.getPullRequestsCount(result.value, String(repoResult.value), params);
-        },
-    };
-};

package/build/tools/getResolutions.js

@@ -1,13 +0,0 @@
-import { z } from 'zod';
-import { buildToolSchema } from '../types/tool.js';
-import { ResolutionSchema } from '../types/zod/backlogOutputDefinition.js';
-const getResolutionsSchema = buildToolSchema((_t) => ({}));
-export const getResolutionsTool = (backlog, { t }) => {
-    return {
-        name: 'get_resolutions',
-        description: t('TOOL_GET_RESOLUTIONS_DESCRIPTION', 'Returns list of issue resolutions'),
-        schema: z.object(getResolutionsSchema(t)),
-        outputSchema: ResolutionSchema,
-        handler: async () => backlog.getResolutions(),
-    };
-};

package/build/tools/getSpace.js

@@ -1,14 +0,0 @@
-import { z } from 'zod';
-import { buildToolSchema } from '../types/tool.js';
-import { SpaceSchema } from '../types/zod/backlogOutputDefinition.js';
-const getSpaceSchema = buildToolSchema((_t) => ({}));
-export const getSpaceTool = (backlog, { t }) => {
-    return {
-        name: 'get_space',
-        description: t('TOOL_GET_SPACE_DESCRIPTION', 'Returns information about the Backlog space'),
-        schema: z.object(getSpaceSchema(t)),
-        outputSchema: SpaceSchema,
-        importantFields: ['spaceKey', 'name', 'lang', 'timezone'],
-        handler: async () => backlog.getSpace(),
-    };
-};

package/build/tools/getUsers.js

@@ -1,14 +0,0 @@
-import { z } from 'zod';
-import { buildToolSchema } from '../types/tool.js';
-import { UserSchema } from '../types/zod/backlogOutputDefinition.js';
-const getUsersSchema = buildToolSchema((_t) => ({}));
-export const getUsersTool = (backlog, { t }) => {
-    return {
-        name: 'get_users',
-        description: t('TOOL_GET_USERS_DESCRIPTION', 'Returns list of users in the Backlog space'),
-        schema: z.object(getUsersSchema(t)),
-        outputSchema: UserSchema,
-        importantFields: ['userId', 'name', 'roleType', 'lang'],
-        handler: async () => backlog.getUsers(),
-    };
-};

package/build/tools/getVersionMilestoneList.js

@@ -1,37 +0,0 @@
-import { z } from 'zod';
-import { buildToolSchema } from '../types/tool.js';
-import { VersionSchema } from '../types/zod/backlogOutputDefinition.js';
-import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
-const getVersionMilestoneListSchema = buildToolSchema((t) => ({
-    projectId: z
-        .number()
-        .optional()
-        .describe(t('TOOL_GET_VERSION_MILESTONE_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
-    projectKey: z
-        .string()
-        .optional()
-        .describe(t('TOOL_GET_VERSION_MILESTONE_PROJECT_KEY', 'The key of the project (e.g., TEST_PROJECT)')),
-}));
-export const getVersionMilestoneListTool = (backlog, { t }) => {
-    return {
-        name: 'get_version_milestone_list',
-        description: t('TOOL_GET_VERSION_MILESTONE_LIST_DESCRIPTION', 'Returns list of versions/milestones in the Backlog space'),
-        schema: z.object(getVersionMilestoneListSchema(t)),
-        outputSchema: VersionSchema,
-        importantFields: [
-            'id',
-            'name',
-            'description',
-            'startDate',
-            'releaseDueDate',
-            'archived',
-        ],
-        handler: async ({ projectId, projectKey }) => {
-            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
-            if (!result.ok) {
-                throw result.error;
-            }
-            return backlog.getVersions(result.value);
-        },
-    };
-};

package/build/tools/getWatchingListCount.js

@@ -1,17 +0,0 @@
-import { z } from 'zod';
-import { buildToolSchema } from '../types/tool.js';
-import { WatchingListCountSchema } from '../types/zod/backlogOutputDefinition.js';
-const getWatchingListCountSchema = buildToolSchema((t) => ({
-    userId: z
-        .number()
-        .describe(t('TOOL_GET_WATCHING_LIST_COUNT_USER_ID', 'User ID')),
-}));
-export const getWatchingListCountTool = (backlog, { t }) => {
-    return {
-        name: 'get_watching_list_count',
-        description: t('TOOL_GET_WATCHING_LIST_COUNT_DESCRIPTION', 'Returns count of watching items for a user'),
-        schema: z.object(getWatchingListCountSchema(t)),
-        outputSchema: WatchingListCountSchema,
-        handler: async ({ userId }) => backlog.getWatchingListCount(userId),
-    };
-};

package/build/tools/getWatchingListItems.js

@@ -1,17 +0,0 @@
-import { z } from 'zod';
-import { buildToolSchema } from '../types/tool.js';
-import { WatchingListItemSchema } from '../types/zod/backlogOutputDefinition.js';
-const getWatchingListItemsSchema = buildToolSchema((t) => ({
-    userId: z
-        .number()
-        .describe(t('TOOL_GET_WATCHING_LIST_ITEMS_USER_ID', 'User ID')),
-}));
-export const getWatchingListItemsTool = (backlog, { t }) => {
-    return {
-        name: 'get_watching_list_items',
-        description: t('TOOL_GET_WATCHING_LIST_ITEMS_DESCRIPTION', 'Returns list of watching items for a user'),
-        schema: z.object(getWatchingListItemsSchema(t)),
-        outputSchema: WatchingListItemSchema,
-        handler: async ({ userId }) => backlog.getWatchingListItems(userId),
-    };
-};

package/build/tools/getWiki.js

@@ -1,21 +0,0 @@
-import { z } from 'zod';
-import { buildToolSchema } from '../types/tool.js';
-import { WikiSchema } from '../types/zod/backlogOutputDefinition.js';
-const getWikiSchema = buildToolSchema((t) => ({
-    wikiId: z
-        .union([z.string(), z.number()])
-        .describe(t('TOOL_GET_WIKI_ID', 'Wiki ID')),
-}));
-export const getWikiTool = (backlog, { t }) => {
-    return {
-        name: 'get_wiki',
-        description: t('TOOL_GET_WIKI_DESCRIPTION', 'Returns information about a specific wiki page'),
-        schema: z.object(getWikiSchema(t)),
-        outputSchema: WikiSchema,
-        importantFields: ['id', 'projectId', 'name', 'content'],
-        handler: async ({ wikiId }) => {
-            const wikiIdNumber = typeof wikiId === 'string' ? parseInt(wikiId, 10) : wikiId;
-            return backlog.getWiki(wikiIdNumber);
-        },
-    };
-};

package/build/tools/getWikiPages.js

@@ -1,37 +0,0 @@
-import { z } from 'zod';
-import { buildToolSchema } from '../types/tool.js';
-import { WikiListItemSchema } from '../types/zod/backlogOutputDefinition.js';
-import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
-const getWikiPagesSchema = buildToolSchema((t) => ({
-    projectId: z
-        .number()
-        .optional()
-        .describe(t('TOOL_GET_WIKI_PAGES_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
-    projectKey: z
-        .string()
-        .optional()
-        .describe(t('TOOL_GET_WIKI_PAGES_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
-    keyword: z
-        .string()
-        .optional()
-        .describe(t('TOOL_GET_WIKI_PAGES_KEYWORD', 'Keyword to search for in Wiki pages')),
-}));
-export const getWikiPagesTool = (backlog, { t }) => {
-    return {
-        name: 'get_wiki_pages',
-        description: t('TOOL_GET_WIKI_PAGES_DESCRIPTION', 'Returns list of Wiki pages'),
-        schema: z.object(getWikiPagesSchema(t)),
-        outputSchema: WikiListItemSchema,
-        importantFields: ['projectId', 'name', 'tags'],
-        handler: async ({ projectId, projectKey, keyword }) => {
-            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
-            if (!result.ok) {
-                throw result.error;
-            }
-            return backlog.getWikis({
-                projectIdOrKey: result.value,
-                keyword,
-            });
-        },
-    };
-};

package/build/tools/getWikisCount.js

@@ -1,29 +0,0 @@
-import { z } from 'zod';
-import { buildToolSchema } from '../types/tool.js';
-import { WikiCountSchema } from '../types/zod/backlogOutputDefinition.js';
-import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
-const getWikisCountSchema = buildToolSchema((t) => ({
-    projectId: z
-        .number()
-        .optional()
-        .describe(t('TOOL_GET_WIKIS_COUNT_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
-    projectKey: z
-        .string()
-        .optional()
-        .describe(t('TOOL_GET_WIKIS_COUNT_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
-}));
-export const getWikisCountTool = (backlog, { t }) => {
-    return {
-        name: 'get_wikis_count',
-        description: t('TOOL_GET_WIKIS_COUNT_DESCRIPTION', 'Returns count of wiki pages in a project'),
-        schema: z.object(getWikisCountSchema(t)),
-        outputSchema: WikiCountSchema,
-        handler: async ({ projectId, projectKey }) => {
-            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
-            if (!result.ok) {
-                throw result.error;
-            }
-            return backlog.getWikisCount(result.value);
-        },
-    };
-};

package/build/tools/markNotificationAsRead.js

@@ -1,26 +0,0 @@
-import { z } from 'zod';
-import { buildToolSchema } from '../types/tool.js';
-const markNotificationAsReadSchema = buildToolSchema((t) => ({
-    id: z
-        .number()
-        .describe(t('TOOL_MARK_NOTIFICATION_AS_READ_ID', 'Notification ID to mark as read')),
-}));
-export const MarkNotificationAsReadResultSchema = z.object({
-    success: z.boolean(),
-    message: z.string(),
-});
-export const markNotificationAsReadTool = (backlog, { t }) => {
-    return {
-        name: 'mark_notification_as_read',
-        description: t('TOOL_MARK_NOTIFICATION_AS_READ_DESCRIPTION', 'Mark a notification as read'),
-        schema: z.object(markNotificationAsReadSchema(t)),
-        outputSchema: MarkNotificationAsReadResultSchema,
-        handler: async ({ id }) => {
-            await backlog.markAsReadNotification(id);
-            return {
-                success: true,
-                message: `Notification ${id} marked as read`,
-            };
-        },
-    };
-};

package/build/tools/markWatchingAsRead.js

@@ -1,26 +0,0 @@
-import { z } from 'zod';
-import { buildToolSchema } from '../types/tool.js';
-const markWatchingAsReadSchema = buildToolSchema((t) => ({
-    watchId: z
-        .number()
-        .describe(t('TOOL_MARK_WATCHING_AS_READ_WATCH_ID', 'Watch ID to mark as read')),
-}));
-export const MarkWatchingAsReadResultSchema = z.object({
-    success: z.boolean(),
-    message: z.string(),
-});
-export const markWatchingAsReadTool = (backlog, { t }) => {
-    return {
-        name: 'mark_watching_as_read',
-        description: t('TOOL_MARK_WATCHING_AS_READ_DESCRIPTION', 'Mark a watch as read'),
-        schema: z.object(markWatchingAsReadSchema(t)),
-        outputSchema: MarkWatchingAsReadResultSchema,
-        handler: async ({ watchId }) => {
-            await backlog.resetWatchingListItemAsRead(watchId);
-            return {
-                success: true,
-                message: `Watch ${watchId} marked as read`,
-            };
-        },
-    };
-};

package/build/tools/resetUnreadNotificationCount.js

@@ -1,13 +0,0 @@
-import { z } from 'zod';
-import { buildToolSchema } from '../types/tool.js';
-import { NotificationCountSchema } from '../types/zod/backlogOutputDefinition.js';
-const resetUnreadNotificationCountSchema = buildToolSchema((_t) => ({}));
-export const resetUnreadNotificationCountTool = (backlog, { t }) => {
-    return {
-        name: 'reset_unread_notification_count',
-        description: t('TOOL_RESET_UNREAD_NOTIFICATION_COUNT_DESCRIPTION', 'Reset unread notification count'),
-        schema: z.object(resetUnreadNotificationCountSchema(t)),
-        outputSchema: NotificationCountSchema,
-        handler: async () => backlog.resetNotificationsMarkAsRead(),
-    };
-};

package/build/tools/shared/customFieldFiltersSchema.js

@@ -1,78 +0,0 @@
-import { z, ZodIssueCode } from 'zod';
-export const buildCustomFieldFilterSchema = (t) => {
-    const schema = z.discriminatedUnion('type', [
-        z
-            .object({
-            type: z.literal('text'),
-            id: z
-                .number()
-                .describe(t('TOOL_CUSTOM_FIELD_FILTER_ID', 'Custom field ID (e.g., 12345)')),
-            value: z
-                .string()
-                .min(1)
-                .describe(t('TOOL_CUSTOM_FIELD_FILTER_TEXT_VALUE', 'Keyword to match for the custom field')),
-        })
-            .describe(t('TOOL_CUSTOM_FIELD_FILTER_TEXT', 'Text custom field filter')),
-        z
-            .object({
-            type: z.literal('numeric'),
-            id: z
-                .number()
-                .describe(t('TOOL_CUSTOM_FIELD_FILTER_ID', 'Custom field ID (e.g., 12345)')),
-            min: z
-                .number()
-                .optional()
-                .describe(t('TOOL_CUSTOM_FIELD_FILTER_NUMERIC_MIN', 'Minimum numeric value (inclusive)')),
-            max: z
-                .number()
-                .optional()
-                .describe(t('TOOL_CUSTOM_FIELD_FILTER_NUMERIC_MAX', 'Maximum numeric value (inclusive)')),
-        })
-            .describe(t('TOOL_CUSTOM_FIELD_FILTER_NUMERIC', 'Numeric custom field filter')),
-        z
-            .object({
-            type: z.literal('date'),
-            id: z
-                .number()
-                .describe(t('TOOL_CUSTOM_FIELD_FILTER_ID', 'Custom field ID (e.g., 12345)')),
-            min: z
-                .string()
-                .optional()
-                .describe(t('TOOL_CUSTOM_FIELD_FILTER_DATE_MIN', 'Start date (yyyy-MM-dd)')),
-            max: z
-                .string()
-                .optional()
-                .describe(t('TOOL_CUSTOM_FIELD_FILTER_DATE_MAX', 'End date (yyyy-MM-dd)')),
-        })
-            .describe(t('TOOL_CUSTOM_FIELD_FILTER_DATE', 'Date custom field filter')),
-        z
-            .object({
-            type: z.literal('list'),
-            id: z
-                .number()
-                .describe(t('TOOL_CUSTOM_FIELD_FILTER_ID', 'Custom field ID (e.g., 12345)')),
-            value: z
-                .union([z.number(), z.array(z.number()).min(1)])
-                .describe(t('TOOL_CUSTOM_FIELD_FILTER_LIST_VALUE', 'Value ID(s) to match for list-type custom field')),
-        })
-            .describe(t('TOOL_CUSTOM_FIELD_FILTER_LIST', 'List custom field filter')),
-    ]);
-    return schema.superRefine((data, ctx) => {
-        if (data.type === 'numeric' &&
-            data.min === undefined &&
-            data.max === undefined) {
-            ctx.addIssue({
-                code: ZodIssueCode.custom,
-                message: t('TOOL_CUSTOM_FIELD_FILTER_NUMERIC_REQUIRED', 'Provide at least one of min or max for numeric filters'),
-                path: ['min'],
-            });
-        }
-        if (data.type === 'date' && !data.min && !data.max) {
-            ctx.addIssue({
-                code: ZodIssueCode.custom,
-                message: t('TOOL_CUSTOM_FIELD_FILTER_DATE_REQUIRED', 'Provide at least one of min or max for date filters'),
-                path: ['min'],
-            });
-        }
-    });
-};

package/build/tools/tools.js

@@ -1,163 +0,0 @@
-import { addIssueTool } from './addIssue.js';
-import { addIssueCommentTool } from './addIssueComment.js';
-import { addProjectTool } from './addProject.js';
-import { addPullRequestTool } from './addPullRequest.js';
-import { addPullRequestCommentTool } from './addPullRequestComment.js';
-import { addWikiTool } from './addWiki.js';
-import { updateWikiTool } from './updateWiki.js';
-import { countIssuesTool } from './countIssues.js';
-import { deleteIssueTool } from './deleteIssue.js';
-import { deleteProjectTool } from './deleteProject.js';
-import { getCategoriesTool } from './getCategories.js';
-import { getCustomFieldsTool } from './getCustomFields.js';
-import { getGitRepositoriesTool } from './getGitRepositories.js';
-import { getGitRepositoryTool } from './getGitRepository.js';
-import { getIssueTool } from './getIssue.js';
-import { getIssueCommentsTool } from './getIssueComments.js';
-import { getIssuesTool } from './getIssues.js';
-import { getIssueTypesTool } from './getIssueTypes.js';
-import { getMyselfTool } from './getMyself.js';
-import { getNotificationsTool } from './getNotifications.js';
-import { getNotificationsCountTool } from './getNotificationsCount.js';
-import { getPrioritiesTool } from './getPriorities.js';
-import { getProjectTool } from './getProject.js';
-import { getProjectListTool } from './getProjectList.js';
-import { getPullRequestTool } from './getPullRequest.js';
-import { getPullRequestCommentsTool } from './getPullRequestComments.js';
-import { getPullRequestsTool } from './getPullRequests.js';
-import { getPullRequestsCountTool } from './getPullRequestsCount.js';
-import { getResolutionsTool } from './getResolutions.js';
-import { getSpaceTool } from './getSpace.js';
-import { getUsersTool } from './getUsers.js';
-import { getWatchingListCountTool } from './getWatchingListCount.js';
-import { getWatchingListItemsTool } from './getWatchingListItems.js';
-import { addWatchingTool } from './addWatching.js';
-import { updateWatchingTool } from './updateWatching.js';
-import { deleteWatchingTool } from './deleteWatching.js';
-import { markWatchingAsReadTool } from './markWatchingAsRead.js';
-import { getWikiTool } from './getWiki.js';
-import { getWikiPagesTool } from './getWikiPages.js';
-import { getWikisCountTool } from './getWikisCount.js';
-import { markNotificationAsReadTool } from './markNotificationAsRead.js';
-import { resetUnreadNotificationCountTool } from './resetUnreadNotificationCount.js';
-import { updateIssueTool } from './updateIssue.js';
-import { updateProjectTool } from './updateProject.js';
-import { updatePullRequestTool } from './updatePullRequest.js';
-import { updatePullRequestCommentTool } from './updatePullRequestComment.js';
-import { getDocumentTool } from './getDocument.js';
-import { getDocumentsTool } from './getDocuments.js';
-import { getDocumentTreeTool } from './getDocumentTree.js';
-import { getVersionMilestoneListTool } from './getVersionMilestoneList.js';
-import { addVersionMilestoneTool } from './addVersionMilestone.js';
-import { updateVersionMilestoneTool } from './updateVersionMilestone.js';
-import { deleteVersionTool } from './deleteVersion.js';
-import { addDocumentTool } from './addDocument.js';
-export const allTools = (backlog, helper) => {
-    return {
-        toolsets: [
-            {
-                name: 'space',
-                description: 'Tools for managing Backlog space settings and general information.',
-                enabled: false,
-                tools: [
-                    getSpaceTool(backlog, helper),
-                    getUsersTool(backlog, helper),
-                    getMyselfTool(backlog, helper),
-                ],
-            },
-            {
-                name: 'project',
-                description: 'Tools for managing projects, categories, custom fields, and issue types.',
-                enabled: false,
-                tools: [
-                    getProjectListTool(backlog, helper),
-                    addProjectTool(backlog, helper),
-                    getProjectTool(backlog, helper),
-                    updateProjectTool(backlog, helper),
-                    deleteProjectTool(backlog, helper),
-                ],
-            },
-            {
-                name: 'issue',
-                description: 'Tools for managing issues and their comments.',
-                enabled: false,
-                tools: [
-                    getIssueTool(backlog, helper),
-                    getIssuesTool(backlog, helper),
-                    countIssuesTool(backlog, helper),
-                    addIssueTool(backlog, helper),
-                    updateIssueTool(backlog, helper),
-                    deleteIssueTool(backlog, helper),
-                    getIssueCommentsTool(backlog, helper),
-                    addIssueCommentTool(backlog, helper),
-                    getPrioritiesTool(backlog, helper),
-                    getCategoriesTool(backlog, helper),
-                    getCustomFieldsTool(backlog, helper),
-                    getIssueTypesTool(backlog, helper),
-                    getResolutionsTool(backlog, helper),
-                    getWatchingListItemsTool(backlog, helper),
-                    getWatchingListCountTool(backlog, helper),
-                    addWatchingTool(backlog, helper),
-                    updateWatchingTool(backlog, helper),
-                    deleteWatchingTool(backlog, helper),
-                    markWatchingAsReadTool(backlog, helper),
-                    getVersionMilestoneListTool(backlog, helper),
-                    addVersionMilestoneTool(backlog, helper),
-                    updateVersionMilestoneTool(backlog, helper),
-                    deleteVersionTool(backlog, helper),
-                ],
-            },
-            {
-                name: 'wiki',
-                description: 'Tools for managing wiki pages.',
-                enabled: false,
-                tools: [
-                    getWikiPagesTool(backlog, helper),
-                    getWikisCountTool(backlog, helper),
-                    getWikiTool(backlog, helper),
-                    addWikiTool(backlog, helper),
-                    updateWikiTool(backlog, helper),
-                ],
-            },
-            {
-                name: 'git',
-                description: 'Tools for managing Git repositories and pull requests.',
-                enabled: false,
-                tools: [
-                    getGitRepositoriesTool(backlog, helper),
-                    getGitRepositoryTool(backlog, helper),
-                    getPullRequestsTool(backlog, helper),
-                    getPullRequestsCountTool(backlog, helper),
-                    getPullRequestTool(backlog, helper),
-                    addPullRequestTool(backlog, helper),
-                    updatePullRequestTool(backlog, helper),
-                    getPullRequestCommentsTool(backlog, helper),
-                    addPullRequestCommentTool(backlog, helper),
-                    updatePullRequestCommentTool(backlog, helper),
-                ],
-            },
-            {
-                name: 'document',
-                description: 'Tools for managing documents.',
-                enabled: false,
-                tools: [
-                    getDocumentsTool(backlog, helper),
-                    getDocumentTreeTool(backlog, helper),
-                    getDocumentTool(backlog, helper),
-                    addDocumentTool(backlog, helper),
-                ],
-            },
-            {
-                name: 'notifications',
-                description: 'Tools for managing user notifications.',
-                enabled: false,
-                tools: [
-                    getNotificationsTool(backlog, helper),
-                    getNotificationsCountTool(backlog, helper),
-                    resetUnreadNotificationCountTool(backlog, helper),
-                    markNotificationAsReadTool(backlog, helper),
-                ],
-            },
-        ],
-    };
-};