@thammarongg/jira-mcp 0.1.0

package/dist/tools/boards.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { run } from "../util.js";
+export function registerBoardTools(server, client) {
+    server.registerTool("list_boards", {
+        title: "List Jira boards",
+        description: "List Jira agile boards (scrum or kanban), optionally filtered by type, name, or project keys.",
+        inputSchema: {
+            type: z.enum(["scrum", "kanban"]).optional().describe("Board type filter"),
+            name: z.string().optional().describe("Filter by board name (partial match)"),
+            projectKeys: z.string().optional().describe("Comma-separated project keys, e.g. 'PROJ1,PROJ2'"),
+            maxResults: z.number().int().min(1).max(1000).default(50),
+            startAt: z.number().int().min(0).default(0),
+        },
+    }, async ({ type, name, projectKeys, maxResults, startAt }) => run(() => client.agileGet("/board", { type, name, projectKeys, maxResults, startAt })));
+    server.registerTool("get_board", {
+        title: "Get board",
+        description: "Get a single Jira board by ID, including its projects, location, and settings.",
+        inputSchema: {
+            boardId: z.number().int().describe("Board ID (numeric, from list_boards)"),
+        },
+    }, async ({ boardId }) => run(() => client.agileGet(`/board/${boardId}`)));
+}

package/dist/tools/epics.js

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import { rapidViewId, run } from "../util.js";
+export function registerEpicTools(server, client) {
+    server.registerTool("list_epics", {
+        title: "List epics",
+        description: "List epics visible in a board's sprint view (agile rapid view).",
+        inputSchema: {
+            boardId: z.number().int().describe("Board ID"),
+            sprintId: z.number().int().describe("Sprint ID (any sprint on the board works)"),
+            maxResults: z.number().int().min(1).max(1000).default(100),
+            startAt: z.number().int().min(0).default(0),
+        },
+    }, async ({ boardId, sprintId, maxResults, startAt }) => run(() => client.agileGet(`/rapid/${rapidViewId(boardId, sprintId)}/epic`, { maxResults, startAt })));
+    server.registerTool("get_epic", {
+        title: "Get epic",
+        description: "Get a single epic by its issue ID (numeric).",
+        inputSchema: {
+            epicId: z.number().int().describe("Epic issue ID (numeric, not the key)"),
+        },
+    }, async ({ epicId }) => run(() => client.agileGet(`/epic/${epicId}`)));
+    server.registerTool("get_epic_issues", {
+        title: "Get epic issues",
+        description: "List the issues belonging to an epic.",
+        inputSchema: {
+            epicId: z.number().int().describe("Epic issue ID (numeric)"),
+            maxResults: z.number().int().min(1).max(1000).default(100),
+            startAt: z.number().int().min(0).default(0),
+        },
+    }, async ({ epicId, maxResults, startAt }) => run(() => client.agileGet(`/epic/${epicId}/issue`, { maxResults, startAt })));
+    server.registerTool("create_epic", {
+        title: "Create epic",
+        description: "Create a new epic on a board (agile rapid view).",
+        inputSchema: {
+            boardId: z.number().int().describe("Board ID"),
+            sprintId: z.number().int().describe("Sprint ID (any sprint on the board works)"),
+            name: z.string().describe("Epic name"),
+            description: z.string().optional(),
+            lead: z.string().optional().describe("Epic lead (user account ID or username)"),
+        },
+    }, async ({ boardId, sprintId, name, description, lead }) => run(() => client.agilePost(`/rapid/${rapidViewId(boardId, sprintId)}/epic`, {
+        name,
+        description,
+        lead,
+    })));
+    server.registerTool("move_issue_to_epic", {
+        title: "Move issue to epic",
+        description: 'Add an issue to an epic. To remove an issue from an epic, use `update_issue` with fields `{ "epic": null }`.',
+        inputSchema: {
+            epicId: z.number().int().describe("Epic issue ID (numeric)"),
+            issueId: z.number().int().describe("Issue ID to move (numeric)"),
+            epicKey: z.string().describe("Epic key, e.g. PROJ-1"),
+        },
+    }, async ({ epicId, issueId, epicKey }) => run(() => client.agilePut(`/epic/${epicId}/issue/${issueId}`, { epic: { key: epicKey } })));
+    server.registerTool("get_epic_meta", {
+        title: "Get epic meta",
+        description: "Get epic metadata (available epic issue types) for a project.",
+        inputSchema: {
+            projectKey: z.string().optional().describe("Project key filter"),
+        },
+    }, async ({ projectKey }) => run(() => client.agileGet("/epic/meta", { projectKey })));
+}

