backlog-mcp-server 0.8.0 → 0.9.0

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/addVersionMilestone.js

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { VersionSchema } from '../types/zod/backlogOutputDefinition.js';
+import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
+const addVersionMilestoneSchema = buildToolSchema((t) => ({
+    projectId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_ADD_VERSION_MILESTONE_PROJECT_ID', 'Project ID')),
+    projectKey: z
+        .string()
+        .optional()
+        .describe(t('TOOL_ADD_VERSION_MILESTONE_PROJECT_KEY', 'Project key')),
+    name: z
+        .string()
+        .describe(t('TOOL_ADD_VERSION_MILESTONE_NAME', 'Version name')),
+    description: z
+        .string()
+        .optional()
+        .describe(t('TOOL_ADD_VERSION_MILESTONE_DESCRIPTION', 'Version description')),
+    startDate: z
+        .string()
+        .optional()
+        .describe(t('TOOL_ADD_VERSION_MILESTONE_START_DATE', 'Start date of the version')),
+    releaseDueDate: z
+        .string()
+        .optional()
+        .describe(t('TOOL_ADD_VERSION_MILESTONE_RELEASE_DUE_DATE', 'Release due date of the version')),
+}));
+export const addVersionMilestoneTool = (backlog, { t }) => {
+    return {
+        name: 'add_version_milestone',
+        description: t('TOOL_ADD_VERSION_MILESTONE_DESCRIPTION', 'Creates a new version milestone'),
+        schema: z.object(addVersionMilestoneSchema(t)),
+        outputSchema: VersionSchema,
+        importantFields: [
+            'id',
+            'name',
+            'description',
+            'startDate',
+            'releaseDueDate',
+        ],
+        handler: async ({ projectId, projectKey, ...params }) => {
+            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            return backlog.postVersions(result.value, params);
+        },
+    };
+};

package/build/tools/addWatching.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { WatchingListItemSchema } from '../types/zod/backlogOutputDefinition.js';
+const addWatchingSchema = buildToolSchema((t) => ({
+    issueIdOrKey: z
+        .union([z.number(), z.string()])
+        .describe(t('TOOL_ADD_WATCHING_ISSUE_ID_OR_KEY', 'Issue ID or issue key (e.g., 1234 or "PROJECT-123")')),
+    note: z
+        .string()
+        .describe(t('TOOL_ADD_WATCHING_NOTE', 'Optional note for the watch'))
+        .optional()
+        .default(''),
+}));
+export const addWatchingTool = (backlog, { t }) => {
+    return {
+        name: 'add_watching',
+        description: t('TOOL_ADD_WATCHING_DESCRIPTION', 'Adds a new watch to an issue'),
+        schema: z.object(addWatchingSchema(t)),
+        outputSchema: WatchingListItemSchema,
+        handler: async ({ issueIdOrKey, note }) => backlog.postWatchingListItem({
+            issueIdOrKey,
+            note,
+        }),
+    };
+};

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

package/build/tools/deleteDocument.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { DocumentItemSchema } from '../types/zod/backlogOutputDefinition.js';
+import { buildToolSchema } from '../types/tool.js';
+const deleteDocumentSchema = buildToolSchema((t) => ({
+    documentId: z
+        .string()
+        .describe(t('TOOL_DELETE_DOCUMENT_DOCUMENT_ID', 'Document ID')),
+}));
+export const deleteDocumentTool = (backlog, { t }) => {
+    return {
+        name: 'delete_document',
+        description: t('TOOL_DELETE_DOCUMENT_DESCRIPTION', 'Permanently deletes a document. This is irreversible (hard delete) and the document cannot be recovered. Unlike the Backlog UI trash feature, this operation does not move the document to trash.'),
+        schema: z.object(deleteDocumentSchema(t)),
+        outputSchema: DocumentItemSchema,
+        handler: async ({ documentId }) => {
+            return backlog.deleteDocument(documentId);
+        },
+    };
+};

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);
+        },
+    };
+};

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/deleteVersion.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { VersionSchema } from '../types/zod/backlogOutputDefinition.js';
+import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
+const deleteVersionSchema = buildToolSchema((t) => ({
+    projectId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_DELETE_VERSION_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
+    projectKey: z
+        .string()
+        .optional()
+        .describe(t('TOOL_DELETE_VERSION_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
+    id: z
+        .number()
+        .describe(t('TOOL_DELETE_VERSION_ID', 'The numeric ID of the version to delete (e.g., 67890)')),
+}));
+export const deleteVersionTool = (backlog, { t }) => {
+    return {
+        name: 'delete_version',
+        description: t('TOOL_DELETE_VERSION_DESCRIPTION', 'Deletes a version from a project'),
+        schema: z.object(deleteVersionSchema(t)),
+        outputSchema: VersionSchema,
+        handler: async ({ projectId, projectKey, id }) => {
+            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            if (!id) {
+                throw new Error(t('TOOL_DELETE_VERSION_MISSING_ID', 'Version ID is required'));
+            }
+            return backlog.deleteVersions(result.value, id);
+        },
+    };
+};

package/build/tools/deleteWatching.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { WatchingListItemSchema } from '../types/zod/backlogOutputDefinition.js';
+const deleteWatchingSchema = buildToolSchema((t) => ({
+    watchId: z
+        .number()
+        .describe(t('TOOL_DELETE_WATCHING_WATCH_ID', 'Watch ID to delete')),
+}));
+export const deleteWatchingTool = (backlog, { t }) => {
+    return {
+        name: 'delete_watching',
+        description: t('TOOL_DELETE_WATCHING_DESCRIPTION', 'Deletes a watch from an issue'),
+        schema: z.object(deleteWatchingSchema(t)),
+        outputSchema: WatchingListItemSchema,
+        handler: async ({ watchId }) => backlog.deletehWatchingListItem(watchId),
+    };
+};

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);
+        },
+    };
+};