@ecubelabs/atlassian-mcp 1.2.0 → 1.3.0

package/dist/jira-tools-register.js

@@ -0,0 +1,1593 @@
+import { z } from 'zod';
+import { JiraService } from './libs/jira-client.js';
+export const registerJiraTools = (server) => {
+    // Initialize Jira service
+    const jiraService = new JiraService();
+    // Register Jira tools
+    server.tool('get-issue', 'Get details of a Jira issue by key', {
+        issueKey: z.string().describe('Jira issue key (e.g. PROJ-123)'),
+        expand: z
+            .enum([
+            'renderedFields',
+            'names',
+            'schema',
+            'transitions',
+            'editmeta',
+            'changelog',
+            'versionedRepresentations',
+        ])
+            .array()
+            .optional()
+            .describe('Optional fields to expand in the response. Options include: renderedFields (HTML format), names (display names), schema (field type descriptions), transitions (possible transitions), editmeta (field editing info), changelog (recent updates), versionedRepresentations (field value history)'),
+    }, async ({ issueKey, expand }) => {
+        try {
+            const issue = await jiraService.getIssue(issueKey, expand);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(issue),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to retrieve issue: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('search-issues', 'Search Jira issues using JQL', {
+        jql: z.string().describe('JQL query string. Must be a bounded query with search restrictions.'),
+        fields: z
+            .array(z.string())
+            .optional()
+            .describe("Optional fields to include in the response. Examples: ['summary', 'comment'] or ['*all', '-comment']"),
+        maxResults: z
+            .number()
+            .min(1)
+            .max(5000)
+            .optional()
+            .describe('Maximum number of results to return per page (default: 50, max: 5000)'),
+        nextPageToken: z
+            .string()
+            .optional()
+            .describe('Token for fetching the next page of results. The first page has null nextPageToken.'),
+        expand: z
+            .enum([
+            'renderedFields',
+            'names',
+            'schema',
+            'transitions',
+            'editmeta',
+            'changelog',
+            'versionedRepresentations',
+        ])
+            .array()
+            .optional()
+            .describe('Comma-separated values to expand in response: renderedFields, names, schema, transitions, operations, editmeta, changelog, versionedRepresentations'),
+        properties: z
+            .array(z.string())
+            .max(5)
+            .optional()
+            .describe('List of up to 5 issue properties to include in results'),
+        fieldsByKeys: z
+            .boolean()
+            .optional()
+            .describe('Reference fields by their key rather than ID (default: false)'),
+        failFast: z
+            .boolean()
+            .optional()
+            .describe("Fail request early if we can't retrieve all field data (default: false)"),
+        reconcileIssues: z
+            .array(z.number())
+            .max(50)
+            .optional()
+            .describe('Strong consistency issue IDs to be reconciled with search results (max: 50 IDs)'),
+    }, async ({ jql, fields, maxResults, nextPageToken, expand, properties, fieldsByKeys, failFast, reconcileIssues, }) => {
+        try {
+            const result = await jiraService.searchIssues({
+                jql,
+                fields,
+                maxResults,
+                nextPageToken,
+                expand,
+                properties,
+                fieldsByKeys,
+                failFast,
+                reconcileIssues,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to search issues: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('get-comments', 'Get comments for a Jira issue', {
+        issueKey: z.string().describe('Jira issue key (e.g. PROJ-123)'),
+        startAt: z
+            .number()
+            .min(0)
+            .optional()
+            .describe('The index of the first item to return (page offset). Default: 0'),
+        maxResults: z
+            .number()
+            .min(1)
+            .max(100)
+            .optional()
+            .describe('Maximum number of items per page. Default: 100'),
+        orderBy: z
+            .enum(['created', '-created', '+created'])
+            .optional()
+            .describe('Order comments by creation date. Default: created'),
+        expand: z
+            .array(z.enum(['renderedBody']))
+            .optional()
+            .describe('Include additional information: renderedBody (comment body in HTML format)'),
+    }, async ({ issueKey, startAt, maxResults, orderBy, expand }) => {
+        try {
+            const result = await jiraService.getComments(issueKey, {
+                startAt,
+                maxResults,
+                orderBy,
+                expand,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to retrieve comments: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('get-projects', 'Get list of Jira projects', {
+        startAt: z
+            .number()
+            .min(0)
+            .optional()
+            .describe('The index of the first item to return (page offset). Default: 0'),
+        maxResults: z
+            .number()
+            .min(1)
+            .max(100)
+            .optional()
+            .describe('Maximum number of items per page. Default: 50, Maximum: 100'),
+        orderBy: z
+            .enum([
+            'category',
+            '-category',
+            '+category',
+            'key',
+            '-key',
+            '+key',
+            'name',
+            '-name',
+            '+name',
+            'owner',
+            '-owner',
+            '+owner',
+            'issueCount',
+            '-issueCount',
+            '+issueCount',
+            'lastIssueUpdatedTime',
+            '-lastIssueUpdatedTime',
+            '+lastIssueUpdatedTime',
+            'archivedDate',
+            '-archivedDate',
+            '+archivedDate',
+            'deletedDate',
+            '-deletedDate',
+            '+deletedDate',
+        ])
+            .optional()
+            .describe('Field to order results by. Default: key'),
+        id: z.array(z.number().int()).max(50).optional().describe('Filter by project IDs. Maximum: 50 IDs'),
+        keys: z.array(z.string()).max(50).optional().describe('Filter by project keys. Maximum: 50 keys'),
+        query: z.string().optional().describe('Filter by matching key or name (case insensitive)'),
+        typeKey: z
+            .string()
+            .optional()
+            .describe('Filter by project type. Accepts comma-separated list: business, service_desk, software'),
+        categoryId: z.number().int().optional().describe('Filter by project category ID'),
+        action: z
+            .enum(['view', 'browse', 'edit', 'create'])
+            .optional()
+            .describe("Filter by user's project permissions. Default: view"),
+        expand: z
+            .array(z.enum(['description', 'projectKeys', 'lead', 'issueTypes', 'url', 'insight']))
+            .optional()
+            .describe('Additional fields to include: description, projectKeys, lead, issueTypes, url, insight'),
+        status: z
+            .array(z.enum(['live', 'archived', 'deleted']))
+            .optional()
+            .describe('EXPERIMENTAL. Filter by project status'),
+    }, async ({ startAt, maxResults, orderBy, id, keys, query, typeKey, categoryId, action, expand, status }) => {
+        try {
+            const result = await jiraService.getProjects({
+                startAt,
+                maxResults,
+                orderBy,
+                id,
+                keys,
+                query,
+                typeKey,
+                categoryId,
+                action,
+                expand,
+                status,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to retrieve projects: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('get-create-metadata-issue-types', 'Get issue types available for creating issues in a project', {
+        projectIdOrKey: z.string().describe('Project ID (numeric) or project key (e.g. PROJ)'),
+    }, async ({ projectIdOrKey }) => {
+        try {
+            const result = await jiraService.getCreateMetadataIssueTypes(projectIdOrKey);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to retrieve issue types: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('get-create-field-metadata', 'Get create field metadata for a project and issue type id', {
+        projectIdOrKey: z.string().describe('Project ID (numeric) or project key (e.g. PROJ)'),
+        issueTypeId: z.string().describe('Issue type ID'),
+    }, async ({ projectIdOrKey, issueTypeId }) => {
+        try {
+            const result = await jiraService.getCreateFieldMetadata(projectIdOrKey, issueTypeId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to retrieve field metadata: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('get-fields', 'Get Jira fields (optionally search/paginate)', {
+        type: z.enum(['all', 'custom', 'system']).optional().describe('Field type to filter'),
+        query: z.string().optional().describe('Search string to filter fields'),
+        orderBy: z.enum(['name', '-name']).optional().describe('Order results by name ascending/descending'),
+        startAt: z.number().min(0).optional().describe('Index of the first item to return'),
+        maxResults: z.number().min(1).max(1000).optional().describe('Max number of items to return'),
+    }, async ({ type, query, orderBy, startAt, maxResults }) => {
+        try {
+            const result = await jiraService.getFields({
+                type,
+                query,
+                orderBy,
+                startAt,
+                maxResults,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to retrieve fields: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('parse-jql', 'Parse a JQL query and return its AST', {
+        query: z.string().describe('JQL query to parse'),
+        validation: z
+            .enum(['strict', 'warn'])
+            .optional()
+            .describe('Validation level during parse (default: strict)'),
+    }, async ({ query, validation }) => {
+        try {
+            const result = await jiraService.parseJql(query, validation);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to parse JQL: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('create-issue', 'Create a new Jira issue', {
+        projectKey: z.string().describe('Project key (e.g. PROJ)'),
+        summary: z.string().describe('Issue summary'),
+        issueTypeId: z.string().optional().describe('Issue type ID'),
+        issueTypeName: z.string().optional().describe('Issue type name'),
+        description: z.string().optional().describe('Issue description (plain text)'),
+        assigneeAccountId: z.string().optional().describe('Assignee accountId (Jira Cloud)'),
+        reporterAccountId: z
+            .string()
+            .optional()
+            .describe('Reporter accountId. If omitted, server attempts to use current user when allowed'),
+        priorityId: z.string().optional().describe('Priority ID'),
+        labels: z.array(z.string()).optional().describe('Labels to apply'),
+        additionalFields: z
+            .record(z.any())
+            .optional()
+            .describe('Additional raw Jira fields to include under fields'),
+    }, async ({ projectKey, summary, issueTypeId, issueTypeName, description, assigneeAccountId, reporterAccountId, priorityId, labels, additionalFields, }) => {
+        try {
+            const issue = await jiraService.createIssue({
+                projectKey,
+                summary,
+                issueTypeId,
+                issueTypeName,
+                description,
+                assigneeAccountId,
+                reporterAccountId,
+                priorityId,
+                labels,
+                additionalFields,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(issue),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to create issue: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('assign-issue', 'Assign or unassign a Jira issue', {
+        issueKey: z.string().describe('Jira issue key (e.g. PROJ-123)'),
+        assigneeAccountId: z.string().optional().describe('AccountId of assignee. Omit if unassigning.'),
+        unassign: z.boolean().optional().describe('Set true to remove current assignee'),
+    }, async ({ issueKey, assigneeAccountId, unassign }) => {
+        try {
+            if (unassign) {
+                await jiraService.assignIssue(issueKey);
+            }
+            else {
+                await jiraService.assignIssue(issueKey, assigneeAccountId);
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Issue assigned successfully',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to assign issue: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('edit-issue', 'Edit fields on a Jira issue', {
+        issueKey: z.string().describe('Jira issue key (e.g. PROJ-123)'),
+        summary: z.string().optional().describe('New summary'),
+        description: z.string().optional().describe('New description (plain text)'),
+        assigneeAccountId: z
+            .string()
+            .optional()
+            .describe('New assignee accountId. Use with unassignAssignee=false'),
+        unassignAssignee: z.boolean().optional().describe('Set true to remove current assignee'),
+        priorityId: z.string().optional().describe('New priority ID'),
+        labels: z.array(z.string()).optional().describe('Replace labels'),
+        additionalFields: z.record(z.any()).optional().describe('Additional raw fields to include under fields'),
+    }, async ({ issueKey, summary, description, assigneeAccountId, unassignAssignee, priorityId, labels, additionalFields, }) => {
+        try {
+            await jiraService.editIssue(issueKey, {
+                summary,
+                description,
+                assigneeAccountId,
+                unassignAssignee,
+                priorityId,
+                labels,
+                additionalFields,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Issue updated successfully',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to update issue: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('search-users', 'Search for users', {
+        query: z.string().optional().describe('Query string to search users'),
+        accountId: z.string().optional().describe('Account ID to search for'),
+        startAt: z.number().min(0).optional().describe('The index of the first item to return'),
+        maxResults: z.number().min(1).max(1000).optional().describe('Maximum number of items to return'),
+        property: z.string().optional().describe('Property key to search for in user properties'),
+    }, async ({ query, accountId, startAt, maxResults, property }) => {
+        try {
+            const users = await jiraService.searchUsers({
+                query,
+                accountId,
+                startAt,
+                maxResults,
+                property,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(users),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to search users: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('get-user-picker', 'Get user picker suggestions for autocomplete', {
+        query: z.string().describe('Query string for user search'),
+        maxResults: z.number().min(1).max(1000).optional().describe('Maximum number of users to return'),
+        showAvatar: z.boolean().optional().describe('Whether to show user avatars'),
+        exclude: z.array(z.string()).optional().describe('List of users to exclude from results'),
+        excludeAccountIds: z.array(z.string()).optional().describe('List of account IDs to exclude'),
+        avatarSize: z.string().optional().describe('Size of avatars to return'),
+        excludeConnectUsers: z.boolean().optional().describe('Whether to exclude Connect app users'),
+    }, async ({ query, maxResults, showAvatar, exclude, excludeAccountIds, avatarSize, excludeConnectUsers }) => {
+        try {
+            const result = await jiraService.getUserPicker({
+                query,
+                maxResults,
+                showAvatar,
+                exclude,
+                excludeAccountIds,
+                avatarSize,
+                excludeConnectUsers,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get user picker suggestions: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('search-assignable-users', 'Search for users who can be assigned to issues', {
+        projectKeys: z.array(z.string()).optional().describe('Project keys to search assignable users for'),
+        query: z.string().optional().describe('Query string to search users'),
+        username: z.string().optional().describe('Username to search for'),
+        accountId: z.string().optional().describe('Account ID to search for'),
+        startAt: z.number().min(0).optional().describe('The index of the first item to return'),
+        maxResults: z.number().min(1).max(1000).optional().describe('Maximum number of items to return'),
+    }, async ({ projectKeys, query, username, accountId, startAt, maxResults }) => {
+        try {
+            const users = await jiraService.searchAssignableUsers({
+                projectKeys,
+                query,
+                username,
+                accountId,
+                startAt,
+                maxResults,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(users),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to search assignable users: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('search-users-by-permission', 'Search for users who have specific permissions', {
+        permissions: z.string().describe('Comma-separated list of permissions (e.g., BROWSE_PROJECTS,EDIT_ISSUES)'),
+        projectKey: z.string().optional().describe('Project key to check permissions for'),
+        issueKey: z.string().optional().describe('Issue key to check permissions for'),
+        query: z.string().optional().describe('Query string to search users'),
+        username: z.string().optional().describe('Username to search for'),
+        accountId: z.string().optional().describe('Account ID to search for'),
+        startAt: z.number().min(0).optional().describe('The index of the first item to return'),
+        maxResults: z.number().min(1).max(1000).optional().describe('Maximum number of items to return'),
+    }, async ({ permissions, projectKey, issueKey, query, username, accountId, startAt, maxResults }) => {
+        try {
+            const users = await jiraService.searchUsersByPermission({
+                permissions,
+                projectKey,
+                issueKey,
+                query,
+                username,
+                accountId,
+                startAt,
+                maxResults,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(users),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to search users by permission: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('get-myself', 'Get current user information', {
+        expand: z
+            .array(z.enum(['groups', 'applicationRoles']))
+            .optional()
+            .describe('List of fields to expand'),
+    }, async ({ expand }) => {
+        try {
+            const user = await jiraService.getMyself(expand);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(user),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get current user info: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('get-my-permissions', "Get current user's permissions", {
+        projectKey: z.string().optional().describe('Project key to check permissions for'),
+        projectId: z.string().optional().describe('Project ID to check permissions for'),
+        issueKey: z.string().optional().describe('Issue key to check permissions for'),
+        issueId: z.string().optional().describe('Issue ID to check permissions for'),
+        permissions: z.string().optional().describe('Comma-separated list of permission keys to check'),
+        projectUuid: z.string().optional().describe('Project UUID'),
+        projectConfigurationUuid: z.string().optional().describe('Project configuration UUID'),
+        commentId: z.string().optional().describe('Comment ID to check permissions for'),
+    }, async ({ projectKey, projectId, issueKey, issueId, permissions, projectUuid, projectConfigurationUuid, commentId, }) => {
+        try {
+            const result = await jiraService.getMyPermissions({
+                projectKey,
+                projectId,
+                issueKey,
+                issueId,
+                permissions,
+                projectUuid,
+                projectConfigurationUuid,
+                commentId,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get permissions: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('update-myself', "Update current user's profile information", {
+        emailAddress: z.string().email().optional().describe('New email address'),
+        displayName: z.string().optional().describe('New display name'),
+        timeZone: z.string().optional().describe("New timezone (e.g., 'America/New_York')"),
+        locale: z.string().optional().describe("New locale (e.g., 'en_US')"),
+    }, async ({ emailAddress, displayName, timeZone, locale }) => {
+        try {
+            const user = await jiraService.updateMyself({
+                emailAddress,
+                displayName,
+                timeZone,
+                locale,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(user),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to update user profile: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('get-my-preferences', "Get current user's preferences", {
+        key: z.string().optional().describe('Specific preference key to retrieve'),
+    }, async ({ key }) => {
+        try {
+            const preferences = await jiraService.getMyPreferences(key);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(preferences),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get preferences: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('update-my-preferences', "Update current user's preferences", {
+        key: z.string().describe('Preference key to update'),
+        value: z.any().describe('New value for the preference'),
+    }, async ({ key, value }) => {
+        try {
+            const result = await jiraService.updateMyPreferences(key, value);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to update preferences: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('get-my-locale', "Get current user's locale setting", {}, async () => {
+        try {
+            const locale = await jiraService.getMyLocale();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(locale),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get locale: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('update-my-locale', "Update current user's locale setting", {
+        locale: z.string().describe("New locale (e.g., 'en_US', 'ko_KR')"),
+    }, async ({ locale }) => {
+        try {
+            const result = await jiraService.updateMyLocale(locale);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to update locale: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('get-priorities', 'Get all priorities', {}, async () => {
+        try {
+            const priorities = await jiraService.getPriorities();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(priorities),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get priorities: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('get-issue-transitions', 'Get available transitions for an issue', {
+        issueKey: z.string().describe('Issue key (e.g. PROJ-123)'),
+        expand: z
+            .array(z.enum(['transitions.fields', 'fields']))
+            .optional()
+            .describe('Fields to expand in the response'),
+    }, async ({ issueKey, expand }) => {
+        try {
+            const result = await jiraService.getIssueTransitions(issueKey, expand);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get issue transitions: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('transition-issue', 'Transition an issue to a new status', {
+        issueKey: z.string().describe('Issue key (e.g. PROJ-123)'),
+        transitionId: z.string().describe('ID of the transition to perform'),
+        comment: z
+            .object({
+            body: z.string().describe('Comment text'),
+            visibility: z
+                .object({
+                type: z.enum(['group', 'role']).describe('Visibility type'),
+                value: z.string().describe('Group name or role name'),
+            })
+                .optional()
+                .describe('Comment visibility restrictions'),
+        })
+            .optional()
+            .describe('Comment to add when transitioning'),
+        fields: z.record(z.any()).optional().describe('Fields to update during transition'),
+        update: z.record(z.any()).optional().describe('Additional update operations'),
+        historyMetadata: z.record(z.any()).optional().describe('History metadata'),
+        properties: z
+            .array(z.object({
+            key: z.string().describe('Property key'),
+            value: z.any().describe('Property value'),
+        }))
+            .optional()
+            .describe('Issue properties to set'),
+    }, async ({ issueKey, transitionId, comment, fields, update, historyMetadata, properties }) => {
+        try {
+            await jiraService.transitionIssue(issueKey, {
+                transitionId,
+                comment,
+                fields,
+                update,
+                historyMetadata,
+                properties: properties,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Issue transitioned successfully',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to transition issue: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('get-statuses', 'Get all workflow statuses', {}, async () => {
+        try {
+            const statuses = await jiraService.getStatuses();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(statuses),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get statuses: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('get-status', 'Get a specific status by ID or name', {
+        idOrName: z.string().describe('Status ID or name'),
+    }, async ({ idOrName }) => {
+        try {
+            const status = await jiraService.getStatus(idOrName);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(status),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get status: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('search-statuses', 'Search statuses with filters', {
+        startAt: z.number().min(0).optional().describe('The index of the first item to return'),
+        maxResults: z.number().min(1).max(100).optional().describe('Maximum number of items to return'),
+        searchString: z.string().optional().describe('Search string to filter statuses'),
+        projectId: z.string().optional().describe('Project ID to filter statuses for'),
+        expand: z.string().optional().describe('Fields to expand in the response'),
+    }, async ({ startAt, maxResults, searchString, projectId, expand }) => {
+        try {
+            const result = await jiraService.searchStatuses({
+                startAt,
+                maxResults,
+                searchString,
+                projectId,
+                expand,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to search statuses: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('get-priority', 'Get a specific priority by ID', {
+        id: z.string().describe('Priority ID'),
+    }, async ({ id }) => {
+        try {
+            const priority = await jiraService.getPriority(id);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(priority),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get priority: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('search-priorities', 'Search priorities with filters', {
+        startAt: z.number().min(0).optional().describe('The index of the first item to return'),
+        maxResults: z.number().min(1).max(100).optional().describe('Maximum number of items to return'),
+        id: z.array(z.string()).optional().describe('List of priority IDs to filter by'),
+        projectId: z.array(z.string()).optional().describe('List of project IDs to filter by'),
+        priorityName: z.string().optional().describe('Priority name to search for'),
+        onlyDefault: z.boolean().optional().describe('Whether to return only default priority'),
+    }, async ({ startAt, maxResults, id, projectId, priorityName, onlyDefault }) => {
+        try {
+            const result = await jiraService.searchPriorities({
+                startAt,
+                maxResults,
+                id,
+                projectId,
+                priorityName,
+                onlyDefault,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to search priorities: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('create-comment', 'Add a comment to an issue', {
+        issueKey: z.string().describe('Issue key (e.g. PROJ-123)'),
+        body: z.string().describe('Comment text'),
+        visibility: z
+            .object({
+            type: z.enum(['group', 'role']).describe('Visibility type'),
+            value: z.string().describe('Group name or role name'),
+        })
+            .optional()
+            .describe('Comment visibility restrictions'),
+        properties: z
+            .array(z.object({
+            key: z.string().describe('Property key'),
+            value: z.any().describe('Property value'),
+        }))
+            .optional()
+            .describe('Comment properties'),
+    }, async ({ issueKey, body, visibility, properties }) => {
+        try {
+            const comment = await jiraService.createComment(issueKey, {
+                body,
+                visibility,
+                properties: properties,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(comment),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to create comment: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('update-comment', 'Update an existing comment', {
+        issueKey: z.string().describe('Issue key (e.g. PROJ-123)'),
+        commentId: z.string().describe('Comment ID to update'),
+        body: z.string().describe('New comment text'),
+        visibility: z
+            .object({
+            type: z.enum(['group', 'role']).describe('Visibility type'),
+            value: z.string().describe('Group name or role name'),
+        })
+            .optional()
+            .describe('Comment visibility restrictions'),
+        properties: z
+            .array(z.object({
+            key: z.string().describe('Property key'),
+            value: z.any().describe('Property value'),
+        }))
+            .optional()
+            .describe('Comment properties'),
+    }, async ({ issueKey, commentId, body, visibility, properties }) => {
+        try {
+            const comment = await jiraService.updateComment(issueKey, commentId, {
+                body,
+                visibility,
+                properties: properties,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(comment),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to update comment: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('delete-comment', 'Delete a comment from an issue', {
+        issueKey: z.string().describe('Issue key (e.g. PROJ-123)'),
+        commentId: z.string().describe('Comment ID to delete'),
+    }, async ({ issueKey, commentId }) => {
+        try {
+            await jiraService.deleteComment(issueKey, commentId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Comment deleted successfully',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to delete comment: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('delete-issue', 'Delete an issue', {
+        issueKey: z.string().describe('Issue key (e.g. PROJ-123)'),
+        deleteSubtasks: z.boolean().optional().describe('Whether to delete subtasks (default: false)'),
+    }, async ({ issueKey, deleteSubtasks }) => {
+        try {
+            await jiraService.deleteIssue(issueKey, deleteSubtasks);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Issue deleted successfully',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to delete issue: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('get-issue-link-types', 'Get available issue link types', {}, async () => {
+        try {
+            const result = await jiraService.getIssueLinkTypes();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get issue link types: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('get-issue-link-type', 'Get a specific issue link type by ID', {
+        issueLinkTypeId: z.string().describe('Issue link type ID'),
+    }, async ({ issueLinkTypeId }) => {
+        try {
+            const result = await jiraService.getIssueLinkType(issueLinkTypeId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get issue link type: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('create-issue-link', 'Create a link between two issues', {
+        linkTypeId: z.string().optional().describe('Link type ID (either this or linkTypeName must be provided)'),
+        linkTypeName: z.string().optional().describe('Link type name (either this or linkTypeId must be provided)'),
+        inwardIssueId: z
+            .string()
+            .optional()
+            .describe('Inward issue ID (either this or inwardIssueKey must be provided)'),
+        inwardIssueKey: z
+            .string()
+            .optional()
+            .describe('Inward issue key (either this or inwardIssueId must be provided)'),
+        outwardIssueId: z
+            .string()
+            .optional()
+            .describe('Outward issue ID (either this or outwardIssueKey must be provided)'),
+        outwardIssueKey: z
+            .string()
+            .optional()
+            .describe('Outward issue key (either this or outwardIssueId must be provided)'),
+        comment: z
+            .object({
+            body: z.string().describe('Comment text'),
+            visibility: z
+                .object({
+                type: z.enum(['group', 'role']).describe('Visibility type'),
+                value: z.string().describe('Group name or role name'),
+            })
+                .optional()
+                .describe('Comment visibility restrictions'),
+        })
+            .optional()
+            .describe('Optional comment when creating the link'),
+    }, async ({ linkTypeId, linkTypeName, inwardIssueId, inwardIssueKey, outwardIssueId, outwardIssueKey, comment, }) => {
+        try {
+            // Validate required parameters
+            if (!linkTypeId && !linkTypeName) {
+                throw new Error('Either linkTypeId or linkTypeName must be provided');
+            }
+            if (!inwardIssueId && !inwardIssueKey) {
+                throw new Error('Either inwardIssueId or inwardIssueKey must be provided');
+            }
+            if (!outwardIssueId && !outwardIssueKey) {
+                throw new Error('Either outwardIssueId or outwardIssueKey must be provided');
+            }
+            const type = {};
+            if (linkTypeId)
+                type.id = linkTypeId;
+            if (linkTypeName)
+                type.name = linkTypeName;
+            const inwardIssue = {};
+            if (inwardIssueId)
+                inwardIssue.id = inwardIssueId;
+            if (inwardIssueKey)
+                inwardIssue.key = inwardIssueKey;
+            const outwardIssue = {};
+            if (outwardIssueId)
+                outwardIssue.id = outwardIssueId;
+            if (outwardIssueKey)
+                outwardIssue.key = outwardIssueKey;
+            await jiraService.createIssueLink({
+                type,
+                inwardIssue,
+                outwardIssue,
+                comment,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Issue link created successfully',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to create issue link: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('get-issue-link', 'Get details of a specific issue link', {
+        linkId: z.string().describe('Issue link ID'),
+    }, async ({ linkId }) => {
+        try {
+            const result = await jiraService.getIssueLink(linkId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get issue link: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('delete-issue-link', 'Delete a link between issues', {
+        linkId: z.string().describe('Issue link ID to delete'),
+    }, async ({ linkId }) => {
+        try {
+            await jiraService.deleteIssueLink(linkId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Issue link deleted successfully',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to delete issue link: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('get-issue-with-links', 'Get an issue with all its links', {
+        issueKey: z.string().describe('Issue key (e.g. PROJ-123)'),
+    }, async ({ issueKey }) => {
+        try {
+            const result = await jiraService.getIssueWithLinks(issueKey);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get issue with links: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('get-issue-watchers', 'Get watchers of an issue', {
+        issueKey: z.string().describe('Issue key (e.g. PROJ-123)'),
+    }, async ({ issueKey }) => {
+        try {
+            const result = await jiraService.getIssueWatchers(issueKey);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to get issue watchers: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('add-watcher', 'Add a user as watcher to an issue', {
+        issueKey: z.string().describe('Issue key (e.g. PROJ-123)'),
+        accountId: z.string().describe('Account ID of the user to add as watcher'),
+    }, async ({ issueKey, accountId }) => {
+        try {
+            await jiraService.addWatcher(issueKey, accountId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Watcher added successfully',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to add watcher: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('remove-watcher', 'Remove a user as watcher from an issue', {
+        issueKey: z.string().describe('Issue key (e.g. PROJ-123)'),
+        accountId: z.string().describe('Account ID of the user to remove as watcher'),
+    }, async ({ issueKey, accountId }) => {
+        try {
+            await jiraService.removeWatcher(issueKey, accountId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Watcher removed successfully',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to remove watcher: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('watch-issue', 'Start watching an issue (for current user)', {
+        issueKey: z.string().describe('Issue key (e.g. PROJ-123)'),
+    }, async ({ issueKey }) => {
+        try {
+            await jiraService.watchIssue(issueKey);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Now watching the issue',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to watch issue: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+    server.tool('unwatch-issue', 'Stop watching an issue (for current user)', {
+        issueKey: z.string().describe('Issue key (e.g. PROJ-123)'),
+    }, async ({ issueKey }) => {
+        try {
+            await jiraService.unwatchIssue(issueKey);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Stopped watching the issue',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to unwatch issue: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+};