package/dist/tools/generic.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { run } from "../util.js";
+export function registerGenericTools(server, client) {
+    server.registerTool("jira_api", {
+        title: "Raw Jira REST API call",
+        description: "Call any Jira REST API endpoint not covered by a dedicated tool. Path must start with /rest/ and stay under it (e.g. '/rest/api/3/issue/PROJ-1/names' or '/rest/agile/1.0/board/1'). Query params go in query, JSON payload in body. Returns the raw JSON response.",
+        inputSchema: {
+            method: z.enum(["GET", "POST", "PUT", "DELETE"]).describe("HTTP method"),
+            path: z
+                .string()
+                .startsWith("/rest/")
+                .refine((p) => !p.includes("?") && !p.includes("#"), "path must not contain ? or #; put query params in query")
+                .describe("API path starting with /rest/, e.g. /rest/api/3/issue/PROJ-1"),
+            query: z.record(z.string(), z.unknown()).optional().describe("Query string parameters"),
+            body: z.unknown().optional().describe("JSON request body (POST/PUT)"),
+        },
+    }, async ({ method, path, query, body }) => run(() => client.request(method, path, { query, body })));
+}

package/dist/tools/issues.js

@@ -0,0 +1,188 @@
+import { z } from "zod";
+import { run } from "../util.js";
+const DEFAULT_ISSUE_FIELDS = "summary,description,status,assignee,reporter,issuetype,labels,components,priority,created,updated,due,project";
+export function registerIssueTools(server, client) {
+    server.registerTool("get_issue", {
+        title: "Get issue",
+        description: "Get a single Jira issue by key (e.g. PROJ-123).",
+        inputSchema: {
+            issueKey: z.string().describe("Issue key, e.g. PROJ-123"),
+            fields: z.string().optional().describe(`Comma-separated fields (default: ${DEFAULT_ISSUE_FIELDS})`),
+            expand: z.string().optional().describe("Comma-separated expansions, e.g. renderedFields,versions,changelog"),
+        },
+    }, async ({ issueKey, fields, expand }) => run(() => client.apiGet(`/issue/${encodeURIComponent(issueKey)}`, { fields: fields ?? DEFAULT_ISSUE_FIELDS, expand })));
+    server.registerTool("create_issue", {
+        title: "Create issue",
+        description: "Create a new issue. Use get_issue_create_meta to discover valid projects, issue types, and required fields. Extra custom fields can be passed via customFields (e.g. { 'customfield_10010': 'value' }).",
+        inputSchema: {
+            projectKey: z.string().describe("Project key, e.g. PROJ"),
+            summary: z.string().describe("Issue summary"),
+            issueType: z.string().describe("Issue type name or ID, e.g. Story, Task, Bug, or 10004"),
+            description: z.string().optional(),
+            assignee: z.string().optional().describe("Account ID on Cloud/v3, username on DC/v2"),
+            reporter: z.string().optional().describe("Account ID on Cloud/v3, username on DC/v2"),
+            labels: z.array(z.string()).optional(),
+            components: z.array(z.string()).optional().describe("Component names"),
+            dueDate: z.string().optional().describe("Due date, e.g. 2026-09-30"),
+            priority: z.string().optional().describe("Priority name, e.g. High"),
+            parent: z.string().optional().describe("Parent issue key (for sub-tasks)"),
+            customFields: z.record(z.string(), z.unknown()).optional().describe("Custom field IDs mapped to values"),
+        },
+    }, async ({ projectKey, summary, issueType, description, assignee, reporter, labels, components, dueDate, priority, parent, customFields, }) => run(() => {
+        const userRef = (value) => client.apiVersion === "3" ? { accountId: value } : { name: value };
+        return client.apiPost("/issue", {
+            fields: {
+                project: { key: projectKey },
+                summary,
+                issuetype: /^\d+$/.test(issueType) ? { id: issueType } : { name: issueType },
+                description,
+                assignee: assignee ? userRef(assignee) : undefined,
+                reporter: reporter ? userRef(reporter) : undefined,
+                labels,
+                components: components?.map((name) => ({ name })),
+                dueDate,
+                priority: priority ? { name: priority } : undefined,
+                parent: parent ? { key: parent } : undefined,
+                ...customFields,
+            },
+        });
+    }));
+    server.registerTool("update_issue", {
+        title: "Update issue",
+        description: "Update an issue. Pass absolute values in fields (e.g. { summary: 'new' }) and/or relative changes in update (e.g. { labels: [{ add: 'x' }, { remove: 'y' }] }).",
+        inputSchema: {
+            issueKey: z.string().describe("Issue key, e.g. PROJ-123"),
+            fields: z.record(z.string(), z.unknown()).optional().describe("Field values to set"),
+            update: z.record(z.string(), z.unknown()).optional().describe("Relative updates (add/remove operations)"),
+        },
+    }, async ({ issueKey, fields, update }) => run(() => client.apiPut(`/issue/${encodeURIComponent(issueKey)}`, { fields, update })));
+    server.registerTool("delete_issue", {
+        title: "Delete issue",
+        description: "Delete an issue. This is destructive.",
+        inputSchema: {
+            issueKey: z.string().describe("Issue key, e.g. PROJ-123"),
+        },
+    }, async ({ issueKey }) => run(() => client.apiDelete(`/issue/${encodeURIComponent(issueKey)}`)));
+    server.registerTool("search_issues", {
+        title: "Search issues (JQL)",
+        description: "Search issues with JQL, e.g. 'project = PROJ AND sprint = 42 ORDER BY rank' or 'project = PROJ AND sprint IS NONE'. Returns issues plus total count and pagination info.",
+        inputSchema: {
+            jql: z.string().describe("JQL query string"),
+            fields: z.string().optional().describe(`Comma-separated fields (default: ${DEFAULT_ISSUE_FIELDS})`),
+            maxResults: z.number().int().min(1).max(100).default(25),
+            startAt: z.number().int().min(0).default(0),
+            expand: z.string().optional().describe("e.g. names, uris"),
+        },
+    }, async ({ jql, fields, maxResults, startAt, expand }) => run(() => client.apiGet("/search", {
+        jql,
+        fields: fields ?? DEFAULT_ISSUE_FIELDS,
+        maxResults,
+        startAt,
+        expand,
+    })));
+    server.registerTool("get_issue_create_meta", {
+        title: "Get issue create metadata",
+        description: "Discover valid projects, issue types, and their fields (with required flags) before creating an issue.",
+        inputSchema: {
+            projectKeys: z.string().optional().describe("Comma-separated project keys to filter"),
+            issuetypeIds: z.string().optional().describe("Comma-separated issue type IDs to filter"),
+            expand: z
+                .string()
+                .optional()
+                .describe("Use 'projects.issuetypes.fields' for full field details (default)"),
+        },
+    }, async ({ projectKeys, issuetypeIds, expand }) => run(() => client.apiGet("/issue/createmeta", {
+        projectKeys,
+        issuetypeIds,
+        expand: expand ?? "projects.issuetypes.fields",
+    })));
+    server.registerTool("get_issue_transitions", {
+        title: "Get issue transitions",
+        description: "List the workflow transitions available for an issue.",
+        inputSchema: {
+            issueKey: z.string().describe("Issue key, e.g. PROJ-123"),
+        },
+    }, async ({ issueKey }) => run(() => client.apiGet(`/issue/${encodeURIComponent(issueKey)}/transitions`)));
+    server.registerTool("transition_issue", {
+        title: "Transition issue",
+        description: "Move an issue through its workflow. Use get_issue_transitions first to find the transition ID and required fields.",
+        inputSchema: {
+            issueKey: z.string().describe("Issue key, e.g. PROJ-123"),
+            transitionId: z.string().describe("Transition ID (string) from get_issue_transitions"),
+            fields: z.record(z.string(), z.unknown()).optional().describe("Fields required by the transition"),
+        },
+    }, async ({ issueKey, transitionId, fields }) => run(() => client.apiPost(`/issue/${encodeURIComponent(issueKey)}/transitions`, {
+        transition: { id: transitionId },
+        fields,
+    })));
+    server.registerTool("assign_issue", {
+        title: "Assign issue",
+        description: "Assign (or unassign, with an empty value) an issue to a user.",
+        inputSchema: {
+            issueKey: z.string().describe("Issue key, e.g. PROJ-123"),
+            accountId: z.string().optional().describe("Account ID (Jira Cloud)"),
+            name: z.string().optional().describe("Username (Data Center) or name"),
+        },
+    }, async ({ issueKey, accountId, name }) => run(() => {
+        const body = {};
+        if (accountId)
+            body.accountId = accountId;
+        else if (name)
+            body.name = name;
+        else if (client.apiVersion === "3")
+            body.accountId = null;
+        else
+            body.name = null;
+        return client.apiPost(`/issue/${encodeURIComponent(issueKey)}/assignee`, body);
+    }));
+    server.registerTool("add_comment", {
+        title: "Add comment",
+        description: "Add a comment to an issue.",
+        inputSchema: {
+            issueKey: z.string().describe("Issue key, e.g. PROJ-123"),
+            body: z.string().describe("Comment text"),
+            visibility: z
+                .object({ type: z.string(), value: z.string() })
+                .optional()
+                .describe("Comment visibility restriction"),
+        },
+    }, async ({ issueKey, body, visibility }) => run(() => client.apiPost(`/issue/${encodeURIComponent(issueKey)}/comment`, { body, visibility })));
+    server.registerTool("list_comments", {
+        title: "List issue comments",
+        description: "List comments on an issue.",
+        inputSchema: {
+            issueKey: z.string().describe("Issue key, e.g. PROJ-123"),
+            maxResults: z.number().int().min(1).max(1000).default(50),
+            startAt: z.number().int().min(0).default(0),
+            orderBy: z.string().optional().describe("'created' or '-created'"),
+        },
+    }, async ({ issueKey, maxResults, startAt, orderBy }) => run(() => client.apiGet(`/issue/${encodeURIComponent(issueKey)}/comment`, { maxResults, startAt, orderBy })));
+    server.registerTool("delete_comment", {
+        title: "Delete comment",
+        description: "Delete a comment by its ID (from list_comments).",
+        inputSchema: {
+            issueKey: z.string().describe("Issue key, e.g. PROJ-123"),
+            commentId: z.string().describe("Comment ID"),
+        },
+    }, async ({ issueKey, commentId }) => run(() => client.apiDelete(`/issue/${encodeURIComponent(issueKey)}/comment/${encodeURIComponent(commentId)}`)));
+    server.registerTool("get_issue_worklogs", {
+        title: "Get issue worklogs",
+        description: "List time-tracking worklogs on an issue.",
+        inputSchema: {
+            issueKey: z.string().describe("Issue key, e.g. PROJ-123"),
+            maxResults: z.number().int().min(1).max(1000).default(50),
+            startAt: z.number().int().min(0).default(0),
+            orderBy: z.string().optional().describe("'started' or '-started'"),
+        },
+    }, async ({ issueKey, maxResults, startAt, orderBy }) => run(() => client.apiGet(`/issue/${encodeURIComponent(issueKey)}/worklog`, { maxResults, startAt, orderBy })));
+    server.registerTool("add_worklog", {
+        title: "Add worklog",
+        description: "Add a worklog (time spent) to an issue. timeSpent uses Jira format, e.g. '2h 30m' or '1d'.",
+        inputSchema: {
+            issueKey: z.string().describe("Issue key, e.g. PROJ-123"),
+            timeSpent: z.string().describe("Time spent, e.g. '1h 30m'"),
+            comment: z.string().optional(),
+            started: z.string().optional().describe("Start timestamp (ISO-8601)"),
+        },
+    }, async ({ issueKey, timeSpent, comment, started }) => run(() => client.apiPost(`/issue/${encodeURIComponent(issueKey)}/worklog`, { timeSpent, comment, started })));
+}

