@stubbedev/atlassian-mcp 0.0.1

package/dist/jira.js

@@ -0,0 +1,189 @@
+function text(t) {
+    return { content: [{ type: 'text', text: t }] };
+}
+function pagination(total, startAt, count) {
+    const end = startAt + count;
+    return total > end ? ` (showing ${startAt + 1}–${end} of ${total}, use startAt=${end} for next page)` : '';
+}
+function buildJQL(args) {
+    if (args.jql)
+        return args.jql;
+    const clauses = [];
+    if (args.query)
+        clauses.push(`text ~ ${JSON.stringify(args.query)}`);
+    if (args.project)
+        clauses.push(`project = "${args.project}"`);
+    if (args.status)
+        clauses.push(`status = "${args.status}"`);
+    if (args.assignee)
+        clauses.push(`assignee = "${args.assignee}"`);
+    if (args.issueType)
+        clauses.push(`issuetype = "${args.issueType}"`);
+    if (clauses.length === 0)
+        throw new Error('Provide at least one of: query, jql, project, status, assignee, issueType');
+    return clauses.join(' AND ') + ' ORDER BY updated DESC';
+}
+export class JiraClient {
+    baseUrl;
+    headers;
+    constructor(baseUrl, token) {
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+        this.headers = {
+            Authorization: `Bearer ${token}`,
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+        };
+    }
+    async request(method, path, body) {
+        const url = `${this.baseUrl}/rest/api/2${path}`;
+        const opts = { method, headers: this.headers };
+        if (body !== undefined)
+            opts.body = JSON.stringify(body);
+        const res = await fetch(url, opts);
+        if (!res.ok) {
+            const errText = await res.text();
+            throw new Error(`Jira ${res.status} ${method} ${path}: ${errText}`);
+        }
+        return res.status === 204 ? null : res.json();
+    }
+    async searchIssues(args) {
+        const { maxResults = 20, startAt = 0 } = args;
+        const jql = buildJQL(args);
+        const params = new URLSearchParams({
+            jql,
+            maxResults: String(maxResults),
+            startAt: String(startAt),
+            fields: 'summary,status,assignee,priority,issuetype',
+        });
+        const data = await this.request('GET', `/search?${params}`);
+        if (!data)
+            return text('No results.');
+        const lines = data.issues.map((i, idx) => {
+            const assignee = i.fields.assignee?.displayName ?? 'Unassigned';
+            return `${startAt + idx + 1}. [${i.key}] ${i.fields.summary} | ${i.fields.status.name} | ${assignee}`;
+        });
+        const page = pagination(data.total, startAt, data.issues.length);
+        return text(`Found ${data.total} issues${page}:\n${lines.join('\n')}`);
+    }
+    async myIssues(args) {
+        return this.searchIssues({
+            jql: 'assignee = currentUser() ORDER BY updated DESC',
+            maxResults: args.maxResults,
+            startAt: args.startAt,
+        });
+    }
+    async getProjects(args) {
+        const limit = args.maxResults ?? 50;
+        const data = await this.request('GET', `/project?maxResults=${limit}`);
+        if (!data || data.length === 0)
+            return text('No projects found.');
+        const lines = data.map((p, i) => `${i + 1}. [${p.key}] ${p.name} (${p.projectTypeKey})`);
+        return text(`${data.length} project(s):\n${lines.join('\n')}`);
+    }
+    async getIssueTypes(args) {
+        const { projectKey } = args;
+        const data = await this.request('GET', `/project/${projectKey}/statuses`);
+        if (!data || data.length === 0)
+            return text('No issue types found.');
+        const lines = data.map((t) => {
+            const statuses = t.statuses.map((s) => s.name).join(', ');
+            return `${t.name}: ${statuses}`;
+        });
+        return text(`Issue types and statuses for ${projectKey}:\n${lines.join('\n')}`);
+    }
+    async searchUsers(args) {
+        const params = new URLSearchParams({
+            username: args.query,
+            maxResults: String(args.maxResults ?? 10),
+        });
+        const data = await this.request('GET', `/user/search?${params}`);
+        if (!data || data.length === 0)
+            return text('No users found.');
+        const lines = data
+            .filter((u) => u.active)
+            .map((u, i) => `${i + 1}. ${u.displayName} (${u.name}) — ${u.emailAddress}`);
+        return text(`${lines.length} user(s) found:\n${lines.join('\n')}`);
+    }
+    async getIssue(args) {
+        const fields = 'summary,description,status,assignee,priority,issuetype,labels,components';
+        const data = await this.request('GET', `/issue/${args.issueKey}?fields=${fields}`);
+        if (!data)
+            return text('Issue not found.');
+        const f = data.fields;
+        const lines = [
+            `Issue: ${data.key} — ${f.summary}`,
+            `Status:     ${f.status.name}`,
+            `Type:       ${f.issuetype.name}`,
+            `Priority:   ${f.priority?.name ?? 'None'}`,
+            `Assignee:   ${f.assignee?.displayName ?? 'Unassigned'}`,
+            `Labels:     ${f.labels?.join(', ') || 'None'}`,
+            `Components: ${f.components?.map((c) => c.name).join(', ') || 'None'}`,
+            '',
+            'Description:',
+            f.description ?? '(no description)',
+        ];
+        return text(lines.join('\n'));
+    }
+    async createIssue(args) {
+        const { projectKey } = args;
+        const fields = {
+            project: { key: projectKey },
+            issuetype: { name: args.issueType },
+            summary: args.summary,
+        };
+        if (args.description)
+            fields.description = args.description;
+        if (args.assignee)
+            fields.assignee = { name: args.assignee };
+        if (args.priority)
+            fields.priority = { name: args.priority };
+        const data = await this.request('POST', '/issue', { fields });
+        if (!data)
+            return text('Issue created.');
+        return text(`Created ${data.key}.`);
+    }
+    async updateIssue(args) {
+        const fields = {};
+        if (args.summary !== undefined)
+            fields.summary = args.summary;
+        if (args.description !== undefined)
+            fields.description = args.description;
+        if (args.assignee !== undefined)
+            fields.assignee = { name: args.assignee };
+        if (args.priority !== undefined)
+            fields.priority = { name: args.priority };
+        if (Object.keys(fields).length === 0)
+            return text('Nothing to update.');
+        await this.request('PUT', `/issue/${args.issueKey}`, { fields });
+        return text(`Updated ${args.issueKey}.`);
+    }
+    async getComments(args) {
+        const { issueKey, maxResults = 50, startAt = 0 } = args;
+        const data = await this.request('GET', `/issue/${issueKey}/comment?startAt=${startAt}&maxResults=${maxResults}`);
+        if (!data || data.comments.length === 0)
+            return text('No comments found.');
+        const blocks = data.comments.map((c) => {
+            const date = c.created.slice(0, 10);
+            return `--- ${c.author.displayName} (${date}) ---\n${c.body}`;
+        });
+        const page = pagination(data.total, startAt, data.comments.length);
+        return text(`${data.total} comment(s) on ${issueKey}${page}:\n\n${blocks.join('\n\n')}`);
+    }
+    async addComment(args) {
+        await this.request('POST', `/issue/${args.issueKey}/comment`, { body: args.body });
+        return text(`Comment added to ${args.issueKey}.`);
+    }
+    async getTransitions(args) {
+        const data = await this.request('GET', `/issue/${args.issueKey}/transitions`);
+        if (!data || data.transitions.length === 0)
+            return text('No transitions available.');
+        const lines = data.transitions.map((t) => `${t.id}: ${t.name} → ${t.to.name}`);
+        return text(`Available transitions for ${args.issueKey}:\n${lines.join('\n')}`);
+    }
+    async transitionIssue(args) {
+        await this.request('POST', `/issue/${args.issueKey}/transitions`, {
+            transition: { id: args.transitionId },
+        });
+        return text(`Transitioned ${args.issueKey} using transition ${args.transitionId}.`);
+    }
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@stubbedev/atlassian-mcp",
+  "version": "0.0.1",
+  "description": "MCP server for self-hosted Jira and Bitbucket",
+  "type": "module",
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "atlassian-mcp.schema.json",
+    "README.md"
+  ],
+  "bin": {
+    "atlassian-mcp": "dist/index.js"
+  },
+  "scripts": {
+    "prepare": "tsc",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "dotenv": "^16.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^22.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stubbedev/atlassian-mcp.git"
+  },
+  "homepage": "https://github.com/stubbedev/atlassian-mcp#readme"
+}