@stubbedev/atlassian-mcp 0.3.2 → 0.3.3

package/dist/bitbucket.js

@@ -133,11 +133,20 @@ function pageHint(data) {
 }
 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 ?? []) {
@@ -327,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);
@@ -495,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}` : '',
             '',
@@ -949,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) {
@@ -974,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',
@@ -989,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;
@@ -1020,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

@@ -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.2",
+  "version": "0.3.3",
   "description": "MCP server for self-hosted Jira and Bitbucket",
   "license": "MIT",
   "type": "module",