backlog-mcp-server 0.7.0 → 0.8.0

package/build/tools/getDocuments.js

@@ -1,25 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,149 +0,0 @@
-import { z } from 'zod';
-import { buildToolSchema } from '../types/tool.js';
-import { IssueSchema } from '../types/zod/backlogOutputDefinition.js';
-import { customFieldFiltersToPayload } from '../backlog/customFields.js';
-import { buildCustomFieldFilterSchema } from './shared/customFieldFiltersSchema.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(buildCustomFieldFilterSchema(t))
-        .optional()
-        .describe(t('TOOL_GET_ISSUES_CUSTOM_FIELDS', 'Custom field filters (text, numeric, date, or list)')),
-}));
-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,
-                ...customFieldFiltersToPayload(customFields),
-            });
-        },
-    };
-};

package/build/tools/getMyself.js

@@ -1,14 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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,
-        }),
-    };
-};

package/build/tools/getNotificationsCount.js

@@ -1,20 +0,0 @@
-import { z } from 'zod';
-import { buildToolSchema } from '../types/tool.js';
-import { NotificationCountSchema } from '../types/zod/backlogOutputDefinition.js';
-const getNotificationsCountSchema = buildToolSchema((t) => ({
-    alreadyRead: z
-        .boolean()
-        .describe(t('TOOL_GET_NOTIFICATIONS_COUNT_ALREADY_READ', 'Whether to include already read notifications')),
-    resourceAlreadyRead: z
-        .boolean()
-        .describe(t('TOOL_GET_NOTIFICATIONS_COUNT_RESOURCE_ALREADY_READ', 'Whether to include notifications for already read resources')),
-}));
-export const getNotificationsCountTool = (backlog, { t }) => {
-    return {
-        name: 'count_notifications',
-        description: t('TOOL_COUNT_NOTIFICATIONS_DESCRIPTION', 'Returns count of notifications'),
-        schema: z.object(getNotificationsCountSchema(t)),
-        outputSchema: NotificationCountSchema,
-        handler: async (params) => backlog.getNotificationsCount(params),
-    };
-};

package/build/tools/getPriorities.js

@@ -1,13 +0,0 @@
-import { z } from 'zod';
-import { buildToolSchema } from '../types/tool.js';
-import { PrioritySchema } from '../types/zod/backlogOutputDefinition.js';
-const getPrioritiesSchema = buildToolSchema((_t) => ({}));
-export const getPrioritiesTool = (backlog, { t }) => {
-    return {
-        name: 'get_priorities',
-        description: t('TOOL_GET_PRIORITIES_DESCRIPTION', 'Returns list of priorities'),
-        schema: z.object(getPrioritiesSchema(t)),
-        outputSchema: PrioritySchema,
-        handler: async () => backlog.getPriorities(),
-    };
-};

package/build/tools/getProject.js