package/dist/tools/meta.js

@@ -0,0 +1,13 @@
+import { run } from "../util.js";
+export function registerMetaTools(server, client) {
+    server.registerTool("get_fields", {
+        title: "Get all fields",
+        description: "List all issue fields (including custom field IDs) in the Jira instance.",
+        inputSchema: {},
+    }, async () => run(() => client.apiGet("/field")));
+    server.registerTool("get_issue_types", {
+        title: "Get issue types",
+        description: "List all issue types (Story, Task, Bug, Epic, ...) in the Jira instance.",
+        inputSchema: {},
+    }, async () => run(() => client.apiGet("/issuetype")));
+}

package/dist/tools/projects.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { run } from "../util.js";
+export function registerProjectTools(server, client) {
+    server.registerTool("list_projects", {
+        title: "List projects",
+        description: "List all Jira projects visible to the current user.",
+        inputSchema: {
+            maxResults: z.number().int().min(1).max(1000).default(100),
+            startAt: z.number().int().min(0).default(0),
+        },
+    }, async ({ maxResults, startAt }) => run(() => client.apiGet("/project", { maxResults, startAt })));
+    server.registerTool("get_project", {
+        title: "Get project",
+        description: "Get a single project by key or ID.",
+        inputSchema: {
+            projectKeyOrId: z.string().describe("Project key (e.g. PROJ) or numeric ID"),
+            expand: z.string().optional().describe("e.g. lead,urls,insight"),
+        },
+    }, async ({ projectKeyOrId, expand }) => run(() => client.apiGet(`/project/${encodeURIComponent(projectKeyOrId)}`, { expand })));
+    server.registerTool("get_project_components", {
+        title: "Get project components",
+        description: "List components of a project.",
+        inputSchema: {
+            projectKey: z.string().describe("Project key"),
+        },
+    }, async ({ projectKey }) => run(() => client.apiGet(`/project/${encodeURIComponent(projectKey)}/components`)));
+    server.registerTool("create_project_component", {
+        title: "Create project component",
+        description: "Create a component in a project.",
+        inputSchema: {
+            projectKey: z.string().describe("Project key"),
+            name: z.string().describe("Component name"),
+            description: z.string().optional(),
+        },
+    }, async ({ projectKey, name, description }) => run(() => client.apiPost(`/project/${encodeURIComponent(projectKey)}/components`, { name, description })));
+    server.registerTool("get_project_issue_types", {
+        title: "Get project issue types",
+        description: "List issue types available in a project.",
+        inputSchema: {
+            projectKey: z.string().describe("Project key"),
+        },
+    }, async ({ projectKey }) => run(() => client.apiGet(`/project/${encodeURIComponent(projectKey)}/issuetypes`)));
+    server.registerTool("get_project_roles", {
+        title: "Get project roles",
+        description: "List roles (and their actors) of a project.",
+        inputSchema: {
+            projectKey: z.string().describe("Project key"),
+        },
+    }, async ({ projectKey }) => run(() => client.apiGet(`/project/${encodeURIComponent(projectKey)}/role`)));
+    server.registerTool("get_project_versions", {
+        title: "Get project versions",
+        description: "List versions (releases) of a project.",
+        inputSchema: {
+            projectKey: z.string().describe("Project key"),
+            maxResults: z.number().int().min(1).max(1000).default(100),
+            startAt: z.number().int().min(0).default(0),
+        },
+    }, async ({ projectKey, maxResults, startAt }) => run(() => client.apiGet(`/project/${encodeURIComponent(projectKey)}/version`, { maxResults, startAt })));
+}

