@stubbedev/atlassian-mcp 0.3.1 → 0.3.3

package/dist/bitbucket.js

@@ -84,6 +84,7 @@ function commentMatchesState(comment, state) {
         const threadState = comment.threadResolved ? 'RESOLVED' : 'OPEN';
         if (threadState === state)
             return true;
+        return (comment.comments ?? []).some((child) => commentMatchesState(child, state));
     }
     const currentState = comment.state ?? 'OPEN';
     if (currentState === state)
@@ -125,18 +126,27 @@ function uniqueCommentsFromActivities(activities) {
     }
     return Array.from(byId.values())
         .filter((comment) => !comment.deleted)
-        .sort((a, b) => (a.createdDate ?? 0) - (b.createdDate ?? 0));
+        .sort((a, b) => (b.createdDate ?? 0) - (a.createdDate ?? 0));
 }
 function pageHint(data) {
     return data.isLastPage ? '' : ` (use start=${data.nextPageStart} for next page)`;
 }
 function formatDiff(data, maxChars = 8000) {
     const parts = [];
+    if (data.fromHash && data.toHash) {
+        parts.push(`# fromHash=${data.fromHash} toHash=${data.toHash}`);
+        parts.push('# Pass these to bitbucket_comment as fromHash/toHash to anchor inline comments to this exact diff.');
+    }
     for (const diff of data.diffs) {
         const from = diff.source?.toString ?? '/dev/null';
         const to = diff.destination?.toString ?? '/dev/null';
         parts.push(`--- a/${from}\n+++ b/${to}`);
         for (const hunk of diff.hunks ?? []) {
+            const srcLine = hunk.sourceLine ?? 0;
+            const srcSpan = hunk.sourceSpan ?? 0;
+            const dstLine = hunk.destinationLine ?? 0;
+            const dstSpan = hunk.destinationSpan ?? 0;
+            parts.push(`@@ -${srcLine},${srcSpan} +${dstLine},${dstSpan} @@`);
             for (const segment of hunk.segments ?? []) {
                 const prefix = segment.type === 'ADDED' ? '+' : segment.type === 'REMOVED' ? '-' : ' ';
                 for (const line of segment.lines ?? []) {
@@ -326,6 +336,49 @@ export class BitbucketClient {
         }
         return res.status === 204 ? null : res.json();
     }
+    /**
+     * Remap a source-side line number through an interim diff.
+     *
+     * Returns the destination line if the source line survives unchanged through the diff
+     * (in a CONTEXT segment), or null if the line was modified/removed and cannot be remapped.
+     */
+    async remapLineThroughDiff(projectKey, repoSlug, filePath, sinceHash, untilHash, sourceLine) {
+        const diff = await this.request('GET', `${this.rp(projectKey, repoSlug)}/diff/${filePath.split('/').map(encodeURIComponent).join('/')}?since=${encodeURIComponent(sinceHash)}&until=${encodeURIComponent(untilHash)}&contextLines=0`).catch(() => null);
+        if (!diff || !diff.diffs?.length)
+            return sourceLine;
+        let offset = 0;
+        for (const fileDiff of diff.diffs) {
+            for (const hunk of fileDiff.hunks ?? []) {
+                const srcStart = hunk.sourceLine ?? 0;
+                const srcSpan = hunk.sourceSpan ?? 0;
+                const srcEnd = srcStart + srcSpan - 1;
+                if (srcSpan > 0 && sourceLine >= srcStart && sourceLine <= srcEnd) {
+                    for (const segment of hunk.segments ?? []) {
+                        if (segment.type === 'ADDED')
+                            continue;
+                        for (const ln of segment.lines ?? []) {
+                            if (ln.source === sourceLine) {
+                                if (segment.type === 'CONTEXT' && ln.destination !== undefined)
+                                    return ln.destination;
+                                return null;
+                            }
+                        }
+                    }
+                    return null;
+                }
+                if (sourceLine > srcEnd || srcSpan === 0) {
+                    const dstSpan = hunk.destinationSpan ?? 0;
+                    if (srcSpan === 0 && (hunk.destinationLine ?? 0) <= sourceLine + offset) {
+                        offset += dstSpan;
+                    }
+                    else if (sourceLine > srcEnd) {
+                        offset += dstSpan - srcSpan;
+                    }
+                }
+            }
+        }
+        return sourceLine + offset;
+    }
     /** Returns true if the given remote URL belongs to this Bitbucket instance. */
     isRemoteForThisInstance(remoteUrl) {
         return this.remoteMatchesInstance(remoteUrl);
@@ -494,11 +547,17 @@ export class BitbucketClient {
         collectAttachmentRefs(pr.description, 'description', attachmentRefs);
         const reviewers = pr.reviewers.map((r) => `${r.user.displayName}${r.approved ? ' ✓' : ''}`).join(', ');
         const url = pr.links?.self?.[0]?.href;
+        const fromHash = pr.toRef.latestCommit;
+        const toHash = pr.fromRef.latestCommit;
+        const commitsLine = fromHash && toHash
+            ? `Commits:   fromHash=${fromHash} toHash=${toHash} (pass to bitbucket_comment to anchor inline comments to this exact state)`
+            : '';
         const header = [
             `PR #${pr.id}: ${pr.title}`,
             `State:     ${pr.state}`,
             `Author:    ${pr.author.user.displayName}`,
             `Branch:    ${pr.fromRef.displayId} → ${pr.toRef.displayId}`,
+            commitsLine,
             `Reviewers: ${reviewers || 'None'}`,
             url ? `URL:       ${url}` : '',
             '',
@@ -535,13 +594,15 @@ export class BitbucketClient {
         if (includeComments) {
             const commentsLimit = args.commentsLimit ?? 50;
             const commentsStart = args.commentsStart ?? 0;
-            const commentsState = args.commentsState ?? 'OPEN';
+            const commentsState = args.commentsState ?? 'ALL';
             const commentsSeverity = args.commentsSeverity ?? 'ALL';
             if (commentsSeverity === 'BLOCKER' && commentsState === 'PENDING') {
-                throw new Error('commentsState=PENDING is not valid when commentsSeverity=BLOCKER. Use OPEN or RESOLVED.');
+                throw new Error('commentsState=PENDING is not valid when commentsSeverity=BLOCKER. Use OPEN, RESOLVED, or ALL.');
             }
             if (commentsSeverity === 'BLOCKER') {
-                const qs = new URLSearchParams({ limit: String(commentsLimit), start: String(commentsStart), state: commentsState });
+                const qs = new URLSearchParams({ limit: String(commentsLimit), start: String(commentsStart) });
+                if (commentsState !== 'ALL')
+                    qs.set('state', commentsState);
                 const data = await this.request('GET', `${this.rp(projectKey, repoSlug)}/pull-requests/${prId}/blocker-comments?${qs}`);
                 if (!data || data.values.length === 0) {
                     sections.push(`Comments:\n(no ${commentsState} BLOCKER comments)`);
@@ -556,7 +617,7 @@ export class BitbucketClient {
             else {
                 const activityData = await this.request('GET', `${this.rp(projectKey, repoSlug)}/pull-requests/${prId}/activities?limit=${commentsLimit}&start=${commentsStart}`);
                 const comments = uniqueCommentsFromActivities(activityData?.values ?? []).filter((comment) => {
-                    const matchesState = commentMatchesState(comment, commentsState);
+                    const matchesState = commentsState === 'ALL' ? true : commentMatchesState(comment, commentsState);
                     return matchesState && commentMatchesSeverity(comment, commentsSeverity);
                 });
                 for (const comment of comments)
@@ -567,7 +628,7 @@ export class BitbucketClient {
                 else {
                     const blocks = comments.flatMap((comment) => formatCommentThread(comment));
                     const paging = activityData ? pageHint(activityData) : '';
-                    sections.push(`Comments (${comments.length} thread(s))${paging}:\n\n${blocks.join('\n\n')}`);
+                    sections.push(`Comments (${comments.length} thread(s), newest first)${paging}:\n\n${blocks.join('\n\n')}`);
                 }
             }
         }
@@ -946,7 +1007,9 @@ export class BitbucketClient {
                 || args.lineType !== undefined
                 || args.fileType !== undefined
                 || args.multilineStartLine !== undefined
-                || args.multilineStartLineType !== undefined)) {
+                || args.multilineStartLineType !== undefined
+                || args.fromHash !== undefined
+                || args.toHash !== undefined)) {
             throw new Error('Replies must target an existing comment thread only. Omit filePath/line and other anchor fields when replying.');
         }
         if (args.text === undefined && args.suggestion === undefined) {
@@ -971,11 +1034,14 @@ export class BitbucketClient {
         if (replyToCommentId !== undefined)
             body.parent = { id: replyToCommentId };
         let inlineAnchor;
+        let usedFallbackHashes = false;
+        let currentToHash;
+        let currentFromHash;
+        let remapNote;
         if (args.filePath !== undefined || args.line !== undefined) {
             if (args.filePath === undefined || args.line === undefined) {
                 throw new Error('filePath and line must be provided together for inline comments.');
             }
-            const pr = await this.request('GET', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}`);
             inlineAnchor = {
                 diffType: 'EFFECTIVE',
                 fileType: args.fileType ?? 'TO',
@@ -986,14 +1052,49 @@ export class BitbucketClient {
             if (args.srcPath !== undefined) {
                 inlineAnchor.srcPath = args.srcPath;
             }
-            const fromHash = pr?.toRef.latestCommit;
-            const toHash = pr?.fromRef.latestCommit;
+            const pr = await this.request('GET', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}`).catch(() => null);
+            currentToHash = pr?.fromRef.latestCommit;
+            currentFromHash = pr?.toRef.latestCommit;
+            let fromHash = args.fromHash ?? currentFromHash;
+            let toHash = args.toHash ?? currentToHash;
+            usedFallbackHashes = args.fromHash === undefined && args.toHash === undefined;
+            const fileType = args.fileType ?? 'TO';
+            const reviewedToHash = args.toHash;
+            if (reviewedToHash
+                && currentToHash
+                && reviewedToHash !== currentToHash
+                && fileType === 'TO') {
+                const remappedLine = await this.remapLineThroughDiff(projectKey, repoSlug, args.filePath, reviewedToHash, currentToHash, args.line);
+                let remappedMultilineStart;
+                if (args.multilineStartLine !== undefined) {
+                    remappedMultilineStart = await this.remapLineThroughDiff(projectKey, repoSlug, args.filePath, reviewedToHash, currentToHash, args.multilineStartLine);
+                }
+                const lineOk = remappedLine !== null;
+                const multilineOk = remappedMultilineStart === undefined || remappedMultilineStart !== null;
+                if (lineOk && multilineOk) {
+                    if (remappedLine !== args.line) {
+                        remapNote = `Reviewed line ${args.line} remapped to ${remappedLine} on current head ${currentToHash.slice(0, 8)}.`;
+                    }
+                    inlineAnchor.line = remappedLine;
+                    if (remappedMultilineStart !== undefined && remappedMultilineStart !== null) {
+                        inlineAnchor.multilineStartLine = remappedMultilineStart;
+                    }
+                    toHash = currentToHash;
+                    if (!args.fromHash)
+                        fromHash = currentFromHash;
+                }
+                else {
+                    remapNote = `Reviewed line ${args.line} was modified or removed in interim commits; anchoring to reviewed commit ${reviewedToHash.slice(0, 8)} (Bitbucket will mark the comment outdated, which is correct — the line you reviewed no longer exists at current head).`;
+                }
+            }
             if (fromHash && toHash) {
                 inlineAnchor.fromHash = fromHash;
                 inlineAnchor.toHash = toHash;
             }
-            if (args.multilineStartLine !== undefined) {
+            if (args.multilineStartLine !== undefined && inlineAnchor.multilineStartLine === undefined) {
                 inlineAnchor.multilineStartLine = args.multilineStartLine;
+            }
+            if (inlineAnchor.multilineStartLine !== undefined) {
                 inlineAnchor.multilineStartLineType = args.multilineStartLineType ?? args.lineType ?? 'ADDED';
             }
             body.anchor = inlineAnchor;
@@ -1017,7 +1118,14 @@ export class BitbucketClient {
             return text(`Reply #${created.id} added to comment #${replyToCommentId} on PR #${args.prId}.`);
         }
         const location = args.filePath && args.line ? ` on ${args.filePath}:${args.line}` : '';
-        return text(`Comment #${created.id} added to PR #${args.prId}${location}.`);
+        const warnings = [];
+        if (inlineAnchor && usedFallbackHashes) {
+            warnings.push('No fromHash/toHash passed — anchored to latest PR head. If you reviewed an older commit, the line may now point at unrelated code. Pass fromHash/toHash from bitbucket_pr_diff or bitbucket_get_pr to bind comments to the exact commit you reviewed.');
+        }
+        if (remapNote)
+            warnings.push(remapNote);
+        const warnSuffix = warnings.length ? `\n\nNote: ${warnings.join(' ')}` : '';
+        return text(`Comment #${created.id} added to PR #${args.prId}${location}.${warnSuffix}`);
     }
     async updatePrComment(args) {
         const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);

package/dist/index.js

@@ -372,7 +372,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                         includeComments: { type: 'boolean', description: 'Include review comments and blockers (default true)', default: true },
                         includeDiff: { type: 'boolean', description: 'Include diff text (default false)', default: false },
                         includeBuildStatus: { type: 'boolean', description: 'Include CI/build status for the head commit (default true)', default: true },
-                        commentsState: { type: 'string', enum: ['OPEN', 'RESOLVED', 'PENDING'], description: 'Comment state filter (default OPEN)', default: 'OPEN' },
+                        commentsState: { type: 'string', enum: ['ALL', 'OPEN', 'RESOLVED', 'PENDING'], description: 'Comment state filter (default ALL — returns every comment with its state badge so nothing is silently hidden). Pass OPEN/RESOLVED only when explicitly narrowing.', default: 'ALL' },
                         commentsSeverity: { type: 'string', enum: ['ALL', 'NORMAL', 'BLOCKER'], description: 'Comment severity filter (default ALL)', default: 'ALL' },
                         commentsLimit: { type: 'number', description: 'Max comments (default 50)', default: 50 },
                         commentsStart: { type: 'number', description: 'Comment pagination offset (default 0)', default: 0 },
@@ -422,7 +422,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
             },
             {
                 name: 'bitbucket_comment',
-                description: `Add, update, or delete a PR comment. action defaults to "add". For code changes, ALWAYS use inline comments with suggestion when exact replacement code is available. Keep any explanatory text before the suggestion block only (never after), or Bitbucket may hide Apply suggestion. Replies MUST use commentId. Keep comments concise, no emojis. Only call proactively (without being asked) when you are a reviewer on the PR (i.e. "Viewing as" says "you are a reviewer") — never post unsolicited comments on PRs you authored.`,
+                description: `Add, update, or delete a PR comment. action defaults to "add". For code changes, ALWAYS use inline comments with suggestion when exact replacement code is available. Keep any explanatory text before the suggestion block only (never after), or Bitbucket may hide Apply suggestion. Replies MUST use commentId. Keep comments concise, no emojis. Only call proactively (without being asked) when you are a reviewer on the PR (i.e. "Viewing as" says "you are a reviewer") — never post unsolicited comments on PRs you authored. For inline comments: ALWAYS pass fromHash + toHash matching the commit you actually reviewed (read from bitbucket_pr_diff or bitbucket_get_pr output). Without them the anchor falls back to current PR head, and if the branch advanced between review and post the line number will point at unrelated code.`,
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -441,6 +441,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                         fileType: { type: 'string', enum: ['TO', 'FROM'], description: 'Diff side: TO (new, default) or FROM (old)' },
                         multilineStartLine: { type: 'number', description: 'First line of multiline anchor (pair with line as last line)' },
                         multilineStartLineType: { type: 'string', enum: ['ADDED', 'REMOVED', 'CONTEXT'], description: 'Line type for multilineStartLine' },
+                        fromHash: { type: 'string', description: 'Base/target commit of the diff you reviewed (from bitbucket_pr_diff or bitbucket_get_pr). Pair with toHash so the anchor binds to the exact commit, not whatever the PR head happens to be at post time.' },
+                        toHash: { type: 'string', description: 'Source/feature commit of the diff you reviewed (from bitbucket_pr_diff or bitbucket_get_pr). Pair with fromHash. If the PR has advanced since, Bitbucket will mark the comment outdated — that is the correct behaviour.' },
                         suggestion: { type: 'string', description: 'Replacement code to suggest. Use whenever proposing a concrete code change. Posted as the final ```suggestion``` block so Apply suggestion appears. Requires filePath + line.' },
                         state: { type: 'string', enum: ['OPEN', 'RESOLVED'], description: 'Task state for BLOCKER comments (update only)' },
                         threadResolved: { type: 'boolean', description: 'Resolve/reopen normal comment thread (update only)' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stubbedev/atlassian-mcp",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "MCP server for self-hosted Jira and Bitbucket",
   "license": "MIT",
   "type": "module",