@stubbedev/atlassian-mcp 0.4.5 → 0.5.1

package/dist/index.js

@@ -1,1055 +0,0 @@
-#!/usr/bin/env node
-import 'dotenv/config';
-import { execFileSync } from 'child_process';
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-const _pkg = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), '../package.json'), 'utf-8'));
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, McpError, ErrorCode, } from '@modelcontextprotocol/sdk/types.js';
-import { loadConfig } from './config.js';
-import { JiraClient } from './jira.js';
-import { BitbucketClient, parseBitbucketRemote } from './bitbucket.js';
-import { getContext, getDiff, createBranch, checkRemoteBranch, checkoutRemoteBranch } from './git.js';
-import { getDevContext, getTopCommitters } from './context.js';
-function currentGitRemote() {
-    try {
-        return execFileSync('git', ['remote', 'get-url', 'origin'], { encoding: 'utf-8' }).trim();
-    }
-    catch {
-        return '';
-    }
-}
-function currentGitBranch() {
-    try {
-        return execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { encoding: 'utf-8' }).trim();
-    }
-    catch {
-        return '';
-    }
-}
-function remoteMatchesBitbucketInstance(remote, bitbucketUrl) {
-    if (!remote)
-        return false;
-    try {
-        const host = new URL(bitbucketUrl).hostname.toLowerCase();
-        return remote.toLowerCase().includes(host);
-    }
-    catch {
-        return false;
-    }
-}
-const config = loadConfig();
-const jira = config.jira ? new JiraClient(config.jira.url, config.jira.token) : null;
-const _remote = currentGitRemote();
-const bitbucket = (config.bitbucket && remoteMatchesBitbucketInstance(_remote, config.bitbucket.url)) ? new BitbucketClient(config.bitbucket.url, config.bitbucket.token) : null;
-if (config.bitbucket && !bitbucket) {
-    console.error(`[atlassian-mcp] Bitbucket configured but remote "${_remote || '(none)'}" does not match ${config.bitbucket.url} — Bitbucket tools disabled for this repo.`);
-}
-async function buildInstructions() {
-    const branch = currentGitBranch();
-    const isGitRepo = branch !== '';
-    const jiraKeys = isGitRepo ? [...new Set(branch.match(/\b[A-Z][A-Z0-9]+-\d+\b/g) ?? [])] : [];
-    const parsed = bitbucket && _remote ? parseBitbucketRemote(_remote) : null;
-    const committers = isGitRepo ? getTopCommitters(process.cwd(), 50, 5) : [];
-    const [jiraMe, bbMe] = await Promise.all([
-        jira ? jira.whoami().catch(() => null) : Promise.resolve(null),
-        bitbucket ? bitbucket.whoami().catch(() => null) : Promise.resolve(null),
-    ]);
-    const lines = [];
-    lines.push('# atlassian-mcp');
-    lines.push('');
-    lines.push('Self-hosted Jira + Bitbucket Server tooling. Prefer these tools over shelling out to `git log`, `gh`, or any `bitbucket`/`bb` CLI for anything that touches tickets, PRs, reviewers, comments, or user lookups.');
-    lines.push('');
-    lines.push('## Configured services');
-    lines.push(`- Jira:      ${jira ? config.jira.url : '(not configured)'}${jiraMe ? ` — you are ${jiraMe.name ?? jiraMe.key ?? '?'}${jiraMe.displayName ? ` "${jiraMe.displayName}"` : ''}` : ''}`);
-    lines.push(`- Bitbucket: ${bitbucket ? config.bitbucket.url : (config.bitbucket ? `${config.bitbucket.url} — DISABLED for this cwd (remote does not match)` : '(not configured)')}${bbMe ? ` — you are ${bbMe}` : ''}`);
-    lines.push('');
-    if (isGitRepo) {
-        lines.push('## Current repo');
-        lines.push(`- Branch: ${branch} (may have changed since startup — re-run \`get_dev_context\` to refresh)`);
-        lines.push(`- Remote: ${_remote || '(none)'}`);
-        if (parsed)
-            lines.push(`- Bitbucket repo: ${parsed.projectKey}/${parsed.repoSlug}`);
-        if (jiraKeys.length)
-            lines.push(`- Jira keys in branch: ${jiraKeys.join(', ')}`);
-    }
-    else {
-        lines.push('## Current repo');
-        lines.push('- Not a git repository.');
-    }
-    if (committers.length) {
-        lines.push('');
-        lines.push('## Recent committers in this repo (last 50 commits)');
-        for (const c of committers) {
-            const ident = c.email ? `${c.name} <${c.email}>` : c.name;
-            lines.push(`- ${c.commits}× ${ident}`);
-        }
-    }
-    lines.push('');
-    lines.push('## Use these tools — do NOT shell out');
-    lines.push('- "What am I working on / what\'s the status / show me the context" → call `get_dev_context` first. It returns branch state, linked Jira tickets, the open PR, and reviewer status in one shot.');
-    lines.push('- Looking up a person\'s username (for reviewers, assignees, mentions) → ALWAYS use `bitbucket_search resource=users` or `jira_search resource=users`. NEVER use `git log`/`git shortlog`/`gh api`/`bb`/any bitbucket CLI to discover who someone is — those return commit-author strings, not Bitbucket/Jira usernames, and the wrong identifier breaks reviewer assignment.');
-    lines.push('- Reading a Jira ticket → `jira_get` (single) or `jira_search` (many). Mutating → `jira_mutate`.');
-    lines.push('- Reading a PR → `bitbucket_get_pr`. Creating/updating/merging → `bitbucket_mutate`. Commenting → `bitbucket_comment`.');
-    lines.push('- Starting work on a ticket (branch + status transition + README) → `start_work`. Closing it (merge + transition) → `complete_work`.');
-    return lines.join('\n');
-}
-const _instructions = await buildInstructions();
-const server = new Server({ name: 'atlassian-mcp', version: _pkg.version }, { capabilities: { tools: {} }, instructions: _instructions });
-server.onerror = (error) => console.error('[MCP Error]', error);
-function normalizeBitbucketArgs(args) {
-    const src = (args && typeof args === 'object') ? args : {};
-    const out = { ...src };
-    if (typeof out.project === 'string' && typeof out.projectKey !== 'string')
-        out.projectKey = out.project;
-    if (typeof out.repo === 'string' && typeof out.repoSlug !== 'string')
-        out.repoSlug = out.repo;
-    return out;
-}
-function normalizeJiraProjectArgs(args) {
-    const src = (args && typeof args === 'object') ? args : {};
-    const out = { ...src };
-    if (typeof out.project === 'string' && typeof out.projectKey !== 'string')
-        out.projectKey = out.project;
-    return out;
-}
-function normalizeJiraMutateArgs(args) {
-    const out = normalizeJiraProjectArgs(args);
-    if (out.create && typeof out.create === 'object') {
-        const create = { ...out.create };
-        if (typeof create.project === 'string' && typeof create.projectKey !== 'string')
-            create.projectKey = create.project;
-        out.create = create;
-    }
-    return out;
-}
-function validateAttachmentArgs(a) {
-    if (a.frames !== undefined && (typeof a.frames !== 'number' || !Number.isFinite(a.frames) || a.frames < 1 || a.frames > 60)) {
-        throw new McpError(ErrorCode.InvalidParams, 'frames must be a number between 1 and 60.');
-    }
-    if (a.start !== undefined && (typeof a.start !== 'number' || !Number.isFinite(a.start) || a.start < 0)) {
-        throw new McpError(ErrorCode.InvalidParams, 'start must be a non-negative number of seconds.');
-    }
-    if (a.end !== undefined && (typeof a.end !== 'number' || !Number.isFinite(a.end) || a.end <= 0)) {
-        throw new McpError(ErrorCode.InvalidParams, 'end must be a positive number of seconds.');
-    }
-    if (typeof a.start === 'number' && typeof a.end === 'number' && a.end <= a.start) {
-        throw new McpError(ErrorCode.InvalidParams, 'end must be greater than start.');
-    }
-    if (a.mode !== undefined && a.mode !== 'uniform' && a.mode !== 'scenes') {
-        throw new McpError(ErrorCode.InvalidParams, 'mode must be "uniform" or "scenes".');
-    }
-    if (a.maxDimension !== undefined && (typeof a.maxDimension !== 'number' || !Number.isFinite(a.maxDimension) || a.maxDimension < 64 || a.maxDimension > 4096)) {
-        throw new McpError(ErrorCode.InvalidParams, 'maxDimension must be a number between 64 and 4096.');
-    }
-    if (a.quality !== undefined && (typeof a.quality !== 'number' || !Number.isFinite(a.quality) || a.quality < 1 || a.quality > 100)) {
-        throw new McpError(ErrorCode.InvalidParams, 'quality must be a number between 1 and 100.');
-    }
-    if (a.sceneThreshold !== undefined && (typeof a.sceneThreshold !== 'number' || !Number.isFinite(a.sceneThreshold) || a.sceneThreshold <= 0 || a.sceneThreshold > 1)) {
-        throw new McpError(ErrorCode.InvalidParams, 'sceneThreshold must be a number in (0, 1].');
-    }
-}
-const JIRA_WIKI_MARKUP_HINT = 'Use Jira wiki markup (Atlassian renderer syntax), not GitHub/CommonMark markdown.';
-function issueTypePrefix(issueType) {
-    const t = issueType.toLowerCase();
-    if (t === 'bug' || t === 'bugfix' || t === 'defect')
-        return 'bugfix';
-    if (t === 'hotfix')
-        return 'hotfix';
-    if (t === 'task' || t === 'sub-task' || t === 'subtask')
-        return 'task';
-    return 'feature'; // story, feature, epic, improvement, etc.
-}
-function slugifyBranchName(issueKey, summary, issueType) {
-    const prefix = issueTypePrefix(issueType);
-    const slug = summary
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-|-$/g, '')
-        .slice(0, 40)
-        .replace(/-$/, '');
-    return `${prefix}/${issueKey}-${slug}`;
-}
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [
-        // ── Git (always available) ────────────────────────────────────────────
-        {
-            name: 'git_get_context',
-            description: 'Start here for any coding or review task: current branch, upstream ahead/behind, remote URL, recent commits, working tree status, diff stat summary, and Jira keys detected in the branch name. Pass includeDiff=true to also include the full uncommitted diff.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    repoPath: { type: 'string', description: 'Path to the git repository (defaults to cwd)' },
-                    commitLimit: { type: 'number', description: 'Number of recent commits to show (default 10)', default: 10 },
-                    includeDiff: { type: 'boolean', description: 'Include full uncommitted diff (default false)', default: false },
-                },
-            },
-        },
-        {
-            name: 'git_get_diff',
-            description: 'Get a diff between two git refs or commits. Use when you need to compare a feature branch to main, inspect a specific commit range, or review changes between two refs. For large diffs, increase maxChars or use charOffset to page through them.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    repoPath: { type: 'string', description: 'Path to the git repository (defaults to cwd)' },
-                    fromRef: { type: 'string', description: 'Base ref or commit' },
-                    toRef: { type: 'string', description: 'Target ref or commit (requires fromRef)' },
-                    maxChars: { type: 'number', description: 'Max characters to return (default 8000). Increase for large diffs.', default: 8000 },
-                    charOffset: { type: 'number', description: 'Skip this many characters from the start (for paging large diffs)', default: 0 },
-                },
-            },
-        },
-        // ── Combined context (jira + bitbucket, or either alone) ─────────────
-        ...(jira || bitbucket ? [{
-                name: 'get_dev_context',
-                description: 'Master entry point for "what am I working on / what\'s the status", and before any review or coding task. Returns: git branch + upstream state, Jira ticket overview (status, transitions, sprint, comments), open PR with reviewer approvals, and actionable next-step hints (create PR, merge, address blockers).',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        repoPath: { type: 'string', description: 'Local path to the git repo (defaults to cwd)' },
-                    },
-                },
-            }] : []),
-        // ── Jira ──────────────────────────────────────────────────────────────
-        ...(jira ? [
-            {
-                name: 'start_work',
-                description: 'Start working on a Jira ticket end-to-end: resolves the ticket (by key or free-text search with a picker when multiple match), creates a local branch with an auto-generated name, fetches the project README from Bitbucket so you have commit/PR conventions in context, and prints a next-steps summary. If issueKey is omitted, provide query for free-text search.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        issueKey: { type: 'string', description: 'Jira issue key, e.g. FOO-123 (provide this OR query)' },
-                        query: { type: 'string', description: 'Free-text search when issueKey is unknown — shows a picker if multiple tickets match' },
-                        repoPath: { type: 'string', description: 'Local repo path (defaults to cwd)' },
-                        baseBranch: { type: 'string', description: 'Branch to base off (default: master)' },
-                        branchName: { type: 'string', description: 'Override the generated branch name' },
-                        transitionName: { type: 'string', description: 'Jira transition to apply, e.g. "In Progress" (optional)' },
-                        push: { type: 'boolean', description: 'Push branch to remote after creation (default false)', default: false },
-                    },
-                },
-            },
-            {
-                name: 'jira_search',
-                description: 'Discover Jira resources (tickets, projects, boards, sprints, versions, users). Set resource:\n• "issues" (default) — search by text, JQL, project, status, assignee, issue type, or mine=true for your queue\n• "projects" — list all projects and their keys\n• "issue_types" — valid types and statuses for a project\n• "boards" — list boards (pass project to filter by project key); use this to find the boardId before fetching sprints or board_overview\n• "sprints" — sprints for a board (pass boardId); if you don\'t know the boardId, first use resource=boards\n• "board_overview" — active/future sprints with their issues for a board (pass boardId); use when asked "what\'s in the sprint", "show me the board", or "what\'s everyone working on"\n• "versions" — list fix versions/releases for a project (pass project; optionally pass query to filter by name substring). If the version you need does not exist, create it yourself with `jira_version action=create` — do NOT ask the user to make it in the Jira UI.\n• "users" — find users by name/email (pass query)',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        resource: { type: 'string', enum: ['issues', 'projects', 'issue_types', 'boards', 'sprints', 'board_overview', 'versions', 'users'], description: 'What to search (default: issues)' },
-                        mine: { type: 'boolean', description: 'Return issues assigned to you (resource=issues only)' },
-                        query: { type: 'string', description: 'Text search or user name query' },
-                        jql: { type: 'string', description: 'Raw JQL (resource=issues only, overrides other filters)' },
-                        project: { type: 'string', description: 'Project key filter or scope for issue_types/boards' },
-                        status: { type: 'string', description: 'Status filter (issues only, or board_overview to filter issues by status)' },
-                        assignee: { type: 'string', description: 'Assignee username filter (issues only, or board_overview to filter issues by assignee)' },
-                        issueType: { type: 'string', description: 'Issue type filter (issues only)' },
-                        boardId: { type: 'number', description: 'Board ID (required for resource=sprints or board_overview)' },
-                        sprintState: { type: 'string', description: 'Sprint state filter: active, future, closed (sprints and board_overview)' },
-                        includeIssues: { type: 'boolean', description: 'Include issues per sprint in board_overview (default true)', default: true },
-                        maxResults: { type: 'number', description: 'Max results (default 20)', default: 20 },
-                        startAt: { type: 'number', description: 'Pagination offset (default 0)', default: 0 },
-                    },
-                },
-            },
-            {
-                name: 'jira_get',
-                description: 'Full details for one Jira issue: summary, description, status, assignee, sprint, available transitions, recent comments, and a list of attachments (filename, size, mime type, attachment ID). To view an attachment\'s contents (e.g. an image), call jira_get_attachment with the attachment ID surfaced here.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        issueKey: { type: 'string', description: 'Jira issue key, e.g. FOO-123' },
-                        includeComments: { type: 'boolean', description: 'Include comments (default true)', default: true },
-                        commentsMaxResults: { type: 'number', description: 'Max comments (default 10)', default: 10 },
-                        commentsStartAt: { type: 'number', description: 'Comment pagination offset (default 0)', default: 0 },
-                        includeTransitions: { type: 'boolean', description: 'Include available transitions (default true)', default: true },
-                        includeSprint: { type: 'boolean', description: 'Include sprint data (default true)', default: true },
-                        fullDescription: { type: 'boolean', description: 'Return the full description even when long (default false — descriptions over ~2000 chars are truncated to save context)', default: false },
-                    },
-                    required: ['issueKey'],
-                },
-            },
-            {
-                name: 'jira_mutate',
-                description: `Create/update a ticket, transition status, assign, comment, link issues, or log work — bundles create/update/transition/comment/link/worklog in one call. ${JIRA_WIKI_MARKUP_HINT}`,
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        issueKey: { type: 'string', description: 'Existing issue key to mutate (optional if create is provided)' },
-                        create: {
-                            type: 'object',
-                            properties: {
-                                projectKey: { type: 'string', description: 'Jira project code (optional, auto-resolved when omitted)' },
-                                project: { type: 'string', description: 'Alias for projectKey' },
-                                issueType: { type: 'string', description: 'Issue type name, e.g. Bug, Story, Task, Sub-task' },
-                                summary: { type: 'string', description: 'Issue title' },
-                                description: { type: 'string', description: `Issue description (optional). ${JIRA_WIKI_MARKUP_HINT}` },
-                                assignee: { type: 'string', description: 'Username to assign to (optional)' },
-                                priority: { type: 'string', description: 'Priority name (optional)' },
-                                labels: { type: 'array', items: { type: 'string' }, description: 'Labels to apply (optional)' },
-                                fixVersion: { type: 'string', description: 'Fix version name (optional)' },
-                                parent: { type: 'string', description: 'Parent issue key. For Sub-task issue types this sets the Jira parent. If the key points to an Epic, the Epic Link custom field is set automatically instead (Jira Server epic membership).' },
-                                epicLink: { type: 'string', description: 'Epic issue key to attach the new issue to as an epic child (Jira Server Epic Link). Overrides parent if both are passed.' },
-                            },
-                            required: ['issueType', 'summary'],
-                        },
-                        update: {
-                            type: 'object',
-                            properties: {
-                                summary: { type: 'string', description: 'New summary (optional)' },
-                                description: { type: 'string', description: `New description (optional). ${JIRA_WIKI_MARKUP_HINT}` },
-                                assignee: { type: 'string', description: 'New assignee username, or empty string to unassign (optional)' },
-                                priority: { type: 'string', description: 'New priority name (optional)' },
-                                labels: { type: 'array', items: { type: 'string' }, description: 'Replace label set (pass [] to clear)' },
-                                fixVersion: { type: 'string', description: 'Fix version name, or empty string to clear (optional)' },
-                                epicLink: { type: 'string', description: 'Epic issue key to set as parent epic (Jira Server Epic Link), or empty string to clear.' },
-                            },
-                        },
-                        sprintId: { type: 'number', description: 'Sprint ID to add the issue into (optional)' },
-                        removeFromSprint: { type: 'boolean', description: 'Move the issue to the backlog (remove from any sprint)' },
-                        transitionId: { type: 'string', description: 'Transition ID (optional if transitionName provided)' },
-                        transitionName: { type: 'string', description: 'Transition name, e.g. "In Progress" (optional if transitionId provided)' },
-                        comment: { type: 'string', description: `Comment to add after other mutations (optional). ${JIRA_WIKI_MARKUP_HINT}` },
-                        link: {
-                            type: 'object',
-                            description: 'Create an issue link, e.g. "FOO-123 blocks BAR-456"',
-                            properties: {
-                                linkType: { type: 'string', description: 'Link type name, e.g. "Blocks", "Relates to", "Duplicates"' },
-                                targetIssueKey: { type: 'string', description: 'The other issue in the relationship' },
-                                direction: { type: 'string', enum: ['outward', 'inward'], description: 'outward (default): issueKey → target; inward: target → issueKey' },
-                            },
-                            required: ['linkType', 'targetIssueKey'],
-                        },
-                        worklog: {
-                            type: 'object',
-                            description: 'Log time spent on this issue',
-                            properties: {
-                                timeSpent: { type: 'string', description: 'Time in Jira format, e.g. "2h 30m" or "1d"' },
-                                comment: { type: 'string', description: 'Work description (optional)' },
-                                started: { type: 'string', description: 'ISO 8601 datetime when work started (defaults to now)' },
-                            },
-                            required: ['timeSpent'],
-                        },
-                    },
-                },
-            },
-            {
-                name: 'jira_get_attachment',
-                description: 'Fetch a Jira attachment by ID and return its contents inline. Images are auto-resized + re-encoded; text/JSON/XML return as text; videos and animated images (GIF/APNG/animated WebP) are decoded with ffmpeg into sampled frames (re-call with start/end/frames or mode=scenes to refine); audio returns as an audio block; PDFs return extracted text. Oversized/non-renderable files are saved to a temp file and the path returned. Use jira_get first to discover attachment IDs.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        attachmentId: { type: 'string', description: 'Numeric attachment ID from jira_get output' },
-                        saveTo: { type: 'string', description: 'Optional absolute path to save the original (un-resized) file to disk instead of returning inline' },
-                        maxDimension: { type: 'number', description: 'Max long-edge size in pixels for inline images (default 1568 for images, 768 for video frames).' },
-                        quality: { type: 'number', description: 'JPEG quality for re-encoded inline images (1-100, default 85 for images, 65 for video frames). Ignored for images with alpha (encoded as PNG).' },
-                        frames: { type: 'number', description: 'Video/animated-image only: number of frames to sample (default 6, range 1-60). Higher = more detail + more context.' },
-                        start: { type: 'number', description: 'Video/animated-image only: start of sample window in seconds (default 0). Use with end/frames to zoom into a moment of interest after a coarse first pass.' },
-                        end: { type: 'number', description: 'Video/animated-image only: end of sample window in seconds (default full duration). Must be greater than start.' },
-                        mode: { type: 'string', enum: ['uniform', 'scenes'], description: 'Video/animated-image only: "uniform" samples N frames evenly (default); "scenes" uses ffmpeg scene-change detection, better for screencasts/narrative content.' },
-                        sceneThreshold: { type: 'number', description: 'Video/animated-image only: scene-change sensitivity in 0-1 (default 0.3). Only used when mode=scenes. Lower = more frames, higher = fewer.' },
-                    },
-                    required: ['attachmentId'],
-                },
-            },
-            {
-                name: 'jira_comment',
-                description: `Add, update, or delete a comment on a Jira issue. action defaults to "add". Can only edit/delete your own comments. ${JIRA_WIKI_MARKUP_HINT}`,
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        action: { type: 'string', enum: ['add', 'update', 'delete'], description: 'Operation (default: add)' },
-                        issueKey: { type: 'string', description: 'Jira issue key, e.g. FOO-123' },
-                        commentId: { type: 'string', description: 'Comment ID (required for update/delete)' },
-                        body: { type: 'string', description: `Comment text. ${JIRA_WIKI_MARKUP_HINT} Required for add/update.` },
-                    },
-                    required: ['issueKey'],
-                },
-            },
-            {
-                name: 'jira_version',
-                description: 'Manage Jira fix versions (releases): create, update, release, archive, delete. action defaults to "create". For create pass projectKey + name. For update/release/archive/delete pass id (look it up via jira_search resource=versions). "release" sets released=true and defaults releaseDate to today. Once a version exists you can set it on tickets via jira_mutate update.fixVersion.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        action: { type: 'string', enum: ['create', 'update', 'release', 'archive', 'delete'], description: 'Operation (default: create)' },
-                        projectKey: { type: 'string', description: 'Jira project code (required for create when not auto-resolvable)' },
-                        project: { type: 'string', description: 'Alias for projectKey' },
-                        id: { type: 'string', description: 'Version id (required for update/release/archive/delete; look up via jira_search resource=versions)' },
-                        name: { type: 'string', description: 'Version name, e.g. "9.1.0" (required for create; optional rename for update)' },
-                        description: { type: 'string', description: 'Version description (optional)' },
-                        startDate: { type: 'string', description: 'Start date in YYYY-MM-DD (optional)' },
-                        releaseDate: { type: 'string', description: 'Release date in YYYY-MM-DD (optional; defaults to today on action=release)' },
-                        released: { type: 'boolean', description: 'Released flag (optional; action=release forces true)' },
-                        archived: { type: 'boolean', description: 'Archived flag (optional; action=archive forces true)' },
-                    },
-                },
-            }
-        ] : []),
-        ...(bitbucket ? [{
-                name: 'bitbucket_search',
-                description: 'Discover Bitbucket resources (PRs, repos, branches, users). Set resource:\n• "pull_requests" (default) — list PRs by state/branch/text; mine=true for your inbox\n• "repos" — list repositories in a project\n• "branches" — list or filter branches in a repo\n• "users" — find users by name/email (pass query); add projectKey+repoSlug to restrict to users with repo access. ALWAYS use this to look up valid usernames before adding reviewers to a PR.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        resource: { type: 'string', enum: ['pull_requests', 'repos', 'branches', 'users'], description: 'What to search (default: pull_requests)' },
-                        mine: { type: 'boolean', description: 'Return your own PRs by role (resource=pull_requests only)' },
-                        role: { type: 'string', enum: ['author', 'reviewer', 'participant'], description: 'Your role filter when mine=true' },
-                        projectKey: { type: 'string', description: 'Bitbucket project code, e.g. "ENG"' },
-                        project: { type: 'string', description: 'Alias for projectKey' },
-                        repoSlug: { type: 'string', description: 'Repository slug' },
-                        repo: { type: 'string', description: 'Alias for repoSlug' },
-                        query: { type: 'string', description: 'Name or email filter (resource=users only)' },
-                        state: { type: 'string', enum: ['OPEN', 'MERGED', 'DECLINED'], description: 'PR state filter (default OPEN)' },
-                        fromBranch: { type: 'string', description: 'Filter PRs from this source branch' },
-                        text: { type: 'string', description: 'Filter PRs by title/description text' },
-                        filter: { type: 'string', description: 'Branch name filter (resource=branches only)' },
-                        limit: { type: 'number', description: 'Max results per page (default 25)', default: 25 },
-                        start: { type: 'number', description: 'Pagination offset (default 0)', default: 0 },
-                    },
-                },
-            },
-            {
-                name: 'bitbucket_get_pr',
-                description: 'Full details for one PR: metadata, commits, open comments, blockers, optional diff, and any attachments referenced from the description or comments (with attachment ID + filename). IMPORTANT: The PR branch is often not the locally checked-out branch. Do NOT read files with local tools (Read, git_get_diff, etc.) for PR context — use bitbucket_get_file with the PR\'s source branch instead. To view an attachment\'s contents, call bitbucket_get_attachment with the surfaced attachment ID. The response includes a "Viewing as" line — if it says "you are the author", do NOT add review comments or a summary unless explicitly asked; just answer questions about the PR. If it says "you are a reviewer", default to posting inline comments for suggested changes and a final summary comment.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        projectKey: { type: 'string', description: 'Bitbucket project code (usually auto-detected)' },
-                        project: { type: 'string', description: 'Alias for projectKey' },
-                        repoSlug: { type: 'string', description: 'Repository slug (usually auto-detected)' },
-                        repo: { type: 'string', description: 'Alias for repoSlug' },
-                        prId: { type: 'number', description: 'Pull request number (optional if fromBranch provided or running from a checked-out branch)' },
-                        fromBranch: { type: 'string', description: 'Source branch — auto-resolves the open PR; omit to use current checked-out branch' },
-                        includeCommits: { type: 'boolean', description: 'Include commit list (default true)', default: true },
-                        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: ['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 },
-                        commitsLimit: { type: 'number', description: 'Max commits (default 25)', default: 25 },
-                        diffMaxChars: { type: 'number', description: 'Max diff chars when includeDiff=true (default 8000)', default: 8000 },
-                        fullDescription: { type: 'boolean', description: 'Return the full PR description even when long (default false — descriptions over ~2000 chars are truncated to save context)', default: false },
-                    },
-                },
-            },
-            {
-                name: 'bitbucket_mutate',
-                description: 'Create, update, approve/unapprove, mark needs_work, decline, or merge a PR — in one call. Auto-targets the open PR for the current branch when prId is omitted. needs_work sets your reviewer status to "Needs work" (Bitbucket Server\'s changes-requested signal); revert with action=unapprove.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        projectKey: { type: 'string', description: 'Bitbucket project code (usually auto-detected)' },
-                        project: { type: 'string', description: 'Alias for projectKey' },
-                        repoSlug: { type: 'string', description: 'Repository slug (usually auto-detected)' },
-                        repo: { type: 'string', description: 'Alias for repoSlug' },
-                        prId: { type: 'number', description: 'Target PR number (optional, auto-resolved from branch)' },
-                        action: { type: 'string', enum: ['approve', 'unapprove', 'needs_work', 'decline', 'merge'], description: 'Lifecycle action to perform (optional). needs_work = mark your reviewer status as "Needs work" (changes requested).' },
-                        mergeStrategy: { type: 'string', enum: ['MERGE_COMMIT', 'SQUASH', 'FAST_FORWARD'], description: 'Merge strategy (action=merge only)' },
-                        mergeMessage: { type: 'string', description: 'Custom merge commit message (action=merge only)' },
-                        declineMessage: { type: 'string', description: 'Decline message (action=decline only)' },
-                        create: {
-                            type: 'object',
-                            properties: {
-                                title: { type: 'string', description: 'PR title' },
-                                description: { type: 'string', description: 'PR description (optional)' },
-                                fromBranch: { type: 'string', description: 'Source branch (defaults to current branch)' },
-                                toBranch: { type: 'string', description: 'Target branch (default: master)' },
-                                reviewers: { type: 'array', items: { type: 'string' }, description: 'Reviewer usernames. Use bitbucket_search resource=users to look up valid usernames before setting this.' },
-                                pickReviewers: { type: 'boolean', description: 'Show an interactive reviewer picker before creating the PR (lists users with repo access)' },
-                            },
-                            required: ['title'],
-                        },
-                        update: {
-                            type: 'object',
-                            properties: {
-                                title: { type: 'string', description: 'Updated PR title (optional)' },
-                                description: { type: 'string', description: 'Updated description, or empty string to clear (optional)' },
-                                toBranch: { type: 'string', description: 'Updated target branch (optional)' },
-                                reviewers: { type: 'array', items: { type: 'string' }, description: 'Updated reviewer usernames. Empty array clears reviewers. Use bitbucket_search resource=users to look up valid usernames before setting this.' },
-                            },
-                        },
-                    },
-                },
-            },
-            {
-                name: 'bitbucket_comment',
-                description: `Add, update, or delete a PR comment. action defaults to "add". This tool posts COMMENTS, never tasks — never set severity=BLOCKER to create a task. severity=BLOCKER is rejected on add and only ever valid on update to escalate an already-blocking comment. To create a task, use bitbucket_pr_tasks (action=create), and only when the user explicitly asks for a task. 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. Only one reply per thread per author: if you already replied to a comment, update your existing reply (action=update commentId=<your-reply-id>) instead of posting a second one. The server enforces this and will reject the second add. 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. When the comment body references another comment by id, render it as a markdown hyperlink \`[#<id>](<baseUrl>/projects/<PROJECT>/repos/<REPO>/pull-requests/<prId>/overview?commentId=<id>)\` — never a bare \`#<id>\`, which is unclickable in Bitbucket's renderer.`,
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        action: { type: 'string', enum: ['add', 'update', 'delete'], description: 'Operation (default: add)' },
-                        projectKey: { type: 'string', description: 'Bitbucket project code (usually auto-detected)' },
-                        project: { type: 'string', description: 'Alias for projectKey' },
-                        repoSlug: { type: 'string', description: 'Repository slug (usually auto-detected)' },
-                        repo: { type: 'string', description: 'Alias for repoSlug' },
-                        prId: { type: 'number', description: 'Pull request number' },
-                        commentId: { type: 'number', description: 'Comment ID to reply to, update, or delete' },
-                        text: { type: 'string', description: 'Comment text for add/update. No filler, no emojis. If suggestion is used, keep this optional and brief; it is placed before the suggestion block.' },
-                        filePath: { type: 'string', description: 'File path for inline comment (must pair with line)' },
-                        srcPath: { type: 'string', description: 'Source path if file was renamed (optional, defaults to filePath)' },
-                        line: { type: 'number', description: 'Line number to anchor inline comment (must pair with filePath)' },
-                        lineType: { type: 'string', enum: ['ADDED', 'REMOVED', 'CONTEXT'], description: 'Diff line type (default ADDED)' },
-                        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)' },
-                        severity: { type: 'string', enum: ['NORMAL', 'BLOCKER'], description: 'Comment severity. Leave unset — comments default to NORMAL. BLOCKER turns the comment into a task and is REJECTED on add; only pass BLOCKER on update to escalate an existing comment when the user explicitly asks. To create a task, use bitbucket_pr_tasks instead.' },
-                    },
-                    required: ['prId'],
-                },
-            },
-            {
-                name: 'bitbucket_get_file',
-                description: 'Raw file content from Bitbucket at a branch, tag, or commit. CRITICAL: if the PR branch being reviewed is NOT the currently checked-out local branch, ALL additional file context for that review MUST come from this tool — never from local Read, git_get_diff, or any tool that reads local disk. Pass the PR source branch as ref.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        projectKey: { type: 'string', description: 'Bitbucket project code (usually auto-detected)' },
-                        project: { type: 'string', description: 'Alias for projectKey' },
-                        repoSlug: { type: 'string', description: 'Repository slug (usually auto-detected)' },
-                        repo: { type: 'string', description: 'Alias for repoSlug' },
-                        path: { type: 'string', description: 'File path, e.g. "src/index.ts"' },
-                        ref: { type: 'string', description: 'Branch, tag, or commit hash (defaults to default branch)' },
-                    },
-                    required: ['path'],
-                },
-            },
-            {
-                name: 'bitbucket_get_attachment',
-                description: 'Fetch a Bitbucket repo attachment by ID and return its contents inline. Attachments are repo-scoped, referenced from PR descriptions/comments via attachment:<id> markdown; use bitbucket_get_pr first to surface IDs. Images are auto-resized + re-encoded; text/JSON/XML return as text; videos and animated images (GIF/APNG/animated WebP) are decoded with ffmpeg into sampled frames (re-call with start/end/frames or mode=scenes to refine); audio returns as an audio block; PDFs return extracted text. Oversized/non-renderable files are saved to a temp file and the path returned.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        projectKey: { type: 'string', description: 'Bitbucket project code (usually auto-detected)' },
-                        project: { type: 'string', description: 'Alias for projectKey' },
-                        repoSlug: { type: 'string', description: 'Repository slug (usually auto-detected)' },
-                        repo: { type: 'string', description: 'Alias for repoSlug' },
-                        attachmentId: { type: 'string', description: 'Numeric attachment ID' },
-                        saveTo: { type: 'string', description: 'Optional absolute path to save the original (un-resized) file to disk instead of returning inline' },
-                        maxDimension: { type: 'number', description: 'Max long-edge size in pixels for inline images (default 1568 for images, 768 for video frames).' },
-                        quality: { type: 'number', description: 'JPEG quality for re-encoded inline images (1-100, default 85 for images, 65 for video frames). Ignored for images with alpha (encoded as PNG).' },
-                        frames: { type: 'number', description: 'Video/animated-image only: number of frames to sample (default 6, range 1-60).' },
-                        start: { type: 'number', description: 'Video/animated-image only: start of sample window in seconds (default 0). Use with end/frames to zoom in.' },
-                        end: { type: 'number', description: 'Video/animated-image only: end of sample window in seconds (default full duration). Must be greater than start.' },
-                        mode: { type: 'string', enum: ['uniform', 'scenes'], description: 'Video/animated-image only: "uniform" samples N frames evenly (default); "scenes" uses scene-change detection.' },
-                        sceneThreshold: { type: 'number', description: 'Video/animated-image only: scene-change sensitivity in 0-1 (default 0.3). Only used when mode=scenes. Lower = more frames, higher = fewer.' },
-                    },
-                    required: ['attachmentId'],
-                },
-            },
-            {
-                name: 'bitbucket_pr_tasks',
-                description: 'Manage PR tasks (checklist items): list, create, resolve, reopen, delete. Tasks are distinct from comments — they appear as a checklist in the PR sidebar.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        action: { type: 'string', enum: ['list', 'create', 'resolve', 'reopen', 'delete'], description: 'Operation (default: list)' },
-                        projectKey: { type: 'string', description: 'Bitbucket project code (usually auto-detected)' },
-                        project: { type: 'string', description: 'Alias for projectKey' },
-                        repoSlug: { type: 'string', description: 'Repository slug (usually auto-detected)' },
-                        repo: { type: 'string', description: 'Alias for repoSlug' },
-                        prId: { type: 'number', description: 'Pull request number' },
-                        taskId: { type: 'number', description: 'Task ID (required for resolve/reopen/delete)' },
-                        text: { type: 'string', description: 'Task description (required for create)' },
-                        commentId: { type: 'number', description: 'Anchor the task to a specific comment ID (optional for create)' },
-                    },
-                    required: ['prId'],
-                },
-            },
-        ] : []),
-        // ── Combined workflow ─────────────────────────────────────────────────
-        ...(jira && bitbucket ? [{
-                name: 'complete_work',
-                description: 'Close the loop on a finished branch: merges the open PR and transitions the Jira ticket to Done (or a named transition). Mirrors start_work.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        issueKey: { type: 'string', description: 'Jira issue key to transition (auto-detected from branch name if omitted)' },
-                        prId: { type: 'number', description: 'PR to merge (auto-detected from current branch if omitted)' },
-                        repoPath: { type: 'string', description: 'Local repo path (defaults to cwd)' },
-                        transitionName: { type: 'string', description: 'Jira transition to apply after merge (default: "Done")' },
-                        mergeStrategy: { type: 'string', enum: ['MERGE_COMMIT', 'SQUASH', 'FAST_FORWARD'], description: 'Merge strategy (optional)' },
-                        mergeMessage: { type: 'string', description: 'Custom merge commit message (optional)' },
-                        projectKey: { type: 'string', description: 'Bitbucket project code (usually auto-detected)' },
-                        repoSlug: { type: 'string', description: 'Repository slug (usually auto-detected)' },
-                        skipJiraTransition: { type: 'boolean', description: 'Skip transitioning the Jira ticket (default false)' },
-                    },
-                },
-            }] : [])
-    ],
-}));
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args = {} } = request.params;
-    try {
-        switch (name) {
-            // Git
-            case 'git_get_context':
-                return getContext(args);
-            case 'git_get_diff': {
-                const diffArgs = args;
-                const result = getDiff(diffArgs);
-                const raw = result.content[0].text;
-                const offset = diffArgs.charOffset ?? 0;
-                const limit = diffArgs.maxChars ?? 8000;
-                if (offset === 0 && raw.length <= limit)
-                    return result;
-                const chunk = raw.slice(offset, offset + limit);
-                const remaining = raw.length - offset - chunk.length;
-                const suffix = remaining > 0 ? `\n\n... (${remaining} more chars, use charOffset=${offset + chunk.length})` : '';
-                return { content: [{ type: 'text', text: chunk + suffix }] };
-            }
-            // Combined context + workflow
-            case 'get_dev_context':
-                if (!jira && !bitbucket)
-                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                return await getDevContext(args, jira, bitbucket);
-            case 'start_work': {
-                if (!jira)
-                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                const a = args;
-                if (!a.issueKey && !a.query) {
-                    throw new Error('Provide issueKey (e.g. FOO-123) or query (free-text search).');
-                }
-                // Resolve issueKey from free-text query if not provided directly
-                let issueKey = a.issueKey;
-                if (!issueKey && a.query) {
-                    const candidates = await jira.findIssues(a.query, 10);
-                    if (candidates.length === 0) {
-                        return { content: [{ type: 'text', text: `No Jira tickets found for: "${a.query}"` }] };
-                    }
-                    if (candidates.length === 1) {
-                        issueKey = candidates[0].key;
-                    }
-                    else {
-                        // Multiple matches — present a picker
-                        const pickerMessage = [
-                            `Found ${candidates.length} tickets matching "${a.query}". Which one do you want to work on?`,
-                            ...candidates.map((c, i) => `${i + 1}. [${c.key}] ${c.summary} (${c.status})`),
-                        ].join('\n');
-                        try {
-                            const pickerResult = await server.elicitInput({
-                                message: pickerMessage,
-                                requestedSchema: {
-                                    type: 'object',
-                                    properties: {
-                                        ticket: {
-                                            type: 'string',
-                                            title: 'Select a ticket',
-                                            oneOf: [
-                                                ...candidates.map((c) => ({ const: c.key, title: `[${c.key}] ${c.summary}` })),
-                                                { const: '__cancel__', title: 'Cancel' },
-                                            ],
-                                        },
-                                    },
-                                    required: ['ticket'],
-                                },
-                            });
-                            if (pickerResult.action === 'cancel' ||
-                                pickerResult.action === 'decline' ||
-                                pickerResult.content?.ticket === '__cancel__') {
-                                return { content: [{ type: 'text', text: 'Cancelled.' }] };
-                            }
-                            issueKey = pickerResult.content?.ticket;
-                            if (!issueKey || issueKey === '__cancel__') {
-                                return { content: [{ type: 'text', text: 'Cancelled.' }] };
-                            }
-                        }
-                        catch {
-                            // Client doesn't support elicitation — list options and ask caller to retry with issueKey
-                            const list = candidates.map((c) => `  • ${c.key} — ${c.summary} (${c.status})`).join('\n');
-                            return {
-                                content: [{
-                                        type: 'text',
-                                        text: `Found ${candidates.length} tickets matching "${a.query}":\n${list}\n\nRe-run start_work with the desired issueKey.`,
-                                    }],
-                            };
-                        }
-                    }
-                }
-                if (!issueKey)
-                    throw new Error('Could not resolve issue key.');
-                const fields = await jira.getIssueFields(issueKey);
-                const branchName = a.branchName ?? slugifyBranchName(issueKey, fields.summary, fields.type);
-                const repoPath = a.repoPath ?? process.cwd();
-                // Check if branch already exists on remote before creating
-                const remote = checkRemoteBranch(branchName, repoPath);
-                if (remote.exists) {
-                    const authorLine = remote.author ? `Last author: ${remote.author}` : null;
-                    const commitLine = remote.date
-                        ? `Last commit: ${remote.date} — ${remote.message ?? ''}${remote.sha ? ` (${remote.sha})` : ''}`
-                        : null;
-                    const contextLines = [authorLine, commitLine].filter(Boolean).join('\n');
-                    const message = [
-                        `Branch "${branchName}" already exists on remote.`,
-                        `Ticket: ${issueKey} — ${fields.summary}`,
-                        contextLines,
-                    ].filter(Boolean).join('\n');
-                    try {
-                        const result = await server.elicitInput({
-                            message,
-                            requestedSchema: {
-                                type: 'object',
-                                properties: {
-                                    action: {
-                                        type: 'string',
-                                        title: 'What would you like to do?',
-                                        oneOf: [
-                                            { const: 'checkout', title: `Check out existing branch "${branchName}"` },
-                                            { const: 'new_name', title: 'Use a different branch name (re-run start_work with branchName)' },
-                                            { const: 'cancel', title: 'Cancel' },
-                                        ],
-                                    },
-                                },
-                                required: ['action'],
-                            },
-                        });
-                        if (result.action === 'cancel' || result.action === 'decline') {
-                            return { content: [{ type: 'text', text: 'Cancelled.' }] };
-                        }
-                        if (result.action === 'accept') {
-                            const chosen = result.content?.action;
-                            if (chosen === 'checkout') {
-                                const checkout = checkoutRemoteBranch(branchName, repoPath);
-                                return { content: [{ type: 'text', text: `${message}\n\n${checkout.content[0].text}` }] };
-                            }
-                            if (chosen === 'cancel') {
-                                return { content: [{ type: 'text', text: 'Cancelled.' }] };
-                            }
-                            return {
-                                content: [{
-                                        type: 'text',
-                                        text: `${message}\n\nRe-run start_work with a custom branchName to proceed.`,
-                                    }],
-                            };
-                        }
-                        return { content: [{ type: 'text', text: 'Cancelled.' }] };
-                    }
-                    catch {
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: [
-                                        message,
-                                        '',
-                                        'Options:',
-                                        `  • Check out existing: git checkout --track origin/${branchName}`,
-                                        `  • Use a different name: re-run start_work with branchName set`,
-                                    ].join('\n'),
-                                }],
-                        };
-                    }
-                }
-                const branchResult = createBranch({
-                    branchName,
-                    baseBranch: a.baseBranch,
-                    repoPath,
-                    push: a.push ?? false,
-                });
-                const lines = [
-                    `Ticket:  ${issueKey} — ${fields.summary}`,
-                    `Status:  ${fields.status}`,
-                    branchResult.content[0].text,
-                ];
-                if (a.transitionName) {
-                    try {
-                        await jira.mutateIssue({ issueKey, transitionName: a.transitionName });
-                        lines.push(`Jira:    transitioned → ${a.transitionName}`);
-                    }
-                    catch (err) {
-                        lines.push(`Jira:    could not transition — ${err.message}`);
-                    }
-                }
-                // Fetch README from Bitbucket for project conventions
-                if (bitbucket) {
-                    try {
-                        const remoteUrl = (() => {
-                            try {
-                                return execFileSync('git', ['remote', 'get-url', 'origin'], { cwd: repoPath, encoding: 'utf-8' }).trim();
-                            }
-                            catch {
-                                return '';
-                            }
-                        })();
-                        const parsed = parseBitbucketRemote(remoteUrl);
-                        if (parsed) {
-                            const readme = await bitbucket.fetchFileText(parsed.projectKey, parsed.repoSlug, 'README.md');
-                            if (readme) {
-                                const maxLen = 4000;
-                                const truncated = readme.length > maxLen ? readme.slice(0, maxLen) + '\n... (truncated)' : readme;
-                                lines.push('');
-                                lines.push('Project conventions (from README.md):');
-                                lines.push('────────────────────────────────────');
-                                lines.push(truncated);
-                                lines.push('────────────────────────────────────');
-                                lines.push('Follow the conventions above when writing commit messages and the PR description.');
-                            }
-                        }
-                    }
-                    catch { /* README fetch is best-effort */ }
-                    lines.push('');
-                    lines.push('Next steps:');
-                    lines.push('  1. Make your changes and commit following the project conventions.');
-                    lines.push('  2. Use bitbucket_mutate (create) to open a PR — the Jira summary and ticket key make a good title/description starting point.');
-                    lines.push('  3. Add reviewers: bitbucket_search resource=users to find colleagues, or pass pickReviewers=true in create to get an interactive picker.');
-                }
-                return { content: [{ type: 'text', text: lines.join('\n') }] };
-            }
-            // Jira
-            case 'jira_search': {
-                if (!jira)
-                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                const a = args;
-                const resource = a.resource ?? 'issues';
-                if (resource === 'projects')
-                    return await jira.getProjects({ maxResults: a.maxResults });
-                if (resource === 'issue_types')
-                    return await jira.getIssueTypes({ projectKey: a.projectKey ?? a.project });
-                if (resource === 'boards')
-                    return await jira.getBoards({ projectKey: a.projectKey ?? a.project, maxResults: a.maxResults, startAt: a.startAt });
-                if (resource === 'sprints')
-                    return await jira.getSprints({ boardId: a.boardId, state: a.sprintState, maxResults: a.maxResults, startAt: a.startAt });
-                if (resource === 'board_overview')
-                    return await jira.boardOverview({ boardId: a.boardId, sprintState: a.sprintState, sprintMaxResults: a.maxResults, sprintStartAt: a.startAt, includeIssues: a.includeIssues, assignee: a.assignee, status: a.status });
-                if (resource === 'versions')
-                    return await jira.listVersions({ projectKey: a.projectKey ?? a.project, query: a.query, maxResults: a.maxResults });
-                if (resource === 'users')
-                    return await jira.searchUsers({ query: a.query ?? '', maxResults: a.maxResults });
-                // issues (default)
-                if (a.mine)
-                    return await jira.myIssues({ maxResults: a.maxResults, startAt: a.startAt });
-                return await jira.searchIssues(a);
-            }
-            case 'jira_get':
-                if (!jira)
-                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                return await jira.issueOverview(args);
-            case 'jira_mutate':
-                if (!jira)
-                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                return await jira.mutateIssue(normalizeJiraMutateArgs(args));
-            case 'jira_get_attachment': {
-                if (!jira)
-                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                const a = args;
-                validateAttachmentArgs(a);
-                return await jira.getAttachment(a);
-            }
-            case 'jira_comment': {
-                if (!jira)
-                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                const a = normalizeJiraProjectArgs(args);
-                const action = a.action ?? 'add';
-                if (action === 'update')
-                    return await jira.editComment({ issueKey: a.issueKey, commentId: a.commentId, body: a.body });
-                if (action === 'delete')
-                    return await jira.deleteComment({ issueKey: a.issueKey, commentId: a.commentId });
-                return await jira.addComment({ issueKey: a.issueKey, body: a.body });
-            }
-            case 'jira_version': {
-                if (!jira)
-                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                const a = normalizeJiraProjectArgs(args);
-                return await jira.mutateVersion(a);
-            }
-            // Bitbucket
-            case 'bitbucket_search': {
-                if (!bitbucket)
-                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                const a = normalizeBitbucketArgs(args);
-                const resource = a.resource ?? 'pull_requests';
-                if (resource === 'repos')
-                    return await bitbucket.listRepos(a);
-                if (resource === 'branches')
-                    return await bitbucket.getBranches(a);
-                if (resource === 'users')
-                    return await bitbucket.searchUsers({ projectKey: a.projectKey, repoSlug: a.repoSlug, query: a.query, limit: a.limit, start: a.start });
-                // pull_requests (default)
-                if (a.mine)
-                    return await bitbucket.myPrs({ limit: a.limit, start: a.start, role: a.role });
-                return await bitbucket.listPullRequests(a);
-            }
-            case 'bitbucket_get_pr':
-                if (!bitbucket)
-                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                return await bitbucket.getPrOverview(normalizeBitbucketArgs(args));
-            case 'bitbucket_mutate': {
-                if (!bitbucket)
-                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                const a = normalizeBitbucketArgs(args);
-                const action = a.action;
-                if (action === 'approve')
-                    return await bitbucket.approvePr(a);
-                if (action === 'unapprove')
-                    return await bitbucket.unapprovePr(a);
-                if (action === 'needs_work')
-                    return await bitbucket.needsWorkPr(a);
-                if (action === 'decline')
-                    return await bitbucket.declinePr({ ...a, message: a.declineMessage });
-                if (action === 'merge')
-                    return await bitbucket.mergePr({ ...a, message: a.mergeMessage, mergeStrategy: a.mergeStrategy });
-                // Handle interactive reviewer picker for PR creation
-                const createArgs = a.create;
-                if (createArgs?.pickReviewers && !a.prId) {
-                    const projectKey = a.projectKey;
-                    const repoSlug = a.repoSlug;
-                    const users = await bitbucket.searchUsersRaw({ projectKey, repoSlug, limit: 30 });
-                    if (users.length > 0) {
-                        // Build boolean checkbox schema — one field per user
-                        // key must be safe for JSON schema property names
-                        const toSchemaKey = (uname) => uname.replace(/[^a-zA-Z0-9]/g, '_');
-                        const userMap = new Map(); // schemaKey -> username
-                        const properties = {};
-                        for (const u of users) {
-                            const key = toSchemaKey(u.name);
-                            userMap.set(key, u.name);
-                            properties[key] = { type: 'boolean', title: `${u.displayName} (${u.name})` };
-                        }
-                        try {
-                            const pickerResult = await server.elicitInput({
-                                message: 'Select reviewers to add to this PR:',
-                                requestedSchema: { type: 'object', properties },
-                            });
-                            if (pickerResult.action === 'accept' && pickerResult.content) {
-                                const selected = [];
-                                for (const [key, username] of userMap) {
-                                    if (pickerResult.content[key] === true)
-                                        selected.push(username);
-                                }
-                                createArgs.reviewers = selected;
-                            }
-                        }
-                        catch {
-                            // elicitation not supported — proceed without reviewer picker
-                        }
-                    }
-                }
-                return await bitbucket.mutatePullRequest(a);
-            }
-            case 'bitbucket_comment': {
-                if (!bitbucket)
-                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                const a = normalizeBitbucketArgs(args);
-                const action = a.action ?? 'add';
-                if (action === 'update')
-                    return await bitbucket.updatePrComment(a);
-                if (action === 'delete')
-                    return await bitbucket.deletePrComment(a);
-                return await bitbucket.addPrComment(a);
-            }
-            case 'bitbucket_get_file':
-                if (!bitbucket)
-                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                return await bitbucket.getFile(normalizeBitbucketArgs(args));
-            case 'bitbucket_get_attachment': {
-                if (!bitbucket)
-                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                const normalized = normalizeBitbucketArgs(args);
-                validateAttachmentArgs(normalized);
-                return await bitbucket.getAttachment(normalized);
-            }
-            case 'bitbucket_pr_tasks': {
-                if (!bitbucket)
-                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                const a = normalizeBitbucketArgs(args);
-                const action = (a.action ?? 'list');
-                if (action === 'list')
-                    return await bitbucket.getPrTasks(a);
-                return await bitbucket.mutatePrTask({ ...a, action: action });
-            }
-            case 'complete_work': {
-                if (!jira || !bitbucket)
-                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                const a = args;
-                const repoPath = a.repoPath ?? process.cwd();
-                const lines = [];
-                // Resolve PR — by prId or current branch
-                let resolvedPrId = a.prId;
-                if (resolvedPrId === undefined) {
-                    const branch = (() => { try {
-                        return execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: repoPath, encoding: 'utf-8' }).trim();
-                    }
-                    catch {
-                        return '';
-                    } })();
-                    if (!branch || branch === 'HEAD') {
-                        throw new Error('Could not determine current branch. Provide prId or run from a checked-out branch.');
-                    }
-                    const remote = (() => { try {
-                        return execFileSync('git', ['remote', 'get-url', 'origin'], { cwd: repoPath, encoding: 'utf-8' }).trim();
-                    }
-                    catch {
-                        return '';
-                    } })();
-                    const parsed = parseBitbucketRemote(remote);
-                    if (!parsed)
-                        throw new Error('Could not parse Bitbucket remote URL. Provide projectKey/repoSlug explicitly.');
-                    const projectKey = a.projectKey ?? parsed.projectKey;
-                    const repoSlug = a.repoSlug ?? parsed.repoSlug;
-                    const pr = await bitbucket.findOpenPrForBranch(projectKey, repoSlug, branch);
-                    if (!pr)
-                        throw new Error(`No open PR found for branch "${branch}". Provide prId explicitly.`);
-                    resolvedPrId = pr.id;
-                    lines.push(`Branch:  ${branch} → PR #${resolvedPrId}`);
-                    // Auto-detect Jira issue key from branch if not provided
-                    if (!a.issueKey) {
-                        const JIRA_KEY_RE = /\b([A-Z][A-Z0-9]+-\d+)\b/;
-                        const match = branch.match(JIRA_KEY_RE);
-                        if (match) {
-                            a.issueKey = match[1];
-                            lines.push(`Jira:    auto-detected ${a.issueKey} from branch name`);
-                        }
-                    }
-                }
-                // Merge the PR
-                const mergeResult = await bitbucket.mergePr({
-                    prId: resolvedPrId,
-                    projectKey: a.projectKey,
-                    repoSlug: a.repoSlug,
-                    mergeStrategy: a.mergeStrategy,
-                    message: a.mergeMessage,
-                });
-                lines.push(mergeResult.content[0].text);
-                // Transition Jira ticket
-                if (!a.skipJiraTransition && a.issueKey) {
-                    const transitionName = a.transitionName ?? 'Done';
-                    try {
-                        await jira.mutateIssue({ issueKey: a.issueKey, transitionName });
-                        lines.push(`Jira:    ${a.issueKey} transitioned → ${transitionName}`);
-                    }
-                    catch (err) {
-                        lines.push(`Jira:    could not transition ${a.issueKey} — ${err.message}`);
-                    }
-                }
-                else if (!a.skipJiraTransition) {
-                    lines.push('Jira:    no issue key — skipped transition (provide issueKey to transition)');
-                }
-                return { content: [{ type: 'text', text: lines.join('\n') }] };
-            }
-            default:
-                throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-        }
-    }
-    catch (err) {
-        if (err instanceof McpError)
-            throw err;
-        return {
-            content: [{ type: 'text', text: `Error: ${err.message}` }],
-            isError: true,
-        };
-    }
-});
-async function shutdown() {
-    await server.close();
-    process.exit(0);
-}
-process.on('SIGINT', shutdown);
-process.on('SIGTERM', shutdown);
-const transport = new StdioServerTransport();
-await server.connect(transport);