package/dist/tools/sprints.js

@@ -0,0 +1,106 @@
+import { z } from "zod";
+import { rapidViewId, run } from "../util.js";
+const sprintState = z.enum(["active", "closed", "future"]).describe("Sprint state filter");
+export function registerSprintTools(server, client) {
+    server.registerTool("list_sprints", {
+        title: "List sprints for a board",
+        description: "List sprints on a board, optionally filtered by state (active, closed, future).",
+        inputSchema: {
+            boardId: z.number().int().describe("Board ID"),
+            state: sprintState.optional(),
+            maxResults: z.number().int().min(1).max(1000).default(50),
+            startAt: z.number().int().min(0).default(0),
+        },
+    }, async ({ boardId, state, maxResults, startAt }) => run(() => client.agileGet(`/board/${boardId}/sprint`, { state, maxResults, startAt })));
+    server.registerTool("get_sprint", {
+        title: "Get sprint",
+        description: "Get a single sprint by ID (name, state, start/end dates, goal).",
+        inputSchema: {
+            sprintId: z.number().int().describe("Sprint ID"),
+        },
+    }, async ({ sprintId }) => run(() => client.agileGet(`/sprint/${sprintId}`)));
+    server.registerTool("create_sprint", {
+        title: "Create sprint",
+        description: "Create a new sprint on a board. Dates are ISO-8601 strings, e.g. 2026-09-01T09:00:00.000+0000.",
+        inputSchema: {
+            boardId: z.number().int().describe("Board ID"),
+            name: z.string().describe("Sprint name"),
+            startDate: z.string().optional().describe("Start date (ISO-8601)"),
+            endDate: z.string().optional().describe("End date (ISO-8601)"),
+            goal: z.string().optional().describe("Sprint goal"),
+        },
+    }, async ({ boardId, name, startDate, endDate, goal }) => run(() => client.agilePost(`/board/${boardId}/sprint`, { name, startDate, endDate, goal })));
+    server.registerTool("update_sprint", {
+        title: "Update sprint",
+        description: "Update a sprint's name, goal, dates, or state (active/closed/future). Only provided fields are changed.",
+        inputSchema: {
+            sprintId: z.number().int().describe("Sprint ID"),
+            name: z.string().optional(),
+            goal: z.string().optional(),
+            startDate: z.string().optional().describe("Start date (ISO-8601)"),
+            endDate: z.string().optional().describe("End date (ISO-8601)"),
+            state: sprintState.optional(),
+        },
+    }, async ({ sprintId, name, goal, startDate, endDate, state }) => run(() => client.agilePut(`/sprint/${sprintId}`, { name, goal, startDate, endDate, state })));
+    server.registerTool("close_sprint", {
+        title: "Close sprint",
+        description: "Close a sprint (sets its state to closed).",
+        inputSchema: {
+            sprintId: z.number().int().describe("Sprint ID"),
+        },
+    }, async ({ sprintId }) => run(() => client.agilePut(`/sprint/${sprintId}`, { state: "closed" })));
+    server.registerTool("get_sprint_issues", {
+        title: "Get sprint issues",
+        description: "List the issues in a sprint.",
+        inputSchema: {
+            sprintId: z.number().int().describe("Sprint ID"),
+            fields: z
+                .string()
+                .optional()
+                .describe("Comma-separated issue fields to return (default: key, summary, status, assignee)"),
+            maxResults: z.number().int().min(1).max(1000).default(100),
+            startAt: z.number().int().min(0).default(0),
+        },
+    }, async ({ sprintId, fields, maxResults, startAt }) => run(() => client.agileGet(`/sprint/${sprintId}/issue`, {
+        fields: fields ?? "key,summary,status,assignee",
+        maxResults,
+        startAt,
+    })));
+    server.registerTool("get_sprint_view", {
+        title: "Get sprint view",
+        description: "Full sprint view like the Jira UI: board info, current sprint, and all its issues. Uses the agile rapid view API (rapidViewId = boardId * 10^13 + sprintId).",
+        inputSchema: {
+            boardId: z.number().int().describe("Board ID"),
+            sprintId: z.number().int().describe("Sprint ID"),
+            fields: z
+                .string()
+                .optional()
+                .describe("Comma-separated issue fields to return (default: key, summary, status, assignee)"),
+        },
+    }, async ({ boardId, sprintId, fields }) => run(() => client.agileGet(`/rapid/${rapidViewId(boardId, sprintId)}`, {
+        fields: fields ?? "key,summary,status,assignee",
+    })));
+    server.registerTool("get_backlog", {
+        title: "Get board backlog",
+        description: "List backlog issues for a board (issues in the board's projects with no sprint), ordered by rank. Implemented via JQL: project in (<board projects>) AND sprint IS NONE ORDER BY rank.",
+        inputSchema: {
+            boardId: z.number().int().describe("Board ID"),
+            fields: z
+                .string()
+                .optional()
+                .describe("Comma-separated issue fields to return (default: key, summary, status, assignee)"),
+            maxResults: z.number().int().min(1).max(100).default(50),
+            startAt: z.number().int().min(0).default(0),
+        },
+    }, async ({ boardId, fields, maxResults, startAt }) => run(async () => {
+        const board = (await client.agileGet(`/board/${boardId}`));
+        const keys = (board.projects ?? []).map((p) => p.key);
+        const jql = keys.length > 0 ? `project in (${keys.join(", ")}) AND sprint IS NONE ORDER BY rank` : "sprint IS NONE ORDER BY rank";
+        return client.apiGet("/search", {
+            jql,
+            fields: fields ?? "key,summary,status,assignee",
+            maxResults,
+            startAt,
+        });
+    }));
+}

