mcp-jira-stdio 1.8.1 → 1.10.0

package/dist/index.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import axios from 'axios';
 import { z } from 'zod';
 import FormData from 'form-data';
@@ -441,7 +440,7 @@ var require_package2 = __commonJS({
   "package.json"(exports$1, module) {
     module.exports = {
       name: "mcp-jira-stdio",
-      version: "1.8.1",
+      version: "1.10.0",
       description: "Model Context Protocol (MCP) server for Jira API integration",
       author: "graslt",
       license: "MIT",
@@ -490,14 +489,14 @@ var require_package2 = __commonJS({
         node: ">=20.0.0"
       },
       dependencies: {
-        "@modelcontextprotocol/sdk": "^1.17.1",
+        "@modelcontextprotocol/sdk": "^1.29.0",
         axios: "^1.7.0",
         "form-data": "^4.0.5",
         "md-to-adf": "^0.5.0",
         zod: "^3.22.4"
       },
       devDependencies: {
-        "@types/node": "^22.5.0",
+        "@types/node": "^25.3.3",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
         "@typescript-eslint/parser": "^8.0.0",
         "@vitest/coverage-v8": "^4.0.10",
@@ -577,7 +576,10 @@ var TOOL_NAMES = {
   GET_COMMENTS: "jira_get_comments",
   ADD_ATTACHMENT: "jira_add_attachment",
   GET_ATTACHMENTS: "jira_get_attachments",
-  DELETE_ATTACHMENT: "jira_delete_attachment"
+  DELETE_ATTACHMENT: "jira_delete_attachment",
+  GET_TRANSITIONS: "jira_get_transitions",
+  TRANSITION_ISSUE: "jira_transition_issue",
+  GET_ISSUE_GRAPH: "jira_get_issue_graph"
 };
 
 // src/utils/logger.ts
@@ -883,6 +885,9 @@ var UpdateIssueInputSchema = z.object({
   assignee: z.string().optional().describe("New assignee account ID"),
   labels: z.array(z.string()).optional().describe("New labels (replaces existing)"),
   components: z.array(z.string()).optional().describe("New components (replaces existing)"),
+  parent: z.string().optional().describe(
+    "New parent issue key (e.g., PROJECT-100). Set to empty string to remove the parent."
+  ),
   returnIssue: z.boolean().optional().describe("When false, skip fetching full issue after update"),
   format: z.enum(["markdown", "adf", "plain"]).optional().default("markdown").describe(
     'Description format: "markdown" (converts Markdown to ADF), "adf" (use as-is ADF object), "plain" (converts plain text to ADF with basic formatting). Default: "markdown"'
@@ -985,6 +990,37 @@ var GetAttachmentsInputSchema = z.object({
 var DeleteAttachmentInputSchema = z.object({
   attachmentId: z.string().min(1).describe("ID of the attachment to delete")
 });
+var GetTransitionsInputSchema = z.object({
+  issueKey: z.string().describe("Issue key to get available transitions for (e.g., PROJECT-123)").refine((v) => isValidIssueKey(v), "Invalid issue key format")
+});
+var TransitionIssueInputSchema = z.object({
+  issueKey: z.string().describe("Issue key to transition (e.g., PROJECT-123)").refine((v) => isValidIssueKey(v), "Invalid issue key format"),
+  transitionId: z.string().optional().describe(
+    "ID of the transition to perform. Use jira_get_transitions to find available transition IDs."
+  ),
+  transitionName: z.string().optional().describe(
+    'Name of the transition to perform (e.g., "In Progress", "Done"). Case-insensitive. Alternative to transitionId.'
+  ),
+  comment: z.string().optional().describe("Optional comment to add when transitioning the issue"),
+  resolution: z.string().optional().describe(
+    'Resolution name when transitioning to a resolved/done status (e.g., "Done", "Fixed")'
+  ),
+  format: z.enum(["markdown", "adf", "plain"]).optional().default("markdown").describe(
+    'Comment format: "markdown" (converts Markdown to ADF), "adf" (use as-is ADF object), "plain" (converts plain text to ADF with basic formatting). Default: "markdown"'
+  )
+}).refine((data) => data.transitionId || data.transitionName, {
+  message: "Either transitionId or transitionName must be provided"
+});
+var GetIssueGraphInputSchema = z.object({
+  issueKey: z.string().min(1).describe("Seed issue key to start graph traversal from (e.g., PROJECT-123)").refine((v) => isValidIssueKey(v), "Invalid issue key format"),
+  maxDepth: z.number().min(1).max(5).default(2).describe("Maximum BFS traversal depth from seed issue (default: 2, max: 5)"),
+  maxNodes: z.number().min(1).max(200).default(50).describe("Maximum number of nodes to include in the graph (default: 50, max: 200)"),
+  includeHierarchy: z.boolean().default(true).describe("Include parent/child/subtask edges (default: true)"),
+  linkTypes: z.array(z.string()).optional().describe(
+    'Filter to specific link types (e.g., ["Blocks", "Relates"]). If omitted, includes all link types.'
+  ),
+  direction: z.enum(["all", "inward", "outward"]).default("all").describe('Which link directions to follow: "all", "inward", or "outward" (default: "all")')
+});
 function ensureAdfDescription(desc, format = "markdown") {
   if (!desc) return desc;
   if (typeof desc === "object") return desc;
@@ -1237,6 +1273,9 @@ async function updateIssue(issueKey, updates) {
   if (updates.components !== void 0) {
     fields.components = updates.components.map((name) => ({ name }));
   }
+  if (updates.parent !== void 0) {
+    fields.parent = updates.parent ? { key: updates.parent } : null;
+  }
   const config = {
     method: "PUT",
     url: `/issue/${issueKey}`,
@@ -1521,6 +1560,42 @@ async function deleteAttachment(attachmentId) {
   };
   await makeJiraRequest(config);
 }
+async function getTransitions(issueKey) {
+  const config = {
+    method: "GET",
+    url: `/issue/${issueKey}/transitions`
+  };
+  const response = await makeJiraRequest(config);
+  return response.transitions;
+}
+async function transitionIssue(issueKey, transitionId, options = {}) {
+  const data = {
+    transition: { id: transitionId }
+  };
+  if (options.resolution) {
+    data.fields = {
+      resolution: { name: options.resolution }
+    };
+  }
+  if (options.comment) {
+    const adfBody = ensureAdfDescription(options.comment, options.format || "markdown");
+    data.update = {
+      comment: [
+        {
+          add: {
+            body: adfBody
+          }
+        }
+      ]
+    };
+  }
+  const config = {
+    method: "POST",
+    url: `/issue/${issueKey}/transitions`,
+    data
+  };
+  await makeJiraRequest(config);
+}
 
 // src/utils/redaction.ts
 function isRedactionEnabled() {
@@ -1608,6 +1683,8 @@ function formatIssueResponse(issue) {
   }
   const createdText = fields?.created ? new Date(fields.created).toISOString() : "N/A";
   const updatedText = fields?.updated ? new Date(fields.updated).toISOString() : "N/A";
+  const parentText = fields?.parent ? `
+**Parent:** ${fields.parent.key}${fields.parent.fields?.summary ? ` - ${fields.parent.fields.summary}` : ""}${fields.parent.fields?.status ? ` (${fields.parent.fields.status.name})` : ""}` : "";
   return {
     content: [
       {
@@ -1621,7 +1698,7 @@ function formatIssueResponse(issue) {
 **Project:** ${fields?.project?.name || "Unknown"} (${fields?.project?.key || "N/A"})
 **Issue Type:** ${fields?.issuetype?.name || "Unknown"}
 **Labels:** ${labelsText}
-**Components:** ${componentsText}
+**Components:** ${componentsText}${parentText}
 **Created:** ${createdText}
 **Updated:** ${updatedText}
 
@@ -2062,6 +2139,34 @@ ${attachmentsList}
     ]
   };
 }
+function formatTransitionsResponse(transitions, issueKey) {
+  if (transitions.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `No transitions available for issue ${issueKey}. The issue may be in a final state or you may lack permission.`
+        }
+      ]
+    };
+  }
+  const transitionsList = transitions.map(
+    (t) => `\u2022 **${t.name}** (ID: ${t.id})
+  Target status: ${t.to.name} (Category: ${t.to.statusCategory?.name || "Unknown"})`
+  ).join("\n\n");
+  return {
+    content: [
+      {
+        type: "text",
+        text: `**Available transitions for ${issueKey}** (${transitions.length}):
+
+${transitionsList}
+
+\u{1F4A1} **Tip:** Use \`jira_transition_issue\` with the transition ID or name to move this issue.`
+      }
+    ]
+  };
+}
 
 // src/utils/error-handler.ts
 var log2 = createLogger("error-handler");
@@ -2114,27 +2219,7 @@ function handleError(error) {
 // src/tools/get-visible-projects.ts
 var log3 = createLogger("tool:get-visible-projects");
 var getVisibleProjectsTool = {
-  name: TOOL_NAMES.GET_VISIBLE_PROJECTS,
-  description: "Retrieves all projects accessible to the authenticated user. Returns project keys, names, descriptions, and basic metadata.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      expand: {
-        type: "array",
-        items: { type: "string" },
-        description: 'Additional project details to include (e.g., ["description", "lead", "issueTypes"])',
-        default: []
-      },
-      recent: {
-        type: "number",
-        description: "Limit results to recently accessed projects (max number)",
-        minimum: 1,
-        maximum: 100
-      }
-    },
-    required: []
-  }
-};
+  description: "Retrieves all projects accessible to the authenticated user. Returns project keys, names, descriptions, and basic metadata."};
 async function handleGetVisibleProjects(input) {
   try {
     const validated = validateInput(GetVisibleProjectsInputSchema, input);
@@ -2154,30 +2239,7 @@ async function handleGetVisibleProjects(input) {
 // src/tools/get-issue.ts
 var log4 = createLogger("tool:get-issue");
 var getIssueTool = {
-  name: TOOL_NAMES.GET_ISSUE,
-  description: 'Retrieve details for a specific Jira issue by key or URL. Use this when the user mentions an issue like "PAYWALL-943" or pastes a Jira link (e.g., https://your.atlassian.net/browse/PAYWALL-943). Returns status, assignee, priority, project, type, labels, components, timestamps, and description.',
-  inputSchema: {
-    type: "object",
-    properties: {
-      issueKey: {
-        type: "string",
-        description: "Issue key or full Jira URL (e.g., PROJECT-123 or https://your.atlassian.net/browse/PROJECT-123)"
-      },
-      expand: {
-        type: "array",
-        items: { type: "string" },
-        description: 'Additional issue details to include (e.g., ["comments", "attachments", "changelog"])',
-        default: []
-      },
-      fields: {
-        type: "array",
-        items: { type: "string" },
-        description: 'Specific fields to retrieve (e.g., ["summary", "status", "assignee"])'
-      }
-    },
-    required: ["issueKey"]
-  }
-};
+  description: 'Retrieve details for a specific Jira issue by key or URL. Use this when the user mentions an issue like "PAYWALL-943" or pastes a Jira link (e.g., https://your.atlassian.net/browse/PAYWALL-943). Returns status, assignee, priority, project, type, labels, components, timestamps, and description.'};
 async function handleGetIssue(input) {
   try {
     const validated = validateInput(GetIssueInputSchema, input);
@@ -2199,41 +2261,7 @@ async function handleGetIssue(input) {
 // src/tools/search-issues.ts
 var log5 = createLogger("tool:search-issues");
 var searchIssuesTool = {
-  name: TOOL_NAMES.SEARCH_ISSUES,
-  description: 'Search for Jira issues using JQL. Supports complex queries with pagination and field selection. Examples: "project = PROJECT AND status = Open", "assignee = currentUser()". For pagination, use nextPageToken from previous response.',
-  inputSchema: {
-    type: "object",
-    properties: {
-      jql: {
-        type: "string",
-        description: 'JQL query string (e.g., "project = PROJECT AND status = Open")'
-      },
-      nextPageToken: {
-        type: "string",
-        description: "Token for pagination. Omit for first page, use value from previous response for next page."
-      },
-      maxResults: {
-        type: "number",
-        description: "Maximum number of results to return per page",
-        minimum: 1,
-        maximum: 100,
-        default: 50
-      },
-      fields: {
-        type: "array",
-        items: { type: "string" },
-        description: "Specific fields to retrieve for each issue"
-      },
-      expand: {
-        type: "array",
-        items: { type: "string" },
-        description: "Additional details to include for each issue",
-        default: []
-      }
-    },
-    required: ["jql"]
-  }
-};
+  description: 'Search for Jira issues using JQL. Supports complex queries with pagination and field selection. Examples: "project = PROJECT AND status = Open", "assignee = currentUser()". For pagination, use nextPageToken from previous response.'};
 async function handleSearchIssues(input) {
   try {
     const validated = validateInput(SearchIssuesInputSchema, input);
@@ -2257,37 +2285,7 @@ async function handleSearchIssues(input) {
 // src/tools/get-my-issues.ts
 var log6 = createLogger("tool:get-my-issues");
 var getMyIssuesTool = {
-  name: TOOL_NAMES.GET_MY_ISSUES,
-  description: "Retrieves issues assigned to current user, sorted by most recently updated first. Supports pagination and field selection. For pagination, use nextPageToken from previous response.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      nextPageToken: {
-        type: "string",
-        description: "Token for pagination. Omit for first page, use value from previous response for next page."
-      },
-      maxResults: {
-        type: "number",
-        description: "Maximum number of results to return per page",
-        minimum: 1,
-        maximum: 100,
-        default: 50
-      },
-      fields: {
-        type: "array",
-        items: { type: "string" },
-        description: "Specific fields to retrieve for each issue"
-      },
-      expand: {
-        type: "array",
-        items: { type: "string" },
-        description: "Additional details to include for each issue",
-        default: []
-      }
-    },
-    required: []
-  }
-};
+  description: "Retrieves issues assigned to current user, sorted by most recently updated first. Supports pagination and field selection. For pagination, use nextPageToken from previous response."};
 async function handleGetMyIssues(input) {
   try {
     const validated = validateInput(GetMyIssuesInputSchema, input);
@@ -2311,19 +2309,7 @@ async function handleGetMyIssues(input) {
 // src/tools/get-issue-types.ts
 var log7 = createLogger("tool:get-issue-types");
 var getIssueTypesTool = {
-  name: TOOL_NAMES.GET_ISSUE_TYPES,
-  description: "Retrieves available issue types. Can get global issue types or project-specific issue types including regular issues and subtasks (Bug, Story, Task, Epic, etc.).",
-  inputSchema: {
-    type: "object",
-    properties: {
-      projectKey: {
-        type: "string",
-        description: "Project key to get issue types for specific project (optional - if not provided, returns global issue types)"
-      }
-    },
-    required: []
-  }
-};
+  description: "Retrieves available issue types. Can get global issue types or project-specific issue types including regular issues and subtasks (Bug, Story, Task, Epic, etc.)."};
 async function handleGetIssueTypes(input) {
   try {
     const validated = validateInput(GetIssueTypesInputSchema, input);
@@ -2344,40 +2330,7 @@ async function handleGetIssueTypes(input) {
 // src/tools/get-users.ts
 var log8 = createLogger("tool:get-users");
 var getUsersTool = {
-  name: TOOL_NAMES.GET_USERS,
-  description: "Search for users by name, email, username, or account ID. Returns display name, email, account status, and account type. Supports pagination.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      query: {
-        type: "string",
-        description: "Search query for user name or email (partial matches supported)"
-      },
-      username: {
-        type: "string",
-        description: "Specific username to search for"
-      },
-      accountId: {
-        type: "string",
-        description: "Specific account ID to search for"
-      },
-      startAt: {
-        type: "number",
-        description: "Index of first result to return (for pagination)",
-        minimum: 0,
-        default: 0
-      },
-      maxResults: {
-        type: "number",
-        description: "Maximum number of results to return",
-        minimum: 1,
-        maximum: 50,
-        default: 50
-      }
-    },
-    required: []
-  }
-};
+  description: "Search for users by name, email, username, or account ID. Returns display name, email, account status, and account type. Supports pagination."};
 async function handleGetUsers(input) {
   try {
     const validated = validateInput(GetUsersInputSchema, input);
@@ -2408,14 +2361,7 @@ async function handleGetUsers(input) {
 // src/tools/get-priorities.ts
 var log9 = createLogger("tool:get-priorities");
 var getPrioritiesTool = {
-  name: TOOL_NAMES.GET_PRIORITIES,
-  description: "Retrieves available priorities (e.g., Highest, High, Medium, Low, Lowest). Returns IDs, names, and descriptions.",
-  inputSchema: {
-    type: "object",
-    properties: {},
-    required: []
-  }
-};
+  description: "Retrieves available priorities (e.g., Highest, High, Medium, Low, Lowest). Returns IDs, names, and descriptions."};
 async function handleGetPriorities(input) {
   try {
     validateInput(GetPrioritiesInputSchema, input);
@@ -2432,23 +2378,7 @@ async function handleGetPriorities(input) {
 // src/tools/get-statuses.ts
 var log10 = createLogger("tool:get-statuses");
 var getStatusesTool = {
-  name: TOOL_NAMES.GET_STATUSES,
-  description: "Retrieves available statuses (global or project-specific, e.g., To Do, In Progress, Done). Returns status categories and workflow information.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      projectKey: {
-        type: "string",
-        description: "Project key to get statuses for specific project (optional)"
-      },
-      issueTypeId: {
-        type: "string",
-        description: "Issue type ID to get statuses for specific issue type (requires projectKey)"
-      }
-    },
-    required: []
-  }
-};
+  description: "Retrieves available statuses (global or project-specific, e.g., To Do, In Progress, Done). Returns status categories and workflow information."};
 async function handleGetStatuses(input) {
   try {
     const validated = validateInput(GetStatusesInputSchema, input);
@@ -2476,68 +2406,7 @@ async function handleGetStatuses(input) {
 // src/tools/create-issue.ts
 var log11 = createLogger("tool:create-issue");
 var createIssueTool = {
-  name: TOOL_NAMES.CREATE_ISSUE,
-  description: 'Creates a new Jira issue in the specified project. Supports setting issue type, priority, assignee, labels, components, and custom fields. Description format is controlled by the "format" parameter (default: markdown). For required custom fields, supply them via customFields (e.g., { "customfield_12345": { id: "..." } }). Returns the created issue with all details.',
-  inputSchema: {
-    type: "object",
-    properties: {
-      projectKey: {
-        type: "string",
-        description: "Project key where the issue will be created"
-      },
-      summary: {
-        type: "string",
-        description: "Issue summary/title",
-        minLength: 1
-      },
-      description: {
-        anyOf: [{ type: "string" }, { type: "object" }],
-        description: 'Detailed issue description (optional). Format depends on the "format" parameter.'
-      },
-      issueType: {
-        type: "string",
-        description: "Issue type name (e.g., Bug, Story, Task, Epic)"
-      },
-      priority: {
-        type: "string",
-        description: "Issue priority name (e.g., High, Medium, Low) - optional"
-      },
-      assignee: {
-        type: "string",
-        description: "Assignee account ID (optional)"
-      },
-      labels: {
-        type: "array",
-        items: { type: "string" },
-        description: "Issue labels (optional)",
-        default: []
-      },
-      components: {
-        type: "array",
-        items: { type: "string" },
-        description: "Component names (optional)",
-        default: []
-      },
-      customFields: {
-        type: "object",
-        additionalProperties: true,
-        description: 'Additional Jira fields, e.g. { "customfield_10071": value }. Use this to set required custom fields.'
-      },
-      returnIssue: {
-        type: "boolean",
-        description: "If false, returns only the issue key without fetching full details",
-        default: true
-      },
-      format: {
-        type: "string",
-        enum: ["markdown", "adf", "plain"],
-        description: 'Description format: "markdown" (converts Markdown to ADF, default), "adf" (use as-is ADF object), "plain" (converts plain text to ADF with basic formatting)',
-        default: "markdown"
-      }
-    },
-    required: ["projectKey", "summary", "issueType"]
-  }
-};
+  description: 'Creates a new Jira issue in the specified project. Supports setting issue type, priority, assignee, labels, components, and custom fields. Description format is controlled by the "format" parameter (default: markdown). For required custom fields, supply them via customFields (e.g., { "customfield_12345": { id: "..." } }). Returns the created issue with all details.'};
 async function handleCreateIssue(input) {
   try {
     const validated = validateInput(CreateIssueInputSchema, input);
@@ -2577,56 +2446,7 @@ async function handleCreateIssue(input) {
 // src/tools/update-issue.ts
 var log12 = createLogger("tool:update-issue");
 var updateIssueTool = {
-  name: TOOL_NAMES.UPDATE_ISSUE,
-  description: 'Updates an existing Jira issue by its key. Supports updating summary, description, priority, assignee, labels, and components. Description format is controlled by the "format" parameter (default: markdown). Only specified fields will be updated.',
-  inputSchema: {
-    type: "object",
-    properties: {
-      issueKey: {
-        type: "string",
-        description: "Issue key to update (e.g., PROJECT-123)"
-      },
-      summary: {
-        type: "string",
-        description: "New issue summary/title (optional)"
-      },
-      description: {
-        anyOf: [{ type: "string" }, { type: "object" }],
-        description: 'New issue description (optional). Format depends on the "format" parameter.'
-      },
-      priority: {
-        type: "string",
-        description: "New priority name (e.g., High, Medium, Low) - optional"
-      },
-      assignee: {
-        type: "string",
-        description: "New assignee account ID (optional, use null string to unassign)"
-      },
-      labels: {
-        type: "array",
-        items: { type: "string" },
-        description: "New labels array (replaces existing labels) - optional"
-      },
-      components: {
-        type: "array",
-        items: { type: "string" },
-        description: "New components array (replaces existing components) - optional"
-      },
-      returnIssue: {
-        type: "boolean",
-        description: "If false, returns a success message without fetching the updated issue",
-        default: true
-      },
-      format: {
-        type: "string",
-        enum: ["markdown", "adf", "plain"],
-        description: 'Description format: "markdown" (converts Markdown to ADF, default), "adf" (use as-is ADF object), "plain" (converts plain text to ADF with basic formatting)',
-        default: "markdown"
-      }
-    },
-    required: ["issueKey"]
-  }
-};
+  description: 'Updates an existing Jira issue by its key. Supports updating summary, description, priority, assignee, labels, and components. Description format is controlled by the "format" parameter (default: markdown). Only specified fields will be updated.'};
 async function handleUpdateIssue(input) {
   try {
     const validated = validateInput(UpdateIssueInputSchema, input);
@@ -2638,6 +2458,7 @@ async function handleUpdateIssue(input) {
     if (validated.assignee !== void 0) updateParams.assignee = validated.assignee;
     if (validated.labels !== void 0) updateParams.labels = validated.labels;
     if (validated.components !== void 0) updateParams.components = validated.components;
+    if (validated.parent !== void 0) updateParams.parent = validated.parent;
     if (validated.format !== void 0) updateParams.format = validated.format;
     await updateIssue(validated.issueKey, updateParams);
     if (validated.returnIssue === false) {
@@ -2656,46 +2477,7 @@ async function handleUpdateIssue(input) {
 // src/tools/add-comment.ts
 var log13 = createLogger("tool:add-comment");
 var addCommentTool = {
-  name: TOOL_NAMES.ADD_COMMENT,
-  description: 'Adds a comment to an issue. Supports visibility restrictions for groups or roles. Comment format is controlled by the "format" parameter (default: markdown). Returns the created comment with author details and timestamp.',
-  inputSchema: {
-    type: "object",
-    properties: {
-      issueKey: {
-        type: "string",
-        description: "Issue key to add comment to (e.g., PROJECT-123)"
-      },
-      body: {
-        type: "string",
-        description: 'Comment body text. Format depends on the "format" parameter.',
-        minLength: 1
-      },
-      visibility: {
-        type: "object",
-        description: "Comment visibility restrictions (optional)",
-        properties: {
-          type: {
-            type: "string",
-            enum: ["group", "role"],
-            description: 'Visibility type - either "group" or "role"'
-          },
-          value: {
-            type: "string",
-            description: "Group name or role name for visibility restriction"
-          }
-        },
-        required: ["type", "value"]
-      },
-      format: {
-        type: "string",
-        enum: ["markdown", "adf", "plain"],
-        description: 'Comment format: "markdown" (converts Markdown to ADF, default), "adf" (use as-is ADF object), "plain" (converts plain text to ADF with basic formatting)',
-        default: "markdown"
-      }
-    },
-    required: ["issueKey", "body"]
-  }
-};
+  description: 'Adds a comment to an issue. Supports visibility restrictions for groups or roles. Comment format is controlled by the "format" parameter (default: markdown). Returns the created comment with author details and timestamp.'};
 async function handleAddComment(input) {
   try {
     const validated = validateInput(AddCommentInputSchema, input);
@@ -2717,25 +2499,7 @@ async function handleAddComment(input) {
 // src/tools/get-project-info.ts
 var log14 = createLogger("tool:get-project-info");
 var getProjectInfoTool = {
-  name: TOOL_NAMES.GET_PROJECT_INFO,
-  description: "Retrieves detailed information about a project (components, versions, issue types, roles, insights). More comprehensive than the basic project list.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      projectKey: {
-        type: "string",
-        description: "Project key to get detailed information for"
-      },
-      expand: {
-        type: "array",
-        items: { type: "string" },
-        description: 'Additional project details to include (e.g., ["description", "lead", "issueTypes", "versions"])',
-        default: []
-      }
-    },
-    required: ["projectKey"]
-  }
-};
+  description: "Retrieves detailed information about a project (components, versions, issue types, roles, insights). More comprehensive than the basic project list."};
 async function handleGetProjectInfo(input) {
   try {
     const validated = validateInput(GetProjectInfoInputSchema, input);
@@ -2752,54 +2516,7 @@ async function handleGetProjectInfo(input) {
 // src/tools/create-subtask.ts
 var log15 = createLogger("tool:create-subtask");
 var createSubtaskTool = {
-  name: TOOL_NAMES.CREATE_SUBTASK,
-  description: 'Creates a subtask under an existing parent issue. Automatically determines the correct project and subtask issue type. Supports setting priority, assignee, labels, and components. Description format is controlled by the "format" parameter (default: markdown).',
-  inputSchema: {
-    type: "object",
-    properties: {
-      parentIssueKey: {
-        type: "string",
-        description: "Parent issue key (e.g., PROJECT-123)"
-      },
-      summary: {
-        type: "string",
-        description: "Subtask summary/title",
-        minLength: 1
-      },
-      description: {
-        type: "string",
-        description: 'Detailed subtask description (optional). Format depends on the "format" parameter.'
-      },
-      priority: {
-        type: "string",
-        description: "Subtask priority name (e.g., High, Medium, Low) - optional"
-      },
-      assignee: {
-        type: "string",
-        description: "Assignee account ID (optional)"
-      },
-      labels: {
-        type: "array",
-        items: { type: "string" },
-        description: "Subtask labels (optional)",
-        default: []
-      },
-      components: {
-        type: "array",
-        items: { type: "string" },
-        description: "Component names (optional)",
-        default: []
-      },
-      format: {
-        type: "string",
-        enum: ["markdown", "adf", "plain"],
-        description: 'Description format: "markdown" (converts Markdown to ADF, default), "adf" (use as-is ADF object), "plain" (converts plain text to ADF with basic formatting)',
-        default: "markdown"
-      }
-    },
-    required: ["parentIssueKey", "summary"]
-  }
-};
+  description: 'Creates a subtask under an existing parent issue. Automatically determines the correct project and subtask issue type. Supports setting priority, assignee, labels, and components. Description format is controlled by the "format" parameter (default: markdown).'};
 async function handleCreateSubtask(input) {
   try {
     const validated = validateInput(CreateSubtaskInputSchema, input);
@@ -2825,23 +2542,7 @@ async function handleCreateSubtask(input) {
 // src/tools/get-create-meta.ts
 var log16 = createLogger("tool:get-create-meta");
 var getCreateMetaTool = {
-  name: TOOL_NAMES.GET_CREATE_META,
-  description: "Retrieves create metadata for a project, showing all available fields (including custom fields) for creating issues. Shows required vs optional fields, field types, and allowed values. Use this before creating issues to discover what fields are needed.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      projectKey: {
-        type: "string",
-        description: "Project key to get create metadata for (e.g., PROJECT)"
-      },
-      issueTypeName: {
-        type: "string",
-        description: "Specific issue type name to get metadata for (optional)"
-      }
-    },
-    required: ["projectKey"]
-  }
-};
+  description: "Retrieves create metadata for a project, showing all available fields (including custom fields) for creating issues. Shows required vs optional fields, field types, and allowed values. Use this before creating issues to discover what fields are needed."};
 async function handleGetCreateMeta(input) {
   try {
     const validated = validateInput(GetCreateMetaInputSchema, input);
@@ -2865,19 +2566,7 @@ async function handleGetCreateMeta(input) {
 // src/tools/get-custom-fields.ts
 var log17 = createLogger("tool:get-custom-fields");
 var getCustomFieldsTool = {
-  name: TOOL_NAMES.GET_CUSTOM_FIELDS,
-  description: "Retrieves all custom fields available in Jira. Shows custom field names, IDs (e.g., customfield_10071), and types. Useful for discovering what custom fields exist and their identifiers.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      projectKey: {
-        type: "string",
-        description: "Project key to filter custom fields (optional)"
-      }
-    },
-    required: []
-  }
-};
+  description: "Retrieves all custom fields available in Jira. Shows custom field names, IDs (e.g., customfield_10071), and types. Useful for discovering what custom fields exist and their identifiers."};
 async function handleGetCustomFields(input) {
   try {
     const validated = validateInput(GetCustomFieldsInputSchema, input);
@@ -2895,27 +2584,7 @@ async function handleGetCustomFields(input) {
 // src/tools/create-issue-link.ts
 var log18 = createLogger("tool:create-issue-link");
 var createIssueLinkTool = {
-  name: TOOL_NAMES.CREATE_ISSUE_LINK,
-  description: 'Creates a link between two Jira issues. Supports common link types like "blocks", "relates", "duplicates", and "clones". Use this to establish relationships between issues.',
-  inputSchema: {
-    type: "object",
-    properties: {
-      fromIssue: {
-        type: "string",
-        description: "Source issue key (e.g., PROJECT-123)"
-      },
-      toIssue: {
-        type: "string",
-        description: "Target issue key (e.g., PROJECT-456)"
-      },
-      linkType: {
-        type: "string",
-        description: 'Link type: "blocks" (fromIssue blocks toIssue), "is blocked by", "relates", "duplicates", "clones", or custom link type name'
-      }
-    },
-    required: ["fromIssue", "toIssue", "linkType"]
-  }
-};
+  description: 'Creates a link between two Jira issues. Supports common link types like "blocks", "relates", "duplicates", and "clones". Use this to establish relationships between issues.'};
 async function handleCreateIssueLink(input) {
   try {
     const validated = validateInput(CreateIssueLinkInputSchema, input);
@@ -2936,35 +2605,7 @@ async function handleCreateIssueLink(input) {
 // src/tools/get-comments.ts
 var log19 = createLogger("tool:get-comments");
 var getCommentsTool = {
-  name: TOOL_NAMES.GET_COMMENTS,
-  description: "Retrieves all comments for a Jira issue. Returns comment author, content, timestamps, and visibility settings. Supports pagination for issues with many comments.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      issueKey: {
-        type: "string",
-        description: "Issue key to get comments for (e.g., PROJECT-123)"
-      },
-      maxResults: {
-        type: "number",
-        description: "Maximum number of comments to return (default: 50, max: 100)",
-        minimum: 1,
-        maximum: 100
-      },
-      orderBy: {
-        type: "string",
-        enum: ["created", "-created", "+created"],
-        description: 'Sort order for comments: "created" or "+created" (oldest first), "-created" (newest first)'
-      },
-      startAt: {
-        type: "number",
-        description: "Index of first comment to return (for pagination, default: 0)",
-        minimum: 0
-      }
-    },
-    required: ["issueKey"]
-  }
-};
+  description: "Retrieves all comments for a Jira issue. Returns comment author, content, timestamps, and visibility settings. Supports pagination for issues with many comments."};
 async function handleGetComments(input) {
   try {
     const validated = validateInput(GetCommentsInputSchema, input);
@@ -2991,7 +2632,6 @@ async function handleGetComments(input) {
 // src/tools/add-attachment.ts
 var log20 = createLogger("tool:add-attachment");
 var addAttachmentTool = {
-  name: TOOL_NAMES.ADD_ATTACHMENT,
   description: `Uploads an attachment (image, document, etc.) to a Jira issue.
 
 **EFFICIENT METHOD (recommended for large files):**
@@ -3002,37 +2642,7 @@ var addAttachmentTool = {
 - content: Base64 encoded content - WARNING: HIGH token cost (~330,000 tokens for 1MB file)
   Only suitable for small files (< 500 KB)
 
-Returns attachment metadata including ID and download URL. To reference the image in a comment or description, use wiki markup: !filename.png! or !filename.png|thumbnail!`,
-  inputSchema: {
-    type: "object",
-    properties: {
-      issueKey: {
-        type: "string",
-        description: "Issue key to add attachment to (e.g., PROJECT-123)"
-      },
-      filename: {
-        type: "string",
-        description: "Name of the file to attach (e.g., screenshot.png, document.pdf)",
-        minLength: 1
-      },
-      fileUrl: {
-        type: "string",
-        description: "URL to download file from (efficient for remote files, ~60 tokens). Upload large files to Dropbox/S3/imgur first, then use URL.",
-        format: "uri"
-      },
-      content: {
-        type: "string",
-        description: "Base64-encoded or plain text content. WARNING: HIGH token cost (~330k tokens for 1MB file). Use fileUrl for large files or upload to cloud storage first."
-      },
-      isBase64: {
-        type: "boolean",
-        description: "Whether content is base64-encoded (default: true). Set to false for plain text files.",
-        default: true
-      }
-    },
-    required: ["issueKey", "filename"]
-  }
-};
+Returns attachment metadata including ID and download URL. To reference the image in a comment or description, use wiki markup: !filename.png! or !filename.png|thumbnail!`};
 async function handleAddAttachment(input) {
   try {
     const validated = validateInput(AddAttachmentInputSchema, input);
@@ -3067,19 +2677,7 @@ async function handleAddAttachment(input) {
 // src/tools/get-attachments.ts
 var log21 = createLogger("tool:get-attachments");
 var getAttachmentsTool = {
-  name: TOOL_NAMES.GET_ATTACHMENTS,
-  description: "Lists all attachments on a Jira issue. Returns attachment metadata including filename, size, MIME type, author, and download URL.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      issueKey: {
-        type: "string",
-        description: "Issue key to get attachments for (e.g., PROJECT-123)"
-      }
-    },
-    required: ["issueKey"]
-  }
-};
+  description: "Lists all attachments on a Jira issue. Returns attachment metadata including filename, size, MIME type, author, and download URL."};
 async function handleGetAttachments(input) {
   try {
     const validated = validateInput(GetAttachmentsInputSchema, input);
@@ -3096,20 +2694,7 @@ async function handleGetAttachments(input) {
 // src/tools/delete-attachment.ts
 var log22 = createLogger("tool:delete-attachment");
 var deleteAttachmentTool = {
-  name: TOOL_NAMES.DELETE_ATTACHMENT,
-  description: "Deletes an attachment from Jira by its attachment ID. Use jira_get_attachments to find attachment IDs.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      attachmentId: {
-        type: "string",
-        description: "ID of the attachment to delete (can be found using jira_get_attachments)",
-        minLength: 1
-      }
-    },
-    required: ["attachmentId"]
-  }
-};
+  description: "Deletes an attachment from Jira by its attachment ID. Use jira_get_attachments to find attachment IDs."};
 async function handleDeleteAttachment(input) {
   try {
     const validated = validateInput(DeleteAttachmentInputSchema, input);
@@ -3130,6 +2715,322 @@ async function handleDeleteAttachment(input) {
   }
 }
 
+// src/tools/get-transitions.ts
+var log23 = createLogger("tool:get-transitions");
+var getTransitionsTool = {
+  description: "Retrieves all available workflow transitions for a Jira issue. Use this to discover which status changes are possible for an issue before calling jira_transition_issue."};
+async function handleGetTransitions(input) {
+  try {
+    const validated = validateInput(GetTransitionsInputSchema, input);
+    log23.info(`Getting transitions for issue ${validated.issueKey}...`);
+    const transitions = await getTransitions(validated.issueKey);
+    log23.info(`Found ${transitions.length} transition(s) for ${validated.issueKey}`);
+    return formatTransitionsResponse(transitions, validated.issueKey);
+  } catch (error) {
+    log23.error("Error in handleGetTransitions:", error);
+    return handleError(error);
+  }
+}
+
+// src/tools/transition-issue.ts
+var log24 = createLogger("tool:transition-issue");
+var transitionIssueTool = {
+  description: 'Transitions a Jira issue to a new workflow status (e.g., "To Do" -> "In Progress" -> "Done"). Use jira_get_transitions first to discover available transitions. Supports adding a comment and setting resolution during the transition.'};
+async function handleTransitionIssue(input) {
+  try {
+    const validated = validateInput(TransitionIssueInputSchema, input);
+    let transitionId = validated.transitionId;
+    if (!transitionId && validated.transitionName) {
+      log24.info(
+        `Looking up transition "${validated.transitionName}" for issue ${validated.issueKey}...`
+      );
+      const transitions = await getTransitions(validated.issueKey);
+      const match = transitions.find(
+        (t) => t.name.toLowerCase() === validated.transitionName.toLowerCase()
+      );
+      if (!match) {
+        const available = transitions.map((t) => `"${t.name}" (ID: ${t.id})`).join(", ");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Transition "${validated.transitionName}" not found for issue ${validated.issueKey}.
+
+Available transitions: ${available || "none"}`
+            }
+          ]
+        };
+      }
+      transitionId = match.id;
+    }
+    log24.info(`Transitioning issue ${validated.issueKey} with transition ${transitionId}...`);
+    const transitionOptions = {};
+    if (validated.comment) transitionOptions.comment = validated.comment;
+    if (validated.resolution) transitionOptions.resolution = validated.resolution;
+    if (validated.format) transitionOptions.format = validated.format;
+    await transitionIssue(validated.issueKey, transitionId, transitionOptions);
+    const updatedIssue = await getIssue(validated.issueKey);
+    log24.info(`Transitioned issue ${validated.issueKey} to ${updatedIssue.fields.status.name}`);
+    return formatIssueResponse(updatedIssue);
+  } catch (error) {
+    log24.error("Error in handleTransitionIssue:", error);
+    return handleError(error);
+  }
+}
+
+// src/tools/get-issue-graph.ts
+var log25 = createLogger("tool:get-issue-graph");
+var GRAPH_FIELDS = [
+  "summary",
+  "status",
+  "issuetype",
+  "priority",
+  "parent",
+  "subtasks",
+  "issuelinks"
+];
+var getIssueGraphTool = {
+  description: "Build a dependency/relationship graph starting from a seed issue. Returns a map of connected issues (parent/child hierarchy, blocks, relates to, duplicates, etc.) with nodes and edges, plus a Mermaid diagram for visualization. Use this to understand how issues are connected across epics, stories, and subtasks."};
+function extractIssueData(issue) {
+  const fields = issue.fields;
+  return {
+    key: issue.key,
+    summary: fields?.summary || "No summary",
+    status: fields?.status?.name || "Unknown",
+    statusCategory: fields?.status?.statusCategory?.name || "Unknown",
+    issueType: fields?.issuetype?.name || "Unknown",
+    priority: fields?.priority?.name || "None",
+    issuelinks: fields?.issuelinks || [],
+    parent: fields?.parent ? {
+      key: fields.parent.key,
+      summary: fields.parent.fields?.summary,
+      status: fields.parent.fields?.status?.name,
+      issueType: fields.parent.fields?.issuetype?.name
+    } : void 0,
+    subtasks: fields?.subtasks || []
+  };
+}
+function buildGraph(issueDataMap, rootKey, options) {
+  const nodes = [];
+  const edges = [];
+  const edgeSet = /* @__PURE__ */ new Set();
+  const addEdge = (edge) => {
+    const edgeId = `${edge.from}->${edge.to}:${edge.type}:${edge.category}`;
+    if (!edgeSet.has(edgeId)) {
+      edgeSet.add(edgeId);
+      edges.push(edge);
+    }
+  };
+  for (const [, data] of issueDataMap) {
+    nodes.push({
+      key: data.key,
+      summary: data.summary,
+      status: data.status,
+      statusCategory: data.statusCategory,
+      issueType: data.issueType,
+      priority: data.priority
+    });
+    if (options.includeHierarchy) {
+      if (data.parent && issueDataMap.has(data.parent.key)) {
+        addEdge({
+          from: data.parent.key,
+          to: data.key,
+          type: "parent of",
+          label: "parent of",
+          category: "hierarchy"
+        });
+      }
+      for (const sub of data.subtasks) {
+        if (issueDataMap.has(sub.key)) {
+          addEdge({
+            from: data.key,
+            to: sub.key,
+            type: "parent of",
+            label: "parent of",
+            category: "hierarchy"
+          });
+        }
+      }
+    }
+    for (const link of data.issuelinks) {
+      const typeName = link.type?.name || "Unknown";
+      if (options.linkTypes && options.linkTypes.length > 0) {
+        if (!options.linkTypes.some((lt) => lt.toLowerCase() === typeName.toLowerCase())) {
+          continue;
+        }
+      }
+      if (link.outwardIssue && (options.direction === "all" || options.direction === "outward")) {
+        if (issueDataMap.has(link.outwardIssue.key)) {
+          addEdge({
+            from: data.key,
+            to: link.outwardIssue.key,
+            type: typeName,
+            label: link.type?.outward || typeName,
+            category: "link"
+          });
+        }
+      }
+      if (link.inwardIssue && (options.direction === "all" || options.direction === "inward")) {
+        if (issueDataMap.has(link.inwardIssue.key)) {
+          addEdge({
+            from: link.inwardIssue.key,
+            to: data.key,
+            type: typeName,
+            label: link.type?.outward || typeName,
+            category: "link"
+          });
+        }
+      }
+    }
+  }
+  return {
+    rootIssue: rootKey,
+    nodes,
+    edges,
+    metadata: {
+      totalNodes: nodes.length,
+      totalEdges: edges.length,
+      maxDepthReached: false,
+      // set by caller
+      traversalDepth: 0
+      // set by caller
+    }
+  };
+}
+function formatGraphResponse(graph) {
+  const { nodes, edges, metadata, rootIssue } = graph;
+  const nodesTable = nodes.map((n) => `| ${n.key} | ${n.summary} | ${n.status} | ${n.issueType} | ${n.priority} |`).join("\n");
+  const edgesTable = edges.map((e) => `| ${e.from} | ${e.label} | ${e.to} | ${e.category} |`).join("\n");
+  const mermaidNodes = nodes.map((n) => {
+    const shape = n.statusCategory === "Done" ? `${n.key}[/"${n.issueType}: ${escapeMermaid(n.summary)}"/]` : n.statusCategory === "In Progress" ? `${n.key}[["${n.issueType}: ${escapeMermaid(n.summary)}"]]` : `${n.key}["${n.issueType}: ${escapeMermaid(n.summary)}"]`;
+    return `  ${shape}`;
+  }).join("\n");
+  const mermaidEdges = edges.map((e) => {
+    if (e.category === "hierarchy") {
+      return `  ${e.from} --> ${e.to}`;
+    }
+    return `  ${e.from} -->|${escapeMermaid(e.label)}| ${e.to}`;
+  }).join("\n");
+  const doneNodes = nodes.filter((n) => n.statusCategory === "Done").map((n) => n.key);
+  const inProgressNodes = nodes.filter((n) => n.statusCategory === "In Progress").map((n) => n.key);
+  const todoNodes = nodes.filter((n) => n.statusCategory !== "Done" && n.statusCategory !== "In Progress").map((n) => n.key);
+  let mermaidStyles = "";
+  if (doneNodes.length > 0) mermaidStyles += `
+  classDef done fill:#d4edda,stroke:#28a745`;
+  if (inProgressNodes.length > 0)
+    mermaidStyles += `
+  classDef inprogress fill:#fff3cd,stroke:#ffc107`;
+  if (todoNodes.length > 0) mermaidStyles += `
+  classDef todo fill:#f8d7da,stroke:#dc3545`;
+  if (doneNodes.length > 0) mermaidStyles += `
+  class ${doneNodes.join(",")} done`;
+  if (inProgressNodes.length > 0)
+    mermaidStyles += `
+  class ${inProgressNodes.join(",")} inprogress`;
+  if (todoNodes.length > 0) mermaidStyles += `
+  class ${todoNodes.join(",")} todo`;
+  const depthNote = metadata.maxDepthReached ? " (max depth reached, graph may be incomplete)" : "";
+  const text = `## Issue Graph: ${rootIssue} (depth: ${metadata.traversalDepth}, ${metadata.totalNodes} nodes, ${metadata.totalEdges} edges)${depthNote}
+
+### Nodes
+| Key | Summary | Status | Type | Priority |
+|-----|---------|--------|------|----------|
+${nodesTable}
+
+### Edges
+| From | Relationship | To | Category |
+|------|-------------|-----|----------|
+${edgesTable}
+
+### Mermaid Diagram
+\`\`\`mermaid
+graph TD
+${mermaidNodes}
+${mermaidEdges}${mermaidStyles}
+\`\`\``;
+  return { content: [{ type: "text", text }] };
+}
+function escapeMermaid(text) {
+  return text.replace(/"/g, "'").replace(/[[\]{}()#]/g, "").substring(0, 60);
+}
+async function handleGetIssueGraph(input) {
+  try {
+    const validated = validateInput(GetIssueGraphInputSchema, input);
+    const {
+      issueKey,
+      maxDepth = 2,
+      maxNodes = 50,
+      includeHierarchy = true,
+      linkTypes,
+      direction = "all"
+    } = validated;
+    log25.info(`Building issue graph from ${issueKey} (depth: ${maxDepth}, maxNodes: ${maxNodes})`);
+    const issueDataMap = /* @__PURE__ */ new Map();
+    const queue = [{ key: issueKey, depth: 0 }];
+    const visited = /* @__PURE__ */ new Set();
+    let maxDepthReached = false;
+    let actualDepth = 0;
+    while (queue.length > 0 && issueDataMap.size < maxNodes) {
+      const current = queue.shift();
+      if (visited.has(current.key)) continue;
+      visited.add(current.key);
+      if (current.depth > maxDepth) {
+        maxDepthReached = true;
+        continue;
+      }
+      actualDepth = Math.max(actualDepth, current.depth);
+      let issue;
+      try {
+        issue = await getIssue(current.key, { fields: GRAPH_FIELDS });
+      } catch (err) {
+        log25.warn(`Skipping issue ${current.key}: ${err.message}`);
+        continue;
+      }
+      const data = extractIssueData(issue);
+      issueDataMap.set(current.key, data);
+      if (current.depth >= maxDepth) continue;
+      const nextDepth = current.depth + 1;
+      if (includeHierarchy && data.parent && !visited.has(data.parent.key)) {
+        queue.push({ key: data.parent.key, depth: nextDepth });
+      }
+      if (includeHierarchy) {
+        for (const sub of data.subtasks) {
+          if (!visited.has(sub.key)) {
+            queue.push({ key: sub.key, depth: nextDepth });
+          }
+        }
+      }
+      for (const link of data.issuelinks) {
+        if (linkTypes && linkTypes.length > 0) {
+          const typeName = link.type?.name || "";
+          if (!linkTypes.some((lt) => lt.toLowerCase() === typeName.toLowerCase())) continue;
+        }
+        if (link.outwardIssue && !visited.has(link.outwardIssue.key) && (direction === "all" || direction === "outward")) {
+          queue.push({ key: link.outwardIssue.key, depth: nextDepth });
+        }
+        if (link.inwardIssue && !visited.has(link.inwardIssue.key) && (direction === "all" || direction === "inward")) {
+          queue.push({ key: link.inwardIssue.key, depth: nextDepth });
+        }
+      }
+    }
+    if (queue.length > 0) {
+      maxDepthReached = true;
+    }
+    log25.info(`Graph built: ${issueDataMap.size} nodes discovered`);
+    const graph = buildGraph(issueDataMap, issueKey, {
+      includeHierarchy,
+      linkTypes,
+      direction
+    });
+    graph.metadata.maxDepthReached = maxDepthReached;
+    graph.metadata.traversalDepth = actualDepth;
+    return formatGraphResponse(graph);
+  } catch (error) {
+    log25.error("Error in handleGetIssueGraph:", error);
+    return handleError(error);
+  }
+}
+
 // src/index.ts
 if (process.env.NODE_ENV !== "production") {
   try {
@@ -3138,50 +3039,172 @@ if (process.env.NODE_ENV !== "production") {
   } catch {
   }
 }
-var log23 = createLogger("server");
-var toolHandlers = /* @__PURE__ */ new Map([
-  [TOOL_NAMES.GET_VISIBLE_PROJECTS, handleGetVisibleProjects],
-  [TOOL_NAMES.GET_ISSUE, handleGetIssue],
-  [TOOL_NAMES.SEARCH_ISSUES, handleSearchIssues],
-  [TOOL_NAMES.GET_MY_ISSUES, handleGetMyIssues],
-  [TOOL_NAMES.GET_ISSUE_TYPES, handleGetIssueTypes],
-  [TOOL_NAMES.GET_USERS, handleGetUsers],
-  [TOOL_NAMES.GET_PRIORITIES, handleGetPriorities],
-  [TOOL_NAMES.GET_STATUSES, handleGetStatuses],
-  [TOOL_NAMES.CREATE_ISSUE, handleCreateIssue],
-  [TOOL_NAMES.UPDATE_ISSUE, handleUpdateIssue],
-  [TOOL_NAMES.ADD_COMMENT, handleAddComment],
-  [TOOL_NAMES.GET_PROJECT_INFO, handleGetProjectInfo],
-  [TOOL_NAMES.CREATE_SUBTASK, handleCreateSubtask],
-  [TOOL_NAMES.GET_CREATE_META, handleGetCreateMeta],
-  [TOOL_NAMES.GET_CUSTOM_FIELDS, handleGetCustomFields],
-  [TOOL_NAMES.CREATE_ISSUE_LINK, handleCreateIssueLink],
-  [TOOL_NAMES.GET_COMMENTS, handleGetComments],
-  [TOOL_NAMES.ADD_ATTACHMENT, handleAddAttachment],
-  [TOOL_NAMES.GET_ATTACHMENTS, handleGetAttachments],
-  [TOOL_NAMES.DELETE_ATTACHMENT, handleDeleteAttachment]
-]);
-var allTools = [
-  getVisibleProjectsTool,
-  getIssueTool,
-  searchIssuesTool,
-  getMyIssuesTool,
-  getIssueTypesTool,
-  getUsersTool,
-  getPrioritiesTool,
-  getStatusesTool,
-  createIssueTool,
-  updateIssueTool,
-  addCommentTool,
-  getProjectInfoTool,
-  createSubtaskTool,
-  getCreateMetaTool,
-  getCustomFieldsTool,
-  createIssueLinkTool,
-  getCommentsTool,
-  addAttachmentTool,
-  getAttachmentsTool,
-  deleteAttachmentTool
+var log26 = createLogger("server");
+var toolRegistry = [
+  // === Read-only tools ===
+  {
+    name: TOOL_NAMES.GET_VISIBLE_PROJECTS,
+    description: getVisibleProjectsTool.description,
+    inputSchema: GetVisibleProjectsInputSchema,
+    handler: handleGetVisibleProjects,
+    annotations: { readOnlyHint: true }
+  },
+  {
+    name: TOOL_NAMES.GET_ISSUE,
+    description: getIssueTool.description,
+    inputSchema: GetIssueInputSchema,
+    handler: handleGetIssue,
+    annotations: { readOnlyHint: true }
+  },
+  {
+    name: TOOL_NAMES.SEARCH_ISSUES,
+    description: searchIssuesTool.description,
+    inputSchema: SearchIssuesInputSchema,
+    handler: handleSearchIssues,
+    annotations: { readOnlyHint: true }
+  },
+  {
+    name: TOOL_NAMES.GET_MY_ISSUES,
+    description: getMyIssuesTool.description,
+    inputSchema: GetMyIssuesInputSchema,
+    handler: handleGetMyIssues,
+    annotations: { readOnlyHint: true }
+  },
+  {
+    name: TOOL_NAMES.GET_ISSUE_TYPES,
+    description: getIssueTypesTool.description,
+    inputSchema: GetIssueTypesInputSchema,
+    handler: handleGetIssueTypes,
+    annotations: { readOnlyHint: true }
+  },
+  {
+    name: TOOL_NAMES.GET_USERS,
+    description: getUsersTool.description,
+    inputSchema: GetUsersInputSchema,
+    handler: handleGetUsers,
+    annotations: { readOnlyHint: true }
+  },
+  {
+    name: TOOL_NAMES.GET_PRIORITIES,
+    description: getPrioritiesTool.description,
+    inputSchema: GetPrioritiesInputSchema,
+    handler: handleGetPriorities,
+    annotations: { readOnlyHint: true }
+  },
+  {
+    name: TOOL_NAMES.GET_STATUSES,
+    description: getStatusesTool.description,
+    inputSchema: GetStatusesInputSchema,
+    handler: handleGetStatuses,
+    annotations: { readOnlyHint: true }
+  },
+  {
+    name: TOOL_NAMES.GET_PROJECT_INFO,
+    description: getProjectInfoTool.description,
+    inputSchema: GetProjectInfoInputSchema,
+    handler: handleGetProjectInfo,
+    annotations: { readOnlyHint: true }
+  },
+  {
+    name: TOOL_NAMES.GET_CREATE_META,
+    description: getCreateMetaTool.description,
+    inputSchema: GetCreateMetaInputSchema,
+    handler: handleGetCreateMeta,
+    annotations: { readOnlyHint: true }
+  },
+  {
+    name: TOOL_NAMES.GET_CUSTOM_FIELDS,
+    description: getCustomFieldsTool.description,
+    inputSchema: GetCustomFieldsInputSchema,
+    handler: handleGetCustomFields,
+    annotations: { readOnlyHint: true }
+  },
+  {
+    name: TOOL_NAMES.GET_COMMENTS,
+    description: getCommentsTool.description,
+    inputSchema: GetCommentsInputSchema,
+    handler: handleGetComments,
+    annotations: { readOnlyHint: true }
+  },
+  {
+    name: TOOL_NAMES.GET_ATTACHMENTS,
+    description: getAttachmentsTool.description,
+    inputSchema: GetAttachmentsInputSchema,
+    handler: handleGetAttachments,
+    annotations: { readOnlyHint: true }
+  },
+  {
+    name: TOOL_NAMES.GET_TRANSITIONS,
+    description: getTransitionsTool.description,
+    inputSchema: GetTransitionsInputSchema,
+    handler: handleGetTransitions,
+    annotations: { readOnlyHint: true }
+  },
+  // === Mutating tools ===
+  {
+    name: TOOL_NAMES.CREATE_ISSUE,
+    description: createIssueTool.description,
+    inputSchema: CreateIssueInputSchema,
+    handler: handleCreateIssue,
+    annotations: { readOnlyHint: false }
+  },
+  {
+    name: TOOL_NAMES.UPDATE_ISSUE,
+    description: updateIssueTool.description,
+    inputSchema: UpdateIssueInputSchema,
+    handler: handleUpdateIssue,
+    annotations: { readOnlyHint: false }
+  },
+  {
+    name: TOOL_NAMES.ADD_COMMENT,
+    description: addCommentTool.description,
+    inputSchema: AddCommentInputSchema,
+    handler: handleAddComment,
+    annotations: { readOnlyHint: false }
+  },
+  {
+    name: TOOL_NAMES.CREATE_SUBTASK,
+    description: createSubtaskTool.description,
+    inputSchema: CreateSubtaskInputSchema,
+    handler: handleCreateSubtask,
+    annotations: { readOnlyHint: false }
+  },
+  {
+    name: TOOL_NAMES.CREATE_ISSUE_LINK,
+    description: createIssueLinkTool.description,
+    inputSchema: CreateIssueLinkInputSchema,
+    handler: handleCreateIssueLink,
+    annotations: { readOnlyHint: false }
+  },
+  {
+    name: TOOL_NAMES.ADD_ATTACHMENT,
+    description: addAttachmentTool.description,
+    inputSchema: AddAttachmentInputSchema,
+    handler: handleAddAttachment,
+    annotations: { readOnlyHint: false }
+  },
+  {
+    name: TOOL_NAMES.TRANSITION_ISSUE,
+    description: transitionIssueTool.description,
+    inputSchema: TransitionIssueInputSchema,
+    handler: handleTransitionIssue,
+    annotations: { readOnlyHint: false }
+  },
+  {
+    name: TOOL_NAMES.GET_ISSUE_GRAPH,
+    description: getIssueGraphTool.description,
+    inputSchema: GetIssueGraphInputSchema,
+    handler: handleGetIssueGraph,
+    annotations: { readOnlyHint: true }
+  },
+  // === Destructive tools ===
+  {
+    name: TOOL_NAMES.DELETE_ATTACHMENT,
+    description: deleteAttachmentTool.description,
+    inputSchema: DeleteAttachmentInputSchema,
+    handler: handleDeleteAttachment,
+    annotations: { readOnlyHint: false, destructiveHint: true }
+  }
 ];
 async function main() {
   const isDryRun = (process.env.DRY_RUN || "").toLowerCase() === "1" || (process.env.DRY_RUN || "").toLowerCase() === "true";
@@ -3209,50 +3232,45 @@ async function main() {
     version = pkg.default?.version || pkg.version || version;
   } catch {
   }
-  const server = new Server(
+  const server = new McpServer(
     {
       name: "jira-mcp-server",
       version
     },
     {
       capabilities: {
-        resources: {},
         tools: {}
       }
     }
   );
-  server.setRequestHandler(ListToolsRequestSchema, async () => {
-    console.error(`\u{1F4CB} Listing ${allTools.length} available tool(s)`);
-    return { tools: allTools };
-  });
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    console.error(`\u{1F6E0}\uFE0F Executing tool: ${name}`);
-    const handler = toolHandlers.get(name);
-    if (!handler) {
-      throw new Error(`Unknown tool: ${name}`);
-    }
-    try {
-      const result = await handler(args);
-      console.error(`\u2705 Tool ${name} executed successfully`);
-      return result;
-    } catch (error) {
-      console.error(`\u274C Error executing tool ${name}:`, error.message);
-      throw error;
-    }
-  });
-  server.setRequestHandler(ListResourcesRequestSchema, async () => {
-    return { resources: [] };
-  });
-  server.setRequestHandler(ReadResourceRequestSchema, async () => {
-    throw new Error("Resource reading not implemented");
-  });
+  for (const entry of toolRegistry) {
+    server.registerTool(
+      entry.name,
+      {
+        description: entry.description,
+        inputSchema: entry.inputSchema,
+        annotations: entry.annotations
+      },
+      async (args) => {
+        console.error(`\u{1F6E0}\uFE0F Executing tool: ${entry.name}`);
+        try {
+          const result = await entry.handler(args);
+          console.error(`\u2705 Tool ${entry.name} executed successfully`);
+          return result;
+        } catch (error) {
+          console.error(`\u274C Error executing tool ${entry.name}:`, error.message);
+          throw error;
+        }
+      }
+    );
+  }
+  console.error(`\u{1F4CB} Registered ${toolRegistry.length} tool(s)`);
   const transport = new StdioServerTransport();
   await server.connect(transport);
   console.error("\u{1F680} Jira MCP server running on stdio");
 }
 main().catch((error) => {
-  log23.error("Fatal error:", error);
+  log26.error("Fatal error:", error);
   process.exit(1);
 });
 //# sourceMappingURL=index.js.map