@stubbedev/atlassian-mcp 0.1.6 → 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)`;
@@ -542,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/package.json

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