package/dist/tools/users.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { run } from "../util.js";
+export function registerUserTools(server, client) {
+    server.registerTool("get_current_user", {
+        title: "Get current user",
+        description: "Get the profile of the user whose credentials are configured (also verifies auth works).",
+        inputSchema: {},
+    }, async () => run(() => client.apiGet("/myself")));
+    server.registerTool("find_users", {
+        title: "Find users",
+        description: "Search for users by name/email (Cloud) or username (Data Center). Returns account IDs / usernames usable for assignment.",
+        inputSchema: {
+            query: z.string().describe("Search text (name, email, or username)"),
+            maxResults: z.number().int().min(1).max(1000).default(25),
+        },
+    }, async ({ query, maxResults }) => run(() => client.apiGet("/user/search", client.apiVersion === "3" ? { query, maxResults } : { username: query, maxResults })));
+    server.registerTool("get_user", {
+        title: "Get user",
+        description: "Get a user by account ID (Jira Cloud / API v3) or username (Data Center / API v2).",
+        inputSchema: {
+            accountId: z.string().optional().describe("Account ID (Jira Cloud / API v3)"),
+            username: z.string().optional().describe("Username (Data Center / API v2)"),
+        },
+    }, async ({ accountId, username }) => run(() => {
+        if (!accountId && !username) {
+            throw new Error("Provide at least one of accountId or username.");
+        }
+        if (client.apiVersion === "3") {
+            if (!accountId) {
+                throw new Error("API v3 requires accountId for get_user. Use find_users to look up the account ID for a username.");
+            }
+            return client.apiGet(`/user/${encodeURIComponent(accountId)}`);
+        }
+        return client.apiGet("/user", { username: username ?? accountId });
+    }));
+}

