@stubbedev/atlassian-mcp 0.1.5 → 0.1.7

package/README.md

@@ -52,7 +52,7 @@ A [Model Context Protocol](https://modelcontextprotocol.io) (MCP) server for **s
 | `bitbucket_decline_pr` | Decline a pull request |
 | `bitbucket_get_pr_comments` | Get PR comment threads in bulk, including task-style BLOCKER comments and blocker counts |
 | `bitbucket_add_pr_comment` | Add a top-level PR comment or reply to an existing comment |
-| `bitbucket_update_pr_comment` | Update comment text, state, or severity (`BLOCKER` = task/checklist item) |
+| `bitbucket_update_pr_comment` | Update comment text/severity, resolve or reopen normal threads via `threadResolved`, and resolve/reopen BLOCKER tasks via `state` (strictly enforced) |
 | `bitbucket_delete_pr_comment` | Delete a PR comment by comment ID |
 | `bitbucket_get_pr_commits` | List commits included in a pull request |
 | `bitbucket_get_branches` | List branches in a repository |
@@ -76,6 +76,8 @@ All list tools support `limit` and `start`/`startAt` for pagination.
 - "show review comments on PR 42" → `bitbucket_get_pr_comments`
 - "give me one full overview of PR 42" → `bitbucket_get_pr_overview`
 - "how many open blockers are on PR 42" → `bitbucket_get_pr_comments` with `severity=BLOCKER` and `countOnly=true`
+- "resolve this review thread on PR 42" → `bitbucket_update_pr_comment` with `threadResolved=true`
+- "resolve this blocker task on PR 42" → `bitbucket_update_pr_comment` with `severity=BLOCKER` and `state=RESOLVED`
 - "move FOO-123 to In Progress" → `jira_transition_issue` with `transitionName="In Progress"`
 - "find bugs assigned to me in PAY project" → `jira_search_issues`
 - "give me my coding context for this branch" → `get_dev_context`

package/dist/bitbucket.js

@@ -39,8 +39,11 @@ function formatCommentThread(comment, indent = '') {
     const date = comment.createdDate ? ` (${formatDate(comment.createdDate)})` : '';
     const state = comment.state ?? 'OPEN';
     const severity = comment.severity ?? 'NORMAL';
+    const threadStatus = comment.threadResolved !== undefined
+        ? ` thread=${comment.threadResolved ? 'RESOLVED' : 'OPEN'}`
+        : '';
     const lines = [
-        `${indent}#${comment.id} [${state}/${severity}] ${author}${date} (v${comment.version})`,
+        `${indent}#${comment.id} [${state}/${severity}${threadStatus}] ${author}${date} (v${comment.version})`,
         `${indent}${comment.text}`,
     ];
     if (comment.comments && comment.comments.length > 0) {
@@ -51,6 +54,11 @@ function formatCommentThread(comment, indent = '') {
     return lines;
 }
 function commentMatchesState(comment, state) {
+    if (state !== 'PENDING' && (comment.severity ?? 'NORMAL') !== 'BLOCKER' && comment.threadResolved !== undefined) {
+        const threadState = comment.threadResolved ? 'RESOLVED' : 'OPEN';
+        if (threadState === state)
+            return true;
+    }
     const currentState = comment.state ?? 'OPEN';
     if (currentState === state)
         return true;
@@ -67,11 +75,31 @@ function commentMatchesSeverity(comment, severity) {
 function uniqueCommentsFromActivities(activities) {
     const byId = new Map();
     for (const activity of activities) {
-        if (activity.action === 'COMMENTED' && activity.comment && !byId.has(activity.comment.id)) {
-            byId.set(activity.comment.id, activity.comment);
+        const comment = activity.comment;
+        if (!comment)
+            continue;
+        const existing = byId.get(comment.id);
+        if (!existing) {
+            byId.set(comment.id, comment);
+            continue;
+        }
+        const commentVersion = comment.version ?? -1;
+        const existingVersion = existing.version ?? -1;
+        if (commentVersion > existingVersion) {
+            byId.set(comment.id, comment);
+            continue;
+        }
+        if (commentVersion === existingVersion) {
+            const commentUpdated = comment.updatedDate ?? comment.createdDate ?? 0;
+            const existingUpdated = existing.updatedDate ?? existing.createdDate ?? 0;
+            if (commentUpdated > existingUpdated) {
+                byId.set(comment.id, comment);
+            }
         }
     }
-    return Array.from(byId.values()).sort((a, b) => (a.createdDate ?? 0) - (b.createdDate ?? 0));
+    return Array.from(byId.values())
+        .filter((comment) => !comment.deleted)
+        .sort((a, b) => (a.createdDate ?? 0) - (b.createdDate ?? 0));
 }
 function pageHint(data) {
     return data.isLastPage ? '' : ` (use start=${data.nextPageStart} for next page)`;
@@ -158,6 +186,13 @@ export class BitbucketClient {
             Accept: 'application/json',
         };
     }
+    pullRequestUrl(projectKey, repoSlug, prId, pr) {
+        const apiUrl = pr?.links?.self?.[0]?.href?.trim();
+        if (apiUrl) {
+            return apiUrl;
+        }
+        return `${this.baseUrl}/projects/${encodeURIComponent(projectKey)}/repos/${encodeURIComponent(repoSlug)}/pull-requests/${prId}`;
+    }
     resolveProjectAndRepo(projectKey, repoSlug) {
         if (projectKey && repoSlug)
             return { projectKey, repoSlug };
@@ -375,20 +410,21 @@ export class BitbucketClient {
         const data = await this.request('POST', `/projects/${projectKey}/repos/${repoSlug}/pull-requests`, body);
         if (!data)
             return text('Pull request created.');
-        const url = data.links?.self?.[0]?.href ?? '';
-        return text(`Created PR #${data.id}: "${data.title}"${url ? `\n${url}` : ''}`);
+        const url = this.pullRequestUrl(projectKey, repoSlug, data.id, data);
+        return text(`Created PR #${data.id}: "${data.title}"\n${url}`);
     }
     async approvePr(args) {
         const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
         const data = await this.request('POST', `/projects/${projectKey}/repos/${repoSlug}/pull-requests/${args.prId}/approve`);
+        const url = this.pullRequestUrl(projectKey, repoSlug, args.prId);
         if (!data)
-            return text(`Approved PR #${args.prId}.`);
-        return text(`Approved PR #${args.prId} as ${data.user.displayName}.`);
+            return text(`Approved PR #${args.prId}.\n${url}`);
+        return text(`Approved PR #${args.prId} as ${data.user.displayName}.\n${url}`);
     }
     async unapprovePr(args) {
         const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
         await this.request('DELETE', `/projects/${projectKey}/repos/${repoSlug}/pull-requests/${args.prId}/approve`);
-        return text(`Approval removed from PR #${args.prId}.`);
+        return text(`Approval removed from PR #${args.prId}.\n${this.pullRequestUrl(projectKey, repoSlug, args.prId)}`);
     }
     async declinePr(args) {
         const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
@@ -400,8 +436,8 @@ export class BitbucketClient {
             body.message = args.message;
         const data = await this.request('POST', `/projects/${projectKey}/repos/${repoSlug}/pull-requests/${args.prId}/decline`, body);
         if (!data)
-            return text(`Declined PR #${args.prId}.`);
-        return text(`Declined PR #${data.id}: "${data.title}".`);
+            return text(`Declined PR #${args.prId}.\n${this.pullRequestUrl(projectKey, repoSlug, args.prId)}`);
+        return text(`Declined PR #${data.id}: "${data.title}".\n${this.pullRequestUrl(projectKey, repoSlug, data.id, data)}`);
     }
     async mergePr(args) {
         const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
@@ -415,8 +451,8 @@ export class BitbucketClient {
             body.message = args.message;
         const data = await this.request('POST', `/projects/${projectKey}/repos/${repoSlug}/pull-requests/${args.prId}/merge`, body);
         if (!data)
-            return text(`Merged PR #${args.prId}.`);
-        return text(`Merged PR #${data.id}: "${data.title}" (${data.fromRef.displayId} → ${data.toRef.displayId}).`);
+            return text(`Merged PR #${args.prId}.\n${this.pullRequestUrl(projectKey, repoSlug, args.prId)}`);
+        return text(`Merged PR #${data.id}: "${data.title}" (${data.fromRef.displayId} → ${data.toRef.displayId}).\n${this.pullRequestUrl(projectKey, repoSlug, data.id, data)}`);
     }
     async getBranches(args) {
         const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
@@ -534,26 +570,55 @@ export class BitbucketClient {
     }
     async updatePrComment(args) {
         const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
-        if (!args.text && !args.state && !args.severity) {
-            throw new Error('At least one field is required: text, state, or severity');
+        if (!args.text && !args.state && !args.severity && args.threadResolved === undefined) {
+            throw new Error('At least one field is required: text, state, severity, or threadResolved');
         }
         const current = await this.request('GET', `/projects/${projectKey}/repos/${repoSlug}/pull-requests/${args.prId}/comments/${args.commentId}`);
         if (!current)
             throw new Error(`Comment #${args.commentId} not found.`);
-        const body = {
-            version: current.version,
-            text: args.text !== undefined ? validateCommentText(args.text) : current.text,
+        const targetSeverity = args.severity ?? current.severity ?? 'NORMAL';
+        if (args.state && targetSeverity !== 'BLOCKER') {
+            throw new Error('state is only supported for BLOCKER comments (tasks). Use threadResolved for normal comment threads.');
+        }
+        if (args.threadResolved !== undefined && targetSeverity === 'BLOCKER') {
+            throw new Error('threadResolved is only supported for normal comments. Use state for BLOCKER comment tasks.');
+        }
+        const commentPath = (targetSeverity === 'BLOCKER' || current.severity === 'BLOCKER')
+            ? `/projects/${projectKey}/repos/${repoSlug}/pull-requests/${args.prId}/blocker-comments/${args.commentId}`
+            : `/projects/${projectKey}/repos/${repoSlug}/pull-requests/${args.prId}/comments/${args.commentId}`;
+        const buildBody = (version) => {
+            const body = { version };
+            if (args.text !== undefined)
+                body.text = validateCommentText(args.text);
+            if (args.state && targetSeverity === 'BLOCKER')
+                body.state = args.state;
+            if (args.severity)
+                body.severity = args.severity;
+            if (args.threadResolved !== undefined) {
+                body.threadResolved = args.threadResolved;
+            }
+            return body;
         };
-        if (args.state)
-            body.state = args.state;
-        if (args.severity)
-            body.severity = args.severity;
-        const updated = await this.request('PUT', `/projects/${projectKey}/repos/${repoSlug}/pull-requests/${args.prId}/comments/${args.commentId}`, body);
+        let updated;
+        try {
+            updated = await this.request('PUT', commentPath, buildBody(current.version));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (!message.includes('Bitbucket 409'))
+                throw error;
+            const latest = await this.request('GET', commentPath);
+            if (!latest)
+                throw error;
+            updated = await this.request('PUT', commentPath, buildBody(latest.version));
+        }
         if (!updated)
             return text(`Comment #${args.commentId} updated.`);
         const state = updated.state ?? current.state ?? 'OPEN';
         const severity = updated.severity ?? current.severity ?? 'NORMAL';
-        return text(`Comment #${updated.id} updated (${state}/${severity}).`);
+        const threadResolved = updated.threadResolved ?? current.threadResolved;
+        const threadStatus = threadResolved === undefined ? '' : `, thread=${threadResolved ? 'RESOLVED' : 'OPEN'}`;
+        return text(`Comment #${updated.id} updated (${state}/${severity}${threadStatus}).`);
     }
     async deletePrComment(args) {
         const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);

package/dist/index.js

@@ -505,7 +505,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                     repo: { type: 'string', description: 'Alias for repoSlug' },
                     prId: { type: 'number', description: 'Pull request number (PR ID)' },
                     path: { type: 'string', description: 'Optional file path filter, e.g. "src/index.ts"' },
-                    state: { type: 'string', enum: ['OPEN', 'RESOLVED', 'PENDING'], description: 'Comment state filter (default OPEN; BLOCKER mode supports OPEN/RESOLVED)', default: 'OPEN' },
+                    state: { type: 'string', enum: ['OPEN', 'RESOLVED', 'PENDING'], description: 'State filter. For normal comments this maps to threadResolved (OPEN/RESOLVED). For BLOCKER tasks this uses task state (OPEN/RESOLVED; PENDING allowed only for non-BLOCKER).', default: 'OPEN' },
                     severity: { type: 'string', enum: ['ALL', 'NORMAL', 'BLOCKER'], description: 'Comment severity filter. BLOCKER means task/checklist-style review comments.', default: 'ALL' },
                     countOnly: { type: 'boolean', description: 'When true with severity=BLOCKER, returns counts instead of comment bodies', default: false },
                     limit: { type: 'number', description: 'Max items per page (default 50)', default: 50 },
@@ -533,7 +533,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
         {
             name: 'bitbucket_update_pr_comment',
-            description: 'Use when you want to edit PR comments, resolve/reopen them, or mark comments as task-style BLOCKER items. Keep comments concise, plain text, and free of filler. Never include emojis. You can pass projectKey/repoSlug or project/repo.',
+            description: 'Use when you want to edit PR comments, resolve/reopen normal discussion threads, or manage task-style BLOCKER comments. Hint: for normal comments, resolve/reopen means threadResolved; for BLOCKER tasks, resolve/reopen uses state. Keep comments concise, plain text, and free of filler. Never include emojis. You can pass projectKey/repoSlug or project/repo.',
             inputSchema: {
                 type: 'object',
                 properties: {
@@ -544,7 +544,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                     prId: { type: 'number', description: 'Pull request number (PR ID)' },
                     commentId: { type: 'number', description: 'Comment ID to update' },
                     text: { type: 'string', description: 'New concise comment text only. No filler. Do not include emojis. (optional)' },
-                    state: { type: 'string', enum: ['OPEN', 'RESOLVED'], description: 'Comment state (optional)' },
+                    state: { type: 'string', enum: ['OPEN', 'RESOLVED'], description: 'Task state for BLOCKER comments only (optional). Rejected for normal comments; use threadResolved instead.' },
+                    threadResolved: { type: 'boolean', description: 'Resolve/reopen normal comment threads in Bitbucket UI only (optional). Rejected for BLOCKER comments; use state instead.' },
                     severity: { type: 'string', enum: ['NORMAL', 'BLOCKER'], description: 'Comment severity (optional). BLOCKER marks it as a task/checklist item.' },
                 },
                 required: ['prId', 'commentId'],

package/dist/jira.js

@@ -98,6 +98,18 @@ export class JiraClient {
             Accept: 'application/json',
         };
     }
+    issueUrl(issueKey) {
+        return `${this.baseUrl}/browse/${encodeURIComponent(issueKey)}`;
+    }
+    projectUrl(projectKey) {
+        return `${this.baseUrl}/projects/${encodeURIComponent(projectKey)}`;
+    }
+    boardUrl(boardId) {
+        return `${this.baseUrl}/secure/RapidBoard.jspa?rapidView=${boardId}`;
+    }
+    sprintUrl(boardId, sprintId) {
+        return `${this.boardUrl(boardId)}&sprint=${sprintId}`;
+    }
     async requestWithBase(apiBase, method, path, body) {
         const url = `${this.baseUrl}${apiBase}${path}`;
         const opts = { method, headers: this.headers };
@@ -208,7 +220,7 @@ export class JiraClient {
             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}`;
+            return `${startAt + idx + 1}. [${i.key}] ${i.fields.summary} | ${i.fields.status.name} | ${assignee} | ${this.issueUrl(i.key)}`;
         });
         const page = pagination(data.total, startAt, data.issues.length);
         return text(`Found ${data.total} issues${page}:\n${lines.join('\n')}`);
@@ -225,7 +237,7 @@ export class JiraClient {
         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})`);
+        const lines = data.map((p, i) => `${i + 1}. [${p.key}] ${p.name} (${p.projectTypeKey}) | ${this.projectUrl(p.key)}`);
         return text(`${data.length} project(s):\n${lines.join('\n')}`);
     }
     async getIssueTypes(args) {
@@ -253,11 +265,11 @@ export class JiraClient {
         const lines = data.values.map((s, i) => {
             const window = [s.startDate?.slice(0, 10), s.endDate?.slice(0, 10)].filter(Boolean).join(' -> ');
             const goal = s.goal?.trim() ? ` | Goal: ${s.goal}` : '';
-            return `${startAt + i + 1}. [${s.id}] ${s.name} | ${s.state}${window ? ` | ${window}` : ''}${goal}`;
+            return `${startAt + i + 1}. [${s.id}] ${s.name} | ${s.state}${window ? ` | ${window}` : ''}${goal} | ${this.sprintUrl(boardId, s.id)}`;
         });
         const rangeEnd = startAt + data.values.length;
         const page = data.isLast ? '' : ` (showing ${startAt + 1}-${rangeEnd}, use startAt=${rangeEnd} for next page)`;
-        return text(`Sprints for board ${boardId}${page}:\n${lines.join('\n')}`);
+        return text(`Sprints for board ${boardId}${page}:\nBoard URL: ${this.boardUrl(boardId)}\n${lines.join('\n')}`);
     }
     async searchUsers(args) {
         const params = new URLSearchParams({
@@ -305,6 +317,7 @@ export class JiraClient {
         const f = issue.fields;
         const lines = [
             `Issue: ${issue.key} — ${f.summary}`,
+            `URL:        ${this.issueUrl(issue.key)}`,
             `Status:     ${f.status.name}`,
             `Type:       ${f.issuetype.name}`,
             `Priority:   ${f.priority?.name ?? 'None'}`,
@@ -400,12 +413,13 @@ export class JiraClient {
         const issueBySprint = new Map(sprintIssueData.map((entry) => [entry.sprintId, entry.issues]));
         const lines = [
             `Board: [${args.boardId}] ${board?.name ?? '(unknown)'} | ${board?.type ?? '(unknown type)'}`,
+            `URL: ${this.boardUrl(args.boardId)}`,
             `Sprints: ${sprints.values.length}`,
             '',
         ];
         sprints.values.forEach((sprint, idx) => {
             const window = [sprint.startDate?.slice(0, 10), sprint.endDate?.slice(0, 10)].filter(Boolean).join(' -> ');
-            lines.push(`${sprintStartAt + idx + 1}. [${sprint.id}] ${sprint.name} | ${sprint.state}${window ? ` | ${window}` : ''}`);
+            lines.push(`${sprintStartAt + idx + 1}. [${sprint.id}] ${sprint.name} | ${sprint.state}${window ? ` | ${window}` : ''} | ${this.sprintUrl(args.boardId, sprint.id)}`);
             if (sprint.goal?.trim()) {
                 lines.push(`   Goal: ${sprint.goal}`);
             }
@@ -415,7 +429,7 @@ export class JiraClient {
                 lines.push(`   Issues: ${issueData?.total ?? 0}`);
                 for (const issue of issues) {
                     const assignee = issue.fields.assignee?.displayName ?? 'Unassigned';
-                    lines.push(`   - [${issue.key}] ${issue.fields.summary} | ${issue.fields.status.name} | ${assignee}`);
+                    lines.push(`   - [${issue.key}] ${issue.fields.summary} | ${issue.fields.status.name} | ${assignee} | ${this.issueUrl(issue.key)}`);
                 }
                 if ((issueData?.total ?? 0) > issues.length) {
                     lines.push(`   ...and ${(issueData?.total ?? 0) - issues.length} more (adjust issueStartAt/issueMaxResults).`);
@@ -433,11 +447,12 @@ export class JiraClient {
         const data = await this.createIssueInternal(args);
         if (!data)
             return text('Issue created.');
+        const url = this.issueUrl(data.key);
         if (args.sprintId !== undefined) {
             await this.addIssuesToSprintInternal(args.sprintId, [data.key]);
-            return text(`Created ${data.key} and added it to sprint ${args.sprintId}.`);
+            return text(`Created ${data.key} and added it to sprint ${args.sprintId}.\n${url}`);
         }
-        return text(`Created ${data.key}.`);
+        return text(`Created ${data.key}.\n${url}`);
     }
     async updateIssue(args) {
         const hasFieldUpdates = await this.updateIssueFieldsInternal(args);
@@ -447,12 +462,12 @@ export class JiraClient {
             await this.addIssuesToSprintInternal(args.sprintId, [args.issueKey]);
         }
         if (hasFieldUpdates && args.sprintId !== undefined) {
-            return text(`Updated ${args.issueKey} and added it to sprint ${args.sprintId}.`);
+            return text(`Updated ${args.issueKey} and added it to sprint ${args.sprintId}.\n${this.issueUrl(args.issueKey)}`);
         }
         if (hasFieldUpdates) {
-            return text(`Updated ${args.issueKey}.`);
+            return text(`Updated ${args.issueKey}.\n${this.issueUrl(args.issueKey)}`);
         }
-        return text(`Added ${args.issueKey} to sprint ${args.sprintId}.`);
+        return text(`Added ${args.issueKey} to sprint ${args.sprintId}.\n${this.issueUrl(args.issueKey)}`);
     }
     async addIssuesToSprint(args) {
         const keys = new Set();
@@ -468,7 +483,14 @@ export class JiraClient {
         }
         const issueKeys = Array.from(keys);
         await this.addIssuesToSprintInternal(args.sprintId, issueKeys);
-        return text(`Added ${issueKeys.length} issue(s) to sprint ${args.sprintId}.`);
+        if (issueKeys.length === 1) {
+            return text(`Added ${issueKeys[0]} to sprint ${args.sprintId}.\n${this.issueUrl(issueKeys[0])}`);
+        }
+        const lines = [
+            `Added ${issueKeys.length} issue(s) to sprint ${args.sprintId}.`,
+            ...issueKeys.map((issueKey) => `${issueKey}: ${this.issueUrl(issueKey)}`),
+        ];
+        return text(lines.join('\n'));
     }
     async mutateIssue(args) {
         let issueKey = args.issueKey?.trim();
@@ -504,7 +526,7 @@ export class JiraClient {
         if (actions.length === 0) {
             return text('Nothing to mutate.');
         }
-        return text(`Mutated ${issueKey}: ${actions.join(', ')}.`);
+        return text(`Mutated ${issueKey}: ${actions.join(', ')}.\n${this.issueUrl(issueKey)}`);
     }
     async getComments(args) {
         const { issueKey, maxResults = 50, startAt = 0 } = args;
@@ -525,6 +547,6 @@ export class JiraClient {
     async transitionIssue(args) {
         const transitionId = await this.resolveTransitionId(args.issueKey, args.transitionId, args.transitionName);
         await this.transitionIssueInternal(args.issueKey, transitionId);
-        return text(`Transitioned ${args.issueKey} using transition ${transitionId}.`);
+        return text(`Transitioned ${args.issueKey} using transition ${transitionId}.\n${this.issueUrl(args.issueKey)}`);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stubbedev/atlassian-mcp",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "MCP server for self-hosted Jira and Bitbucket",
   "type": "module",
   "main": "dist/index.js",