mcp-jira-stdio 1.4.0 → 1.5.1

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.1",
       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,6 +815,13 @@ 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
 function ensureAdfDescription(desc) {
@@ -1125,7 +1134,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 +1197,31 @@ async function createSubtask(parentIssueKey, subtaskData) {
   const response = await makeJiraRequest(config);
   return await getIssue(response.key);
 }
+async function getCreateMeta(options = {}) {
+  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 +1344,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 +1379,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,6 +1573,96 @@ 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");
@@ -2248,6 +2389,76 @@ 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"]
+  }
+};
+async function handleGetCreateMeta(input) {
+  try {
+    const validated = validateInput(GetCreateMetaInputSchema, input);
+    log16.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);
+    log16.info(`Retrieved create metadata for ${validated.projectKey}`);
+    return formatCreateMetaResponse(meta);
+  } catch (error) {
+    log16.error("Error in handleGetCreateMeta:", error);
+    return handleError(error);
+  }
+}
+
+// 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: []
+  }
+};
+async function handleGetCustomFields(input) {
+  try {
+    const validated = validateInput(GetCustomFieldsInputSchema, input);
+    const projectMsg = validated.projectKey ? ` for project ${validated.projectKey}` : "";
+    log17.info(`Getting custom fields${projectMsg}...`);
+    const fields = await getFields();
+    log17.info(`Retrieved ${fields.filter((f) => f.custom).length} custom fields`);
+    return formatCustomFieldsResponse(fields, validated.projectKey);
+  } catch (error) {
+    log17.error("Error in handleGetCustomFields:", error);
+    return handleError(error);
+  }
+}
+
 // src/index.ts
 if (process.env.NODE_ENV !== "production") {
   try {
@@ -2256,7 +2467,7 @@ if (process.env.NODE_ENV !== "production") {
   } catch {
   }
 }
-var log16 = createLogger("server");
+var log18 = createLogger("server");
 var toolHandlers = /* @__PURE__ */ new Map([
   [TOOL_NAMES.GET_VISIBLE_PROJECTS, handleGetVisibleProjects],
   [TOOL_NAMES.GET_ISSUE, handleGetIssue],
@@ -2270,7 +2481,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 +2498,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 +2571,7 @@ async function main() {
   console.error("\u{1F680} Jira MCP server running on stdio");
 }
 main().catch((error) => {
-  log16.error("Fatal error:", error);
+  log18.error("Fatal error:", error);
   process.exit(1);
 });
 //# sourceMappingURL=index.js.map