mcp-jira-stdio 1.4.0 → 1.5.2

package/dist/index.js

@@ -439,7 +439,7 @@ var require_package2 = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "mcp-jira-stdio",
-      version: "1.4.0",
+      version: "1.5.2",
       description: "Model Context Protocol (MCP) server for Jira API integration",
       author: "graslt",
       license: "MIT",
@@ -555,7 +555,9 @@ var TOOL_NAMES = {
   UPDATE_ISSUE: "jira_update_issue",
   ADD_COMMENT: "jira_add_comment",
   GET_PROJECT_INFO: "jira_get_project_info",
-  CREATE_SUBTASK: "jira_create_subtask"
+  CREATE_SUBTASK: "jira_create_subtask",
+  GET_CREATE_META: "jira_get_create_meta",
+  GET_CUSTOM_FIELDS: "jira_get_custom_fields"
 };
 
 // src/utils/logger.ts
@@ -813,8 +815,16 @@ var CreateSubtaskInputSchema = z.object({
   labels: z.array(z.string()).optional().describe("Subtask labels"),
   components: z.array(z.string()).optional().describe("Component names")
 });
+var GetCreateMetaInputSchema = z.object({
+  projectKey: z.string().describe("Project key to get create metadata for").refine((v) => isValidProjectKey(v), "Invalid project key format"),
+  issueTypeName: z.string().optional().describe("Specific issue type name to get metadata for (optional)")
+});
+var GetCustomFieldsInputSchema = z.object({
+  projectKey: z.string().optional().describe("Project key to filter custom fields (optional)").refine((v) => v ? isValidProjectKey(v) : true, "Invalid project key format")
+});
 
 // src/utils/api-helpers.ts