package/dist/util.js

@@ -0,0 +1,24 @@
+import { JiraApiError } from "./client.js";
+export function jsonResult(data) {
+    const text = typeof data === "string" ? data : data === null ? "OK (no body)" : JSON.stringify(data, null, 2);
+    return { content: [{ type: "text", text }] };
+}
+export async function run(fn) {
+    try {
+        return jsonResult(await fn());
+    }
+    catch (err) {
+        const message = err instanceof JiraApiError
+            ? err.message
+            : err instanceof Error
+                ? `${err.name}: ${err.message}`
+                : String(err);
+        return {
+            content: [{ type: "text", text: `Error: ${message}` }],
+            isError: true,
+        };
+    }
+}
+export function rapidViewId(boardId, sprintId) {
+    return boardId * 10_000_000_000_000 + sprintId;
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@thammarongg/jira-mcp",
+  "version": "0.1.0",
+  "description": "MCP server exposing the Jira REST API (boards, sprints, issues, JQL, and a generic passthrough) for Jira Cloud and Data Center",
+  "type": "module",
+  "bin": {
+    "jira-mcp": "dist/index.js"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "skill"
+  ],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "jira",
+    "atlassian",
+    "jira-cloud",
+    "jira-data-center",
+    "sprint",
+    "board",
+    "jql",
+    "ai",
+    "claude"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "smoke": "node scripts/smoke.mjs",
+    "prepublishOnly": "npm run build && npm run smoke"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.0",
+    "tsx": "^4.23.12",
+    "typescript": "^7.0.2"
+  }
+}