@stubbedev/atlassian-mcp 0.4.5 → 0.5.0

package/dist/bitbucket.js

@@ -1,1340 +0,0 @@
-import { execSync } from 'child_process';
-import { createWriteStream } from 'fs';
-import { Readable } from 'stream';
-import { pipeline } from 'stream/promises';
-import { resolve as resolvePath } from 'path';
-import { buildAttachmentResult, formatBytes } from './attachment.js';
-import { MAX_VIDEO_SOURCE_BYTES } from './video.js';
-const EMOJI_RE = /\p{Extended_Pictographic}/u;
-const ATTACHMENT_REF_RE = /!?\[([^\]]*)\]\(attachment:(\d+)\)/g;
-function collectAttachmentRefs(input, source, out) {
-    if (!input)
-        return;
-    ATTACHMENT_REF_RE.lastIndex = 0;
-    let match;
-    while ((match = ATTACHMENT_REF_RE.exec(input)) !== null) {
-        const id = match[2];
-        if (!out.has(id)) {
-            out.set(id, { id, filename: match[1] || '(unnamed)', source });
-        }
-    }
-}
-function collectFromCommentTree(comment, out) {
-    if (comment.deleted)
-        return;
-    collectAttachmentRefs(comment.text, `comment #${comment.id}`, out);
-    for (const reply of comment.comments ?? [])
-        collectFromCommentTree(reply, out);
-}
-function safeExec(cmd) {
-    try {
-        return execSync(cmd, { encoding: 'utf-8' }).trim();
-    }
-    catch {
-        return '';
-    }
-}
-/**
- * Parses a Bitbucket Server remote URL into projectKey + repoSlug.
- * Handles SSH (ssh://git@host/PROJ/repo.git), SCP-like (git@host:PROJ/repo.git),
- * and HTTP (https://host/scm/PROJ/repo.git) formats.
- */
-export function parseBitbucketRemote(remoteUrl) {
-    const sshUrl = remoteUrl.match(/ssh:\/\/[^/]+\/([^/]+)\/([^/]+?)(?:\.git)?$/);
-    if (sshUrl)
-        return { projectKey: sshUrl[1], repoSlug: sshUrl[2] };
-    const scpUrl = remoteUrl.match(/^[^@]+@[^:]+:([^/]+)\/([^/]+?)(?:\.git)?$/);
-    if (scpUrl)
-        return { projectKey: scpUrl[1], repoSlug: scpUrl[2] };
-    const httpUrl = remoteUrl.match(/\/scm\/([^/]+)\/([^/]+?)(?:\.git)?$/);
-    if (httpUrl)
-        return { projectKey: httpUrl[1], repoSlug: httpUrl[2] };
-    return null;
-}
-function text(t) {
-    return { content: [{ type: 'text', text: t }] };
-}
-function toBranchRef(branch) {
-    return branch.startsWith('refs/') ? branch : `refs/heads/${branch}`;
-}
-function branchDisplayId(branch) {
-    return branch.replace(/^refs\/heads\//, '');
-}
-function formatDate(ms) {
-    return new Date(ms).toISOString().slice(0, 10);
-}
-// Cap long free-text (e.g. PR descriptions) so one verbose PR does not flood
-// the model's context. Returns the text untouched when within cap.
-function capText(value, max) {
-    if (max <= 0 || value.length <= max)
-        return value;
-    const more = value.length - max;
-    return `${value.slice(0, max)}\n... (truncated, ${more} more chars — pass fullDescription=true for the rest)`;
-}
-function formatCommentThread(comment, indent = '', depth = 0) {
-    if (depth > 20)
-        return [`${indent}... (deeply nested replies omitted)`];
-    const author = comment.author?.displayName ?? comment.author?.name ?? 'Unknown';
-    const date = comment.createdDate ? ` (${formatDate(comment.createdDate)})` : '';
-    // Show only non-default flags: OPEN state, NORMAL severity and unresolved
-    // threads are the implied baseline, so badge only what deviates. Keeps the
-    // RESOLVED/BLOCKER signal while dropping repeated [OPEN/NORMAL thread=OPEN].
-    const flags = [];
-    if ((comment.state ?? 'OPEN') !== 'OPEN')
-        flags.push(comment.state);
-    if ((comment.severity ?? 'NORMAL') !== 'NORMAL')
-        flags.push(comment.severity);
-    if (comment.threadResolved === true)
-        flags.push('thread=RESOLVED');
-    const flagStr = flags.length > 0 ? ` [${flags.join('/')}]` : '';
-    const lines = [
-        `${indent}#${comment.id}${flagStr} ${author}${date} (v${comment.version})`,
-        `${indent}${comment.text}`,
-    ];
-    if (comment.comments && comment.comments.length > 0) {
-        for (const reply of comment.comments) {
-            lines.push(...formatCommentThread(reply, `${indent}  `, depth + 1));
-        }
-    }
-    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;
-        return (comment.comments ?? []).some((child) => commentMatchesState(child, state));
-    }
-    const currentState = comment.state ?? 'OPEN';
-    if (currentState === state)
-        return true;
-    return (comment.comments ?? []).some((child) => commentMatchesState(child, state));
-}
-function commentMatchesSeverity(comment, severity) {
-    if (severity === 'ALL')
-        return true;
-    const currentSeverity = comment.severity ?? 'NORMAL';
-    if (currentSeverity === severity)
-        return true;
-    return (comment.comments ?? []).some((child) => commentMatchesSeverity(child, severity));
-}
-function uniqueCommentsFromActivities(activities) {
-    const byId = new Map();
-    for (const activity of activities) {
-        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())
-        .filter((comment) => !comment.deleted)
-        .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 ?? []) {
-                    parts.push(`${prefix}${line.line}`);
-                }
-            }
-        }
-    }
-    const result = parts.join('\n');
-    if (!result)
-        return '(no diff)';
-    if (result.length > maxChars) {
-        return result.slice(0, maxChars) + `\n\n... (truncated, ${result.length - maxChars} more chars)`;
-    }
-    return result;
-}
-function parseBitbucketErrorDetails(errText) {
-    const trimmed = errText.trim();
-    if (!trimmed)
-        return '';
-    try {
-        const parsed = JSON.parse(trimmed);
-        if (Array.isArray(parsed.errors) && parsed.errors.length > 0) {
-            const messages = parsed.errors
-                .map((e) => {
-                const msg = e.message?.trim() ?? '';
-                if (!msg)
-                    return '';
-                return e.context ? `${e.context}: ${msg}` : msg;
-            })
-                .filter((m) => m.length > 0);
-            if (messages.length > 0)
-                return messages.join(' | ');
-        }
-    }
-    catch {
-        // Fallback to raw text below
-    }
-    return trimmed.length > 500 ? `${trimmed.slice(0, 500)}...` : trimmed;
-}
-function formatBitbucketError(status, method, path, details) {
-    const prefix = `Bitbucket ${status} ${method} ${path}`;
-    if (status === 400)
-        return `${prefix}. Invalid request or parameters. ${details}`.trim();
-    if (status === 401)
-        return `${prefix}. Authentication failed. Check BITBUCKET_ACCESS_TOKEN.`;
-    if (status === 403)
-        return `${prefix}. Permission denied. Check repository/project permissions for this token.`;
-    if (status === 404)
-        return `${prefix}. Resource not found. Verify project/repo/PR identifiers and access.`;
-    if (status === 409)
-        return `${prefix}. Conflict (often stale version/state). Refresh and retry. ${details}`.trim();
-    return details ? `${prefix}. ${details}` : prefix;
-}
-function validateCommentText(textValue) {
-    const trimmed = textValue.trim();
-    if (!trimmed) {
-        throw new Error('Bitbucket comment text must not be empty.');
-    }
-    if (EMOJI_RE.test(trimmed)) {
-        throw new Error('Bitbucket comments must not include emoji. Use concise plain text only.');
-    }
-    return trimmed;
-}
-function validateSuggestionPlacement(textValue) {
-    if (!textValue.includes('```suggestion'))
-        return;
-    const match = textValue.match(/```suggestion[^\n]*\n[\s\S]*?\n```/);
-    if (!match || match.index === undefined) {
-        throw new Error('Invalid suggestion block format. Use the suggestion field to post code suggestions.');
-    }
-    const trailingText = textValue.slice(match.index + match[0].length).trim();
-    if (trailingText.length > 0) {
-        throw new Error('When using ```suggestion```, do not add text after the closing code fence. Put any explanation before the suggestion block or use the suggestion field.');
-    }
-}
-export class BitbucketClient {
-    baseUrl;
-    headers;
-    currentUsernameCache;
-    constructor(baseUrl, token) {
-        this.baseUrl = baseUrl.replace(/\/$/, '');
-        this.headers = {
-            Authorization: `Bearer ${token}`,
-            'Content-Type': 'application/json',
-            Accept: 'application/json',
-        };
-    }
-    /** Returns the slug/username of the authenticated user via the X-AUSERNAME response header. */
-    async getCurrentUsername() {
-        if (this.currentUsernameCache)
-            return this.currentUsernameCache;
-        const url = `${this.baseUrl}/rest/api/1.0/application-properties`;
-        const res = await fetch(url, { method: 'GET', headers: this.headers });
-        const username = res.headers.get('X-AUSERNAME');
-        if (!username)
-            throw new Error('Could not determine current Bitbucket user. Check token permissions.');
-        this.currentUsernameCache = username;
-        return username;
-    }
-    async whoami() {
-        return this.getCurrentUsername();
-    }
-    /** Returns a URL-safe `/projects/.../repos/...` prefix for REST paths. */
-    rp(projectKey, repoSlug) {
-        return `/projects/${encodeURIComponent(projectKey)}/repos/${encodeURIComponent(repoSlug)}`;
-    }
-    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}`;
-    }
-    configuredHostname() {
-        try {
-            return new URL(this.baseUrl).hostname.toLowerCase();
-        }
-        catch {
-            return '';
-        }
-    }
-    remoteMatchesInstance(remote) {
-        const host = this.configuredHostname();
-        if (!host)
-            return true; // can't validate, allow
-        return remote.toLowerCase().includes(host);
-    }
-    resolveProjectAndRepo(projectKey, repoSlug) {
-        if (projectKey && repoSlug)
-            return { projectKey, repoSlug };
-        const remote = safeExec('git remote get-url origin');
-        if (remote) {
-            if (!this.remoteMatchesInstance(remote)) {
-                throw new Error(`This repo's remote does not point to your configured Bitbucket instance (${this.baseUrl}). ` +
-                    `Bitbucket tools only work with repos hosted on that instance.`);
-            }
-            const parsed = parseBitbucketRemote(remote);
-            if (parsed) {
-                return {
-                    projectKey: projectKey ?? parsed.projectKey,
-                    repoSlug: repoSlug ?? parsed.repoSlug,
-                };
-            }
-        }
-        throw new Error('Could not determine projectKey/repoSlug — provide them explicitly or run from a directory with a Bitbucket remote');
-    }
-    async request(method, path, body) {
-        const url = `${this.baseUrl}/rest/api/1.0${path}`;
-        const opts = { method, headers: this.headers, signal: AbortSignal.timeout(30_000) };
-        if (body !== undefined)
-            opts.body = JSON.stringify(body);
-        const res = await fetch(url, opts);
-        if (!res.ok) {
-            const errText = await res.text();
-            const details = parseBitbucketErrorDetails(errText);
-            throw new Error(formatBitbucketError(res.status, method, path, details));
-        }
-        return res.status === 204 ? null : res.json();
-    }
-    async requestText(path) {
-        const url = `${this.baseUrl}/rest/api/1.0${path}`;
-        const res = await fetch(url, {
-            method: 'GET',
-            headers: { Authorization: this.headers.Authorization },
-            signal: AbortSignal.timeout(30_000),
-        });
-        if (!res.ok) {
-            const errText = await res.text();
-            const details = parseBitbucketErrorDetails(errText);
-            throw new Error(formatBitbucketError(res.status, 'GET', path, details));
-        }
-        return res.text();
-    }
-    async requestBuildStatus(method, path, body) {
-        const url = `${this.baseUrl}/rest/build-status/1.0${path}`;
-        const opts = { method, headers: this.headers, signal: AbortSignal.timeout(30_000) };
-        if (body !== undefined)
-            opts.body = JSON.stringify(body);
-        const res = await fetch(url, opts);
-        if (res.status === 404)
-            return null; // no build status yet
-        if (!res.ok) {
-            const errText = await res.text();
-            const details = parseBitbucketErrorDetails(errText);
-            throw new Error(formatBitbucketError(res.status, method, path, details));
-        }
-        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);
-    }
-    // Used internally by context tools — finds the open PR for a given source branch.
-    // Uses the `at` filter to avoid paginating all open PRs.
-    async findOpenPrForBranch(projectKey, repoSlug, branch) {
-        const atRef = encodeURIComponent(toBranchRef(branch));
-        const encodedProject = encodeURIComponent(projectKey);
-        const encodedRepo = encodeURIComponent(repoSlug);
-        const data = await this.request('GET', `/projects/${encodedProject}/repos/${encodedRepo}/pull-requests?state=OPEN&direction=OUTGOING&at=${atRef}&limit=1`);
-        return data?.values[0] ?? null;
-    }
-    // Fallback: search branches matching filterText and check each for an open PR.
-    // Used when exact branch name lookup yields no result (e.g. LLM provides a partial branch name).
-    async findOpenPrByBranchFilter(projectKey, repoSlug, filterText) {
-        const branches = await this.request('GET', `${this.rp(projectKey, repoSlug)}/branches?limit=25&filterText=${encodeURIComponent(filterText)}`);
-        if (!branches?.values?.length)
-            return null;
-        for (const b of branches.values) {
-            const pr = await this.findOpenPrForBranch(projectKey, repoSlug, b.displayId);
-            if (pr)
-                return pr;
-        }
-        return null;
-    }
-    async listRepos(args) {
-        const { limit = 50, start = 0 } = args;
-        const qs = `?limit=${limit}&start=${start}`;
-        const path = args.projectKey
-            ? `/projects/${encodeURIComponent(args.projectKey)}/repos${qs}`
-            : `/repos${qs}`;
-        const data = await this.request('GET', path);
-        if (!data || data.values.length === 0)
-            return text('No repositories found.');
-        const lines = data.values.map((r, i) => `${start + i + 1}. ${r.project.key}/${r.slug} — ${r.name}`);
-        return text(`${data.values.length} repo(s)${pageHint(data)}:\n${lines.join('\n')}`);
-    }
-    async searchUsers(args) {
-        const params = new URLSearchParams();
-        if (args.query)
-            params.set('filter', args.query);
-        params.set('limit', String(args.limit ?? 25));
-        if (args.start)
-            params.set('start', String(args.start));
-        let path;
-        if (args.projectKey && args.repoSlug) {
-            path = `${this.rp(args.projectKey, args.repoSlug)}/permissions/users?${params}`;
-        }
-        else if (args.projectKey) {
-            path = `/projects/${encodeURIComponent(args.projectKey)}/permissions/users?${params}`;
-        }
-        else {
-            path = `/users?${params}`;
-        }
-        const data = await this.request('GET', path);
-        if (!data || data.values.length === 0)
-            return text('No users found.');
-        const lines = data.values.map((entry, i) => {
-            const user = entry.user ?? entry;
-            const parts = [`${i + 1}. ${user.displayName} (${user.name})`];
-            if (user.emailAddress)
-                parts.push(`— ${user.emailAddress}`);
-            if (user.active === false)
-                parts.push('[inactive]');
-            return parts.join(' ');
-        });
-        return text(`${data.values.length} user(s)${pageHint(data)}:\n${lines.join('\n')}`);
-    }
-    async searchUsersRaw(args) {
-        const params = new URLSearchParams();
-        if (args.query)
-            params.set('filter', args.query);
-        params.set('limit', String(args.limit ?? 50));
-        let path;
-        if (args.projectKey && args.repoSlug) {
-            path = `${this.rp(args.projectKey, args.repoSlug)}/permissions/users?${params}`;
-        }
-        else if (args.projectKey) {
-            path = `/projects/${encodeURIComponent(args.projectKey)}/permissions/users?${params}`;
-        }
-        else {
-            path = `/users?${params}`;
-        }
-        const data = await this.request('GET', path);
-        return (data?.values ?? []).map((entry) => entry.user ?? entry);
-    }
-    async listPullRequests(args) {
-        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
-        const { state = 'OPEN', fromBranch, text: searchText, limit = 25, start = 0 } = args;
-        const qs = new URLSearchParams({ state, limit: String(limit), start: String(start) });
-        if (fromBranch) {
-            qs.set('at', toBranchRef(fromBranch));
-            qs.set('direction', 'OUTGOING');
-        }
-        if (searchText)
-            qs.set('filterText', searchText);
-        const path = `/projects/${encodeURIComponent(projectKey)}/repos/${encodeURIComponent(repoSlug)}/pull-requests?${qs}`;
-        const data = await this.request('GET', path);
-        if (!data || data.values.length === 0)
-            return text(`No ${state} pull requests found.`);
-        const lines = data.values.map((pr) => `#${pr.id} [${pr.state}] ${pr.title} | ${pr.fromRef.displayId} → ${pr.toRef.displayId} | by ${pr.author.user.displayName}`);
-        return text(`${data.values.length} PR(s) (${state})${pageHint(data)}:\n${lines.join('\n')}`);
-    }
-    async myPrs(args) {
-        const { limit = 25, start = 0, role } = args;
-        const qs = new URLSearchParams({ limit: String(limit), start: String(start), state: 'OPEN' });
-        if (role)
-            qs.set('role', role.toUpperCase());
-        const data = await this.request('GET', `/dashboard/pull-requests?${qs}`);
-        if (!data || data.values.length === 0)
-            return text('No pull requests found.');
-        const lines = data.values.map((pr) => {
-            const repo = `${pr.toRef.repository.project.key}/${pr.toRef.repository.slug}`;
-            return `#${pr.id} [${pr.state}] ${pr.title} | ${repo} | ${pr.fromRef.displayId} → ${pr.toRef.displayId}`;
-        });
-        return text(`${data.values.length} PR(s)${pageHint(data)}:\n${lines.join('\n')}`);
-    }
-    async getPullRequest(args) {
-        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
-        const data = await this.request('GET', `/projects/${encodeURIComponent(projectKey)}/repos/${encodeURIComponent(repoSlug)}/pull-requests/${args.prId}`);
-        if (!data)
-            return text('Pull request not found.');
-        const reviewers = data.reviewers
-            .map((r) => `${r.user.displayName}${r.approved ? ' ✓' : ''}`)
-            .join(', ');
-        const lines = [
-            `PR #${data.id}: ${data.title}`,
-            `State:     ${data.state}`,
-            `Author:    ${data.author.user.displayName}`,
-            `Branch:    ${data.fromRef.displayId} → ${data.toRef.displayId}`,
-            `Reviewers: ${reviewers || 'None'}`,
-            '',
-            'Description:',
-            data.description ?? '(no description)',
-        ];
-        return text(lines.join('\n'));
-    }
-    async getPrOverview(args) {
-        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
-        const includeCommits = args.includeCommits ?? true;
-        const includeComments = args.includeComments ?? true;
-        const includeDiff = args.includeDiff ?? false;
-        const includeBuildStatus = args.includeBuildStatus ?? true;
-        const descriptionCap = args.fullDescription ? 0 : args.descriptionMaxChars ?? 2000;
-        let prId = args.prId;
-        if (prId === undefined) {
-            const branch = args.fromBranch ?? safeExec('git rev-parse --abbrev-ref HEAD');
-            if (!branch || branch === 'HEAD') {
-                throw new Error('Provide prId or fromBranch, or run from a checked-out branch.');
-            }
-            let found = await this.findOpenPrForBranch(projectKey, repoSlug, branch);
-            if (!found) {
-                // Fallback: search branches matching the input text, then check those for open PRs
-                found = await this.findOpenPrByBranchFilter(projectKey, repoSlug, branchDisplayId(branch));
-            }
-            if (!found)
-                throw new Error(`No open PR found for branch "${branchDisplayId(branch)}".`);
-            prId = found.id;
-        }
-        const pr = await this.request('GET', `${this.rp(projectKey, repoSlug)}/pull-requests/${prId}`);
-        if (!pr)
-            return text('Pull request not found.');
-        const sections = [];
-        const attachmentRefs = new Map();
-        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}` : '',
-            '',
-            'Description:',
-            pr.description ? capText(pr.description, descriptionCap) : '(no description)',
-        ].filter((line) => line !== '');
-        sections.push(header.join('\n'));
-        if (includeBuildStatus && pr.fromRef.latestCommit) {
-            const statuses = await this.requestBuildStatus('GET', `/commits/${pr.fromRef.latestCommit}`).catch(() => null);
-            if (statuses?.values?.length) {
-                const statusLines = statuses.values.map((s) => {
-                    const icon = s.state === 'SUCCESSFUL' ? '✓' : s.state === 'FAILED' ? '✗' : '…';
-                    const urlPart = s.url ? `\n   URL: ${s.url}` : '';
-                    return `${icon} [${s.state}] ${s.name ?? s.key}${s.description ? ` — ${s.description}` : ''}${urlPart}`;
-                });
-                sections.push(`Build status (${pr.fromRef.latestCommit.slice(0, 8)}):\n${statusLines.join('\n')}`);
-            }
-            else {
-                sections.push(`Build status: none reported for ${pr.fromRef.latestCommit.slice(0, 8)}`);
-            }
-        }
-        if (includeCommits) {
-            const commitsLimit = args.commitsLimit ?? 25;
-            const commitsStart = args.commitsStart ?? 0;
-            const data = await this.request('GET', `${this.rp(projectKey, repoSlug)}/pull-requests/${prId}/commits?limit=${commitsLimit}&start=${commitsStart}`);
-            if (!data || data.values.length === 0) {
-                sections.push('Commits:\n(no commits found)');
-            }
-            else {
-                const lines = data.values.map((c) => `${c.displayId} ${formatDate(c.authorTimestamp)} ${c.author.name}: ${c.message.split('\n')[0]}`);
-                sections.push(`Commits (${data.values.length})${pageHint(data)}:\n${lines.join('\n')}`);
-            }
-        }
-        if (includeComments) {
-            const commentsLimit = args.commentsLimit ?? 50;
-            const commentsStart = args.commentsStart ?? 0;
-            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, RESOLVED, or ALL.');
-            }
-            if (commentsSeverity === 'BLOCKER') {
-                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)`);
-                }
-                else {
-                    for (const comment of data.values)
-                        collectFromCommentTree(comment, attachmentRefs);
-                    const blocks = data.values.flatMap((comment) => formatCommentThread(comment));
-                    sections.push(`Comments (${data.values.length} BLOCKER thread(s))${pageHint(data)}:\n\n${blocks.join('\n\n')}`);
-                }
-            }
-            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 = commentsState === 'ALL' ? true : commentMatchesState(comment, commentsState);
-                    return matchesState && commentMatchesSeverity(comment, commentsSeverity);
-                });
-                for (const comment of comments)
-                    collectFromCommentTree(comment, attachmentRefs);
-                if (comments.length === 0) {
-                    sections.push('Comments:\n(no matching comments)');
-                }
-                else {
-                    const blocks = comments.flatMap((comment) => formatCommentThread(comment));
-                    const paging = activityData ? pageHint(activityData) : '';
-                    sections.push(`Comments (${comments.length} thread(s), newest first)${paging}:\n\n${blocks.join('\n\n')}`);
-                }
-            }
-        }
-        if (attachmentRefs.size > 0) {
-            const lines = [`Attachments referenced: ${attachmentRefs.size}`];
-            for (const ref of attachmentRefs.values()) {
-                lines.push(`  #${ref.id} ${ref.filename} — in ${ref.source}`);
-            }
-            lines.push('Use bitbucket_get_attachment with attachmentId to view contents.');
-            sections.push(lines.join('\n'));
-        }
-        if (includeDiff) {
-            const data = await this.request('GET', `${this.rp(projectKey, repoSlug)}/pull-requests/${prId}/diff`);
-            sections.push(`Diff:\n${data ? formatDiff(data, args.diffMaxChars ?? 8000) : '(no diff found)'}`);
-        }
-        return text(sections.join('\n\n'));
-    }
-    async getPrDiff(args) {
-        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
-        const data = await this.request('GET', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}/diff`);
-        if (!data)
-            return text('No diff found.');
-        return text(formatDiff(data));
-    }
-    async getPrCommits(args) {
-        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
-        const limit = args.limit ?? 25;
-        const start = args.start ?? 0;
-        const data = await this.request('GET', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}/commits?limit=${limit}&start=${start}`);
-        if (!data || data.values.length === 0)
-            return text('No commits found.');
-        const lines = data.values.map((c) => `${c.displayId} ${formatDate(c.authorTimestamp)} ${c.author.name}: ${c.message.split('\n')[0]}`);
-        return text(`${data.values.length} commit(s)${pageHint(data)}:\n${lines.join('\n')}`);
-    }
-    async createPullRequest(args) {
-        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
-        const sourceBranch = args.fromBranch ?? safeExec('git rev-parse --abbrev-ref HEAD');
-        if (!sourceBranch || sourceBranch === 'HEAD') {
-            throw new Error('Could not determine source branch. Provide fromBranch or run from a checked-out branch.');
-        }
-        const sourceBranchName = branchDisplayId(sourceBranch);
-        const existing = await this.findOpenPrForBranch(projectKey, repoSlug, sourceBranchName);
-        if (existing) {
-            const url = this.pullRequestUrl(projectKey, repoSlug, existing.id, existing);
-            return text(`Open PR already exists for branch "${sourceBranchName}": #${existing.id} "${existing.title}"\n${url}`);
-        }
-        const { title, description, reviewers = [] } = args;
-        const toRef = args.toBranch
-            ? toBranchRef(args.toBranch)
-            : await this.getDefaultBranchRef(projectKey, repoSlug);
-        const body = {
-            title,
-            description: description ?? '',
-            fromRef: { id: toBranchRef(sourceBranch), repository: { slug: repoSlug, project: { key: projectKey } } },
-            toRef: { id: toRef, repository: { slug: repoSlug, project: { key: projectKey } } },
-            reviewers: reviewers.map((name) => ({ user: { name } })),
-        };
-        const data = await this.request('POST', `${this.rp(projectKey, repoSlug)}/pull-requests`, body);
-        if (!data)
-            return text('Pull request created.');
-        const url = this.pullRequestUrl(projectKey, repoSlug, data.id, data);
-        return text(`Created PR #${data.id}: "${data.title}"\n${url}`);
-    }
-    async updatePullRequest(args) {
-        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
-        if (args.title === undefined
-            && args.description === undefined
-            && args.toBranch === undefined
-            && args.reviewers === undefined) {
-            throw new Error('At least one field is required: title, description, toBranch, or reviewers');
-        }
-        const existing = await this.request('GET', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}`);
-        if (!existing)
-            throw new Error(`PR #${args.prId} not found.`);
-        const buildBody = (pr) => {
-            const body = { version: pr.version };
-            if (args.title !== undefined)
-                body.title = args.title;
-            if (args.description !== undefined)
-                body.description = args.description;
-            if (args.toBranch !== undefined) {
-                body.toRef = {
-                    id: toBranchRef(args.toBranch),
-                    repository: { slug: repoSlug, project: { key: projectKey } },
-                };
-            }
-            // Always include reviewers to avoid Bitbucket clearing them on PUT.
-            // Only replace them when explicitly provided by the caller.
-            body.reviewers = args.reviewers !== undefined
-                ? args.reviewers.map((name) => ({ user: { name } }))
-                : pr.reviewers.map((r) => ({ user: { name: r.user.name } }));
-            return body;
-        };
-        let updated;
-        try {
-            updated = await this.request('PUT', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}`, buildBody(existing));
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            if (!message.includes('Bitbucket 409'))
-                throw error;
-            const latest = await this.request('GET', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}`);
-            if (!latest)
-                throw error;
-            updated = await this.request('PUT', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}`, buildBody(latest));
-        }
-        if (!updated)
-            return text(`Updated PR #${args.prId}.`);
-        const url = this.pullRequestUrl(projectKey, repoSlug, updated.id, updated);
-        return text(`Updated PR #${updated.id}: "${updated.title}" (${updated.fromRef.displayId} → ${updated.toRef.displayId}).\n${url}`);
-    }
-    async mutatePullRequest(args) {
-        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
-        const hasUpdate = args.update !== undefined && (args.update.title !== undefined
-            || args.update.description !== undefined
-            || args.update.toBranch !== undefined
-            || args.update.reviewers !== undefined);
-        if (args.prId !== undefined) {
-            if (!hasUpdate) {
-                return this.getPullRequest({ projectKey, repoSlug, prId: args.prId });
-            }
-            return this.updatePullRequest({
-                projectKey,
-                repoSlug,
-                prId: args.prId,
-                ...args.update,
-            });
-        }
-        const sourceBranch = args.create?.fromBranch ?? safeExec('git rev-parse --abbrev-ref HEAD');
-        if (!sourceBranch || sourceBranch === 'HEAD') {
-            if (args.create) {
-                return this.createPullRequest({
-                    projectKey,
-                    repoSlug,
-                    title: args.create.title,
-                    description: args.create.description,
-                    fromBranch: args.create.fromBranch,
-                    toBranch: args.create.toBranch,
-                    reviewers: args.create.reviewers,
-                });
-            }
-            throw new Error('Could not determine source branch. Provide create.fromBranch or run from a checked-out branch.');
-        }
-        const existing = await this.findOpenPrForBranch(projectKey, repoSlug, sourceBranch);
-        if (existing) {
-            if (hasUpdate) {
-                return this.updatePullRequest({
-                    projectKey,
-                    repoSlug,
-                    prId: existing.id,
-                    ...args.update,
-                });
-            }
-            return this.getPullRequest({ projectKey, repoSlug, prId: existing.id });
-        }
-        if (!args.create) {
-            throw new Error(`No open PR found for branch "${branchDisplayId(sourceBranch)}". Provide create to open one.`);
-        }
-        return this.createPullRequest({
-            projectKey,
-            repoSlug,
-            title: args.create.title,
-            description: args.create.description,
-            fromBranch: args.create.fromBranch,
-            toBranch: args.create.toBranch,
-            reviewers: args.create.reviewers,
-        });
-    }
-    async approvePr(args) {
-        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
-        const data = await this.request('POST', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}/approve`);
-        const url = this.pullRequestUrl(projectKey, repoSlug, args.prId);
-        if (!data)
-            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', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}/approve`);
-        return text(`Approval removed from PR #${args.prId}.\n${this.pullRequestUrl(projectKey, repoSlug, args.prId)}`);
-    }
-    async needsWorkPr(args) {
-        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
-        const userSlug = await this.getCurrentUsername();
-        const data = await this.request('PUT', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}/participants/${encodeURIComponent(userSlug)}`, { user: { name: userSlug }, approved: false, status: 'NEEDS_WORK' });
-        const url = this.pullRequestUrl(projectKey, repoSlug, args.prId);
-        if (!data)
-            return text(`Marked PR #${args.prId} as Needs work.\n${url}`);
-        return text(`Marked PR #${args.prId} as Needs work as ${data.user.displayName}.\n${url}`);
-    }
-    async declinePr(args) {
-        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
-        const pr = await this.request('GET', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}`);
-        if (!pr)
-            throw new Error(`PR #${args.prId} not found.`);
-        const body = { version: pr.version };
-        if (args.message)
-            body.message = args.message;
-        const data = await this.request('POST', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}/decline`, body);
-        if (!data)
-            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);
-        const pr = await this.request('GET', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}`);
-        if (!pr)
-            throw new Error(`PR #${args.prId} not found.`);
-        const body = { version: pr.version };
-        if (args.mergeStrategy)
-            body.strategyId = args.mergeStrategy;
-        if (args.message)
-            body.message = args.message;
-        const data = await this.request('POST', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}/merge`, body);
-        if (!data)
-            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 getDefaultBranchRef(projectKey, repoSlug) {
-        const data = await this.request('GET', `${this.rp(projectKey, repoSlug)}/default-branch`);
-        if (data?.displayId)
-            return `refs/heads/${data.displayId}`;
-        // Fallback: detect from local git
-        const head = safeExec('git rev-parse --abbrev-ref origin/HEAD');
-        if (head.startsWith('origin/'))
-            return `refs/heads/${head.slice('origin/'.length)}`;
-        return 'refs/heads/master';
-    }
-    async createBranch(args) {
-        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
-        const startPoint = args.startPoint ?? await this.getDefaultBranchRef(projectKey, repoSlug);
-        const data = await this.request('POST', `${this.rp(projectKey, repoSlug)}/branches`, { name: args.branchName, startPoint });
-        if (!data)
-            return text(`Branch "${args.branchName}" created.`);
-        return text(`Created branch "${data.displayId}" at ${data.latestCommit.slice(0, 8)} in ${projectKey}/${repoSlug}.`);
-    }
-    async getBranches(args) {
-        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
-        const qs = new URLSearchParams({ limit: String(args.limit ?? 25), start: String(args.start ?? 0) });
-        if (args.filter)
-            qs.set('filterText', args.filter);
-        const data = await this.request('GET', `${this.rp(projectKey, repoSlug)}/branches?${qs}`);
-        if (!data || data.values.length === 0)
-            return text('No branches found.');
-        const lines = data.values.map((b) => `${b.displayId}${b.isDefault ? ' (default)' : ''} — ${b.latestCommit.slice(0, 8)}`);
-        return text(`${data.values.length} branch(es)${pageHint(data)}:\n${lines.join('\n')}`);
-    }
-    async getFile(args) {
-        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
-        const qs = args.ref ? `?at=${encodeURIComponent(args.ref)}` : '';
-        const encodedPath = args.path.split('/').map(encodeURIComponent).join('/');
-        const content = await this.requestText(`${this.rp(projectKey, repoSlug)}/raw/${encodedPath}${qs}`);
-        const MAX_CHARS = 10000;
-        if (content.length > MAX_CHARS) {
-            return text(content.slice(0, MAX_CHARS) + `\n\n... (truncated, ${content.length - MAX_CHARS} more chars)`);
-        }
-        return text(content);
-    }
-    async getAttachment(args) {
-        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
-        const id = String(args.attachmentId ?? '').trim();
-        if (!id)
-            throw new Error('attachmentId is required.');
-        const url = `${this.baseUrl}/rest/api/1.0${this.rp(projectKey, repoSlug)}/attachments/${encodeURIComponent(id)}`;
-        const fetchTimeoutMs = args.saveTo ? 300_000 : 60_000;
-        const res = await fetch(url, {
-            method: 'GET',
-            headers: { Authorization: this.headers.Authorization },
-            signal: AbortSignal.timeout(fetchTimeoutMs),
-        });
-        if (!res.ok) {
-            const errText = await res.text();
-            throw new Error(formatBitbucketError(res.status, 'GET', `${this.rp(projectKey, repoSlug)}/attachments/${id}`, parseBitbucketErrorDetails(errText)));
-        }
-        const contentDisposition = res.headers.get('content-disposition') ?? '';
-        const filenameMatch = contentDisposition.match(/filename\*?=(?:UTF-8'')?"?([^";]+)"?/i);
-        const filename = filenameMatch ? decodeURIComponent(filenameMatch[1]) : `attachment-${id}`;
-        const mimeType = (res.headers.get('content-type') ?? 'application/octet-stream').split(';')[0].trim();
-        const declaredLength = parseInt(res.headers.get('content-length') ?? '0', 10);
-        // saveTo path: stream directly to disk so we never buffer the whole attachment in memory.
-        if (args.saveTo) {
-            const path = resolvePath(args.saveTo);
-            if (!res.body)
-                throw new Error(`Attachment #${id} response has no body.`);
-            await pipeline(Readable.fromWeb(res.body), createWriteStream(path));
-            const sizeLabel = declaredLength > 0 ? formatBytes(declaredLength) : 'unknown size';
-            return { content: [{ type: 'text', text: `Saved attachment #${id} (${filename} — ${mimeType}, ${sizeLabel}) to ${path}` }] };
-        }
-        if (declaredLength > MAX_VIDEO_SOURCE_BYTES) {
-            try {
-                await res.body?.cancel();
-            }
-            catch { /* ignore */ }
-            throw new Error(`Attachment #${id} is ${formatBytes(declaredLength)}, exceeds the ${formatBytes(MAX_VIDEO_SOURCE_BYTES)} inline cap. Pass saveTo=/absolute/path to stream it to disk.`);
-        }
-        const buffer = Buffer.from(await res.arrayBuffer());
-        if (buffer.length > MAX_VIDEO_SOURCE_BYTES) {
-            throw new Error(`Attachment #${id} downloaded ${formatBytes(buffer.length)}, exceeds the ${formatBytes(MAX_VIDEO_SOURCE_BYTES)} inline cap. Pass saveTo=/absolute/path to stream it to disk.`);
-        }
-        return buildAttachmentResult({
-            id,
-            filename,
-            mimeType,
-            buffer,
-            maxDimension: args.maxDimension,
-            quality: args.quality,
-            frames: args.frames,
-            start: args.start,
-            end: args.end,
-            mode: args.mode,
-            sceneThreshold: args.sceneThreshold,
-        });
-    }
-    async fetchFileText(projectKey, repoSlug, filePath) {
-        try {
-            const encoded = filePath.split('/').map(encodeURIComponent).join('/');
-            const content = await this.requestText(`${this.rp(projectKey, repoSlug)}/raw/${encoded}`);
-            return content;
-        }
-        catch {
-            return null;
-        }
-    }
-    async getPrComments(args) {
-        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
-        const limit = args.limit ?? 50;
-        const start = args.start ?? 0;
-        const severity = args.severity ?? 'ALL';
-        const state = args.state ?? (args.countOnly ? undefined : 'OPEN');
-        if (args.countOnly) {
-            if (severity !== 'BLOCKER') {
-                throw new Error('countOnly is supported only for BLOCKER severity. Set severity="BLOCKER".');
-            }
-            if (state === 'PENDING') {
-                throw new Error('PENDING is not valid for blocker comment counts. Use OPEN or RESOLVED.');
-            }
-            const qs = new URLSearchParams({ count: 'true' });
-            if (state)
-                qs.set('state', state);
-            const data = await this.request('GET', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}/blocker-comments?${qs}`);
-            let open = data?.open ?? 0;
-            let resolved = data?.resolved ?? 0;
-            if ((open === 0 && resolved === 0) && data?.values && data.values.length > 0) {
-                for (const v of data.values) {
-                    if ((v.state ?? '').toUpperCase() === 'OPEN')
-                        open = v.count ?? open;
-                    if ((v.state ?? '').toUpperCase() === 'RESOLVED')
-                        resolved = v.count ?? resolved;
-                }
-            }
-            if (state === 'OPEN')
-                return text(`PR #${args.prId} BLOCKER comments: OPEN=${open}`);
-            if (state === 'RESOLVED')
-                return text(`PR #${args.prId} BLOCKER comments: RESOLVED=${resolved}`);
-            return text(`PR #${args.prId} BLOCKER comments: OPEN=${open}, RESOLVED=${resolved}`);
-        }
-        if (severity === 'BLOCKER' && !args.path) {
-            if (state === 'PENDING') {
-                throw new Error('PENDING is not valid for blocker comments. Use OPEN or RESOLVED.');
-            }
-            const qs = new URLSearchParams({ limit: String(limit), start: String(start) });
-            if (state)
-                qs.set('state', state);
-            const data = await this.request('GET', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}/blocker-comments?${qs}`);
-            if (!data || data.values.length === 0) {
-                return text(`No ${state ?? 'OPEN/RESOLVED'} BLOCKER comments on PR #${args.prId}.`);
-            }
-            const blocks = data.values.flatMap((comment) => formatCommentThread(comment));
-            return text(`${data.values.length} ${state ?? 'OPEN/RESOLVED'} BLOCKER comment thread(s) on PR #${args.prId}${pageHint(data)}:\n\n${blocks.join('\n\n')}`);
-        }
-        if (args.path) {
-            const qs = new URLSearchParams({
-                limit: String(limit),
-                start: String(start),
-                path: args.path,
-            });
-            if (state)
-                qs.set('state', state);
-            const data = await this.request('GET', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}/comments?${qs}`);
-            const filtered = (data?.values ?? []).filter((comment) => {
-                const matchesState = state ? commentMatchesState(comment, state) : true;
-                return matchesState && commentMatchesSeverity(comment, severity);
-            });
-            if (filtered.length === 0) {
-                return text(`No matching comments on PR #${args.prId} for path ${args.path}.`);
-            }
-            const blocks = filtered.flatMap((comment) => formatCommentThread(comment));
-            const paging = data ? pageHint(data) : '';
-            return text(`${filtered.length} comment thread(s) on PR #${args.prId} for ${args.path}${paging}:\n\n${blocks.join('\n\n')}`);
-        }
-        const activityData = await this.request('GET', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}/activities?limit=${limit}&start=${start}`);
-        const comments = uniqueCommentsFromActivities(activityData?.values ?? []).filter((comment) => {
-            const matchesState = state ? commentMatchesState(comment, state) : true;
-            return matchesState && commentMatchesSeverity(comment, severity);
-        });
-        if (comments.length === 0) {
-            return text(`No matching comments on PR #${args.prId}.`);
-        }
-        const blocks = comments.flatMap((comment) => formatCommentThread(comment));
-        const paging = activityData ? pageHint(activityData) : '';
-        return text(`${comments.length} comment thread(s) on PR #${args.prId}${paging}:\n\n${blocks.join('\n\n')}`);
-    }
-    async addPrComment(args) {
-        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
-        const replyToCommentId = args.commentId;
-        if (replyToCommentId !== undefined
-            && (args.filePath !== undefined
-                || args.srcPath !== undefined
-                || args.line !== undefined
-                || args.lineType !== undefined
-                || args.fileType !== undefined
-                || args.multilineStartLine !== 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 (replyToCommentId !== undefined) {
-            const parent = await this.request('GET', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}/comments/${replyToCommentId}`).catch(() => null);
-            if (parent) {
-                const me = await this.getCurrentUsername();
-                const existingReply = (parent.comments ?? []).find((r) => !r.deleted && r.author?.name === me);
-                if (existingReply) {
-                    throw new Error(`You already replied to comment #${replyToCommentId} (your reply is #${existingReply.id}). Never post a second reply on the same thread — update your existing reply instead: action=update commentId=${existingReply.id}.`);
-                }
-            }
-        }
-        if (args.text === undefined && args.suggestion === undefined) {
-            throw new Error('Either text or suggestion is required when adding a comment.');
-        }
-        let commentText = args.text ?? '';
-        if (args.suggestion !== undefined) {
-            const suggestion = args.suggestion.trim();
-            if (!suggestion) {
-                throw new Error('suggestion must not be empty.');
-            }
-            const suggestionBlock = `\`\`\`suggestion\n${suggestion}\n\`\`\``;
-            const prefix = (args.text ?? '').trim();
-            commentText = prefix ? `${prefix}\n\n${suggestionBlock}` : suggestionBlock;
-        }
-        else {
-            validateSuggestionPlacement(commentText);
-        }
-        // Adding a comment must never create a task. In Bitbucket Server a comment with
-        // severity=BLOCKER renders as a PR task; tasks are created only via
-        // bitbucket_pr_tasks, and only when explicitly requested. Reject the BLOCKER
-        // severity here so an inline review comment can never silently become a task.
-        if (args.severity === 'BLOCKER') {
-            throw new Error('Adding a comment never creates a task. Omit severity (comments post as NORMAL). To create a task, use bitbucket_pr_tasks (action=create) — only when the user explicitly asks for one.');
-        }
-        const body = { text: validateCommentText(commentText) };
-        if (args.severity)
-            body.severity = args.severity;
-        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.');
-            }
-            inlineAnchor = {
-                diffType: 'EFFECTIVE',
-                fileType: args.fileType ?? 'TO',
-                line: args.line,
-                lineType: args.lineType ?? 'ADDED',
-                path: args.filePath,
-            };
-            if (args.srcPath !== undefined) {
-                inlineAnchor.srcPath = args.srcPath;
-            }
-            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 && inlineAnchor.multilineStartLine === undefined) {
-                inlineAnchor.multilineStartLine = args.multilineStartLine;
-            }
-            if (inlineAnchor.multilineStartLine !== undefined) {
-                inlineAnchor.multilineStartLineType = args.multilineStartLineType ?? args.lineType ?? 'ADDED';
-            }
-            body.anchor = inlineAnchor;
-        }
-        let created;
-        try {
-            created = await this.request('POST', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}/comments`, body);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            if (!inlineAnchor || !message.includes('Bitbucket 409') || !('fromHash' in inlineAnchor) || !('toHash' in inlineAnchor)) {
-                throw error;
-            }
-            const { fromHash: _fromHash, toHash: _toHash, ...anchorWithoutHashes } = inlineAnchor;
-            body.anchor = anchorWithoutHashes;
-            created = await this.request('POST', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}/comments`, body);
-        }
-        if (!created)
-            return text(`Comment added to PR #${args.prId}.`);
-        if (replyToCommentId !== undefined) {
-            return text(`Reply #${created.id} added to comment #${replyToCommentId} on PR #${args.prId}.`);
-        }
-        const location = args.filePath && args.line ? ` on ${args.filePath}:${args.line}` : '';
-        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);
-        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', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}/comments/${args.commentId}`);
-        if (!current)
-            throw new Error(`Comment #${args.commentId} not found.`);
-        const currentSeverity = current.severity ?? 'NORMAL';
-        const targetSeverity = args.severity ?? currentSeverity;
-        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')
-            ? `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}/blocker-comments/${args.commentId}`
-            : `${this.rp(projectKey, 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;
-        };
-        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';
-        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);
-        const current = await this.request('GET', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}/comments/${args.commentId}`);
-        if (!current)
-            throw new Error(`Comment #${args.commentId} not found.`);
-        const commentPath = current.severity === 'BLOCKER'
-            ? `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}/blocker-comments/${args.commentId}`
-            : `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}/comments/${args.commentId}`;
-        const path = `${commentPath}?version=${current.version}`;
-        await this.request('DELETE', path);
-        return text(`Comment #${args.commentId} deleted from PR #${args.prId}.`);
-    }
-    async getPrTasks(args) {
-        const { projectKey, repoSlug } = this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
-        const data = await this.request('GET', `${this.rp(projectKey, repoSlug)}/pull-requests/${args.prId}/tasks`);
-        if (!data || data.values.length === 0)
-            return text(`No tasks on PR #${args.prId}.`);
-        const lines = data.values.map((t) => {
-            const author = t.author?.displayName ?? t.author?.name ?? 'Unknown';
-            const date = t.createdDate ? ` (${formatDate(t.createdDate)})` : '';
-            const anchor = t.anchor?.id ? ` [on comment #${t.anchor.id}]` : '';
-            return `#${t.id} [${t.state}] ${author}${date}${anchor}: ${t.text}`;
-        });
-        const open = data.values.filter((t) => t.state === 'OPEN').length;
-        return text(`${data.values.length} task(s) on PR #${args.prId} (${open} open)${pageHint(data)}:\n${lines.join('\n')}`);
-    }
-    async mutatePrTask(args) {
-        this.resolveProjectAndRepo(args.projectKey, args.repoSlug);
-        if (args.action === 'create') {
-            if (!args.text)
-                throw new Error('text is required to create a task.');
-            const body = { text: args.text };
-            if (args.commentId !== undefined) {
-                body.anchor = { id: args.commentId, type: 'COMMENT' };
-            }
-            else if (args.prId !== undefined) {
-                body.anchor = { id: args.prId, type: 'PULL_REQUEST' };
-            }
-            else {
-                throw new Error('Provide prId or commentId to anchor the task.');
-            }
-            const created = await this.request('POST', '/tasks', body);
-            if (!created)
-                return text('Task created.');
-            return text(`Task #${created.id} created: "${created.text}"`);
-        }
-        if (!args.taskId)
-            throw new Error('taskId is required for resolve/reopen/delete.');
-        if (args.action === 'delete') {
-            const task = await this.request('GET', `/tasks/${args.taskId}`);
-            if (!task)
-                throw new Error(`Task #${args.taskId} not found.`);
-            // Verify the task belongs to the given PR (when anchor is a direct PR anchor)
-            if (args.prId !== undefined && task.anchor?.type === 'PULL_REQUEST' && task.anchor.id !== args.prId) {
-                throw new Error(`Task #${args.taskId} does not belong to PR #${args.prId}.`);
-            }
-            await this.request('DELETE', `/tasks/${args.taskId}?version=${task.version}`);
-            return text(`Task #${args.taskId} deleted.`);
-        }
-        // resolve or reopen
-        const task = await this.request('GET', `/tasks/${args.taskId}`);
-        if (!task)
-            throw new Error(`Task #${args.taskId} not found.`);
-        if (args.prId !== undefined && task.anchor?.type === 'PULL_REQUEST' && task.anchor.id !== args.prId) {
-            throw new Error(`Task #${args.taskId} does not belong to PR #${args.prId}.`);
-        }
-        const newState = args.action === 'resolve' ? 'RESOLVED' : 'OPEN';
-        const updated = await this.request('PUT', `/tasks/${args.taskId}?version=${task.version}`, {
-            id: task.id,
-            state: newState,
-            text: task.text,
-        });
-        if (!updated)
-            return text(`Task #${args.taskId} ${newState}.`);
-        return text(`Task #${updated.id} is now ${updated.state}: "${updated.text}"`);
-    }
-    async getBuildStatuses(args) {
-        const data = await this.requestBuildStatus('GET', `/commits/${args.commitSha}`);
-        if (!data?.values?.length)
-            return text(`No build statuses reported for ${args.commitSha}.`);
-        const lines = data.values.map((s) => {
-            const icon = s.state === 'SUCCESSFUL' ? '✓' : s.state === 'FAILED' ? '✗' : '…';
-            const date = s.dateAdded ? ` (${new Date(s.dateAdded).toISOString().slice(0, 10)})` : '';
-            return `${icon} [${s.state}] ${s.name ?? s.key}${date}${s.description ? `\n  ${s.description}` : ''}${s.url ? `\n  ${s.url}` : ''}`;
-        });
-        return text(`${data.values.length} build status(es) for ${args.commitSha.slice(0, 8)}:\n${lines.join('\n')}`);
-    }
-}