+var log2 = createLogger("api-helpers");
 function ensureAdfDescription(desc) {
   if (!desc) return desc;
   if (typeof desc === "object") return desc;
@@ -929,20 +939,32 @@ function ensureAdfDescription(desc) {
   return { type: "doc", version: 1, content };
 }
 async function getVisibleProjects(options = {}) {
-  const params = {};
-  if (options.expand) {
-    params.expand = options.expand.join(",");
-  }
-  if (options.recent) {
-    params.recent = options.recent;
+  const allProjects = [];
+  let startAt = 0;
+  let isLast = false;
+  while (!isLast) {
+    const params = {
+      startAt,
+      maxResults: 50
+      // Jira default, fetch 50 projects per page
+    };
+    if (options.expand) {
+      params.expand = options.expand.join(",");
+    }
+    if (options.recent) {
+      params.recent = options.recent;
+    }
+    const config = {
+      method: "GET",
+      url: "/project/search",
+      params
+    };
+    const response = await makeJiraRequest(config);
+    allProjects.push(...response.values);
+    isLast = response.isLast;
+    startAt += response.maxResults;
   }
-  const config = {
-    method: "GET",
-    url: "/project/search",
-    params
-  };
-  const response = await makeJiraRequest(config);
-  return response.values;
+  return allProjects;
 }
 async function getIssue(issueKey, options = {}) {
   const params = {};
@@ -1125,7 +1147,10 @@ async function getStatuses(options = {}) {
   return await makeJiraRequest(config);
 }
 async function addComment(issueKey, body, visibility) {
-  const data = { body };
+  const adfBody = ensureAdfDescription(body);
+  const data = {
+    body: adfBody
+  };
   if (visibility) {
     data.visibility = visibility;
   }
@@ -1185,6 +1210,81 @@ async function createSubtask(parentIssueKey, subtaskData) {
   const response = await makeJiraRequest(config);
   return await getIssue(response.key);
 }
+async function getCreateMeta(options = {}) {
+  if (options.projectKeys && options.projectKeys.length === 1) {
+    const projectKey = options.projectKeys[0];
+    const allIssueTypes = await getIssueTypes(projectKey);
+    let issueTypesToFetch = allIssueTypes;
+    if (options.issueTypeNames && options.issueTypeNames.length > 0) {
+      issueTypesToFetch = allIssueTypes.filter(
+        (type) => options.issueTypeNames?.includes(type.name)
+      );
+    }
+    const issueTypesWithFields = [];
+    for (const issueType of issueTypesToFetch) {
+      try {
+        const config2 = {
+          method: "GET",
+          url: `/issue/createmeta/${projectKey}/issuetypes/${issueType.id}`
+        };
+        const issueTypeMetadata = await makeJiraRequest(config2);
+        const fieldsMap = {};
+        if (issueTypeMetadata.values && Array.isArray(issueTypeMetadata.values)) {
+          for (const field of issueTypeMetadata.values) {
+            const fieldKey = field.key || field.fieldId || field.name;
+            if (fieldKey) {
+              fieldsMap[fieldKey] = field;
+            }
+          }
+        }
+        issueTypesWithFields.push({
+          id: issueType.id,
+          name: issueType.name,
+          description: issueType.description,
+          iconUrl: issueType.iconUrl,
+          subtask: issueType.subtask,
+          fields: fieldsMap
+        });
+      } catch (error) {
+        log2.error(`Failed to get metadata for issue type ${issueType.name}:`, error);
+      }
+    }
+    const projectDetails = await getProjectDetails(projectKey);
+    return {
+      projects: [
+        {
+          id: projectDetails.id,
+          key: projectDetails.key,
+          name: projectDetails.name,
+          issuetypes: issueTypesWithFields
+        }
+      ]
+    };
+  }
+  const params = {};
+  if (options.projectKeys && options.projectKeys.length > 0) {
+    params.projectKeys = options.projectKeys.join(",");
+  }
+  if (options.issueTypeNames && options.issueTypeNames.length > 0) {
+    params.issuetypeNames = options.issueTypeNames.join(",");
+  }
+  if (options.expand) {
+    params.expand = options.expand;
+  }
+  const config = {
+    method: "GET",
+    url: "/issue/createmeta",
+    params
+  };
+  return await makeJiraRequest(config);
+}
+async function getFields() {
+  const config = {
+    method: "GET",
+    url: "/field"
+  };
+  return await makeJiraRequest(config);
+}
 
 // src/utils/redaction.ts
 function isRedactionEnabled() {
@@ -1307,9 +1407,12 @@ function formatSearchResultsResponse(result) {
     };
   }
   const issuesList = result.issues.map((issue) => {
-    const assignee = issue.fields.assignee?.displayName || "Unassigned";
-    return `\u2022 **${issue.key}** - ${issue.fields.summary}
-  Status: ${issue.fields.status.name} | Assignee: ${assignee} | Priority: ${issue.fields.priority?.name || "None"}`;
+    const assignee = issue.fields?.assignee?.displayName || "Unassigned";
+    const summary = issue.fields?.summary || "No summary";
+    const status = issue.fields?.status?.name || "Unknown";
+    const priority = issue.fields?.priority?.name || "None";
+    return `\u2022 **${issue.key}** - ${summary}
+  Status: ${status} | Assignee: ${assignee} | Priority: ${priority}`;
   }).join("\n\n");
   const rangeStart = result.startAt + 1;
   const rangeEnd = Math.min(result.startAt + result.maxResults, result.total);
@@ -1339,23 +1442,34 @@ ${issuesList}${paginationInfo}`
 }
 function formatErrorResponse(error) {
   let errorMessage = "An unexpected error occurred.";
+  let hasCustomFieldError = false;
   if (typeof error === "string") {
     errorMessage = error;
+    hasCustomFieldError = error.includes("customfield_");
   } else if (error instanceof Error) {
     errorMessage = error.message;
+    hasCustomFieldError = error.message.includes("customfield_");
   } else if (error?.response?.data) {
     const jiraError = error.response.data;
     if (jiraError.errorMessages && jiraError.errorMessages.length > 0) {
       errorMessage = jiraError.errorMessages.join(", ");
     } else if (jiraError.errors) {
-      errorMessage = Object.entries(jiraError.errors).map(([field, message]) => `${field}: ${message}`).join(", ");
+      const errors = Object.entries(jiraError.errors);
+      errorMessage = errors.map(([field, message]) => `${field}: ${message}`).join(", ");
+      hasCustomFieldError = errors.some(([field]) => field.startsWith("customfield_"));
     }
   }
+  let hint = "";
+  if (hasCustomFieldError) {
+    hint = `
+
+\u{1F4A1} **Hint:** This error involves custom fields. Use 'jira_get_create_meta' tool to discover required fields and their allowed values before creating an issue.`;
+  }
   return {
     content: [
       {
         type: "text",
-        text: `\u274C Error: ${errorMessage}`
+        text: `\u274C Error: ${errorMessage}${hint}`
       }
     ]
   };
@@ -1522,9 +1636,99 @@ Last Updated: ${new Date(project.insight.lastIssueUpdateTime).toISOString()}` :
     ]
   };
 }
+function formatCreateMetaResponse(meta) {
+  if (!meta.projects || meta.projects.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "No create metadata found for the specified project."
+        }
+      ]
+    };
+  }
+  const project = meta.projects[0];
+  if (!project) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "No create metadata found for the specified project."
+        }
+      ]
+    };
+  }
+  const issueTypesList = project.issuetypes.map((issueType) => {
+    const requiredFields = [];
+    const optionalFields = [];
+    Object.entries(issueType.fields).forEach(([fieldKey, field]) => {
+      const allowedValuesText = field.allowedValues ? `
+    Allowed values: ${field.allowedValues.map((v) => v.name || v.value || v.id).join(", ")}` : "";
+      const defaultValueText = field.hasDefaultValue ? `
+    Default: ${JSON.stringify(field.defaultValue)}` : "";
+      const fieldInfo = `  \u2022 **${field.name}** (${fieldKey})
+    Type: ${field.schema.type}${allowedValuesText}${defaultValueText}`;
+      if (field.required) {
+        requiredFields.push(fieldInfo);
+      } else {
+        optionalFields.push(fieldInfo);
+      }
+    });
+    const requiredSection = requiredFields.length > 0 ? `**Required Fields:**
+${requiredFields.join("\n\n")}` : "No required fields";
+    const optionalSection = optionalFields.length > 0 ? `
+
+**Optional Fields:**
+${optionalFields.join("\n\n")}` : "";
+    return `### ${issueType.name} (${issueType.subtask ? "Subtask" : "Issue"})
+${issueType.description}
+
+${requiredSection}${optionalSection}`;
+  }).join("\n\n---\n\n");
+  return {
+    content: [
+      {
+        type: "text",
+        text: `**Create Metadata for Project: ${project.name} (${project.key})**
+
+${issueTypesList}`
+      }
+    ]
+  };
+}
+function formatCustomFieldsResponse(fields, projectKey) {
+  const customFields = fields.filter((field) => field.custom);
+  if (customFields.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: projectKey ? `No custom fields found for project ${projectKey}.` : "No custom fields found."
+        }
+      ]
+    };
+  }
+  const fieldsList = customFields.map((field) => {
+    const schemaInfo = field.schema.custom ? `Custom Type: ${field.schema.custom}` : `Type: ${field.schema.type}`;
+    return `\u2022 **${field.name}** (${field.key})
+  ${schemaInfo}
+  ID: ${field.id}`;
+  }).join("\n\n");
+  const header = projectKey ? `Found ${customFields.length} custom field(s) for project ${projectKey}:` : `Found ${customFields.length} custom field(s):`;
+  return {
+    content: [
+      {
+        type: "text",
+        text: `${header}
+
+${fieldsList}`
+      }
+    ]
+  };
+}
 
 // src/utils/error-handler.ts
