@zierocode/mcp-atlassian-cloud 2.6.1

package/dist/atlassian.js

@@ -0,0 +1,1384 @@
+import axios, { AxiosError } from "axios";
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+import { createRequire } from "module";
+// CommonJS require for @atlaskit packages (they don't have proper ESM exports)
+const require = createRequire(import.meta.url);
+const { defaultSchema } = require("@atlaskit/adf-schema/schema-default");
+const { MarkdownTransformer } = require("@atlaskit/editor-markdown-transformer");
+const { JSONTransformer } = require("@atlaskit/editor-json-transformer");
+class MetadataCache {
+    cache = new Map();
+    TTL_MS = 30 * 60 * 1000; // 30 minutes
+    async get(key, fetchFn) {
+        const cached = this.cache.get(key);
+        const now = Date.now();
+        if (cached && now < cached.expiresAt) {
+            return cached.data;
+        }
+        const data = await fetchFn();
+        this.cache.set(key, { data, expiresAt: now + this.TTL_MS });
+        return data;
+    }
+    clear() {
+        this.cache.clear();
+    }
+    getStats() {
+        return {
+            size: this.cache.size,
+            keys: Array.from(this.cache.keys()),
+        };
+    }
+}
+// Singleton cache instance (shared across all sessions)
+const metadataCache = new MetadataCache();
+// ============================================================
+// RETRY WITH EXPONENTIAL BACKOFF
+// ============================================================
+const RETRYABLE_STATUS_CODES = [408, 429, 500, 502, 503, 504];
+const MAX_RETRIES = 3;
+const BASE_DELAY_MS = 1000;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function axiosWithRetry(config, context) {
+    let lastError = null;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+        try {
+            const response = await axios.request(config);
+            return response.data;
+        }
+        catch (error) {
+            lastError = error;
+            if (error instanceof AxiosError) {
+                const status = error.response?.status;
+                // Don't retry client errors (4xx except 408, 429)
+                if (status && status >= 400 && status < 500 && !RETRYABLE_STATUS_CODES.includes(status)) {
+                    throw error;
+                }
+                // Retry for network errors and retryable status codes
+                if (attempt < MAX_RETRIES - 1) {
+                    const delay = BASE_DELAY_MS * Math.pow(2, attempt); // 1s, 2s, 4s
+                    console.log(`[Retry] ${context} - attempt ${attempt + 1}/${MAX_RETRIES}, waiting ${delay}ms`);
+                    await sleep(delay);
+                    continue;
+                }
+            }
+            throw error;
+        }
+    }
+    throw lastError;
+}
+// ============================================================
+// HELPER FUNCTIONS
+// ============================================================
+function getRequiredEnv(name) {
+    const value = process.env[name];
+    if (!value) {
+        throw new Error(`Missing required environment variable: ${name}\n` +
+            "Please set this variable before starting the server.");
+    }
+    return value;
+}
+function validateConfig() {
+    return {
+        domain: getRequiredEnv("ATLASSIAN_DOMAIN"),
+        email: getRequiredEnv("ATLASSIAN_EMAIL"),
+        apiToken: getRequiredEnv("ATLASSIAN_API_TOKEN"),
+    };
+}
+// ============================================================
+// MARKDOWN TO ADF CONVERTER (Official Atlaskit Library)
+// ============================================================
+// Initialize transformers with Jira-compatible schema
+const markdownTransformer = new MarkdownTransformer(defaultSchema);
+const jsonTransformer = new JSONTransformer();
+/**
+ * Convert Markdown text to Atlassian Document Format (ADF)
+ * Uses official @atlaskit/editor-markdown-transformer library
+ *
+ * Supported Markdown:
+ * - **bold** → strong mark
+ * - *italic* → em mark
+ * - ~~strikethrough~~ → strike mark
+ * - `inline code` → code mark
+ * - [link](url) → link mark
+ * - # Heading 1-6 → heading node
+ * - - bullet list → bulletList node
+ * - 1. ordered list → orderedList node
+ * - > blockquote → blockquote node
+ * - ```code block``` → codeBlock node
+ */
+function textToAdf(text) {
+    try {
+        // Parse markdown to ProseMirror document
+        const pmDoc = markdownTransformer.parse(text);
+        // Convert to ADF JSON
+        const adf = jsonTransformer.encode(pmDoc);
+        return adf;
+    }
+    catch (error) {
+        // Fallback to plain text if parsing fails
+        console.warn("[textToAdf] Markdown parse failed, using plain text:", error);
+        return {
+            type: "doc",
+            version: 1,
+            content: [
+                {
+                    type: "paragraph",
+                    content: [{ type: "text", text }],
+                },
+            ],
+        };
+    }
+}
+/**
+ * Convert an array of DescriptionBlocks to a single ADF document
+ * Supports mixing Markdown blocks with raw ADF nodes
+ *
+ * Example:
+ * [
+ *   { markdown: "# Title\nSome **bold** text" },
+ *   { adf: { type: "panel", attrs: { panelType: "info" }, content: [...] } },
+ *   { markdown: "More text\n- List item 1\n- List item 2" }
+ * ]
+ */
+function blocksToAdf(blocks) {
+    const allContent = [];
+    for (const block of blocks) {
+        if ("markdown" in block) {
+            // Convert Markdown to ADF and extract content nodes
+            const adf = textToAdf(block.markdown);
+            if (adf.content) {
+                allContent.push(...adf.content);
+            }
+        }
+        else if ("adf" in block) {
+            // Raw ADF node - add directly
+            allContent.push(block.adf);
+        }
+    }
+    return {
+        type: "doc",
+        version: 1,
+        content: allContent,
+    };
+}
+/**
+ * Resolve description from multiple possible formats
+ * Priority: description_adf > description_blocks > description (markdown)
+ */
+function resolveDescription(params) {
+    // Raw ADF document takes highest priority
+    if (params.description_adf) {
+        return params.description_adf;
+    }
+    // Hybrid blocks (mix of Markdown + ADF)
+    if (params.description_blocks && params.description_blocks.length > 0) {
+        return blocksToAdf(params.description_blocks);
+    }
+    // Simple Markdown string
+    if (params.description) {
+        return textToAdf(params.description);
+    }
+    return undefined;
+}
+// ============================================================
+// ATLASSIAN MANAGER CLASS
+// ============================================================
+export class AtlassianManager {
+    config;
+    baseUrl;
+    agileBaseUrl;
+    constructor() {
+        this.config = validateConfig();
+        this.baseUrl = `https://${this.config.domain}/rest/api/3`;
+        this.agileBaseUrl = `https://${this.config.domain}/rest/agile/1.0`;
+    }
+    get authHeader() {
+        const auth = Buffer.from(`${this.config.email}:${this.config.apiToken}`).toString("base64");
+        return { Authorization: `Basic ${auth}` };
+    }
+    get defaultHeaders() {
+        return {
+            ...this.authHeader,
+            Accept: "application/json",
+            "Content-Type": "application/json",
+        };
+    }
+    handleError(error, context) {
+        if (error instanceof AxiosError) {
+            const status = error.response?.status;
+            const errorData = error.response?.data;
+            const messages = errorData?.errorMessages ?? [];
+            const fieldErrors = errorData?.errors
+                ? Object.entries(errorData.errors).map(([k, v]) => `${k}: ${v}`)
+                : [];
+            const allErrors = [...messages, ...fieldErrors];
+            const message = allErrors.length > 0
+                ? allErrors.join("; ")
+                : error.message ?? "Unknown error";
+            if (status === 404) {
+                throw new McpError(ErrorCode.InvalidRequest, `${context}: Not found`);
+            }
+            if (status === 400) {
+                throw new McpError(ErrorCode.InvalidRequest, `${context}: ${message}`);
+            }
+            if (status === 401 || status === 403) {
+                throw new McpError(ErrorCode.InvalidRequest, "Authentication failed. Check your Atlassian credentials.");
+            }
+            throw new McpError(ErrorCode.InternalError, `${context}: ${message}`);
+        }
+        throw new McpError(ErrorCode.InternalError, `${context}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    // ============================================================
+    // ISSUES - CRUD
+    // ============================================================
+    async getJiraIssue(issueKey) {
+        try {
+            const response = await axios.get(`${this.baseUrl}/issue/${encodeURIComponent(issueKey)}`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            if (error instanceof AxiosError && error.response?.status === 404) {
+                throw new McpError(ErrorCode.InvalidRequest, `Jira issue not found: ${issueKey}`);
+            }
+            this.handleError(error, `Failed to get issue ${issueKey}`);
+        }
+    }
+    async searchIssues(jql, maxResults = 20, fields) {
+        try {
+            const response = await axios.post(`${this.baseUrl}/search`, {
+                jql,
+                maxResults,
+                fields: fields ?? ["key", "summary", "status", "assignee", "priority", "issuetype", "created", "updated"],
+            }, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, "Failed to search issues");
+        }
+    }
+    async createIssue(params) {
+        try {
+            const fields = {
+                project: { key: params.projectKey },
+                issuetype: { name: params.issueType },
+                summary: params.summary,
+            };
+            // Resolve description from multiple formats (adf > blocks > markdown)
+            const description = resolveDescription(params);
+            if (description) {
+                fields.description = description;
+            }
+            if (params.assignee) {
+                fields.assignee = { accountId: params.assignee };
+            }
+            if (params.priority) {
+                fields.priority = { name: params.priority };
+            }
+            if (params.labels && params.labels.length > 0) {
+                fields.labels = params.labels;
+            }
+            if (params.components && params.components.length > 0) {
+                fields.components = params.components.map((name) => ({ name }));
+            }
+            if (params.parentKey) {
+                fields.parent = { key: params.parentKey };
+            }
+            const response = await axios.post(`${this.baseUrl}/issue`, { fields }, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, "Failed to create issue");
+        }
+    }
+    async updateIssue(issueKey, params) {
+        try {
+            const fields = {};
+            if (params.summary !== undefined) {
+                fields.summary = params.summary;
+            }
+            // Resolve description from multiple formats (adf > blocks > markdown)
+            const description = resolveDescription(params);
+            if (description) {
+                fields.description = description;
+            }
+            if (params.assignee !== undefined) {
+                fields.assignee = params.assignee ? { accountId: params.assignee } : null;
+            }
+            if (params.priority !== undefined) {
+                fields.priority = { name: params.priority };
+            }
+            if (params.labels !== undefined) {
+                fields.labels = params.labels;
+            }
+            if (params.components !== undefined) {
+                fields.components = params.components.map((name) => ({ name }));
+            }
+            await axios.put(`${this.baseUrl}/issue/${encodeURIComponent(issueKey)}`, { fields }, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+        }
+        catch (error) {
+            this.handleError(error, `Failed to update issue ${issueKey}`);
+        }
+    }
+    async deleteIssue(issueKey, deleteSubtasks = false) {
+        try {
+            await axios.delete(`${this.baseUrl}/issue/${encodeURIComponent(issueKey)}`, {
+                headers: this.defaultHeaders,
+                params: { deleteSubtasks },
+                timeout: 30000,
+            });
+        }
+        catch (error) {
+            this.handleError(error, `Failed to delete issue ${issueKey}`);
+        }
+    }
+    // ============================================================
+    // ISSUES - TRANSITIONS & ASSIGNMENT
+    // ============================================================
+    async getIssueTransitions(issueKey) {
+        try {
+            const response = await axios.get(`${this.baseUrl}/issue/${encodeURIComponent(issueKey)}/transitions`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data.transitions;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to get transitions for ${issueKey}`);
+        }
+    }
+    async transitionIssue(issueKey, transitionId, comment) {
+        try {
+            const body = {
+                transition: { id: transitionId },
+            };
+            if (comment) {
+                body.update = {
+                    comment: [{ add: { body: textToAdf(comment) } }],
+                };
+            }
+            await axios.post(`${this.baseUrl}/issue/${encodeURIComponent(issueKey)}/transitions`, body, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+        }
+        catch (error) {
+            this.handleError(error, `Failed to transition issue ${issueKey}`);
+        }
+    }
+    async assignIssue(issueKey, accountId) {
+        try {
+            await axios.put(`${this.baseUrl}/issue/${encodeURIComponent(issueKey)}/assignee`, { accountId }, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+        }
+        catch (error) {
+            this.handleError(error, `Failed to assign issue ${issueKey}`);
+        }
+    }
+    async bulkCreateIssues(issues) {
+        try {
+            const issueUpdates = issues.map((params) => {
+                const fields = {
+                    project: { key: params.projectKey },
+                    issuetype: { name: params.issueType },
+                    summary: params.summary,
+                };
+                if (params.description) {
+                    fields.description = textToAdf(params.description);
+                }
+                if (params.assignee) {
+                    fields.assignee = { accountId: params.assignee };
+                }
+                if (params.priority) {
+                    fields.priority = { name: params.priority };
+                }
+                if (params.labels && params.labels.length > 0) {
+                    fields.labels = params.labels;
+                }
+                if (params.parentKey) {
+                    fields.parent = { key: params.parentKey };
+                }
+                return { fields };
+            });
+            const response = await axios.post(`${this.baseUrl}/issue/bulk`, { issueUpdates }, {
+                headers: this.defaultHeaders,
+                timeout: 60000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, "Failed to bulk create issues");
+        }
+    }
+    // ============================================================
+    // COMMENTS
+    // ============================================================
+    async getIssueComments(issueKey, maxResults = 50) {
+        try {
+            const response = await axios.get(`${this.baseUrl}/issue/${encodeURIComponent(issueKey)}/comment`, {
+                headers: this.defaultHeaders,
+                params: { maxResults },
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to get comments for ${issueKey}`);
+        }
+    }
+    async addIssueComment(issueKey, body) {
+        try {
+            const response = await axios.post(`${this.baseUrl}/issue/${encodeURIComponent(issueKey)}/comment`, { body: textToAdf(body) }, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to add comment to ${issueKey}`);
+        }
+    }
+    async updateIssueComment(issueKey, commentId, body) {
+        try {
+            const response = await axios.put(`${this.baseUrl}/issue/${encodeURIComponent(issueKey)}/comment/${commentId}`, { body: textToAdf(body) }, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to update comment ${commentId}`);
+        }
+    }
+    async deleteIssueComment(issueKey, commentId) {
+        try {
+            await axios.delete(`${this.baseUrl}/issue/${encodeURIComponent(issueKey)}/comment/${commentId}`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+        }
+        catch (error) {
+            this.handleError(error, `Failed to delete comment ${commentId}`);
+        }
+    }
+    // ============================================================
+    // WORKLOGS
+    // ============================================================
+    async getIssueWorklogs(issueKey, maxResults = 50) {
+        try {
+            const response = await axios.get(`${this.baseUrl}/issue/${encodeURIComponent(issueKey)}/worklog`, {
+                headers: this.defaultHeaders,
+                params: { maxResults },
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to get worklogs for ${issueKey}`);
+        }
+    }
+    async addWorklog(issueKey, timeSpent, comment, started) {
+        try {
+            const body = { timeSpent };
+            if (comment) {
+                body.comment = textToAdf(comment);
+            }
+            if (started) {
+                body.started = started;
+            }
+            const response = await axios.post(`${this.baseUrl}/issue/${encodeURIComponent(issueKey)}/worklog`, body, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to add worklog to ${issueKey}`);
+        }
+    }
+    async updateWorklog(issueKey, worklogId, timeSpent, comment) {
+        try {
+            const body = { timeSpent };
+            if (comment) {
+                body.comment = textToAdf(comment);
+            }
+            const response = await axios.put(`${this.baseUrl}/issue/${encodeURIComponent(issueKey)}/worklog/${worklogId}`, body, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to update worklog ${worklogId}`);
+        }
+    }
+    async deleteWorklog(issueKey, worklogId) {
+        try {
+            await axios.delete(`${this.baseUrl}/issue/${encodeURIComponent(issueKey)}/worklog/${worklogId}`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+        }
+        catch (error) {
+            this.handleError(error, `Failed to delete worklog ${worklogId}`);
+        }
+    }
+    // ============================================================
+    // ATTACHMENTS
+    // ============================================================
+    async addAttachment(issueKey, filename, content) {
+        try {
+            const FormData = (await import("form-data")).default;
+            const form = new FormData();
+            form.append("file", content, { filename });
+            const response = await axios.post(`${this.baseUrl}/issue/${encodeURIComponent(issueKey)}/attachments`, form, {
+                headers: {
+                    ...this.authHeader,
+                    ...form.getHeaders(),
+                    "X-Atlassian-Token": "no-check",
+                },
+                timeout: 60000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to add attachment to ${issueKey}`);
+        }
+    }
+    async deleteAttachment(attachmentId) {
+        try {
+            await axios.delete(`${this.baseUrl}/attachment/${attachmentId}`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+        }
+        catch (error) {
+            this.handleError(error, `Failed to delete attachment ${attachmentId}`);
+        }
+    }
+    async getAttachmentContent(attachmentId) {
+        try {
+            // First get attachment metadata
+            const metaResponse = await axios.get(`${this.baseUrl}/attachment/${attachmentId}`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            // Then get content
+            const contentResponse = await axios.get(`${this.baseUrl}/attachment/content/${attachmentId}`, {
+                headers: this.authHeader,
+                responseType: "arraybuffer",
+                timeout: 60000,
+            });
+            return {
+                content: contentResponse.data.toString("base64"),
+                filename: metaResponse.data.filename,
+            };
+        }
+        catch (error) {
+            this.handleError(error, `Failed to get attachment ${attachmentId}`);
+        }
+    }
+    // ============================================================
+    // ISSUE LINKS
+    // ============================================================
+    async linkIssues(inwardIssueKey, outwardIssueKey, linkType) {
+        try {
+            await axios.post(`${this.baseUrl}/issueLink`, {
+                type: { name: linkType },
+                inwardIssue: { key: inwardIssueKey },
+                outwardIssue: { key: outwardIssueKey },
+            }, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+        }
+        catch (error) {
+            this.handleError(error, `Failed to link issues ${inwardIssueKey} and ${outwardIssueKey}`);
+        }
+    }
+    async deleteIssueLink(linkId) {
+        try {
+            await axios.delete(`${this.baseUrl}/issueLink/${linkId}`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+        }
+        catch (error) {
+            this.handleError(error, `Failed to delete issue link ${linkId}`);
+        }
+    }
+    async getIssueLinkTypes() {
+        try {
+            const response = await axios.get(`${this.baseUrl}/issueLinkType`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data.issueLinkTypes;
+        }
+        catch (error) {
+            this.handleError(error, "Failed to get issue link types");
+        }
+    }
+    // ============================================================
+    // WATCHERS
+    // ============================================================
+    async getIssueWatchers(issueKey) {
+        try {
+            const response = await axios.get(`${this.baseUrl}/issue/${encodeURIComponent(issueKey)}/watchers`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return { watchers: response.data.watchers };
+        }
+        catch (error) {
+            this.handleError(error, `Failed to get watchers for ${issueKey}`);
+        }
+    }
+    async addWatcher(issueKey, accountId) {
+        try {
+            await axios.post(`${this.baseUrl}/issue/${encodeURIComponent(issueKey)}/watchers`, JSON.stringify(accountId), {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+        }
+        catch (error) {
+            this.handleError(error, `Failed to add watcher to ${issueKey}`);
+        }
+    }
+    async removeWatcher(issueKey, accountId) {
+        try {
+            await axios.delete(`${this.baseUrl}/issue/${encodeURIComponent(issueKey)}/watchers`, {
+                headers: this.defaultHeaders,
+                params: { accountId },
+                timeout: 30000,
+            });
+        }
+        catch (error) {
+            this.handleError(error, `Failed to remove watcher from ${issueKey}`);
+        }
+    }
+    // ============================================================
+    // PROJECTS
+    // ============================================================
+    async listProjects(maxResults = 50) {
+        try {
+            const response = await axios.get(`${this.baseUrl}/project/search`, {
+                headers: this.defaultHeaders,
+                params: { maxResults },
+                timeout: 30000,
+            });
+            return response.data.values;
+        }
+        catch (error) {
+            this.handleError(error, "Failed to list projects");
+        }
+    }
+    async getProject(projectKey) {
+        try {
+            const response = await axios.get(`${this.baseUrl}/project/${encodeURIComponent(projectKey)}`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to get project ${projectKey}`);
+        }
+    }
+    async getProjectComponents(projectKey) {
+        try {
+            const response = await axios.get(`${this.baseUrl}/project/${encodeURIComponent(projectKey)}/components`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to get components for ${projectKey}`);
+        }
+    }
+    async getProjectVersions(projectKey) {
+        try {
+            const response = await axios.get(`${this.baseUrl}/project/${encodeURIComponent(projectKey)}/versions`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to get versions for ${projectKey}`);
+        }
+    }
+    async getProjectStatuses(projectKey) {
+        try {
+            const response = await axios.get(`${this.baseUrl}/project/${encodeURIComponent(projectKey)}/statuses`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            // Flatten statuses from all issue types
+            const allStatuses = response.data.flatMap((it) => it.statuses);
+            // Remove duplicates by id
+            const uniqueStatuses = [...new Map(allStatuses.map((s) => [s.id, s])).values()];
+            return uniqueStatuses;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to get statuses for ${projectKey}`);
+        }
+    }
+    async createProjectVersion(projectKey, name, description, releaseDate, startDate) {
+        try {
+            // First get project ID
+            const project = await this.getProject(projectKey);
+            const response = await axios.post(`${this.baseUrl}/version`, {
+                projectId: project.id,
+                name,
+                description,
+                releaseDate,
+                startDate,
+            }, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to create version in ${projectKey}`);
+        }
+    }
+    async batchCreateVersions(projectKey, versions) {
+        const created = [];
+        const errors = [];
+        // Get project ID once
+        const project = await this.getProject(projectKey);
+        for (const version of versions) {
+            try {
+                const response = await axios.post(`${this.baseUrl}/version`, {
+                    projectId: project.id,
+                    name: version.name,
+                    description: version.description,
+                    releaseDate: version.releaseDate,
+                    startDate: version.startDate,
+                }, {
+                    headers: this.defaultHeaders,
+                    timeout: 30000,
+                });
+                created.push(response.data);
+            }
+            catch (error) {
+                const axiosError = error;
+                errors.push({
+                    name: version.name,
+                    error: axiosError.message || "Unknown error",
+                });
+            }
+        }
+        return { created, errors };
+    }
+    async createProjectComponent(projectKey, name, description, leadAccountId) {
+        try {
+            const response = await axios.post(`${this.baseUrl}/component`, {
+                project: projectKey,
+                name,
+                description,
+                leadAccountId,
+            }, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to create component in ${projectKey}`);
+        }
+    }
+    // ============================================================
+    // USERS
+    // ============================================================
+    async searchUsers(query, maxResults = 20) {
+        try {
+            const response = await axios.get(`${this.baseUrl}/user/search`, {
+                headers: this.defaultHeaders,
+                params: { query, maxResults },
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, "Failed to search users");
+        }
+    }
+    async getCurrentUser() {
+        try {
+            const response = await axios.get(`${this.baseUrl}/myself`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, "Failed to get current user");
+        }
+    }
+    async getUser(accountId) {
+        try {
+            const response = await axios.get(`${this.baseUrl}/user`, {
+                headers: this.defaultHeaders,
+                params: { accountId },
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to get user ${accountId}`);
+        }
+    }
+    async getAssignableUsers(projectKey, issueKey, maxResults = 50) {
+        try {
+            const params = { project: projectKey, maxResults };
+            if (issueKey) {
+                params.issueKey = issueKey;
+            }
+            const response = await axios.get(`${this.baseUrl}/user/assignable/search`, {
+                headers: this.defaultHeaders,
+                params,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, "Failed to get assignable users");
+        }
+    }
+    // ============================================================
+    // AGILE - BOARDS
+    // ============================================================
+    async listBoards(projectKeyOrId, type, maxResults = 50) {
+        try {
+            const params = { maxResults };
+            if (projectKeyOrId) {
+                params.projectKeyOrId = projectKeyOrId;
+            }
+            if (type) {
+                params.type = type;
+            }
+            const response = await axios.get(`${this.agileBaseUrl}/board`, {
+                headers: this.defaultHeaders,
+                params,
+                timeout: 30000,
+            });
+            return response.data.values;
+        }
+        catch (error) {
+            this.handleError(error, "Failed to list boards");
+        }
+    }
+    async getBoard(boardId) {
+        try {
+            const response = await axios.get(`${this.agileBaseUrl}/board/${boardId}`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to get board ${boardId}`);
+        }
+    }
+    async getBoardIssues(boardId, jql, maxResults = 50) {
+        try {
+            const params = { maxResults };
+            if (jql) {
+                params.jql = jql;
+            }
+            const response = await axios.get(`${this.agileBaseUrl}/board/${boardId}/issue`, {
+                headers: this.defaultHeaders,
+                params,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to get issues for board ${boardId}`);
+        }
+    }
+    async getBacklogIssues(boardId, maxResults = 50) {
+        try {
+            const response = await axios.get(`${this.agileBaseUrl}/board/${boardId}/backlog`, {
+                headers: this.defaultHeaders,
+                params: { maxResults },
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to get backlog for board ${boardId}`);
+        }
+    }
+    // ============================================================
+    // AGILE - SPRINTS
+    // ============================================================
+    async listSprints(boardId, state, maxResults = 50) {
+        try {
+            const params = { maxResults };
+            if (state) {
+                params.state = state;
+            }
+            const response = await axios.get(`${this.agileBaseUrl}/board/${boardId}/sprint`, {
+                headers: this.defaultHeaders,
+                params,
+                timeout: 30000,
+            });
+            return response.data.values;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to list sprints for board ${boardId}`);
+        }
+    }
+    async getSprint(sprintId) {
+        try {
+            const response = await axios.get(`${this.agileBaseUrl}/sprint/${sprintId}`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to get sprint ${sprintId}`);
+        }
+    }
+    async getSprintIssues(sprintId, maxResults = 50) {
+        try {
+            const response = await axios.get(`${this.agileBaseUrl}/sprint/${sprintId}/issue`, {
+                headers: this.defaultHeaders,
+                params: { maxResults },
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to get issues for sprint ${sprintId}`);
+        }
+    }
+    async createSprint(boardId, name, goal, startDate, endDate) {
+        try {
+            const response = await axios.post(`${this.agileBaseUrl}/sprint`, {
+                originBoardId: boardId,
+                name,
+                goal,
+                startDate,
+                endDate,
+            }, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, "Failed to create sprint");
+        }
+    }
+    async updateSprint(sprintId, updates) {
+        try {
+            const response = await axios.put(`${this.agileBaseUrl}/sprint/${sprintId}`, updates, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to update sprint ${sprintId}`);
+        }
+    }
+    async moveIssuesToSprint(sprintId, issueKeys) {
+        try {
+            await axios.post(`${this.agileBaseUrl}/sprint/${sprintId}/issue`, { issues: issueKeys }, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+        }
+        catch (error) {
+            this.handleError(error, `Failed to move issues to sprint ${sprintId}`);
+        }
+    }
+    // ============================================================
+    // AGILE - EPICS
+    // ============================================================
+    async getEpic(epicIdOrKey) {
+        try {
+            const response = await axios.get(`${this.agileBaseUrl}/epic/${encodeURIComponent(epicIdOrKey)}`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to get epic ${epicIdOrKey}`);
+        }
+    }
+    async getEpicIssues(epicIdOrKey, maxResults = 50) {
+        try {
+            const response = await axios.get(`${this.agileBaseUrl}/epic/${encodeURIComponent(epicIdOrKey)}/issue`, {
+                headers: this.defaultHeaders,
+                params: { maxResults },
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to get issues for epic ${epicIdOrKey}`);
+        }
+    }
+    async moveIssuesToEpic(epicIdOrKey, issueKeys) {
+        try {
+            await axios.post(`${this.agileBaseUrl}/epic/${encodeURIComponent(epicIdOrKey)}/issue`, { issues: issueKeys }, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+        }
+        catch (error) {
+            this.handleError(error, `Failed to move issues to epic ${epicIdOrKey}`);
+        }
+    }
+    async removeIssuesFromEpic(issueKeys) {
+        try {
+            await axios.post(`${this.agileBaseUrl}/epic/none/issue`, { issues: issueKeys }, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+        }
+        catch (error) {
+            this.handleError(error, "Failed to remove issues from epic");
+        }
+    }
+    // ============================================================
+    // FILTERS
+    // ============================================================
+    async getMyFilters() {
+        try {
+            const response = await axios.get(`${this.baseUrl}/filter/my`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, "Failed to get my filters");
+        }
+    }
+    async getFavoriteFilters() {
+        try {
+            const response = await axios.get(`${this.baseUrl}/filter/favourite`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, "Failed to get favorite filters");
+        }
+    }
+    async getFilter(filterId) {
+        try {
+            const response = await axios.get(`${this.baseUrl}/filter/${filterId}`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to get filter ${filterId}`);
+        }
+    }
+    async createFilter(name, jql, description, favourite) {
+        try {
+            const response = await axios.post(`${this.baseUrl}/filter`, { name, jql, description, favourite }, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, "Failed to create filter");
+        }
+    }
+    // ============================================================
+    // METADATA (with caching - 30 min TTL)
+    // ============================================================
+    async getFields() {
+        return metadataCache.get("fields", async () => {
+            try {
+                return await axiosWithRetry({
+                    method: "GET",
+                    url: `${this.baseUrl}/field`,
+                    headers: this.defaultHeaders,
+                    timeout: 30000,
+                }, "getFields");
+            }
+            catch (error) {
+                this.handleError(error, "Failed to get fields");
+            }
+        });
+    }
+    async getIssueTypes() {
+        return metadataCache.get("issueTypes", async () => {
+            try {
+                return await axiosWithRetry({
+                    method: "GET",
+                    url: `${this.baseUrl}/issuetype`,
+                    headers: this.defaultHeaders,
+                    timeout: 30000,
+                }, "getIssueTypes");
+            }
+            catch (error) {
+                this.handleError(error, "Failed to get issue types");
+            }
+        });
+    }
+    async getPriorities() {
+        return metadataCache.get("priorities", async () => {
+            try {
+                return await axiosWithRetry({
+                    method: "GET",
+                    url: `${this.baseUrl}/priority`,
+                    headers: this.defaultHeaders,
+                    timeout: 30000,
+                }, "getPriorities");
+            }
+            catch (error) {
+                this.handleError(error, "Failed to get priorities");
+            }
+        });
+    }
+    async getStatuses() {
+        return metadataCache.get("statuses", async () => {
+            try {
+                return await axiosWithRetry({
+                    method: "GET",
+                    url: `${this.baseUrl}/status`,
+                    headers: this.defaultHeaders,
+                    timeout: 30000,
+                }, "getStatuses");
+            }
+            catch (error) {
+                this.handleError(error, "Failed to get statuses");
+            }
+        });
+    }
+    async getResolutions() {
+        return metadataCache.get("resolutions", async () => {
+            try {
+                return await axiosWithRetry({
+                    method: "GET",
+                    url: `${this.baseUrl}/resolution`,
+                    headers: this.defaultHeaders,
+                    timeout: 30000,
+                }, "getResolutions");
+            }
+            catch (error) {
+                this.handleError(error, "Failed to get resolutions");
+            }
+        });
+    }
+    // Cache management
+    clearMetadataCache() {
+        const stats = metadataCache.getStats();
+        metadataCache.clear();
+        return { cleared: true, stats };
+    }
+    getMetadataCacheStats() {
+        return metadataCache.getStats();
+    }
+    async getLabels(maxResults = 1000) {
+        try {
+            const response = await axios.get(`${this.baseUrl}/label`, {
+                headers: this.defaultHeaders,
+                params: { maxResults },
+                timeout: 30000,
+            });
+            return response.data.values;
+        }
+        catch (error) {
+            this.handleError(error, "Failed to get labels");
+        }
+    }
+    async getServerInfo() {
+        try {
+            const response = await axios.get(`${this.baseUrl}/serverInfo`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, "Failed to get server info");
+        }
+    }
+    // ============================================================
+    // CHANGELOG METHODS (Cloud only)
+    // ============================================================
+    async getIssueChangelog(issueKey, maxResults = 100) {
+        try {
+            const response = await axios.get(`${this.baseUrl}/issue/${issueKey}/changelog`, {
+                headers: this.defaultHeaders,
+                params: { maxResults },
+                timeout: 30000,
+            });
+            return {
+                changelogs: response.data.values,
+                total: response.data.total,
+            };
+        }
+        catch (error) {
+            this.handleError(error, `Failed to get changelog for ${issueKey}`);
+        }
+    }
+    async batchGetChangelogs(issueKeys, maxResults = 50) {
+        const results = [];
+        // Process in parallel with limit of 5 concurrent requests
+        const batchSize = 5;
+        for (let i = 0; i < issueKeys.length; i += batchSize) {
+            const batch = issueKeys.slice(i, i + batchSize);
+            const batchResults = await Promise.all(batch.map(async (issueKey) => {
+                try {
+                    // First get issue ID
+                    const issue = await this.getJiraIssue(issueKey);
+                    const changelog = await this.getIssueChangelog(issueKey, maxResults);
+                    return {
+                        issueKey,
+                        issueId: issue.id,
+                        changelogs: changelog.changelogs,
+                    };
+                }
+                catch {
+                    return {
+                        issueKey,
+                        issueId: "",
+                        changelogs: [],
+                    };
+                }
+            }));
+            results.push(...batchResults);
+        }
+        return results;
+    }
+    // ============================================================
+    // SEARCH FIELDS (fuzzy search)
+    // ============================================================
+    async searchFields(keyword, limit = 10) {
+        const allFields = await this.getFields();
+        const keywordLower = keyword.toLowerCase();
+        // Fuzzy match: name or id contains keyword
+        const matches = allFields.filter((field) => {
+            const nameLower = field.name.toLowerCase();
+            const idLower = field.id.toLowerCase();
+            return nameLower.includes(keywordLower) || idLower.includes(keywordLower);
+        });
+        // Sort by relevance: exact match first, then startsWith, then contains
+        matches.sort((a, b) => {
+            const aName = a.name.toLowerCase();
+            const bName = b.name.toLowerCase();
+            // Exact match
+            if (aName === keywordLower && bName !== keywordLower)
+                return -1;
+            if (bName === keywordLower && aName !== keywordLower)
+                return 1;
+            // Starts with
+            if (aName.startsWith(keywordLower) && !bName.startsWith(keywordLower))
+                return -1;
+            if (bName.startsWith(keywordLower) && !aName.startsWith(keywordLower))
+                return 1;
+            // Alphabetical
+            return aName.localeCompare(bName);
+        });
+        return matches.slice(0, limit);
+    }
+    // ============================================================
+    // REMOTE ISSUE LINKS (web links, Confluence)
+    // ============================================================
+    async createRemoteIssueLink(issueKey, url, title, summary, iconUrl, relationship) {
+        try {
+            const response = await axios.post(`${this.baseUrl}/issue/${encodeURIComponent(issueKey)}/remotelink`, {
+                object: {
+                    url,
+                    title,
+                    summary,
+                    icon: iconUrl ? { url16x16: iconUrl } : undefined,
+                },
+                relationship: relationship || "relates to",
+            }, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error, `Failed to create remote link for ${issueKey}`);
+        }
+    }
+    // ============================================================
+    // DOWNLOAD ATTACHMENTS
+    // ============================================================
+    async getIssueAttachments(issueKey) {
+        try {
+            const issue = await this.getJiraIssue(issueKey);
+            const attachments = issue.fields.attachment;
+            return attachments || [];
+        }
+        catch (error) {
+            this.handleError(error, `Failed to get attachments for ${issueKey}`);
+        }
+    }
+    async downloadAttachment(attachmentId) {
+        try {
+            // Get metadata
+            const metaResponse = await axios.get(`${this.baseUrl}/attachment/${attachmentId}`, {
+                headers: this.defaultHeaders,
+                timeout: 30000,
+            });
+            // Download content
+            const contentResponse = await axios.get(metaResponse.data.content, {
+                headers: this.authHeader,
+                responseType: "arraybuffer",
+                timeout: 120000, // 2 min for large files
+            });
+            return {
+                content: contentResponse.data.toString("base64"),
+                filename: metaResponse.data.filename,
+                mimeType: metaResponse.data.mimeType,
+                size: metaResponse.data.size,
+            };
+        }
+        catch (error) {
+            this.handleError(error, `Failed to download attachment ${attachmentId}`);
+        }
+    }
+    // ============================================================
+    // PROJECT ISSUES (convenience wrapper)
+    // ============================================================
+    async getProjectIssues(projectKey, maxResults = 50, fields) {
+        const jql = `project = "${projectKey}" ORDER BY created DESC`;
+        return this.searchIssues(jql, maxResults, fields);
+    }
+    // ============================================================
+    // LINK ISSUE TO EPIC (convenience wrapper)
+    // ============================================================
+    async linkIssueToEpic(issueKey, epicKey) {
+        await this.moveIssuesToEpic(epicKey, [issueKey]);
+    }
+}
+//# sourceMappingURL=atlassian.js.map