@@ -1,29 +0,0 @@
-import { z } from 'zod';
-import { buildToolSchema } from '../types/tool.js';
-import { ProjectSchema } from '../types/zod/backlogOutputDefinition.js';
-import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
-const getProjectSchema = buildToolSchema((t) => ({
-    projectId: z
-        .number()
-        .optional()
-        .describe(t('TOOL_GET_PROJECT_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
-    projectKey: z
-        .string()
-        .optional()
-        .describe(t('TOOL_GET_PROJECT_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
-}));
-export const getProjectTool = (backlog, { t }) => {
-    return {
-        name: 'get_project',
-        description: t('TOOL_GET_PROJECT_DESCRIPTION', 'Returns information about a specific project'),
-        schema: z.object(getProjectSchema(t)),
-        outputSchema: ProjectSchema,
-        handler: async ({ projectId, projectKey }) => {
-            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
-            if (!result.ok) {
-                throw result.error;
-            }
-            return backlog.getProject(result.value);
-        },
-    };
-};

package/build/tools/getProjectList.js

@@ -1,23 +0,0 @@
-import { z } from 'zod';
-import { buildToolSchema } from '../types/tool.js';
-import { ProjectSchema } from '../types/zod/backlogOutputDefinition.js';
-const getProjectListSchema = buildToolSchema((t) => ({
-    archived: z
-        .boolean()
-        .optional()
-        .describe(t('TOOL_GET_PROJECT_LIST_ARCHIVED', 'For unspecified parameters, this form returns all projects. For ‘false’ parameters, it returns unarchived projects. For ‘true’ parameters, it returns archived projects.')),
-    all: z
-        .boolean()
-        .optional()
-        .describe(t('TOOL_GET_PROJECT_LIST_ALL', 'Only applies to administrators. If ‘true,’ it returns all projects. If ‘false,’ it returns only projects they have joined.')),
-}));
-export const getProjectListTool = (backlog, { t }) => {
-    return {
-        name: 'get_project_list',
-        description: t('TOOL_GET_PROJECT_LIST_DESCRIPTION', 'Returns list of projects'),
-        schema: z.object(getProjectListSchema(t)),
-        outputSchema: ProjectSchema,
-        importantFields: ['id', 'projectKey', 'name'],
-        handler: async ({ archived, all }) => backlog.getProjects({ archived, all }),
-    };
-};

package/build/tools/getPullRequest.js

@@ -1,44 +0,0 @@
-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 getPullRequestSchema = buildToolSchema((t) => ({
-    projectId: z
-        .number()
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUEST_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
-    projectKey: z
-        .string()
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUEST_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
-    repoId: z
-        .number()
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUEST_REPO_ID', 'Repository ID')),
-    repoName: z
-        .string()
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUEST_REPO_NAME', 'Repository name')),
-    number: z
-        .number()
-        .describe(t('TOOL_GET_PULL_REQUEST_NUMBER', 'Pull request number')),
-}));
-export const getPullRequestTool = (backlog, { t }) => {
-    return {
-        name: 'get_pull_request',
-        description: t('TOOL_GET_PULL_REQUEST_DESCRIPTION', 'Returns information about a specific pull request'),
-        schema: z.object(getPullRequestSchema(t)),
-        outputSchema: PullRequestSchema,
-        handler: async ({ projectId, projectKey, repoId, repoName, number }) => {
-            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.getPullRequest(result.value, String(repoRes.value), number);
-        },
-    };
-};

package/build/tools/getPullRequestComments.js

@@ -1,60 +0,0 @@
-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 getPullRequestCommentsSchema = buildToolSchema((t) => ({
-    projectId: z
-        .number()
-        .optional()
-        .describe(t('TOOL_GET_PROJECT_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
-    projectKey: z
-        .string()
-        .optional()
-        .describe(t('TOOL_GET_PROJECT_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
-    repoId: z
-        .number()
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUEST_COMMENTS_REPO_ID_OR_NAME', 'Repository ID')),
-    repoName: z
-        .string()
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUEST_COMMENTS_REPO_ID_OR_NAME', 'Repository name')),
-    number: z
-        .number()
-        .describe(t('TOOL_GET_PULL_REQUEST_COMMENTS_NUMBER', 'Pull request number')),
-    minId: z
-        .number()
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUEST_COMMENTS_MIN_ID', 'Minimum comment ID')),
-    maxId: z
-        .number()
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUEST_COMMENTS_MAX_ID', 'Maximum comment ID')),
-    count: z
-        .number()
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUEST_COMMENTS_COUNT', 'Number of comments to retrieve')),
-    order: z
-        .enum(['asc', 'desc'])
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUEST_COMMENTS_ORDER', 'Sort order')),
-}));
-export const getPullRequestCommentsTool = (backlog, { t }) => {
-    return {
-        name: 'get_pull_request_comments',
-        description: t('TOOL_GET_PULL_REQUEST_COMMENTS_DESCRIPTION', 'Returns list of comments for a pull request'),
-        schema: z.object(getPullRequestCommentsSchema(t)),
-        outputSchema: PullRequestCommentSchema,
-        handler: async ({ projectId, projectKey, repoId, repoName, number, ...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.getPullRequestComments(result.value, String(repoResult.value), number, params);
-        },
-    };
-};

package/build/tools/getPullRequests.js

@@ -1,65 +0,0 @@
-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 getPullRequestsSchema = buildToolSchema((t) => ({
-    projectId: z
-        .number()
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUESTS_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
-    projectKey: z
-        .string()
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUESTS_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
-    repoId: z
-        .number()
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUESTS_REPO_ID', 'Repository ID')),
-    repoName: z
-        .string()
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUESTS_REPO_NAME', 'Repository name')),
-    statusId: z
-        .array(z.number())
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUESTS_STATUS_ID', 'Status IDs')),
-    assigneeId: z
-        .array(z.number())
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUESTS_ASSIGNEE_ID', 'Assignee user IDs')),
-    issueId: z
-        .array(z.number())
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUESTS_ISSUE_ID', 'Issue IDs')),
-    createdUserId: z
-        .array(z.number())
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUESTS_CREATED_USER_ID', 'Created user IDs')),
-    offset: z
-        .number()
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUESTS_OFFSET', 'Offset for pagination')),
-    count: z
-        .number()
-        .optional()
-        .describe(t('TOOL_GET_PULL_REQUESTS_COUNT', 'Number of pull requests to retrieve')),
-}));
-export const getPullRequestsTool = (backlog, { t }) => {
-    return {
-        name: 'get_pull_requests',
-        description: t('TOOL_GET_PULL_REQUESTS_DESCRIPTION', 'Returns list of pull requests for a repository'),
-        schema: z.object(getPullRequestsSchema(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 repoResult = resolveIdOrName('repository', { id: repoId, name: repoName }, t);
-            if (!repoResult.ok) {
-                throw repoResult.error;
-            }
-            return backlog.getPullRequests(result.value, String(repoResult.value), params);
-        },
-    };
-};