-var log2 = createLogger("error-handler");
+var log3 = createLogger("error-handler");
 var JiraApiError = class extends Error {
   constructor(message, statusCode, jiraErrors, originalError) {
     super(message);
@@ -1535,7 +1739,7 @@ var JiraApiError = class extends Error {
   }
 };
 function handleError(error) {
-  log2.error("Tool error:", error);
+  log3.error("Tool error:", error);
   if (typeof error === "string") {
     return formatErrorResponse(error);
   }
@@ -1572,7 +1776,7 @@ function handleError(error) {
 }
 
 // src/tools/get-visible-projects.ts
-var log3 = createLogger("tool:get-visible-projects");
+var log4 = 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.",
@@ -1598,21 +1802,21 @@ var getVisibleProjectsTool = {
 async function handleGetVisibleProjects(input) {
   try {
     const validated = validateInput(GetVisibleProjectsInputSchema, input);
-    log3.info("Getting visible projects...");
+    log4.info("Getting visible projects...");
     const getParams = {};
     if (validated.expand !== void 0) getParams.expand = validated.expand;
     if (validated.recent !== void 0) getParams.recent = validated.recent;
     const projects = await getVisibleProjects(getParams);
-    log3.info(`Found ${projects.length} project(s)`);
+    log4.info(`Found ${projects.length} project(s)`);
     return formatProjectsResponse(projects);
   } catch (error) {
-    log3.error("Error in handleGetVisibleProjects:", error);
+    log4.error("Error in handleGetVisibleProjects:", error);
     return handleError(error);
   }
 }
 
 // src/tools/get-issue.ts
-var log4 = createLogger("tool:get-issue");
+var log5 = 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.',
@@ -1643,21 +1847,21 @@ async function handleGetIssue(input) {
     const validated = validateInput(GetIssueInputSchema, input);
     const trimmedInput = (validated.issueKey || "").trim();
     const key = extractIssueKey(trimmedInput) || trimmedInput;
-    log4.info(`Getting issue ${key}...`);
+    log5.info(`Getting issue ${key}...`);
     const getParams = {};
     if (validated.expand !== void 0) getParams.expand = validated.expand;
     if (validated.fields !== void 0) getParams.fields = validated.fields;
     const issue = await getIssue(key, getParams);
-    log4.info(`Retrieved issue ${issue.key}`);
+    log5.info(`Retrieved issue ${issue.key}`);
     return formatIssueResponse(issue);
   } catch (error) {
-    log4.error("Error in handleGetIssue:", error);
+    log5.error("Error in handleGetIssue:", error);
     return handleError(error);
   }
 }
 
 // src/tools/search-issues.ts
-var log5 = createLogger("tool:search-issues");
+var log6 = 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.',
@@ -1697,7 +1901,7 @@ var searchIssuesTool = {
 async function handleSearchIssues(input) {
   try {
     const validated = validateInput(SearchIssuesInputSchema, input);
-    log5.info(`Searching issues with JQL: "${validated.jql}"...`);
+    log6.info(`Searching issues with JQL: "${validated.jql}"...`);
     const searchParams = {
       jql: validated.jql
     };
@@ -1706,16 +1910,16 @@ async function handleSearchIssues(input) {
     if (validated.fields !== void 0) searchParams.fields = validated.fields;
     if (validated.expand !== void 0) searchParams.expand = validated.expand;
     const result = await searchIssues(searchParams);
-    log5.info(`Found ${result.total} issue(s), showing ${result.issues.length}`);
+    log6.info(`Found ${result.total} issue(s), showing ${result.issues.length}`);
     return formatSearchResultsResponse(result);
   } catch (error) {
-    log5.error("Error in handleSearchIssues:", error);
+    log6.error("Error in handleSearchIssues:", error);
     return handleError(error);
   }
 }
 
 // src/tools/get-my-issues.ts
-var log6 = createLogger("tool:get-my-issues");
+var log7 = 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.",
@@ -1751,23 +1955,23 @@ var getMyIssuesTool = {
 async function handleGetMyIssues(input) {
   try {
     const validated = validateInput(GetMyIssuesInputSchema, input);
-    log6.info("Getting issues assigned to current user...");
+    log7.info("Getting issues assigned to current user...");
     const getParams = {};
     if (validated.nextPageToken !== void 0) getParams.nextPageToken = validated.nextPageToken;
     if (validated.maxResults !== void 0) getParams.maxResults = validated.maxResults;
     if (validated.fields !== void 0) getParams.fields = validated.fields;
     if (validated.expand !== void 0) getParams.expand = validated.expand;
     const result = await getMyIssues(getParams);
-    log6.info(`Found ${result.total} issue(s) assigned to you, showing ${result.issues.length}`);
+    log7.info(`Found ${result.total} issue(s) assigned to you, showing ${result.issues.length}`);
     return formatSearchResultsResponse(result);
   } catch (error) {
-    log6.error("Error in handleGetMyIssues:", error);
+    log7.error("Error in handleGetMyIssues:", error);
     return handleError(error);
   }
 }
 
 // src/tools/get-issue-types.ts
-var log7 = createLogger("tool:get-issue-types");
+var log8 = 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.).",
@@ -1786,21 +1990,21 @@ async function handleGetIssueTypes(input) {
   try {
     const validated = validateInput(GetIssueTypesInputSchema, input);
     if (validated.projectKey) {
-      log7.info(`Getting issue types for project ${validated.projectKey}...`);
+      log8.info(`Getting issue types for project ${validated.projectKey}...`);
     } else {
-      log7.info("Getting global issue types...");
+      log8.info("Getting global issue types...");
     }
     const issueTypes = await getIssueTypes(validated.projectKey);
-    log7.info(`Found ${issueTypes.length} issue type(s)`);
+    log8.info(`Found ${issueTypes.length} issue type(s)`);
     return formatIssueTypesResponse(issueTypes);
   } catch (error) {
-    log7.error("Error in handleGetIssueTypes:", error);
+    log8.error("Error in handleGetIssueTypes:", error);
     return handleError(error);
   }
 }
 
 // src/tools/get-users.ts
-var log8 = createLogger("tool:get-users");
+var log9 = 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.",
@@ -1840,13 +2044,13 @@ async function handleGetUsers(input) {
   try {
     const validated = validateInput(GetUsersInputSchema, input);
     if (validated.query) {
-      log8.info(`Searching users with query: "${validated.query}"...`);
+      log9.info(`Searching users with query: "${validated.query}"...`);
     } else if (validated.username) {
-      log8.info(`Searching for username: "${validated.username}"...`);
+      log9.info(`Searching for username: "${validated.username}"...`);
     } else if (validated.accountId) {
-      log8.info(`Searching for account ID: "${validated.accountId}"...`);
+      log9.info(`Searching for account ID: "${validated.accountId}"...`);
     } else {
-      log8.info("Getting all users...");
+      log9.info("Getting all users...");
     }
     const getParams = {};
     if (validated.query !== void 0) getParams.query = validated.query;
@@ -1855,16 +2059,16 @@ async function handleGetUsers(input) {
     if (validated.startAt !== void 0) getParams.startAt = validated.startAt;
     if (validated.maxResults !== void 0) getParams.maxResults = validated.maxResults;
     const users = await getUsers(getParams);
-    log8.info(`Found ${users.length} user(s)`);
+    log9.info(`Found ${users.length} user(s)`);
     return formatUsersResponse(users);
   } catch (error) {
-    log8.error("Error in handleGetUsers:", error);
+    log9.error("Error in handleGetUsers:", error);
     return handleError(error);
   }
 }
 
 // src/tools/get-priorities.ts
-var log9 = createLogger("tool:get-priorities");
+var log10 = 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.",
@@ -1877,18 +2081,18 @@ var getPrioritiesTool = {
 async function handleGetPriorities(input) {
   try {
     validateInput(GetPrioritiesInputSchema, input);
-    log9.info("Getting all priority levels...");
+    log10.info("Getting all priority levels...");
     const priorities = await getPriorities();
-    log9.info(`Found ${priorities.length} priority level(s)`);
+    log10.info(`Found ${priorities.length} priority level(s)`);
     return formatPrioritiesResponse(priorities);
   } catch (error) {
-    log9.error("Error in handleGetPriorities:", error);
+    log10.error("Error in handleGetPriorities:", error);
     return handleError(error);
   }
 }
 
 // src/tools/get-statuses.ts
-var log10 = createLogger("tool:get-statuses");
+var log11 = 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.",
@@ -1911,28 +2115,28 @@ async function handleGetStatuses(input) {
   try {
     const validated = validateInput(GetStatusesInputSchema, input);
     if (validated.projectKey && validated.issueTypeId) {
-      log10.info(
+      log11.info(
         `Getting statuses for project ${validated.projectKey} and issue type ${validated.issueTypeId}...`
       );
     } else if (validated.projectKey) {
-      log10.info(`Getting statuses for project ${validated.projectKey}...`);
+      log11.info(`Getting statuses for project ${validated.projectKey}...`);
     } else {
-      log10.info("Getting global statuses...");
+      log11.info("Getting global statuses...");
     }
     const getParams = {};
     if (validated.projectKey !== void 0) getParams.projectKey = validated.projectKey;
     if (validated.issueTypeId !== void 0) getParams.issueTypeId = validated.issueTypeId;
     const statuses = await getStatuses(getParams);
-    log10.info(`Found ${statuses.length} status(es)`);
+    log11.info(`Found ${statuses.length} status(es)`);
     return formatStatusesResponse(statuses);
   } catch (error) {
-    log10.error("Error in handleGetStatuses:", error);
+    log11.error("Error in handleGetStatuses:", error);
     return handleError(error);
   }
 }
 
 // src/tools/create-issue.ts
-var log11 = createLogger("tool:create-issue");
+var log12 = 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 accepts plain text and is auto-formatted to ADF: lines ending with ":" become headings, numbered lines create ordered lists, and URLs are linkified. For required custom fields, supply them via customFields (e.g., { "customfield_12345": { id: "..." } }). Returns the created issue with all details.',
@@ -1993,7 +2197,7 @@ var createIssueTool = {
 async function handleCreateIssue(input) {
   try {
     const validated = validateInput(CreateIssueInputSchema, input);
-    log11.info(`Creating issue in project ${validated.projectKey}...`);
+    log12.info(`Creating issue in project ${validated.projectKey}...`);
     const createParams = {
       projectKey: validated.projectKey,
       summary: validated.summary,
@@ -2013,20 +2217,20 @@ async function handleCreateIssue(input) {
     }
     if (validated.returnIssue === false) {
       const key = typeof issueOrKey === "string" ? issueOrKey : issueOrKey.key;
-      log11.info(`Created issue ${key}`);
+      log12.info(`Created issue ${key}`);
       return formatSuccessResponse(`Issue created: ${key}`);
     }
     const issue = issueOrKey;
-    log11.info(`Created issue ${issue.key}`);
+    log12.info(`Created issue ${issue.key}`);
     return formatIssueResponse(issue);
   } catch (error) {
-    log11.error("Error in handleCreateIssue:", error);
+    log12.error("Error in handleCreateIssue:", error);
     return handleError(error);
   }
 }
 
 // src/tools/update-issue.ts
-var log12 = createLogger("tool:update-issue");
+var log13 = 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 accepts plain text and is auto-formatted to ADF: headings (lines ending with ":"), numbered/bullet lists, and links. Only specified fields will be updated.',
@@ -2075,7 +2279,7 @@ var updateIssueTool = {
 async function handleUpdateIssue(input) {
   try {
     const validated = validateInput(UpdateIssueInputSchema, input);
-    log12.info(`Updating issue ${validated.issueKey}...`);
+    log13.info(`Updating issue ${validated.issueKey}...`);
     const updateParams = {};
     if (validated.summary !== void 0) updateParams.summary = validated.summary;
     if (validated.description !== void 0) updateParams.description = validated.description;
@@ -2085,20 +2289,20 @@ async function handleUpdateIssue(input) {
     if (validated.components !== void 0) updateParams.components = validated.components;
     await updateIssue(validated.issueKey, updateParams);
     if (validated.returnIssue === false) {
-      log12.info(`Updated issue ${validated.issueKey}`);
+      log13.info(`Updated issue ${validated.issueKey}`);
       return formatSuccessResponse(`Issue ${validated.issueKey} updated successfully`);
     }
     const updatedIssue = await getIssue(validated.issueKey);
-    log12.info(`Updated issue ${updatedIssue.key}`);
+    log13.info(`Updated issue ${updatedIssue.key}`);
     return formatIssueResponse(updatedIssue);
   } catch (error) {
-    log12.error("Error in handleUpdateIssue:", error);
+    log13.error("Error in handleUpdateIssue:", error);
     return handleError(error);
   }
 }
 
 // src/tools/add-comment.ts
-var log13 = createLogger("tool:add-comment");
+var log14 = 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. Returns the created comment with author details and timestamp.",
@@ -2137,18 +2341,18 @@ var addCommentTool = {
 async function handleAddComment(input) {
   try {
     const validated = validateInput(AddCommentInputSchema, input);
-    log13.info(`Adding comment to issue ${validated.issueKey}...`);
+    log14.info(`Adding comment to issue ${validated.issueKey}...`);
     const comment = await addComment(validated.issueKey, validated.body, validated.visibility);
-    log13.info(`Added comment to ${validated.issueKey}`);
+    log14.info(`Added comment to ${validated.issueKey}`);
     return formatCommentResponse(comment);
   } catch (error) {
-    log13.error("Error in handleAddComment:", error);
+    log14.error("Error in handleAddComment:", error);
     return handleError(error);
   }
 }
 
 // src/tools/get-project-info.ts
-var log14 = createLogger("tool:get-project-info");
+var log15 = 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.",
@@ -2172,18 +2376,18 @@ var getProjectInfoTool = {
 async function handleGetProjectInfo(input) {
   try {
     const validated = validateInput(GetProjectInfoInputSchema, input);
-    log14.info(`Getting detailed project information for ${validated.projectKey}...`);
+    log15.info(`Getting detailed project information for ${validated.projectKey}...`);
     const project = await getProjectDetails(validated.projectKey, validated.expand);
-    log14.info(`Retrieved project details for ${project.key}`);
+    log15.info(`Retrieved project details for ${project.key}`);
     return formatProjectDetailsResponse(project);
   } catch (error) {
-    log14.error("Error in handleGetProjectInfo:", error);
+    log15.error("Error in handleGetProjectInfo:", error);
     return handleError(error);
   }
 }
 
 // src/tools/create-subtask.ts
-var log15 = createLogger("tool:create-subtask");
+var log16 = 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.",
@@ -2230,7 +2434,7 @@ var createSubtaskTool = {
 async function handleCreateSubtask(input) {
   try {
     const validated = validateInput(CreateSubtaskInputSchema, input);
-    log15.info(`Creating subtask under parent issue ${validated.parentIssueKey}...`);
+    log16.info(`Creating subtask under parent issue ${validated.parentIssueKey}...`);
     const subtaskParams = {
       summary: validated.summary
     };
@@ -2240,10 +2444,80 @@ async function handleCreateSubtask(input) {
     if (validated.labels !== void 0) subtaskParams.labels = validated.labels;
     if (validated.components !== void 0) subtaskParams.components = validated.components;
     const subtask = await createSubtask(validated.parentIssueKey, subtaskParams);
-    log15.info(`Created subtask ${subtask.key}`);
+    log16.info(`Created subtask ${subtask.key}`);
     return formatIssueResponse(subtask);
   } catch (error) {
-    log15.error("Error in handleCreateSubtask:", error);
+    log16.error("Error in handleCreateSubtask:", error);
+    return handleError(error);
+  }
+}
+
+// src/tools/get-create-meta.ts
+var log17 = 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"]
+  }
+};
+async function handleGetCreateMeta(input) {
+  try {
+    const validated = validateInput(GetCreateMetaInputSchema, input);
+    log17.info(`Getting create metadata for project ${validated.projectKey}...`);
+    const options = {
+      projectKeys: [validated.projectKey],
+      expand: "projects.issuetypes.fields"
+    };
+    if (validated.issueTypeName) {
+      options.issueTypeNames = [validated.issueTypeName];
+    }
+    const meta = await getCreateMeta(options);
+    log17.info(`Retrieved create metadata for ${validated.projectKey}`);
+    return formatCreateMetaResponse(meta);
+  } catch (error) {
+    log17.error("Error in handleGetCreateMeta:", error);
+    return handleError(error);
+  }
+}
+
+// src/tools/get-custom-fields.ts
+var log18 = 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: []
+  }
+};
+async function handleGetCustomFields(input) {
+  try {
+    const validated = validateInput(GetCustomFieldsInputSchema, input);
+    const projectMsg = validated.projectKey ? ` for project ${validated.projectKey}` : "";
+    log18.info(`Getting custom fields${projectMsg}...`);
+    const fields = await getFields();
+    log18.info(`Retrieved ${fields.filter((f) => f.custom).length} custom fields`);
+    return formatCustomFieldsResponse(fields, validated.projectKey);
+  } catch (error) {
+    log18.error("Error in handleGetCustomFields:", error);
     return handleError(error);
   }
 }
@@ -2256,7 +2530,7 @@ if (process.env.NODE_ENV !== "production") {
   } catch {
   }
 }
-var log16 = createLogger("server");
+var log19 = createLogger("server");
 var toolHandlers = /* @__PURE__ */ new Map([
   [TOOL_NAMES.GET_VISIBLE_PROJECTS, handleGetVisibleProjects],
   [TOOL_NAMES.GET_ISSUE, handleGetIssue],
@@ -2270,7 +2544,9 @@ var toolHandlers = /* @__PURE__ */ new Map([
   [TOOL_NAMES.UPDATE_ISSUE, handleUpdateIssue],
   [TOOL_NAMES.ADD_COMMENT, handleAddComment],
   [TOOL_NAMES.GET_PROJECT_INFO, handleGetProjectInfo],
-  [TOOL_NAMES.CREATE_SUBTASK, handleCreateSubtask]
+  [TOOL_NAMES.CREATE_SUBTASK, handleCreateSubtask],
+  [TOOL_NAMES.GET_CREATE_META, handleGetCreateMeta],
+  [TOOL_NAMES.GET_CUSTOM_FIELDS, handleGetCustomFields]
 ]);
 var allTools = [
   getVisibleProjectsTool,
@@ -2285,7 +2561,9 @@ var allTools = [
   updateIssueTool,
   addCommentTool,
   getProjectInfoTool,
-  createSubtaskTool
+  createSubtaskTool,
+  getCreateMetaTool,
+  getCustomFieldsTool
 ];
 async function main() {
   const isDryRun = (process.env.DRY_RUN || "").toLowerCase() === "1" || (process.env.DRY_RUN || "").toLowerCase() === "true";
@@ -2356,7 +2634,7 @@ async function main() {
   console.error("\u{1F680} Jira MCP server running on stdio");
 }
 main().catch((error) => {
-  log16.error("Fatal error:", error);
+  log19.error("Fatal error:", error);
   process.exit(1);
 });
 //# sourceMappingURL=index.js.map